*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 1715 insertions, 1965 deletions

diff --git a/lldb/source/Target/StackFrame.cpp b/lldb/source/Target/StackFrame.cpp
index 887207199e2..e491c594a1f 100644
--- a/lldb/source/Target/StackFrame.cpp
+++ b/lldb/source/Target/StackFrame.cpp
@@ -18,9 +18,9 @@
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
-#include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
+#include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
@@ -40,289 +40,221 @@ using namespace lldb_private;
 // The first bits in the flags are reserved for the SymbolContext::Scope bits
 // so we know if we have tried to look up information in our internal symbol
 // context (m_sc) already.
-#define RESOLVED_FRAME_CODE_ADDR        (uint32_t(eSymbolContextEverything + 1))
-#define RESOLVED_FRAME_ID_SYMBOL_SCOPE  (RESOLVED_FRAME_CODE_ADDR << 1)
-#define GOT_FRAME_BASE                  (RESOLVED_FRAME_ID_SYMBOL_SCOPE << 1)
-#define RESOLVED_VARIABLES              (GOT_FRAME_BASE << 1)
-#define RESOLVED_GLOBAL_VARIABLES       (RESOLVED_VARIABLES << 1)
-
-StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx, user_id_t unwind_frame_index, addr_t cfa,
-                       bool cfa_is_valid, addr_t pc, uint32_t stop_id, bool stop_id_is_valid, bool is_history_frame,
+#define RESOLVED_FRAME_CODE_ADDR (uint32_t(eSymbolContextEverything + 1))
+#define RESOLVED_FRAME_ID_SYMBOL_SCOPE (RESOLVED_FRAME_CODE_ADDR << 1)
+#define GOT_FRAME_BASE (RESOLVED_FRAME_ID_SYMBOL_SCOPE << 1)
+#define RESOLVED_VARIABLES (GOT_FRAME_BASE << 1)
+#define RESOLVED_GLOBAL_VARIABLES (RESOLVED_VARIABLES << 1)
+
+StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
+                       user_id_t unwind_frame_index, addr_t cfa,
+                       bool cfa_is_valid, addr_t pc, uint32_t stop_id,
+                       bool stop_id_is_valid, bool is_history_frame,
                        const SymbolContext *sc_ptr)
-    : m_thread_wp(thread_sp),
-      m_frame_index(frame_idx),
-      m_concrete_frame_index(unwind_frame_index),
-      m_reg_context_sp(),
-      m_id(pc, cfa, nullptr),
-      m_frame_code_addr(pc),
-      m_sc(),
-      m_flags(),
-      m_frame_base(),
-      m_frame_base_error(),
-      m_cfa_is_valid(cfa_is_valid),
-      m_stop_id(stop_id),
-      m_stop_id_is_valid(stop_id_is_valid),
-      m_is_history_frame(is_history_frame),
-      m_variable_list_sp(),
-      m_variable_list_value_objects(),
-      m_disassembly(),
-      m_mutex()
-{
-    // If we don't have a CFA value, use the frame index for our StackID so that recursive
-    // functions properly aren't confused with one another on a history stack.
-    if (m_is_history_frame && !m_cfa_is_valid)
-    {
-        m_id.SetCFA(m_frame_index);
-    }
-
-    if (sc_ptr != nullptr)
-    {
-        m_sc = *sc_ptr;
-        m_flags.Set(m_sc.GetResolvedMask());
-    }
+    : m_thread_wp(thread_sp), m_frame_index(frame_idx),
+      m_concrete_frame_index(unwind_frame_index), m_reg_context_sp(),
+      m_id(pc, cfa, nullptr), m_frame_code_addr(pc), m_sc(), m_flags(),
+      m_frame_base(), m_frame_base_error(), m_cfa_is_valid(cfa_is_valid),
+      m_stop_id(stop_id), m_stop_id_is_valid(stop_id_is_valid),
+      m_is_history_frame(is_history_frame), m_variable_list_sp(),
+      m_variable_list_value_objects(), m_disassembly(), m_mutex() {
+  // If we don't have a CFA value, use the frame index for our StackID so that
+  // recursive
+  // functions properly aren't confused with one another on a history stack.
+  if (m_is_history_frame && !m_cfa_is_valid) {
+    m_id.SetCFA(m_frame_index);
+  }
+
+  if (sc_ptr != nullptr) {
+    m_sc = *sc_ptr;
+    m_flags.Set(m_sc.GetResolvedMask());
+  }
 }
 
-StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx, user_id_t unwind_frame_index,
-                       const RegisterContextSP &reg_context_sp, addr_t cfa, addr_t pc, const SymbolContext *sc_ptr)
-    : m_thread_wp(thread_sp),
-      m_frame_index(frame_idx),
+StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
+                       user_id_t unwind_frame_index,
+                       const RegisterContextSP &reg_context_sp, addr_t cfa,
+                       addr_t pc, const SymbolContext *sc_ptr)
+    : m_thread_wp(thread_sp), m_frame_index(frame_idx),
       m_concrete_frame_index(unwind_frame_index),
-      m_reg_context_sp(reg_context_sp),
-      m_id(pc, cfa, nullptr),
-      m_frame_code_addr(pc),
-      m_sc(),
-      m_flags(),
-      m_frame_base(),
-      m_frame_base_error(),
-      m_cfa_is_valid(true),
-      m_stop_id(0),
-      m_stop_id_is_valid(false),
-      m_is_history_frame(false),
-      m_variable_list_sp(),
-      m_variable_list_value_objects(),
-      m_disassembly(),
-      m_mutex()
-{
-    if (sc_ptr != nullptr)
-    {
-        m_sc = *sc_ptr;
-        m_flags.Set(m_sc.GetResolvedMask());
-    }
-
-    if (reg_context_sp && !m_sc.target_sp)
-    {
-        m_sc.target_sp = reg_context_sp->CalculateTarget();
-        if (m_sc.target_sp)
-            m_flags.Set(eSymbolContextTarget);
-    }
+      m_reg_context_sp(reg_context_sp), m_id(pc, cfa, nullptr),
+      m_frame_code_addr(pc), m_sc(), m_flags(), m_frame_base(),
+      m_frame_base_error(), m_cfa_is_valid(true), m_stop_id(0),
+      m_stop_id_is_valid(false), m_is_history_frame(false),
+      m_variable_list_sp(), m_variable_list_value_objects(), m_disassembly(),
+      m_mutex() {
+  if (sc_ptr != nullptr) {
+    m_sc = *sc_ptr;
+    m_flags.Set(m_sc.GetResolvedMask());
+  }
+
+  if (reg_context_sp && !m_sc.target_sp) {
+    m_sc.target_sp = reg_context_sp->CalculateTarget();
+    if (m_sc.target_sp)
+      m_flags.Set(eSymbolContextTarget);
+  }
 }
 
-StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx, user_id_t unwind_frame_index,
-                       const RegisterContextSP &reg_context_sp, addr_t cfa, const Address &pc_addr,
-                       const SymbolContext *sc_ptr)
-    : m_thread_wp(thread_sp),
-      m_frame_index(frame_idx),
+StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
+                       user_id_t unwind_frame_index,
+                       const RegisterContextSP &reg_context_sp, addr_t cfa,
+                       const Address &pc_addr, const SymbolContext *sc_ptr)
+    : m_thread_wp(thread_sp), m_frame_index(frame_idx),
       m_concrete_frame_index(unwind_frame_index),
       m_reg_context_sp(reg_context_sp),
-      m_id(pc_addr.GetLoadAddress(thread_sp->CalculateTarget().get()), cfa, nullptr),
-      m_frame_code_addr(pc_addr),
-      m_sc(),
-      m_flags(),
-      m_frame_base(),
-      m_frame_base_error(),
-      m_cfa_is_valid(true),
-      m_stop_id(0),
-      m_stop_id_is_valid(false),
-      m_is_history_frame(false),
-      m_variable_list_sp(),
-      m_variable_list_value_objects(),
-      m_disassembly(),
-      m_mutex()
-{
-    if (sc_ptr != nullptr)
-    {
-        m_sc = *sc_ptr;
-        m_flags.Set(m_sc.GetResolvedMask());
-    }
-
-    if (!m_sc.target_sp && reg_context_sp)
-    {
-        m_sc.target_sp = reg_context_sp->CalculateTarget();
-        if (m_sc.target_sp)
-            m_flags.Set(eSymbolContextTarget);
-    }
-
-    ModuleSP pc_module_sp(pc_addr.GetModule());
-    if (!m_sc.module_sp || m_sc.module_sp != pc_module_sp)
-    {
-        if (pc_module_sp)
-        {
-            m_sc.module_sp = pc_module_sp;
-            m_flags.Set(eSymbolContextModule);
-        }
-        else
-        {
-            m_sc.module_sp.reset();
-        }
+      m_id(pc_addr.GetLoadAddress(thread_sp->CalculateTarget().get()), cfa,
+           nullptr),
+      m_frame_code_addr(pc_addr), m_sc(), m_flags(), m_frame_base(),
+      m_frame_base_error(), m_cfa_is_valid(true), m_stop_id(0),
+      m_stop_id_is_valid(false), m_is_history_frame(false),
+      m_variable_list_sp(), m_variable_list_value_objects(), m_disassembly(),
+      m_mutex() {
+  if (sc_ptr != nullptr) {
+    m_sc = *sc_ptr;
+    m_flags.Set(m_sc.GetResolvedMask());
+  }
+
+  if (!m_sc.target_sp && reg_context_sp) {
+    m_sc.target_sp = reg_context_sp->CalculateTarget();
+    if (m_sc.target_sp)
+      m_flags.Set(eSymbolContextTarget);
+  }
+
+  ModuleSP pc_module_sp(pc_addr.GetModule());
+  if (!m_sc.module_sp || m_sc.module_sp != pc_module_sp) {
+    if (pc_module_sp) {
+      m_sc.module_sp = pc_module_sp;
+      m_flags.Set(eSymbolContextModule);
+    } else {
+      m_sc.module_sp.reset();
     }
+  }
 }
 
 StackFrame::~StackFrame() = default;
 
-StackID&
-StackFrame::GetStackID()
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    // Make sure we have resolved the StackID object's symbol context scope if
-    // we already haven't looked it up.
-
-    if (m_flags.IsClear (RESOLVED_FRAME_ID_SYMBOL_SCOPE))
-    {
-        if (m_id.GetSymbolContextScope ())
-        {
-            // We already have a symbol context scope, we just don't have our
-            // flag bit set.
-            m_flags.Set (RESOLVED_FRAME_ID_SYMBOL_SCOPE);
-        }
-        else
-        {
-            // Calculate the frame block and use this for the stack ID symbol
-            // context scope if we have one.
-            SymbolContextScope *scope = GetFrameBlock (); 
-            if (scope == nullptr)
-            {
-                // We don't have a block, so use the symbol
-                if (m_flags.IsClear (eSymbolContextSymbol))
-                    GetSymbolContext (eSymbolContextSymbol);
-                
-                // It is ok if m_sc.symbol is nullptr here
-                scope = m_sc.symbol;
-            }
-            // Set the symbol context scope (the accessor will set the
-            // RESOLVED_FRAME_ID_SYMBOL_SCOPE bit in m_flags).
-            SetSymbolContextScope (scope);
-        }
+StackID &StackFrame::GetStackID() {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  // Make sure we have resolved the StackID object's symbol context scope if
+  // we already haven't looked it up.
+
+  if (m_flags.IsClear(RESOLVED_FRAME_ID_SYMBOL_SCOPE)) {
+    if (m_id.GetSymbolContextScope()) {
+      // We already have a symbol context scope, we just don't have our
+      // flag bit set.
+      m_flags.Set(RESOLVED_FRAME_ID_SYMBOL_SCOPE);
+    } else {
+      // Calculate the frame block and use this for the stack ID symbol
+      // context scope if we have one.
+      SymbolContextScope *scope = GetFrameBlock();
+      if (scope == nullptr) {
+        // We don't have a block, so use the symbol
+        if (m_flags.IsClear(eSymbolContextSymbol))
+          GetSymbolContext(eSymbolContextSymbol);
+
+        // It is ok if m_sc.symbol is nullptr here
+        scope = m_sc.symbol;
+      }
+      // Set the symbol context scope (the accessor will set the
+      // RESOLVED_FRAME_ID_SYMBOL_SCOPE bit in m_flags).
+      SetSymbolContextScope(scope);
     }
-    return m_id;
+  }
+  return m_id;
 }
 
-uint32_t
-StackFrame::GetFrameIndex () const
-{
-    ThreadSP thread_sp = GetThread();
-    if (thread_sp)
-        return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(m_frame_index);
-    else
-        return m_frame_index;
+uint32_t StackFrame::GetFrameIndex() const {
+  ThreadSP thread_sp = GetThread();
+  if (thread_sp)
+    return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(
+        m_frame_index);
+  else
+    return m_frame_index;
 }
 
-void
-StackFrame::SetSymbolContextScope (SymbolContextScope *symbol_scope)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    m_flags.Set (RESOLVED_FRAME_ID_SYMBOL_SCOPE);
-    m_id.SetSymbolContextScope (symbol_scope);
+void StackFrame::SetSymbolContextScope(SymbolContextScope *symbol_scope) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  m_flags.Set(RESOLVED_FRAME_ID_SYMBOL_SCOPE);
+  m_id.SetSymbolContextScope(symbol_scope);
 }
 
-const Address&
-StackFrame::GetFrameCodeAddress()
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    if (m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR) && !m_frame_code_addr.IsSectionOffset())
-    {
-        m_flags.Set (RESOLVED_FRAME_CODE_ADDR);
-
-        // Resolve the PC into a temporary address because if ResolveLoadAddress
-        // fails to resolve the address, it will clear the address object...
-        ThreadSP thread_sp (GetThread());
-        if (thread_sp)
-        {
-            TargetSP target_sp (thread_sp->CalculateTarget());
-            if (target_sp)
-            {
-                if (m_frame_code_addr.SetOpcodeLoadAddress (m_frame_code_addr.GetOffset(), target_sp.get(), eAddressClassCode))
-                {
-                    ModuleSP module_sp (m_frame_code_addr.GetModule());
-                    if (module_sp)
-                    {
-                        m_sc.module_sp = module_sp;
-                        m_flags.Set(eSymbolContextModule);
-                    }
-                }
-            }
+const Address &StackFrame::GetFrameCodeAddress() {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  if (m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR) &&
+      !m_frame_code_addr.IsSectionOffset()) {
+    m_flags.Set(RESOLVED_FRAME_CODE_ADDR);
+
+    // Resolve the PC into a temporary address because if ResolveLoadAddress
+    // fails to resolve the address, it will clear the address object...
+    ThreadSP thread_sp(GetThread());
+    if (thread_sp) {
+      TargetSP target_sp(thread_sp->CalculateTarget());
+      if (target_sp) {
+        if (m_frame_code_addr.SetOpcodeLoadAddress(
+                m_frame_code_addr.GetOffset(), target_sp.get(),
+                eAddressClassCode)) {
+          ModuleSP module_sp(m_frame_code_addr.GetModule());
+          if (module_sp) {
+            m_sc.module_sp = module_sp;
+            m_flags.Set(eSymbolContextModule);
+          }
         }
+      }
     }
-    return m_frame_code_addr;
+  }
+  return m_frame_code_addr;
 }
 
-bool
-StackFrame::ChangePC (addr_t pc)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    // We can't change the pc value of a history stack frame - it is immutable.
-    if (m_is_history_frame)
-        return false;
-    m_frame_code_addr.SetRawAddress(pc);
-    m_sc.Clear(false);
-    m_flags.Reset(0);
-    ThreadSP thread_sp (GetThread());
-    if (thread_sp)
-        thread_sp->ClearStackFrames ();
-    return true;
+bool StackFrame::ChangePC(addr_t pc) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  // We can't change the pc value of a history stack frame - it is immutable.
+  if (m_is_history_frame)
+    return false;
+  m_frame_code_addr.SetRawAddress(pc);
+  m_sc.Clear(false);
+  m_flags.Reset(0);
+  ThreadSP thread_sp(GetThread());
+  if (thread_sp)
+    thread_sp->ClearStackFrames();
+  return true;
 }
 
-const char *
-StackFrame::Disassemble ()
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    if (m_disassembly.GetSize() == 0)
-    {
-        ExecutionContext exe_ctx (shared_from_this());
-        Target *target = exe_ctx.GetTargetPtr();
-        if (target)
-        {
-            const char *plugin_name = nullptr;
-            const char *flavor = nullptr;
-            Disassembler::Disassemble (target->GetDebugger(),
-                                       target->GetArchitecture(),
-                                       plugin_name,
-                                       flavor,
-                                       exe_ctx,
-                                       0,
-                                       0,
-                                       0,
-                                       m_disassembly);
-        }
-        if (m_disassembly.GetSize() == 0)
-            return nullptr;
+const char *StackFrame::Disassemble() {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  if (m_disassembly.GetSize() == 0) {
+    ExecutionContext exe_ctx(shared_from_this());
+    Target *target = exe_ctx.GetTargetPtr();
+    if (target) {
+      const char *plugin_name = nullptr;
+      const char *flavor = nullptr;
+      Disassembler::Disassemble(target->GetDebugger(),
+                                target->GetArchitecture(), plugin_name, flavor,
+                                exe_ctx, 0, 0, 0, m_disassembly);
     }
-    return m_disassembly.GetData();
+    if (m_disassembly.GetSize() == 0)
+      return nullptr;
+  }
+  return m_disassembly.GetData();
 }
 
-Block *
-StackFrame::GetFrameBlock ()
-{
-    if (m_sc.block == nullptr && m_flags.IsClear(eSymbolContextBlock))
-        GetSymbolContext (eSymbolContextBlock);
-
-    if (m_sc.block)
-    {    
-        Block *inline_block = m_sc.block->GetContainingInlinedBlock();
-        if (inline_block)
-        {
-            // Use the block with the inlined function info
-            // as the frame block we want this frame to have only the variables
-            // for the inlined function and its non-inlined block child blocks.
-            return inline_block;
-        }
-        else
-        {
-            // This block is not contained within any inlined function blocks
-            // with so we want to use the top most function block.
-            return &m_sc.function->GetBlock (false);
-        }
-    }    
-    return nullptr;
+Block *StackFrame::GetFrameBlock() {
+  if (m_sc.block == nullptr && m_flags.IsClear(eSymbolContextBlock))
+    GetSymbolContext(eSymbolContextBlock);
+
+  if (m_sc.block) {
+    Block *inline_block = m_sc.block->GetContainingInlinedBlock();
+    if (inline_block) {
+      // Use the block with the inlined function info
+      // as the frame block we want this frame to have only the variables
+      // for the inlined function and its non-inlined block child blocks.
+      return inline_block;
+    } else {
+      // This block is not contained within any inlined function blocks
+      // with so we want to use the top most function block.
+      return &m_sc.function->GetBlock(false);
+    }
+  }
+  return nullptr;
 }
 
 //----------------------------------------------------------------------
@@ -331,1840 +263,1658 @@ StackFrame::GetFrameBlock ()
 // StackFrame object, everyone will have as much information as
 // possible and no one will ever have to look things up manually.
 //----------------------------------------------------------------------
-const SymbolContext&
-StackFrame::GetSymbolContext (uint32_t resolve_scope)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    // Copy our internal symbol context into "sc".
-    if ((m_flags.Get() & resolve_scope) != resolve_scope)
-    {
-        uint32_t resolved = 0;
-
-        // If the target was requested add that:
-        if (!m_sc.target_sp)
-        {
-            m_sc.target_sp = CalculateTarget();
-            if (m_sc.target_sp)
-                resolved |= eSymbolContextTarget;
-        }
-        
-        // Resolve our PC to section offset if we haven't already done so
-        // and if we don't have a module. The resolved address section will
-        // contain the module to which it belongs
-        if (!m_sc.module_sp && m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR))
-            GetFrameCodeAddress();
-
-        // If this is not frame zero, then we need to subtract 1 from the PC
-        // value when doing address lookups since the PC will be on the 
-        // instruction following the function call instruction...
-        
-        Address lookup_addr(GetFrameCodeAddress());
-        if (m_frame_index > 0 && lookup_addr.IsValid())
-        {
-            addr_t offset = lookup_addr.GetOffset();
-            if (offset > 0)
-            {
-                lookup_addr.SetOffset(offset - 1);
+const SymbolContext &StackFrame::GetSymbolContext(uint32_t resolve_scope) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  // Copy our internal symbol context into "sc".
+  if ((m_flags.Get() & resolve_scope) != resolve_scope) {
+    uint32_t resolved = 0;
+
+    // If the target was requested add that:
+    if (!m_sc.target_sp) {
+      m_sc.target_sp = CalculateTarget();
+      if (m_sc.target_sp)
+        resolved |= eSymbolContextTarget;
+    }
 
-            }
-            else
-            {
-                // lookup_addr is the start of a section.  We need
-                // do the math on the actual load address and re-compute
-                // the section.  We're working with a 'noreturn' function
-                // at the end of a section.
-                ThreadSP thread_sp (GetThread());
-                if (thread_sp)
-                {
-                    TargetSP target_sp (thread_sp->CalculateTarget());
-                    if (target_sp)
-                    {
-                        addr_t addr_minus_one = lookup_addr.GetLoadAddress(target_sp.get()) - 1;
-                        lookup_addr.SetLoadAddress (addr_minus_one, target_sp.get());
-                    }
-                    else
-                    {
-                    lookup_addr.SetOffset(offset - 1);
-                    }
-                }
-            }
+    // Resolve our PC to section offset if we haven't already done so
+    // and if we don't have a module. The resolved address section will
+    // contain the module to which it belongs
+    if (!m_sc.module_sp && m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR))
+      GetFrameCodeAddress();
+
+    // If this is not frame zero, then we need to subtract 1 from the PC
+    // value when doing address lookups since the PC will be on the
+    // instruction following the function call instruction...
+
+    Address lookup_addr(GetFrameCodeAddress());
+    if (m_frame_index > 0 && lookup_addr.IsValid()) {
+      addr_t offset = lookup_addr.GetOffset();
+      if (offset > 0) {
+        lookup_addr.SetOffset(offset - 1);
+
+      } else {
+        // lookup_addr is the start of a section.  We need
+        // do the math on the actual load address and re-compute
+        // the section.  We're working with a 'noreturn' function
+        // at the end of a section.
+        ThreadSP thread_sp(GetThread());
+        if (thread_sp) {
+          TargetSP target_sp(thread_sp->CalculateTarget());
+          if (target_sp) {
+            addr_t addr_minus_one =
+                lookup_addr.GetLoadAddress(target_sp.get()) - 1;
+            lookup_addr.SetLoadAddress(addr_minus_one, target_sp.get());
+          } else {
+            lookup_addr.SetOffset(offset - 1);
+          }
         }
+      }
+    }
 
-        if (m_sc.module_sp)
-        {
-            // We have something in our stack frame symbol context, lets check
-            // if we haven't already tried to lookup one of those things. If we
-            // haven't then we will do the query.
-            
-            uint32_t actual_resolve_scope = 0;
-            
-            if (resolve_scope & eSymbolContextCompUnit)
-            {
-                if (m_flags.IsClear (eSymbolContextCompUnit))
-                {
-                    if (m_sc.comp_unit)
-                        resolved |= eSymbolContextCompUnit;
-                    else
-                        actual_resolve_scope |= eSymbolContextCompUnit;
-                }
-            }
-
-            if (resolve_scope & eSymbolContextFunction)
-            {
-                if (m_flags.IsClear (eSymbolContextFunction))
-                {
-                    if (m_sc.function)
-                        resolved |= eSymbolContextFunction;
-                    else
-                        actual_resolve_scope |= eSymbolContextFunction;
-                }
-            }
-
-            if (resolve_scope & eSymbolContextBlock)
-            {
-                if (m_flags.IsClear (eSymbolContextBlock))
-                {
-                    if (m_sc.block)
-                        resolved |= eSymbolContextBlock;
-                    else
-                        actual_resolve_scope |= eSymbolContextBlock;
-                }
-            }
+    if (m_sc.module_sp) {
+      // We have something in our stack frame symbol context, lets check
+      // if we haven't already tried to lookup one of those things. If we
+      // haven't then we will do the query.
 
-            if (resolve_scope & eSymbolContextSymbol)
-            {
-                if (m_flags.IsClear (eSymbolContextSymbol))
-                {
-                    if (m_sc.symbol)
-                        resolved |= eSymbolContextSymbol;
-                    else
-                        actual_resolve_scope |= eSymbolContextSymbol;
-                }
-            }
+      uint32_t actual_resolve_scope = 0;
 
-            if (resolve_scope & eSymbolContextLineEntry)
-            {
-                if (m_flags.IsClear (eSymbolContextLineEntry))
-                {
-                    if (m_sc.line_entry.IsValid())
-                        resolved |= eSymbolContextLineEntry;
-                    else
-                        actual_resolve_scope |= eSymbolContextLineEntry;
-                }
-            }
-            
-            if (actual_resolve_scope)
-            {
-                // We might be resolving less information than what is already
-                // in our current symbol context so resolve into a temporary 
-                // symbol context "sc" so we don't clear out data we have 
-                // already found in "m_sc"
-                SymbolContext sc;
-                // Set flags that indicate what we have tried to resolve
-                resolved |= m_sc.module_sp->ResolveSymbolContextForAddress (lookup_addr, actual_resolve_scope, sc);
-                // Only replace what we didn't already have as we may have 
-                // information for an inlined function scope that won't match
-                // what a standard lookup by address would match
-                if ((resolved & eSymbolContextCompUnit)  && m_sc.comp_unit == nullptr)  
-                    m_sc.comp_unit = sc.comp_unit;
-                if ((resolved & eSymbolContextFunction)  && m_sc.function == nullptr)  
-                    m_sc.function = sc.function;
-                if ((resolved & eSymbolContextBlock)     && m_sc.block == nullptr)  
-                    m_sc.block = sc.block;
-                if ((resolved & eSymbolContextSymbol)    && m_sc.symbol == nullptr)  
-                    m_sc.symbol = sc.symbol;
-                if ((resolved & eSymbolContextLineEntry) && !m_sc.line_entry.IsValid())
-                {
-                    m_sc.line_entry = sc.line_entry;
-                    m_sc.line_entry.ApplyFileMappings(m_sc.target_sp);
-                }
-            }
+      if (resolve_scope & eSymbolContextCompUnit) {
+        if (m_flags.IsClear(eSymbolContextCompUnit)) {
+          if (m_sc.comp_unit)
+            resolved |= eSymbolContextCompUnit;
+          else
+            actual_resolve_scope |= eSymbolContextCompUnit;
         }
-        else
-        {
-            // If we don't have a module, then we can't have the compile unit,
-            // function, block, line entry or symbol, so we can safely call
-            // ResolveSymbolContextForAddress with our symbol context member m_sc.
-            if (m_sc.target_sp)
-            {
-                resolved |= m_sc.target_sp->GetImages().ResolveSymbolContextForAddress (lookup_addr, resolve_scope, m_sc);
-            }
+      }
+
+      if (resolve_scope & eSymbolContextFunction) {
+        if (m_flags.IsClear(eSymbolContextFunction)) {
+          if (m_sc.function)
+            resolved |= eSymbolContextFunction;
+          else
+            actual_resolve_scope |= eSymbolContextFunction;
         }
-
-        // Update our internal flags so we remember what we have tried to locate so
-        // we don't have to keep trying when more calls to this function are made.
-        // We might have dug up more information that was requested (for example
-        // if we were asked to only get the block, we will have gotten the 
-        // compile unit, and function) so set any additional bits that we resolved
-        m_flags.Set (resolve_scope | resolved);
+      }
+
+      if (resolve_scope & eSymbolContextBlock) {
+        if (m_flags.IsClear(eSymbolContextBlock)) {
+          if (m_sc.block)
+            resolved |= eSymbolContextBlock;
+          else
+            actual_resolve_scope |= eSymbolContextBlock;
+        }
+      }
+
+      if (resolve_scope & eSymbolContextSymbol) {
+        if (m_flags.IsClear(eSymbolContextSymbol)) {
+          if (m_sc.symbol)
+            resolved |= eSymbolContextSymbol;
+          else
+            actual_resolve_scope |= eSymbolContextSymbol;
+        }
+      }
+
+      if (resolve_scope & eSymbolContextLineEntry) {
+        if (m_flags.IsClear(eSymbolContextLineEntry)) {
+          if (m_sc.line_entry.IsValid())
+            resolved |= eSymbolContextLineEntry;
+          else
+            actual_resolve_scope |= eSymbolContextLineEntry;
+        }
+      }
+
+      if (actual_resolve_scope) {
+        // We might be resolving less information than what is already
+        // in our current symbol context so resolve into a temporary
+        // symbol context "sc" so we don't clear out data we have
+        // already found in "m_sc"
+        SymbolContext sc;
+        // Set flags that indicate what we have tried to resolve
+        resolved |= m_sc.module_sp->ResolveSymbolContextForAddress(
+            lookup_addr, actual_resolve_scope, sc);
+        // Only replace what we didn't already have as we may have
+        // information for an inlined function scope that won't match
+        // what a standard lookup by address would match
+        if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == nullptr)
+          m_sc.comp_unit = sc.comp_unit;
+        if ((resolved & eSymbolContextFunction) && m_sc.function == nullptr)
+          m_sc.function = sc.function;
+        if ((resolved & eSymbolContextBlock) && m_sc.block == nullptr)
+          m_sc.block = sc.block;
+        if ((resolved & eSymbolContextSymbol) && m_sc.symbol == nullptr)
+          m_sc.symbol = sc.symbol;
+        if ((resolved & eSymbolContextLineEntry) &&
+            !m_sc.line_entry.IsValid()) {
+          m_sc.line_entry = sc.line_entry;
+          m_sc.line_entry.ApplyFileMappings(m_sc.target_sp);
+        }
+      }
+    } else {
+      // If we don't have a module, then we can't have the compile unit,
+      // function, block, line entry or symbol, so we can safely call
+      // ResolveSymbolContextForAddress with our symbol context member m_sc.
+      if (m_sc.target_sp) {
+        resolved |= m_sc.target_sp->GetImages().ResolveSymbolContextForAddress(
+            lookup_addr, resolve_scope, m_sc);
+      }
     }
 
-    // Return the symbol context with everything that was possible to resolve
-    // resolved.
-    return m_sc;
+    // Update our internal flags so we remember what we have tried to locate so
+    // we don't have to keep trying when more calls to this function are made.
+    // We might have dug up more information that was requested (for example
+    // if we were asked to only get the block, we will have gotten the
+    // compile unit, and function) so set any additional bits that we resolved
+    m_flags.Set(resolve_scope | resolved);
+  }
+
+  // Return the symbol context with everything that was possible to resolve
+  // resolved.
+  return m_sc;
 }
 
-VariableList *
-StackFrame::GetVariableList (bool get_file_globals)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    if (m_flags.IsClear(RESOLVED_VARIABLES))
-    {
-        m_flags.Set(RESOLVED_VARIABLES);
-
-        Block *frame_block = GetFrameBlock();
-        
-        if (frame_block)
-        {
-            const bool get_child_variables = true;
-            const bool can_create = true;
-            const bool stop_if_child_block_is_inlined_function = true;
-            m_variable_list_sp.reset(new VariableList());
-            frame_block->AppendBlockVariables(can_create,
-                                              get_child_variables,
-                                              stop_if_child_block_is_inlined_function,
-                                              [this](Variable* v) { return true; },
-                                              m_variable_list_sp.get());
-        }
+VariableList *StackFrame::GetVariableList(bool get_file_globals) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  if (m_flags.IsClear(RESOLVED_VARIABLES)) {
+    m_flags.Set(RESOLVED_VARIABLES);
+
+    Block *frame_block = GetFrameBlock();
+
+    if (frame_block) {
+      const bool get_child_variables = true;
+      const bool can_create = true;
+      const bool stop_if_child_block_is_inlined_function = true;
+      m_variable_list_sp.reset(new VariableList());
+      frame_block->AppendBlockVariables(can_create, get_child_variables,
+                                        stop_if_child_block_is_inlined_function,
+                                        [this](Variable *v) { return true; },
+                                        m_variable_list_sp.get());
     }
-    
-    if (m_flags.IsClear(RESOLVED_GLOBAL_VARIABLES) &&
-        get_file_globals)
-    {
-        m_flags.Set(RESOLVED_GLOBAL_VARIABLES);
-        
-        if (m_flags.IsClear (eSymbolContextCompUnit))
-            GetSymbolContext (eSymbolContextCompUnit);
-        
-        if (m_sc.comp_unit)
-        {
-            VariableListSP global_variable_list_sp (m_sc.comp_unit->GetVariableList(true));
-            if (m_variable_list_sp)
-                m_variable_list_sp->AddVariables (global_variable_list_sp.get());
-            else
-                m_variable_list_sp = global_variable_list_sp;
-        }
+  }
+
+  if (m_flags.IsClear(RESOLVED_GLOBAL_VARIABLES) && get_file_globals) {
+    m_flags.Set(RESOLVED_GLOBAL_VARIABLES);
+
+    if (m_flags.IsClear(eSymbolContextCompUnit))
+      GetSymbolContext(eSymbolContextCompUnit);
+
+    if (m_sc.comp_unit) {
+      VariableListSP global_variable_list_sp(
+          m_sc.comp_unit->GetVariableList(true));
+      if (m_variable_list_sp)
+        m_variable_list_sp->AddVariables(global_variable_list_sp.get());
+      else
+        m_variable_list_sp = global_variable_list_sp;
     }
-    
-    return m_variable_list_sp.get();
+  }
+
+  return m_variable_list_sp.get();
 }
 
 VariableListSP
-StackFrame::GetInScopeVariableList (bool get_file_globals, bool must_have_valid_location)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    // We can't fetch variable information for a history stack frame.
-    if (m_is_history_frame)
-        return VariableListSP();
-
-    VariableListSP var_list_sp(new VariableList);
-    GetSymbolContext (eSymbolContextCompUnit | eSymbolContextBlock);
-
-    if (m_sc.block)
-    {
-        const bool can_create = true;
-        const bool get_parent_variables = true;
-        const bool stop_if_block_is_inlined_function = true;
-        m_sc.block->AppendVariables (can_create, 
-                                     get_parent_variables,
-                                     stop_if_block_is_inlined_function,
-                                     [this, must_have_valid_location](Variable* v)
-                                     {
-                                         return v->IsInScope(this) && (!must_have_valid_location || v->LocationIsValidForFrame(this));
-                                     },
-                                     var_list_sp.get());
-    }
-                     
-    if (m_sc.comp_unit && get_file_globals)
-    {
-        VariableListSP global_variable_list_sp (m_sc.comp_unit->GetVariableList(true));
-        if (global_variable_list_sp)
-            var_list_sp->AddVariables (global_variable_list_sp.get());
-    }
-    
-    return var_list_sp;
+StackFrame::GetInScopeVariableList(bool get_file_globals,
+                                   bool must_have_valid_location) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  // We can't fetch variable information for a history stack frame.
+  if (m_is_history_frame)
+    return VariableListSP();
+
+  VariableListSP var_list_sp(new VariableList);
+  GetSymbolContext(eSymbolContextCompUnit | eSymbolContextBlock);
+
+  if (m_sc.block) {
+    const bool can_create = true;
+    const bool get_parent_variables = true;
+    const bool stop_if_block_is_inlined_function = true;
+    m_sc.block->AppendVariables(
+        can_create, get_parent_variables, stop_if_block_is_inlined_function,
+        [this, must_have_valid_location](Variable *v) {
+          return v->IsInScope(this) && (!must_have_valid_location ||
+                                        v->LocationIsValidForFrame(this));
+        },
+        var_list_sp.get());
+  }
+
+  if (m_sc.comp_unit && get_file_globals) {
+    VariableListSP global_variable_list_sp(
+        m_sc.comp_unit->GetVariableList(true));
+    if (global_variable_list_sp)
+      var_list_sp->AddVariables(global_variable_list_sp.get());
+  }
+
+  return var_list_sp;
 }
 
-ValueObjectSP
-StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr,
-                                               DynamicValueType use_dynamic,
-                                               uint32_t options, 
-                                               VariableSP &var_sp,
-                                               Error &error)
-{
-    // We can't fetch variable information for a history stack frame.
-    if (m_is_history_frame)
-        return ValueObjectSP();
+ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
+    const char *var_expr_cstr, DynamicValueType use_dynamic, uint32_t options,
+    VariableSP &var_sp, Error &error) {
+  // We can't fetch variable information for a history stack frame.
+  if (m_is_history_frame)
+    return ValueObjectSP();
 
-    if (var_expr_cstr && var_expr_cstr[0])
-    {
-        const bool check_ptr_vs_member = (options & eExpressionPathOptionCheckPtrVsMember) != 0;
-        const bool no_fragile_ivar = (options & eExpressionPathOptionsNoFragileObjcIvar) != 0;
-        const bool no_synth_child = (options & eExpressionPathOptionsNoSyntheticChildren) != 0;
-        //const bool no_synth_array = (options & eExpressionPathOptionsNoSyntheticArrayRange) != 0;
-        error.Clear();
-        bool deref = false;
-        bool address_of = false;
-        ValueObjectSP valobj_sp;
-        const bool get_file_globals = true;
-        // When looking up a variable for an expression, we need only consider the
-        // variables that are in scope.
-        VariableListSP var_list_sp (GetInScopeVariableList (get_file_globals));
-        VariableList *variable_list = var_list_sp.get();
-        
-        if (variable_list)
-        {
-            // If first character is a '*', then show pointer contents
-            const char *var_expr = var_expr_cstr;
-            if (var_expr[0] == '*')
-            {
-                deref = true;
-                var_expr++; // Skip the '*'
+  if (var_expr_cstr && var_expr_cstr[0]) {
+    const bool check_ptr_vs_member =
+        (options & eExpressionPathOptionCheckPtrVsMember) != 0;
+    const bool no_fragile_ivar =
+        (options & eExpressionPathOptionsNoFragileObjcIvar) != 0;
+    const bool no_synth_child =
+        (options & eExpressionPathOptionsNoSyntheticChildren) != 0;
+    // const bool no_synth_array = (options &
+    // eExpressionPathOptionsNoSyntheticArrayRange) != 0;
+    error.Clear();
+    bool deref = false;
+    bool address_of = false;
+    ValueObjectSP valobj_sp;
+    const bool get_file_globals = true;
+    // When looking up a variable for an expression, we need only consider the
+    // variables that are in scope.
+    VariableListSP var_list_sp(GetInScopeVariableList(get_file_globals));
+    VariableList *variable_list = var_list_sp.get();
+
+    if (variable_list) {
+      // If first character is a '*', then show pointer contents
+      const char *var_expr = var_expr_cstr;
+      if (var_expr[0] == '*') {
+        deref = true;
+        var_expr++; // Skip the '*'
+      } else if (var_expr[0] == '&') {
+        address_of = true;
+        var_expr++; // Skip the '&'
+      }
+
+      std::string var_path(var_expr);
+      size_t separator_idx = var_path.find_first_of(".-[=+~|&^%#@!/?,<>{}");
+      StreamString var_expr_path_strm;
+
+      ConstString name_const_string;
+      if (separator_idx == std::string::npos)
+        name_const_string.SetCString(var_path.c_str());
+      else
+        name_const_string.SetCStringWithLength(var_path.c_str(), separator_idx);
+
+      var_sp = variable_list->FindVariable(name_const_string, false);
+
+      bool synthetically_added_instance_object = false;
+
+      if (var_sp) {
+        var_path.erase(0, name_const_string.GetLength());
+      }
+
+      if (!var_sp && (options & eExpressionPathOptionsAllowDirectIVarAccess)) {
+        // Check for direct ivars access which helps us with implicit
+        // access to ivars with the "this->" or "self->"
+        GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock);
+        lldb::LanguageType method_language = eLanguageTypeUnknown;
+        bool is_instance_method = false;
+        ConstString method_object_name;
+        if (m_sc.GetFunctionMethodInfo(method_language, is_instance_method,
+                                       method_object_name)) {
+          if (is_instance_method && method_object_name) {
+            var_sp = variable_list->FindVariable(method_object_name);
+            if (var_sp) {
+              separator_idx = 0;
+              var_path.insert(0, "->");
+              synthetically_added_instance_object = true;
             }
-            else if (var_expr[0] == '&')
-            {
-                address_of = true;
-                var_expr++; // Skip the '&'
+          }
+        }
+      }
+
+      if (!var_sp && (options & eExpressionPathOptionsInspectAnonymousUnions)) {
+        // Check if any anonymous unions are there which contain a variable with
+        // the name we need
+        for (size_t i = 0; i < variable_list->GetSize(); i++) {
+          if (VariableSP variable_sp = variable_list->GetVariableAtIndex(i)) {
+            if (variable_sp->GetName().IsEmpty()) {
+              if (Type *var_type = variable_sp->GetType()) {
+                if (var_type->GetForwardCompilerType().IsAnonymousType()) {
+                  valobj_sp =
+                      GetValueObjectForFrameVariable(variable_sp, use_dynamic);
+                  if (!valobj_sp)
+                    return valobj_sp;
+                  valobj_sp = valobj_sp->GetChildMemberWithName(
+                      name_const_string, true);
+                  if (valobj_sp)
+                    break;
+                }
+              }
             }
-
-            std::string var_path (var_expr);
-            size_t separator_idx = var_path.find_first_of(".-[=+~|&^%#@!/?,<>{}");
-            StreamString var_expr_path_strm;
-
-            ConstString name_const_string;
+          }
+        }
+      }
+
+      if (var_sp && !valobj_sp) {
+        valobj_sp = GetValueObjectForFrameVariable(var_sp, use_dynamic);
+        if (!valobj_sp)
+          return valobj_sp;
+      }
+      if (valobj_sp) {
+        // We are dumping at least one child
+        while (separator_idx != std::string::npos) {
+          // Calculate the next separator index ahead of time
+          ValueObjectSP child_valobj_sp;
+          const char separator_type = var_path[0];
+          switch (separator_type) {
+          case '-':
+            if (var_path.size() >= 2 && var_path[1] != '>')
+              return ValueObjectSP();
+
+            if (no_fragile_ivar) {
+              // Make sure we aren't trying to deref an objective
+              // C ivar if this is not allowed
+              const uint32_t pointer_type_flags =
+                  valobj_sp->GetCompilerType().GetTypeInfo(nullptr);
+              if ((pointer_type_flags & eTypeIsObjC) &&
+                  (pointer_type_flags & eTypeIsPointer)) {
+                // This was an objective C object pointer and
+                // it was requested we skip any fragile ivars
+                // so return nothing here
+                return ValueObjectSP();
+              }
+            }
+            var_path.erase(0, 1); // Remove the '-'
+            LLVM_FALLTHROUGH;
+          case '.': {
+            const bool expr_is_ptr = var_path[0] == '>';
+
+            var_path.erase(0, 1); // Remove the '.' or '>'
+            separator_idx = var_path.find_first_of(".-[");
+            ConstString child_name;
             if (separator_idx == std::string::npos)
-                name_const_string.SetCString (var_path.c_str());
+              child_name.SetCString(var_path.c_str());
             else
-                name_const_string.SetCStringWithLength (var_path.c_str(), separator_idx);
-
-            var_sp = variable_list->FindVariable(name_const_string, false);
-            
-            bool synthetically_added_instance_object = false;
-
-            if (var_sp)
-            {
-                var_path.erase (0, name_const_string.GetLength ());
+              child_name.SetCStringWithLength(var_path.c_str(), separator_idx);
+
+            if (check_ptr_vs_member) {
+              // We either have a pointer type and need to verify
+              // valobj_sp is a pointer, or we have a member of a
+              // class/union/struct being accessed with the . syntax
+              // and need to verify we don't have a pointer.
+              const bool actual_is_ptr = valobj_sp->IsPointerType();
+
+              if (actual_is_ptr != expr_is_ptr) {
+                // Incorrect use of "." with a pointer, or "->" with
+                // a class/union/struct instance or reference.
+                valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                if (actual_is_ptr)
+                  error.SetErrorStringWithFormat(
+                      "\"%s\" is a pointer and . was used to attempt to access "
+                      "\"%s\". Did you mean \"%s->%s\"?",
+                      var_expr_path_strm.GetString().c_str(),
+                      child_name.GetCString(),
+                      var_expr_path_strm.GetString().c_str(), var_path.c_str());
+                else
+                  error.SetErrorStringWithFormat(
+                      "\"%s\" is not a pointer and -> was used to attempt to "
+                      "access \"%s\". Did you mean \"%s.%s\"?",
+                      var_expr_path_strm.GetString().c_str(),
+                      child_name.GetCString(),
+                      var_expr_path_strm.GetString().c_str(), var_path.c_str());
+                return ValueObjectSP();
+              }
             }
-            
-            if (!var_sp && (options & eExpressionPathOptionsAllowDirectIVarAccess))
-            {
-                // Check for direct ivars access which helps us with implicit
-                // access to ivars with the "this->" or "self->"
-                GetSymbolContext(eSymbolContextFunction|eSymbolContextBlock);
-                lldb::LanguageType method_language = eLanguageTypeUnknown;
-                bool is_instance_method = false;
-                ConstString method_object_name;
-                if (m_sc.GetFunctionMethodInfo (method_language, is_instance_method, method_object_name))
-                {
-                    if (is_instance_method && method_object_name)
-                    {
-                        var_sp = variable_list->FindVariable(method_object_name);
-                        if (var_sp)
-                        {
-                            separator_idx = 0;
-                            var_path.insert(0, "->");
-                            synthetically_added_instance_object = true;
-                        }
-                    }
+            child_valobj_sp =
+                valobj_sp->GetChildMemberWithName(child_name, true);
+            if (!child_valobj_sp) {
+              if (!no_synth_child) {
+                child_valobj_sp = valobj_sp->GetSyntheticValue();
+                if (child_valobj_sp)
+                  child_valobj_sp =
+                      child_valobj_sp->GetChildMemberWithName(child_name, true);
+              }
+
+              if (no_synth_child || !child_valobj_sp) {
+                // No child member with name "child_name"
+                if (synthetically_added_instance_object) {
+                  // We added a "this->" or "self->" to the beginning of the
+                  // expression
+                  // and this is the first pointer ivar access, so just return
+                  // the normal
+                  // error
+                  error.SetErrorStringWithFormat(
+                      "no variable or instance variable named '%s' found in "
+                      "this frame",
+                      name_const_string.GetCString());
+                } else {
+                  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                  if (child_name) {
+                    error.SetErrorStringWithFormat(
+                        "\"%s\" is not a member of \"(%s) %s\"",
+                        child_name.GetCString(),
+                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                        var_expr_path_strm.GetString().c_str());
+                  } else {
+                    error.SetErrorStringWithFormat(
+                        "incomplete expression path after \"%s\" in \"%s\"",
+                        var_expr_path_strm.GetString().c_str(), var_expr_cstr);
+                  }
                 }
+                return ValueObjectSP();
+              }
             }
-            
-            if (!var_sp && (options & eExpressionPathOptionsInspectAnonymousUnions))
-            {
-                // Check if any anonymous unions are there which contain a variable with the name we need
-                for (size_t i = 0;
-                     i < variable_list->GetSize();
-                     i++)
-                {
-                    if (VariableSP variable_sp = variable_list->GetVariableAtIndex(i))
-                    {
-                        if (variable_sp->GetName().IsEmpty())
-                        {
-                            if (Type *var_type = variable_sp->GetType())
-                            {
-                                if (var_type->GetForwardCompilerType().IsAnonymousType())
-                                {
-                                    valobj_sp = GetValueObjectForFrameVariable (variable_sp, use_dynamic);
-                                    if (!valobj_sp)
-                                        return valobj_sp;
-                                    valobj_sp = valobj_sp->GetChildMemberWithName(name_const_string, true);
-                                    if (valobj_sp)
-                                        break;
-                                }
-                            }
-                        }
-                    }
-                }
+            synthetically_added_instance_object = false;
+            // Remove the child name from the path
+            var_path.erase(0, child_name.GetLength());
+            if (use_dynamic != eNoDynamicValues) {
+              ValueObjectSP dynamic_value_sp(
+                  child_valobj_sp->GetDynamicValue(use_dynamic));
+              if (dynamic_value_sp)
+                child_valobj_sp = dynamic_value_sp;
             }
+          } break;
 
-            if (var_sp && !valobj_sp)
+          case '[':
+            // Array member access, or treating pointer as an array
+            if (var_path.size() > 2) // Need at least two brackets and a number
             {
-                valobj_sp = GetValueObjectForFrameVariable (var_sp, use_dynamic);
-                if (!valobj_sp)
-                    return valobj_sp;
-            }
-            if (valobj_sp)
-            {
-                // We are dumping at least one child
-                while (separator_idx != std::string::npos)
-                {
-                    // Calculate the next separator index ahead of time
-                    ValueObjectSP child_valobj_sp;
-                    const char separator_type = var_path[0];
-                    switch (separator_type)
+              char *end = nullptr;
+              long child_index = ::strtol(&var_path[1], &end, 0);
+              if (end && *end == ']' &&
+                  *(end - 1) != '[') // this code forces an error in the case of
+                                     // arr[]. as bitfield[] is not a good
+                                     // syntax we're good to go
+              {
+                if (valobj_sp->GetCompilerType().IsPointerToScalarType() &&
+                    deref) {
+                  // what we have is *ptr[low]. the most similar C++ syntax is
+                  // to deref ptr
+                  // and extract bit low out of it. reading array item low
+                  // would be done by saying ptr[low], without a deref * sign
+                  Error error;
+                  ValueObjectSP temp(valobj_sp->Dereference(error));
+                  if (error.Fail()) {
+                    valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                    error.SetErrorStringWithFormat(
+                        "could not dereference \"(%s) %s\"",
+                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                        var_expr_path_strm.GetString().c_str());
+                    return ValueObjectSP();
+                  }
+                  valobj_sp = temp;
+                  deref = false;
+                } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() &&
+                           deref) {
+                  // what we have is *arr[low]. the most similar C++ syntax is
+                  // to get arr[0]
+                  // (an operation that is equivalent to deref-ing arr)
+                  // and extract bit low out of it. reading array item low
+                  // would be done by saying arr[low], without a deref * sign
+                  Error error;
+                  ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
+                  if (error.Fail()) {
+                    valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                    error.SetErrorStringWithFormat(
+                        "could not get item 0 for \"(%s) %s\"",
+                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                        var_expr_path_strm.GetString().c_str());
+                    return ValueObjectSP();
+                  }
+                  valobj_sp = temp;
+                  deref = false;
+                }
+
+                bool is_incomplete_array = false;
+                if (valobj_sp->IsPointerType()) {
+                  bool is_objc_pointer = true;
+
+                  if (valobj_sp->GetCompilerType().GetMinimumLanguage() !=
+                      eLanguageTypeObjC)
+                    is_objc_pointer = false;
+                  else if (!valobj_sp->GetCompilerType().IsPointerType())
+                    is_objc_pointer = false;
+
+                  if (no_synth_child && is_objc_pointer) {
+                    error.SetErrorStringWithFormat(
+                        "\"(%s) %s\" is an Objective-C pointer, and cannot be "
+                        "subscripted",
+                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                        var_expr_path_strm.GetString().c_str());
+
+                    return ValueObjectSP();
+                  } else if (is_objc_pointer) {
+                    // dereferencing ObjC variables is not valid.. so let's try
+                    // and recur to synthetic children
+                    ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
+                    if (!synthetic                 /* no synthetic */
+                        || synthetic == valobj_sp) /* synthetic is the same as
+                                                      the original object */
                     {
-                    case '-':
-                        if (var_path.size() >= 2 && var_path[1] != '>')
-                            return ValueObjectSP();
-
-                        if (no_fragile_ivar)
-                        {
-                            // Make sure we aren't trying to deref an objective
-                            // C ivar if this is not allowed
-                            const uint32_t pointer_type_flags = valobj_sp->GetCompilerType().GetTypeInfo(nullptr);
-                            if ((pointer_type_flags & eTypeIsObjC) &&
-                                (pointer_type_flags & eTypeIsPointer))
-                            {
-                                // This was an objective C object pointer and 
-                                // it was requested we skip any fragile ivars
-                                // so return nothing here
-                                return ValueObjectSP();
-                            }
-                        }
-                        var_path.erase (0, 1); // Remove the '-'
-                        LLVM_FALLTHROUGH;
-                    case '.':
-                        {
-                            const bool expr_is_ptr = var_path[0] == '>';
-
-                            var_path.erase (0, 1); // Remove the '.' or '>'
-                            separator_idx = var_path.find_first_of(".-[");
-                            ConstString child_name;
-                            if (separator_idx == std::string::npos)
-                                child_name.SetCString (var_path.c_str());
-                            else
-                                child_name.SetCStringWithLength(var_path.c_str(), separator_idx);
-
-                            if (check_ptr_vs_member)
-                            {
-                                // We either have a pointer type and need to verify 
-                                // valobj_sp is a pointer, or we have a member of a 
-                                // class/union/struct being accessed with the . syntax 
-                                // and need to verify we don't have a pointer.
-                                const bool actual_is_ptr = valobj_sp->IsPointerType ();
-                                
-                                if (actual_is_ptr != expr_is_ptr)
-                                {
-                                    // Incorrect use of "." with a pointer, or "->" with
-                                    // a class/union/struct instance or reference.
-                                    valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                    if (actual_is_ptr)
-                                        error.SetErrorStringWithFormat ("\"%s\" is a pointer and . was used to attempt to access \"%s\". Did you mean \"%s->%s\"?", 
-                                                                        var_expr_path_strm.GetString().c_str(), 
-                                                                        child_name.GetCString(),
-                                                                        var_expr_path_strm.GetString().c_str(), 
-                                                                        var_path.c_str());
-                                    else
-                                        error.SetErrorStringWithFormat ("\"%s\" is not a pointer and -> was used to attempt to access \"%s\". Did you mean \"%s.%s\"?", 
-                                                                        var_expr_path_strm.GetString().c_str(), 
-                                                                        child_name.GetCString(),
-                                                                        var_expr_path_strm.GetString().c_str(), 
-                                                                        var_path.c_str());
-                                    return ValueObjectSP();
-                                }
-                            }
-                            child_valobj_sp = valobj_sp->GetChildMemberWithName (child_name, true);
-                            if (!child_valobj_sp)
-                            {
-                                if (!no_synth_child)
-                                {
-                                    child_valobj_sp = valobj_sp->GetSyntheticValue();
-                                    if (child_valobj_sp)
-                                        child_valobj_sp = child_valobj_sp->GetChildMemberWithName (child_name, true);
-                                }
-                                
-                                if (no_synth_child || !child_valobj_sp)
-                                {
-                                    // No child member with name "child_name"
-                                    if (synthetically_added_instance_object)
-                                    {
-                                        // We added a "this->" or "self->" to the beginning of the expression
-                                        // and this is the first pointer ivar access, so just return the normal
-                                        // error
-                                        error.SetErrorStringWithFormat("no variable or instance variable named '%s' found in this frame",
-                                                                       name_const_string.GetCString());
-                                    }
-                                    else
-                                    {
-                                        valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                        if (child_name)
-                                        {
-                                            error.SetErrorStringWithFormat ("\"%s\" is not a member of \"(%s) %s\"", 
-                                                                            child_name.GetCString(), 
-                                                                            valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                            var_expr_path_strm.GetString().c_str());
-                                        }
-                                        else
-                                        {
-                                            error.SetErrorStringWithFormat ("incomplete expression path after \"%s\" in \"%s\"",
-                                                                            var_expr_path_strm.GetString().c_str(),
-                                                                            var_expr_cstr);
-                                        }
-                                    }
-                                    return ValueObjectSP();
-                                }
-                            }
-                            synthetically_added_instance_object = false;
-                            // Remove the child name from the path
-                            var_path.erase(0, child_name.GetLength());
-                            if (use_dynamic != eNoDynamicValues)
-                            {
-                                ValueObjectSP dynamic_value_sp(child_valobj_sp->GetDynamicValue(use_dynamic));
-                                if (dynamic_value_sp)
-                                    child_valobj_sp = dynamic_value_sp;
-                            }
-                        }
-                        break;
-
-                    case '[':
-                        // Array member access, or treating pointer as an array
-                        if (var_path.size() > 2) // Need at least two brackets and a number
-                        {
-                            char *end = nullptr;
-                            long child_index = ::strtol (&var_path[1], &end, 0);
-                            if (end && *end == ']'
-                                && *(end-1) != '[') // this code forces an error in the case of arr[]. as bitfield[] is not a good syntax we're good to go
-                            {
-                                if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref)
-                                {
-                                    // what we have is *ptr[low]. the most similar C++ syntax is to deref ptr
-                                    // and extract bit low out of it. reading array item low
-                                    // would be done by saying ptr[low], without a deref * sign
-                                    Error error;
-                                    ValueObjectSP temp(valobj_sp->Dereference(error));
-                                    if (error.Fail())
-                                    {
-                                        valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                        error.SetErrorStringWithFormat ("could not dereference \"(%s) %s\"", 
-                                                                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                        var_expr_path_strm.GetString().c_str());
-                                        return ValueObjectSP();
-                                    }
-                                    valobj_sp = temp;
-                                    deref = false;
-                                }
-                                else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() && deref)
-                                {
-                                    // what we have is *arr[low]. the most similar C++ syntax is to get arr[0]
-                                    // (an operation that is equivalent to deref-ing arr)
-                                    // and extract bit low out of it. reading array item low
-                                    // would be done by saying arr[low], without a deref * sign
-                                    Error error;
-                                    ValueObjectSP temp(valobj_sp->GetChildAtIndex (0, true));
-                                    if (error.Fail())
-                                    {
-                                        valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                        error.SetErrorStringWithFormat ("could not get item 0 for \"(%s) %s\"", 
-                                                                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                        var_expr_path_strm.GetString().c_str());
-                                        return ValueObjectSP();
-                                    }
-                                    valobj_sp = temp;
-                                    deref = false;
-                                }
-                                
-                                bool is_incomplete_array = false;
-                                if (valobj_sp->IsPointerType ())
-                                {
-                                    bool is_objc_pointer = true;
-                                    
-                                    if (valobj_sp->GetCompilerType().GetMinimumLanguage() != eLanguageTypeObjC)
-                                        is_objc_pointer = false;
-                                    else if (!valobj_sp->GetCompilerType().IsPointerType())
-                                        is_objc_pointer = false;
-
-                                    if (no_synth_child && is_objc_pointer)
-                                    {
-                                        error.SetErrorStringWithFormat("\"(%s) %s\" is an Objective-C pointer, and cannot be subscripted",
-                                                                       valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                       var_expr_path_strm.GetString().c_str());
-                                        
-                                        return ValueObjectSP();
-                                    }
-                                    else if (is_objc_pointer)
-                                    {                                            
-                                        // dereferencing ObjC variables is not valid.. so let's try and recur to synthetic children
-                                        ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
-                                        if (!synthetic /* no synthetic */
-                                            || synthetic == valobj_sp) /* synthetic is the same as the original object */
-                                        {
-                                            valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                            error.SetErrorStringWithFormat ("\"(%s) %s\" is not an array type", 
-                                                                            valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                            var_expr_path_strm.GetString().c_str());
-                                        }
-                                        else if (static_cast<uint32_t>(child_index) >= synthetic->GetNumChildren() /* synthetic does not have that many values */)
-                                        {
-                                            valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                            error.SetErrorStringWithFormat ("array index %ld is not valid for \"(%s) %s\"", 
-                                                                            child_index, 
-                                                                            valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                            var_expr_path_strm.GetString().c_str());
-                                        }
-                                        else
-                                        {
-                                            child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
-                                            if (!child_valobj_sp)
-                                            {
-                                                valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                                error.SetErrorStringWithFormat ("array index %ld is not valid for \"(%s) %s\"", 
-                                                                                child_index, 
-                                                                                valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                                var_expr_path_strm.GetString().c_str());
-                                            }
-                                        }
-                                    }
-                                    else
-                                    {
-                                        child_valobj_sp = valobj_sp->GetSyntheticArrayMember (child_index, true);
-                                        if (!child_valobj_sp)
-                                        {
-                                            valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                            error.SetErrorStringWithFormat ("failed to use pointer as array for index %ld for \"(%s) %s\"", 
-                                                                            child_index, 
-                                                                            valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                            var_expr_path_strm.GetString().c_str());
-                                        }
-                                    }
-                                }
-                                else if (valobj_sp->GetCompilerType().IsArrayType(nullptr, nullptr, &is_incomplete_array))
-                                {
-                                    // Pass false to dynamic_value here so we can tell the difference between
-                                    // no dynamic value and no member of this type...
-                                    child_valobj_sp = valobj_sp->GetChildAtIndex (child_index, true);
-                                    if (!child_valobj_sp && (is_incomplete_array || !no_synth_child))
-                                        child_valobj_sp = valobj_sp->GetSyntheticArrayMember (child_index, true);
-
-                                    if (!child_valobj_sp)
-                                    {
-                                        valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                        error.SetErrorStringWithFormat ("array index %ld is not valid for \"(%s) %s\"", 
-                                                                        child_index, 
-                                                                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                        var_expr_path_strm.GetString().c_str());
-                                    }
-                                }
-                                else if (valobj_sp->GetCompilerType().IsScalarType())
-                                {
-                                    // this is a bitfield asking to display just one bit
-                                    child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(child_index, child_index, true);
-                                    if (!child_valobj_sp)
-                                    {
-                                        valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                        error.SetErrorStringWithFormat ("bitfield range %ld-%ld is not valid for \"(%s) %s\"", 
-                                                                        child_index, child_index, 
-                                                                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                        var_expr_path_strm.GetString().c_str());
-                                    }
-                                }
-                                else
-                                {
-                                    ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
-                                    if (no_synth_child /* synthetic is forbidden */ ||
-                                        !synthetic /* no synthetic */
-                                        || synthetic == valobj_sp) /* synthetic is the same as the original object */
-                                    {
-                                        valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                        error.SetErrorStringWithFormat ("\"(%s) %s\" is not an array type", 
-                                                                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                        var_expr_path_strm.GetString().c_str());
-                                    }
-                                    else if (static_cast<uint32_t>(child_index) >= synthetic->GetNumChildren() /* synthetic does not have that many values */)
-                                    {
-                                        valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                        error.SetErrorStringWithFormat ("array index %ld is not valid for \"(%s) %s\"", 
-                                                                        child_index, 
-                                                                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                        var_expr_path_strm.GetString().c_str());
-                                    }
-                                    else
-                                    {
-                                        child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
-                                        if (!child_valobj_sp)
-                                        {
-                                            valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                            error.SetErrorStringWithFormat ("array index %ld is not valid for \"(%s) %s\"", 
-                                                                            child_index, 
-                                                                            valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                            var_expr_path_strm.GetString().c_str());
-                                        }
-                                    }
-                                }
-
-                                if (!child_valobj_sp)
-                                {
-                                    // Invalid array index...
-                                    return ValueObjectSP();
-                                }
-
-                                // Erase the array member specification '[%i]' where 
-                                // %i is the array index
-                                var_path.erase(0, (end - var_path.c_str()) + 1);
-                                separator_idx = var_path.find_first_of(".-[");
-                                if (use_dynamic != eNoDynamicValues)
-                                {
-                                    ValueObjectSP dynamic_value_sp(child_valobj_sp->GetDynamicValue(use_dynamic));
-                                    if (dynamic_value_sp)
-                                        child_valobj_sp = dynamic_value_sp;
-                                }
-                                // Break out early from the switch since we were 
-                                // able to find the child member
-                                break;
-                            }
-                            else if (end && *end == '-')
-                            {
-                                // this is most probably a BitField, let's take a look
-                                char *real_end = nullptr;
-                                long final_index = ::strtol (end+1, &real_end, 0);
-                                bool expand_bitfield = true;
-                                if (real_end && *real_end == ']')
-                                {
-                                    // if the format given is [high-low], swap range
-                                    if (child_index > final_index)
-                                    {
-                                        long temp = child_index;
-                                        child_index = final_index;
-                                        final_index = temp;
-                                    }
-                                    
-                                    if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref)
-                                    {
-                                        // what we have is *ptr[low-high]. the most similar C++ syntax is to deref ptr
-                                        // and extract bits low thru high out of it. reading array items low thru high
-                                        // would be done by saying ptr[low-high], without a deref * sign
-                                        Error error;
-                                        ValueObjectSP temp(valobj_sp->Dereference(error));
-                                        if (error.Fail())
-                                        {
-                                            valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                            error.SetErrorStringWithFormat ("could not dereference \"(%s) %s\"", 
-                                                                            valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                            var_expr_path_strm.GetString().c_str());
-                                            return ValueObjectSP();
-                                        }
-                                        valobj_sp = temp;
-                                        deref = false;
-                                    }
-                                    else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() && deref)
-                                    {
-                                        // what we have is *arr[low-high]. the most similar C++ syntax is to get arr[0]
-                                        // (an operation that is equivalent to deref-ing arr)
-                                        // and extract bits low thru high out of it. reading array items low thru high
-                                        // would be done by saying arr[low-high], without a deref * sign
-                                        Error error;
-                                        ValueObjectSP temp(valobj_sp->GetChildAtIndex (0, true));
-                                        if (error.Fail())
-                                        {
-                                            valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                            error.SetErrorStringWithFormat ("could not get item 0 for \"(%s) %s\"", 
-                                                                            valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                            var_expr_path_strm.GetString().c_str());
-                                            return ValueObjectSP();
-                                        }
-                                        valobj_sp = temp;
-                                        deref = false;
-                                    }
-                                    /*else if (valobj_sp->IsArrayType() || valobj_sp->IsPointerType())
-                                    {
-                                        child_valobj_sp = valobj_sp->GetSyntheticArrayRangeChild(child_index, final_index, true);
-                                        expand_bitfield = false;
-                                        if (!child_valobj_sp)
-                                        {
-                                            valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                            error.SetErrorStringWithFormat ("array range %i-%i is not valid for \"(%s) %s\"", 
-                                                                            child_index, final_index, 
-                                                                            valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                            var_expr_path_strm.GetString().c_str());
-                                        }
-                                    }*/
-
-                                    if (expand_bitfield)
-                                    {
-                                        child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(child_index, final_index, true);
-                                        if (!child_valobj_sp)
-                                        {
-                                            valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                                            error.SetErrorStringWithFormat ("bitfield range %ld-%ld is not valid for \"(%s) %s\"", 
-                                                                            child_index, final_index, 
-                                                                            valobj_sp->GetTypeName().AsCString("<invalid type>"),
-                                                                            var_expr_path_strm.GetString().c_str());
-                                        }
-                                    }
-                                }
-                                
-                                if (!child_valobj_sp)
-                                {
-                                    // Invalid bitfield range...
-                                    return ValueObjectSP();
-                                }
-                                
-                                // Erase the bitfield member specification '[%i-%i]' where 
-                                // %i is the index
-                                var_path.erase(0, (real_end - var_path.c_str()) + 1);
-                                separator_idx = var_path.find_first_of(".-[");
-                                if (use_dynamic != eNoDynamicValues)
-                                {
-                                    ValueObjectSP dynamic_value_sp(child_valobj_sp->GetDynamicValue(use_dynamic));
-                                    if (dynamic_value_sp)
-                                        child_valobj_sp = dynamic_value_sp;
-                                }
-                                // Break out early from the switch since we were 
-                                // able to find the child member
-                                break;
-
-                            }
-                        }
-                        else
-                        {
-                            error.SetErrorStringWithFormat("invalid square bracket encountered after \"%s\" in \"%s\"", 
-                                                           var_expr_path_strm.GetString().c_str(),
-                                                           var_path.c_str());
-                        }
-                        return ValueObjectSP();
-
-                    default:
-                        // Failure...
-                        {
-                            valobj_sp->GetExpressionPath (var_expr_path_strm, false);
-                            error.SetErrorStringWithFormat ("unexpected char '%c' encountered after \"%s\" in \"%s\"", 
-                                                            separator_type,
-                                                            var_expr_path_strm.GetString().c_str(),
-                                                            var_path.c_str());
-
-                            return ValueObjectSP();
-                        }
+                      valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                      error.SetErrorStringWithFormat(
+                          "\"(%s) %s\" is not an array type",
+                          valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                          var_expr_path_strm.GetString().c_str());
+                    } else if (
+                        static_cast<uint32_t>(child_index) >=
+                        synthetic
+                            ->GetNumChildren() /* synthetic does not have that many values */) {
+                      valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                      error.SetErrorStringWithFormat(
+                          "array index %ld is not valid for \"(%s) %s\"",
+                          child_index,
+                          valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                          var_expr_path_strm.GetString().c_str());
+                    } else {
+                      child_valobj_sp =
+                          synthetic->GetChildAtIndex(child_index, true);
+                      if (!child_valobj_sp) {
+                        valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                        error.SetErrorStringWithFormat(
+                            "array index %ld is not valid for \"(%s) %s\"",
+                            child_index, valobj_sp->GetTypeName().AsCString(
+                                             "<invalid type>"),
+                            var_expr_path_strm.GetString().c_str());
+                      }
+                    }
+                  } else {
+                    child_valobj_sp =
+                        valobj_sp->GetSyntheticArrayMember(child_index, true);
+                    if (!child_valobj_sp) {
+                      valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                      error.SetErrorStringWithFormat(
+                          "failed to use pointer as array for index %ld for "
+                          "\"(%s) %s\"",
+                          child_index,
+                          valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                          var_expr_path_strm.GetString().c_str());
                     }
+                  }
+                } else if (valobj_sp->GetCompilerType().IsArrayType(
+                               nullptr, nullptr, &is_incomplete_array)) {
+                  // Pass false to dynamic_value here so we can tell the
+                  // difference between
+                  // no dynamic value and no member of this type...
+                  child_valobj_sp =
+                      valobj_sp->GetChildAtIndex(child_index, true);
+                  if (!child_valobj_sp &&
+                      (is_incomplete_array || !no_synth_child))
+                    child_valobj_sp =
+                        valobj_sp->GetSyntheticArrayMember(child_index, true);
+
+                  if (!child_valobj_sp) {
+                    valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                    error.SetErrorStringWithFormat(
+                        "array index %ld is not valid for \"(%s) %s\"",
+                        child_index,
+                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                        var_expr_path_strm.GetString().c_str());
+                  }
+                } else if (valobj_sp->GetCompilerType().IsScalarType()) {
+                  // this is a bitfield asking to display just one bit
+                  child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(
+                      child_index, child_index, true);
+                  if (!child_valobj_sp) {
+                    valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                    error.SetErrorStringWithFormat(
+                        "bitfield range %ld-%ld is not valid for \"(%s) %s\"",
+                        child_index, child_index,
+                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                        var_expr_path_strm.GetString().c_str());
+                  }
+                } else {
+                  ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
+                  if (no_synth_child /* synthetic is forbidden */ ||
+                      !synthetic /* no synthetic */
+                      ||
+                      synthetic == valobj_sp) /* synthetic is the same as the
+                                                 original object */
+                  {
+                    valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                    error.SetErrorStringWithFormat(
+                        "\"(%s) %s\" is not an array type",
+                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                        var_expr_path_strm.GetString().c_str());
+                  } else if (
+                      static_cast<uint32_t>(child_index) >=
+                      synthetic
+                          ->GetNumChildren() /* synthetic does not have that many values */) {
+                    valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                    error.SetErrorStringWithFormat(
+                        "array index %ld is not valid for \"(%s) %s\"",
+                        child_index,
+                        valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                        var_expr_path_strm.GetString().c_str());
+                  } else {
+                    child_valobj_sp =
+                        synthetic->GetChildAtIndex(child_index, true);
+                    if (!child_valobj_sp) {
+                      valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                      error.SetErrorStringWithFormat(
+                          "array index %ld is not valid for \"(%s) %s\"",
+                          child_index,
+                          valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                          var_expr_path_strm.GetString().c_str());
+                    }
+                  }
+                }
 
-                    if (child_valobj_sp)
-                        valobj_sp = child_valobj_sp;
+                if (!child_valobj_sp) {
+                  // Invalid array index...
+                  return ValueObjectSP();
+                }
 
-                    if (var_path.empty())
-                        break;
+                // Erase the array member specification '[%i]' where
+                // %i is the array index
+                var_path.erase(0, (end - var_path.c_str()) + 1);
+                separator_idx = var_path.find_first_of(".-[");
+                if (use_dynamic != eNoDynamicValues) {
+                  ValueObjectSP dynamic_value_sp(
+                      child_valobj_sp->GetDynamicValue(use_dynamic));
+                  if (dynamic_value_sp)
+                    child_valobj_sp = dynamic_value_sp;
                 }
-                if (valobj_sp)
-                {
-                    if (deref)
-                    {
-                        ValueObjectSP deref_valobj_sp (valobj_sp->Dereference(error));
-                        valobj_sp = deref_valobj_sp;
+                // Break out early from the switch since we were
+                // able to find the child member
+                break;
+              } else if (end && *end == '-') {
+                // this is most probably a BitField, let's take a look
+                char *real_end = nullptr;
+                long final_index = ::strtol(end + 1, &real_end, 0);
+                bool expand_bitfield = true;
+                if (real_end && *real_end == ']') {
+                  // if the format given is [high-low], swap range
+                  if (child_index > final_index) {
+                    long temp = child_index;
+                    child_index = final_index;
+                    final_index = temp;
+                  }
+
+                  if (valobj_sp->GetCompilerType().IsPointerToScalarType() &&
+                      deref) {
+                    // what we have is *ptr[low-high]. the most similar C++
+                    // syntax is to deref ptr
+                    // and extract bits low thru high out of it. reading array
+                    // items low thru high
+                    // would be done by saying ptr[low-high], without a deref *
+                    // sign
+                    Error error;
+                    ValueObjectSP temp(valobj_sp->Dereference(error));
+                    if (error.Fail()) {
+                      valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                      error.SetErrorStringWithFormat(
+                          "could not dereference \"(%s) %s\"",
+                          valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                          var_expr_path_strm.GetString().c_str());
+                      return ValueObjectSP();
                     }
-                    else if (address_of)
-                    {
-                        ValueObjectSP address_of_valobj_sp (valobj_sp->AddressOf(error));
-                        valobj_sp = address_of_valobj_sp;
+                    valobj_sp = temp;
+                    deref = false;
+                  } else if (valobj_sp->GetCompilerType()
+                                 .IsArrayOfScalarType() &&
+                             deref) {
+                    // what we have is *arr[low-high]. the most similar C++
+                    // syntax is to get arr[0]
+                    // (an operation that is equivalent to deref-ing arr)
+                    // and extract bits low thru high out of it. reading array
+                    // items low thru high
+                    // would be done by saying arr[low-high], without a deref *
+                    // sign
+                    Error error;
+                    ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
+                    if (error.Fail()) {
+                      valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                      error.SetErrorStringWithFormat(
+                          "could not get item 0 for \"(%s) %s\"",
+                          valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                          var_expr_path_strm.GetString().c_str());
+                      return ValueObjectSP();
                     }
+                    valobj_sp = temp;
+                    deref = false;
+                  }
+                  /*else if (valobj_sp->IsArrayType() ||
+                  valobj_sp->IsPointerType())
+                  {
+                      child_valobj_sp =
+                  valobj_sp->GetSyntheticArrayRangeChild(child_index,
+                  final_index, true);
+                      expand_bitfield = false;
+                      if (!child_valobj_sp)
+                      {
+                          valobj_sp->GetExpressionPath (var_expr_path_strm,
+                  false);
+                          error.SetErrorStringWithFormat ("array range %i-%i is
+                  not valid for \"(%s) %s\"",
+                                                          child_index,
+                  final_index,
+                                                          valobj_sp->GetTypeName().AsCString("<invalid
+                  type>"),
+                                                          var_expr_path_strm.GetString().c_str());
+                      }
+                  }*/
+
+                  if (expand_bitfield) {
+                    child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(
+                        child_index, final_index, true);
+                    if (!child_valobj_sp) {
+                      valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+                      error.SetErrorStringWithFormat(
+                          "bitfield range %ld-%ld is not valid for \"(%s) %s\"",
+                          child_index, final_index,
+                          valobj_sp->GetTypeName().AsCString("<invalid type>"),
+                          var_expr_path_strm.GetString().c_str());
+                    }
+                  }
                 }
-                return valobj_sp;
-            }
-            else
-            {
-                error.SetErrorStringWithFormat("no variable named '%s' found in this frame", 
-                                               name_const_string.GetCString());
-            }
-        }
-    }
-    else
-    {
-        error.SetErrorStringWithFormat("invalid variable path '%s'", var_expr_cstr);
-    }
-    return ValueObjectSP();
-}
 
-bool
-StackFrame::GetFrameBaseValue (Scalar &frame_base, Error *error_ptr)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    if (!m_cfa_is_valid)
-    {
-        m_frame_base_error.SetErrorString("No frame base available for this historical stack frame.");
-        return false;
-    }
+                if (!child_valobj_sp) {
+                  // Invalid bitfield range...
+                  return ValueObjectSP();
+                }
 
-    if (m_flags.IsClear(GOT_FRAME_BASE))
-    {
-        if (m_sc.function)
-        {
-            m_frame_base.Clear();
-            m_frame_base_error.Clear();
-
-            m_flags.Set(GOT_FRAME_BASE);
-            ExecutionContext exe_ctx (shared_from_this());
-            Value expr_value;
-            addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
-            if (m_sc.function->GetFrameBaseExpression().IsLocationList())
-                loclist_base_addr = m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (exe_ctx.GetTargetPtr());
-
-            if (m_sc.function->GetFrameBaseExpression().Evaluate(&exe_ctx,
-                                                                 nullptr,
-                                                                 nullptr,
-                                                                 nullptr,
-                                                                 loclist_base_addr,
-                                                                 nullptr,
-                                                                 nullptr,
-                                                                 expr_value,
-                                                                 &m_frame_base_error) == false)
-            {
-                // We should really have an error if evaluate returns, but in case
-                // we don't, lets set the error to something at least.
-                if (m_frame_base_error.Success())
-                    m_frame_base_error.SetErrorString("Evaluation of the frame base expression failed.");
+                // Erase the bitfield member specification '[%i-%i]' where
+                // %i is the index
+                var_path.erase(0, (real_end - var_path.c_str()) + 1);
+                separator_idx = var_path.find_first_of(".-[");
+                if (use_dynamic != eNoDynamicValues) {
+                  ValueObjectSP dynamic_value_sp(
+                      child_valobj_sp->GetDynamicValue(use_dynamic));
+                  if (dynamic_value_sp)
+                    child_valobj_sp = dynamic_value_sp;
+                }
+                // Break out early from the switch since we were
+                // able to find the child member
+                break;
+              }
+            } else {
+              error.SetErrorStringWithFormat(
+                  "invalid square bracket encountered after \"%s\" in \"%s\"",
+                  var_expr_path_strm.GetString().c_str(), var_path.c_str());
             }
-            else
+            return ValueObjectSP();
+
+          default:
+            // Failure...
             {
-                m_frame_base = expr_value.ResolveValue(&exe_ctx);
+              valobj_sp->GetExpressionPath(var_expr_path_strm, false);
+              error.SetErrorStringWithFormat(
+                  "unexpected char '%c' encountered after \"%s\" in \"%s\"",
+                  separator_type, var_expr_path_strm.GetString().c_str(),
+                  var_path.c_str());
+
+              return ValueObjectSP();
             }
+          }
+
+          if (child_valobj_sp)
+            valobj_sp = child_valobj_sp;
+
+          if (var_path.empty())
+            break;
         }
-        else
-        {
-            m_frame_base_error.SetErrorString ("No function in symbol context.");
+        if (valobj_sp) {
+          if (deref) {
+            ValueObjectSP deref_valobj_sp(valobj_sp->Dereference(error));
+            valobj_sp = deref_valobj_sp;
+          } else if (address_of) {
+            ValueObjectSP address_of_valobj_sp(valobj_sp->AddressOf(error));
+            valobj_sp = address_of_valobj_sp;
+          }
         }
+        return valobj_sp;
+      } else {
+        error.SetErrorStringWithFormat(
+            "no variable named '%s' found in this frame",
+            name_const_string.GetCString());
+      }
+    }
+  } else {
+    error.SetErrorStringWithFormat("invalid variable path '%s'", var_expr_cstr);
+  }
+  return ValueObjectSP();
+}
+
+bool StackFrame::GetFrameBaseValue(Scalar &frame_base, Error *error_ptr) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  if (!m_cfa_is_valid) {
+    m_frame_base_error.SetErrorString(
+        "No frame base available for this historical stack frame.");
+    return false;
+  }
+
+  if (m_flags.IsClear(GOT_FRAME_BASE)) {
+    if (m_sc.function) {
+      m_frame_base.Clear();
+      m_frame_base_error.Clear();
+
+      m_flags.Set(GOT_FRAME_BASE);
+      ExecutionContext exe_ctx(shared_from_this());
+      Value expr_value;
+      addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
+      if (m_sc.function->GetFrameBaseExpression().IsLocationList())
+        loclist_base_addr =
+            m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(
+                exe_ctx.GetTargetPtr());
+
+      if (m_sc.function->GetFrameBaseExpression().Evaluate(
+              &exe_ctx, nullptr, nullptr, nullptr, loclist_base_addr, nullptr,
+              nullptr, expr_value, &m_frame_base_error) == false) {
+        // We should really have an error if evaluate returns, but in case
+        // we don't, lets set the error to something at least.
+        if (m_frame_base_error.Success())
+          m_frame_base_error.SetErrorString(
+              "Evaluation of the frame base expression failed.");
+      } else {
+        m_frame_base = expr_value.ResolveValue(&exe_ctx);
+      }
+    } else {
+      m_frame_base_error.SetErrorString("No function in symbol context.");
     }
+  }
 
-    if (m_frame_base_error.Success())
-        frame_base = m_frame_base;
+  if (m_frame_base_error.Success())
+    frame_base = m_frame_base;
 
-    if (error_ptr)
-        *error_ptr = m_frame_base_error;
-    return m_frame_base_error.Success();
+  if (error_ptr)
+    *error_ptr = m_frame_base_error;
+  return m_frame_base_error.Success();
 }
 
-DWARFExpression *
-StackFrame::GetFrameBaseExpression(Error *error_ptr)
-{
-    if (!m_sc.function)
-    {
-        if (error_ptr)
-        {
-            error_ptr->SetErrorString ("No function in symbol context.");
-        }
-        return nullptr;
+DWARFExpression *StackFrame::GetFrameBaseExpression(Error *error_ptr) {
+  if (!m_sc.function) {
+    if (error_ptr) {
+      error_ptr->SetErrorString("No function in symbol context.");
     }
+    return nullptr;
+  }
 
-    return &m_sc.function->GetFrameBaseExpression();
+  return &m_sc.function->GetFrameBaseExpression();
 }
 
-RegisterContextSP
-StackFrame::GetRegisterContext ()
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    if (!m_reg_context_sp)
-    {
-        ThreadSP thread_sp (GetThread());
-        if (thread_sp)
-            m_reg_context_sp = thread_sp->CreateRegisterContextForFrame (this);
-    }
-    return m_reg_context_sp;
+RegisterContextSP StackFrame::GetRegisterContext() {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  if (!m_reg_context_sp) {
+    ThreadSP thread_sp(GetThread());
+    if (thread_sp)
+      m_reg_context_sp = thread_sp->CreateRegisterContextForFrame(this);
+  }
+  return m_reg_context_sp;
 }
 
-bool
-StackFrame::HasDebugInformation ()
-{
-    GetSymbolContext (eSymbolContextLineEntry);
-    return m_sc.line_entry.IsValid();
+bool StackFrame::HasDebugInformation() {
+  GetSymbolContext(eSymbolContextLineEntry);
+  return m_sc.line_entry.IsValid();
 }
 
 ValueObjectSP
-StackFrame::GetValueObjectForFrameVariable (const VariableSP &variable_sp, DynamicValueType use_dynamic)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    ValueObjectSP valobj_sp;
-    if (m_is_history_frame)
-    {
-        return valobj_sp;
-    }
-    VariableList *var_list = GetVariableList (true);
-    if (var_list)
-    {
-        // Make sure the variable is a frame variable
-        const uint32_t var_idx = var_list->FindIndexForVariable (variable_sp.get());
-        const uint32_t num_variables = var_list->GetSize();
-        if (var_idx < num_variables)
-        {
-            valobj_sp = m_variable_list_value_objects.GetValueObjectAtIndex (var_idx);
-            if (!valobj_sp)
-            {
-                if (m_variable_list_value_objects.GetSize() < num_variables)
-                    m_variable_list_value_objects.Resize(num_variables);
-                valobj_sp = ValueObjectVariable::Create (this, variable_sp);
-                m_variable_list_value_objects.SetValueObjectAtIndex (var_idx, valobj_sp);
-            }
-        }
-    }
-    if (use_dynamic != eNoDynamicValues && valobj_sp)
-    {
-        ValueObjectSP dynamic_sp = valobj_sp->GetDynamicValue (use_dynamic);
-        if (dynamic_sp)
-            return dynamic_sp;
-    }
+StackFrame::GetValueObjectForFrameVariable(const VariableSP &variable_sp,
+                                           DynamicValueType use_dynamic) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  ValueObjectSP valobj_sp;
+  if (m_is_history_frame) {
     return valobj_sp;
+  }
+  VariableList *var_list = GetVariableList(true);
+  if (var_list) {
+    // Make sure the variable is a frame variable
+    const uint32_t var_idx = var_list->FindIndexForVariable(variable_sp.get());
+    const uint32_t num_variables = var_list->GetSize();
+    if (var_idx < num_variables) {
+      valobj_sp = m_variable_list_value_objects.GetValueObjectAtIndex(var_idx);
+      if (!valobj_sp) {
+        if (m_variable_list_value_objects.GetSize() < num_variables)
+          m_variable_list_value_objects.Resize(num_variables);
+        valobj_sp = ValueObjectVariable::Create(this, variable_sp);
+        m_variable_list_value_objects.SetValueObjectAtIndex(var_idx, valobj_sp);
+      }
+    }
+  }
+  if (use_dynamic != eNoDynamicValues && valobj_sp) {
+    ValueObjectSP dynamic_sp = valobj_sp->GetDynamicValue(use_dynamic);
+    if (dynamic_sp)
+      return dynamic_sp;
+  }
+  return valobj_sp;
 }
 
-ValueObjectSP
-StackFrame::TrackGlobalVariable (const VariableSP &variable_sp, DynamicValueType use_dynamic)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    if (m_is_history_frame)
-        return ValueObjectSP();
+ValueObjectSP StackFrame::TrackGlobalVariable(const VariableSP &variable_sp,
+                                              DynamicValueType use_dynamic) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  if (m_is_history_frame)
+    return ValueObjectSP();
 
-    // Check to make sure we aren't already tracking this variable?
-    ValueObjectSP valobj_sp (GetValueObjectForFrameVariable (variable_sp, use_dynamic));
-    if (!valobj_sp)
-    {
-        // We aren't already tracking this global
-        VariableList *var_list = GetVariableList (true);
-        // If this frame has no variables, create a new list
-        if (var_list == nullptr)
-            m_variable_list_sp.reset (new VariableList());
-
-        // Add the global/static variable to this frame
-        m_variable_list_sp->AddVariable (variable_sp);
-
-        // Now make a value object for it so we can track its changes
-        valobj_sp = GetValueObjectForFrameVariable (variable_sp, use_dynamic);
-    }
-    return valobj_sp;
+  // Check to make sure we aren't already tracking this variable?
+  ValueObjectSP valobj_sp(
+      GetValueObjectForFrameVariable(variable_sp, use_dynamic));
+  if (!valobj_sp) {
+    // We aren't already tracking this global
+    VariableList *var_list = GetVariableList(true);
+    // If this frame has no variables, create a new list
+    if (var_list == nullptr)
+      m_variable_list_sp.reset(new VariableList());
+
+    // Add the global/static variable to this frame
+    m_variable_list_sp->AddVariable(variable_sp);
+
+    // Now make a value object for it so we can track its changes
+    valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
+  }
+  return valobj_sp;
 }
 
-bool
-StackFrame::IsInlined ()
-{
-    if (m_sc.block == nullptr)
-        GetSymbolContext (eSymbolContextBlock);
-    if (m_sc.block)
-        return m_sc.block->GetContainingInlinedBlock() != nullptr;
-    return false;
+bool StackFrame::IsInlined() {
+  if (m_sc.block == nullptr)
+    GetSymbolContext(eSymbolContextBlock);
+  if (m_sc.block)
+    return m_sc.block->GetContainingInlinedBlock() != nullptr;
+  return false;
 }
 
-lldb::LanguageType
-StackFrame::GetLanguage ()
-{
-    CompileUnit *cu = GetSymbolContext(eSymbolContextCompUnit).comp_unit;
-    if (cu)
-        return cu->GetLanguage();
-    return lldb::eLanguageTypeUnknown;
+lldb::LanguageType StackFrame::GetLanguage() {
+  CompileUnit *cu = GetSymbolContext(eSymbolContextCompUnit).comp_unit;
+  if (cu)
+    return cu->GetLanguage();
+  return lldb::eLanguageTypeUnknown;
 }
 
-lldb::LanguageType
-StackFrame::GuessLanguage ()
-{
-    LanguageType lang_type = GetLanguage();
-    
-    if (lang_type == eLanguageTypeUnknown)
-    {
-        Function *f = GetSymbolContext(eSymbolContextFunction).function;
-        if (f)
-        {
-            lang_type = f->GetMangled().GuessLanguage();
-        }
+lldb::LanguageType StackFrame::GuessLanguage() {
+  LanguageType lang_type = GetLanguage();
+
+  if (lang_type == eLanguageTypeUnknown) {
+    Function *f = GetSymbolContext(eSymbolContextFunction).function;
+    if (f) {
+      lang_type = f->GetMangled().GuessLanguage();
     }
-    
-    return lang_type;
+  }
+
+  return lang_type;
 }
 
-namespace
-{
-    std::pair<const Instruction::Operand *, int64_t>
-    GetBaseExplainingValue(const Instruction::Operand &operand,
-                           RegisterContext &register_context,
-                           lldb::addr_t value)
-    {
-        switch(operand.m_type)
-        {
-        case Instruction::Operand::Type::Dereference:
-        case Instruction::Operand::Type::Immediate:
-        case Instruction::Operand::Type::Invalid:
-        case Instruction::Operand::Type::Product:
-            // These are not currently interesting
-            return std::make_pair(nullptr, 0);
-        case Instruction::Operand::Type::Sum:
-            {
-                const Instruction::Operand *immediate_child = nullptr;
-                const Instruction::Operand *variable_child = nullptr;
-                if (operand.m_children[0].m_type == Instruction::Operand::Type::Immediate)
-                {
-                    immediate_child = &operand.m_children[0];
-                    variable_child = &operand.m_children[1];
-                }
-                else if (operand.m_children[1].m_type == Instruction::Operand::Type::Immediate)
-                {
-                    immediate_child = &operand.m_children[1];
-                    variable_child = &operand.m_children[0];
-                }
-                if (!immediate_child)
-                {
-                    return std::make_pair(nullptr, 0);
-                }
-                lldb::addr_t adjusted_value = value;
-                if (immediate_child->m_negative)
-                {
-                    adjusted_value += immediate_child->m_immediate;
-                }
-                else
-                {
-                    adjusted_value -= immediate_child->m_immediate;
-                }
-                std::pair<const Instruction::Operand *, int64_t> base_and_offset = GetBaseExplainingValue(*variable_child, register_context, adjusted_value);
-                if (!base_and_offset.first)
-                {
-                    return std::make_pair(nullptr, 0);
-                }
-                if (immediate_child->m_negative)
-                {
-                    base_and_offset.second -= immediate_child->m_immediate;
-                }
-                else
-                {
-                    base_and_offset.second += immediate_child->m_immediate;
-                }
-                return base_and_offset;
-            }
-        case Instruction::Operand::Type::Register:
-            {
-                const RegisterInfo *info = register_context.GetRegisterInfoByName(operand.m_register.AsCString());
-                if (!info)
-                {
-                    return std::make_pair(nullptr, 0);
-                }
-                RegisterValue reg_value;
-                if (!register_context.ReadRegister(info, reg_value))
-                {
-                    return std::make_pair(nullptr, 0);
-                }
-                if (reg_value.GetAsUInt64() == value)
-                {
-                    return std::make_pair(&operand, 0);
-                }
-                else
-                {
-                    return std::make_pair(nullptr, 0);
-                }
-            }
-        }
+namespace {
+std::pair<const Instruction::Operand *, int64_t>
+GetBaseExplainingValue(const Instruction::Operand &operand,
+                       RegisterContext &register_context, lldb::addr_t value) {
+  switch (operand.m_type) {
+  case Instruction::Operand::Type::Dereference:
+  case Instruction::Operand::Type::Immediate:
+  case Instruction::Operand::Type::Invalid:
+  case Instruction::Operand::Type::Product:
+    // These are not currently interesting
+    return std::make_pair(nullptr, 0);
+  case Instruction::Operand::Type::Sum: {
+    const Instruction::Operand *immediate_child = nullptr;
+    const Instruction::Operand *variable_child = nullptr;
+    if (operand.m_children[0].m_type == Instruction::Operand::Type::Immediate) {
+      immediate_child = &operand.m_children[0];
+      variable_child = &operand.m_children[1];
+    } else if (operand.m_children[1].m_type ==
+               Instruction::Operand::Type::Immediate) {
+      immediate_child = &operand.m_children[1];
+      variable_child = &operand.m_children[0];
     }
-    
-    std::pair<const Instruction::Operand *, int64_t>
-    GetBaseExplainingDereference(const Instruction::Operand &operand,
-                                 RegisterContext &register_context,
-                                 lldb::addr_t addr)
-    {
-        if (operand.m_type == Instruction::Operand::Type::Dereference)
-        {
-            return GetBaseExplainingValue(operand.m_children[0],
-                                          register_context,
-                                          addr);
-        }
-        return std::make_pair(nullptr, 0);
+    if (!immediate_child) {
+      return std::make_pair(nullptr, 0);
+    }
+    lldb::addr_t adjusted_value = value;
+    if (immediate_child->m_negative) {
+      adjusted_value += immediate_child->m_immediate;
+    } else {
+      adjusted_value -= immediate_child->m_immediate;
+    }
+    std::pair<const Instruction::Operand *, int64_t> base_and_offset =
+        GetBaseExplainingValue(*variable_child, register_context,
+                               adjusted_value);
+    if (!base_and_offset.first) {
+      return std::make_pair(nullptr, 0);
+    }
+    if (immediate_child->m_negative) {
+      base_and_offset.second -= immediate_child->m_immediate;
+    } else {
+      base_and_offset.second += immediate_child->m_immediate;
+    }
+    return base_and_offset;
+  }
+  case Instruction::Operand::Type::Register: {
+    const RegisterInfo *info =
+        register_context.GetRegisterInfoByName(operand.m_register.AsCString());
+    if (!info) {
+      return std::make_pair(nullptr, 0);
     }
+    RegisterValue reg_value;
+    if (!register_context.ReadRegister(info, reg_value)) {
+      return std::make_pair(nullptr, 0);
+    }
+    if (reg_value.GetAsUInt64() == value) {
+      return std::make_pair(&operand, 0);
+    } else {
+      return std::make_pair(nullptr, 0);
+    }
+  }
+  }
+}
+
+std::pair<const Instruction::Operand *, int64_t>
+GetBaseExplainingDereference(const Instruction::Operand &operand,
+                             RegisterContext &register_context,
+                             lldb::addr_t addr) {
+  if (operand.m_type == Instruction::Operand::Type::Dereference) {
+    return GetBaseExplainingValue(operand.m_children[0], register_context,
+                                  addr);
+  }
+  return std::make_pair(nullptr, 0);
+}
 };
 
-lldb::ValueObjectSP
-StackFrame::GuessValueForAddress(lldb::addr_t addr)
-{
-    TargetSP target_sp = CalculateTarget();
-    
-    const ArchSpec &target_arch = target_sp->GetArchitecture();
-    
-    AddressRange pc_range;
-    pc_range.GetBaseAddress() = GetFrameCodeAddress();
-    pc_range.SetByteSize(target_arch.GetMaximumOpcodeByteSize());
-    
-    ExecutionContext exe_ctx (shared_from_this());
-    
-    const char *plugin_name = nullptr;
-    const char *flavor = nullptr;
-    const bool prefer_file_cache = false;
-    
-    DisassemblerSP disassembler_sp = Disassembler::DisassembleRange (target_arch,
-                                                                     plugin_name,
-                                                                     flavor,
-                                                                     exe_ctx,
-                                                                     pc_range,
-                                                                     prefer_file_cache);
-    
-    if (!disassembler_sp->GetInstructionList().GetSize())
-    {
-        return ValueObjectSP();
+lldb::ValueObjectSP StackFrame::GuessValueForAddress(lldb::addr_t addr) {
+  TargetSP target_sp = CalculateTarget();
+
+  const ArchSpec &target_arch = target_sp->GetArchitecture();
+
+  AddressRange pc_range;
+  pc_range.GetBaseAddress() = GetFrameCodeAddress();
+  pc_range.SetByteSize(target_arch.GetMaximumOpcodeByteSize());
+
+  ExecutionContext exe_ctx(shared_from_this());
+
+  const char *plugin_name = nullptr;
+  const char *flavor = nullptr;
+  const bool prefer_file_cache = false;
+
+  DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
+      target_arch, plugin_name, flavor, exe_ctx, pc_range, prefer_file_cache);
+
+  if (!disassembler_sp->GetInstructionList().GetSize()) {
+    return ValueObjectSP();
+  }
+
+  InstructionSP instruction_sp =
+      disassembler_sp->GetInstructionList().GetInstructionAtIndex(0);
+
+  llvm::SmallVector<Instruction::Operand, 3> operands;
+
+  if (!instruction_sp->ParseOperands(operands)) {
+    return ValueObjectSP();
+  }
+
+  RegisterContextSP register_context_sp = GetRegisterContext();
+
+  if (!register_context_sp) {
+    return ValueObjectSP();
+  }
+
+  for (const Instruction::Operand &operand : operands) {
+    std::pair<const Instruction::Operand *, int64_t> base_and_offset =
+        GetBaseExplainingDereference(operand, *register_context_sp, addr);
+
+    if (!base_and_offset.first) {
+      continue;
     }
-    
-    InstructionSP instruction_sp = disassembler_sp->GetInstructionList().GetInstructionAtIndex(0);
-    
-    llvm::SmallVector<Instruction::Operand, 3> operands;
-    
-    if (!instruction_sp->ParseOperands(operands))
-    {
+
+    switch (base_and_offset.first->m_type) {
+    case Instruction::Operand::Type::Immediate: {
+      lldb_private::Address addr;
+      if (target_sp->ResolveLoadAddress(base_and_offset.first->m_immediate +
+                                            base_and_offset.second,
+                                        addr)) {
+        TypeSystem *c_type_system =
+            target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
+        if (!c_type_system) {
+          return ValueObjectSP();
+        } else {
+          CompilerType void_ptr_type =
+              c_type_system
+                  ->GetBasicTypeFromAST(lldb::BasicType::eBasicTypeChar)
+                  .GetPointerType();
+          return ValueObjectMemory::Create(this, "", addr, void_ptr_type);
+        }
+      } else {
         return ValueObjectSP();
+      }
+      break;
     }
-    
-    RegisterContextSP register_context_sp = GetRegisterContext();
-    
-    if (!register_context_sp)
-    {
-        return ValueObjectSP();
+    case Instruction::Operand::Type::Register: {
+      return GuessValueForRegisterAndOffset(base_and_offset.first->m_register,
+                                            base_and_offset.second);
     }
-    
-    for (const Instruction::Operand &operand : operands)
-    {
-        std::pair<const Instruction::Operand *, int64_t>
-            base_and_offset = GetBaseExplainingDereference(operand, *register_context_sp, addr);
-        
-        if (!base_and_offset.first)
-        {
-            continue;
-        }
-        
-        switch (base_and_offset.first->m_type)
-        {
-        case Instruction::Operand::Type::Immediate:
-            {
-                lldb_private::Address addr;
-                if (target_sp->ResolveLoadAddress(base_and_offset.first->m_immediate + base_and_offset.second, addr))
-                {
-                    TypeSystem *c_type_system = target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
-                    if (!c_type_system)
-                    {
-                        return ValueObjectSP();
-                    }
-                    else
-                    {
-                        CompilerType void_ptr_type = c_type_system->GetBasicTypeFromAST(lldb::BasicType::eBasicTypeChar).GetPointerType();
-                        return ValueObjectMemory::Create(this, "", addr, void_ptr_type);
-                    }
-                }
-                else
-                {
-                    return ValueObjectSP();
-                }
-                break;
-            }
-        case Instruction::Operand::Type::Register:
-            {
-                return GuessValueForRegisterAndOffset(base_and_offset.first->m_register, base_and_offset.second);
-            }
-        default:
-            return ValueObjectSP();
-        }
-        
+    default:
+      return ValueObjectSP();
     }
+  }
 
+  return ValueObjectSP();
+}
+
+namespace {
+ValueObjectSP GetValueForOffset(StackFrame &frame, ValueObjectSP &parent,
+                                int64_t offset) {
+  if (offset < 0 || uint64_t(offset) >= parent->GetByteSize()) {
     return ValueObjectSP();
+  }
+
+  if (parent->IsPointerOrReferenceType()) {
+    return parent;
+  }
+
+  for (int ci = 0, ce = parent->GetNumChildren(); ci != ce; ++ci) {
+    const bool can_create = true;
+    ValueObjectSP child_sp = parent->GetChildAtIndex(ci, can_create);
+
+    if (!child_sp) {
+      return ValueObjectSP();
+    }
+
+    int64_t child_offset = child_sp->GetByteOffset();
+    int64_t child_size = child_sp->GetByteSize();
+
+    if (offset >= child_offset && offset < (child_offset + child_size)) {
+      return GetValueForOffset(frame, child_sp, offset - child_offset);
+    }
+  }
+
+  if (offset == 0) {
+    return parent;
+  } else {
+    return ValueObjectSP();
+  }
 }
 
-namespace
-{
-    ValueObjectSP
-    GetValueForOffset(StackFrame &frame, ValueObjectSP &parent, int64_t offset)
-    {
-        if (offset < 0 || uint64_t(offset) >= parent->GetByteSize())
-        {
-            return ValueObjectSP();
-        }
-        
-        if (parent->IsPointerOrReferenceType())
-        {
-            return parent;
+ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame,
+                                             ValueObjectSP &base,
+                                             int64_t offset) {
+  // base is a pointer to something
+  // offset is the thing to add to the pointer
+  // We return the most sensible ValueObject for the result of *(base+offset)
+
+  if (!base->IsPointerOrReferenceType()) {
+    return ValueObjectSP();
+  }
+
+  Error error;
+  ValueObjectSP pointee = base->Dereference(error);
+
+  if (offset >= pointee->GetByteSize()) {
+    int64_t index = offset / pointee->GetByteSize();
+    offset = offset % pointee->GetByteSize();
+    const bool can_create = true;
+    pointee = base->GetSyntheticArrayMember(index, can_create);
+  }
+
+  if (!pointee || error.Fail()) {
+    return ValueObjectSP();
+  }
+
+  return GetValueForOffset(frame, pointee, offset);
+}
+
+//------------------------------------------------------------------
+/// Attempt to reconstruct the ValueObject for the address contained in a
+/// given register plus an offset.
+///
+/// @params [in] frame
+///   The current stack frame.
+///
+/// @params [in] reg
+///   The register.
+///
+/// @params [in] offset
+///   The offset from the register.
+///
+/// @param [in] disassembler
+///   A disassembler containing instructions valid up to the current PC.
+///
+/// @param [in] variables
+///   The variable list from the current frame,
+///
+/// @param [in] pc
+///   The program counter for the instruction considered the 'user'.
+///
+/// @return
+///   A string describing the base for the ExpressionPath.  This could be a
+///     variable, a register value, an argument, or a function return value.
+///   The ValueObject if found.  If valid, it has a valid ExpressionPath.
+//------------------------------------------------------------------
+lldb::ValueObjectSP DoGuessValueAt(StackFrame &frame, ConstString reg,
+                                   int64_t offset, Disassembler &disassembler,
+                                   VariableList &variables, const Address &pc) {
+  // Example of operation for Intel:
+  //
+  // +14: movq   -0x8(%rbp), %rdi
+  // +18: movq   0x8(%rdi), %rdi
+  // +22: addl   0x4(%rdi), %eax
+  //
+  // f, a pointer to a struct, is known to be at -0x8(%rbp).
+  //
+  // DoGuessValueAt(frame, rdi, 4, dis, vars, 0x22) finds the instruction at +18
+  // that assigns to rdi, and calls itself recursively for that dereference
+  //   DoGuessValueAt(frame, rdi, 8, dis, vars, 0x18) finds the instruction at
+  //   +14 that assigns to rdi, and calls itself recursively for that
+  //   derefernece
+  //     DoGuessValueAt(frame, rbp, -8, dis, vars, 0x14) finds "f" in the
+  //     variable list.
+  //     Returns a ValueObject for f.  (That's what was stored at rbp-8 at +14)
+  //   Returns a ValueObject for *(f+8) or f->b (That's what was stored at rdi+8
+  //   at +18)
+  // Returns a ValueObject for *(f->b+4) or f->b->a (That's what was stored at
+  // rdi+4 at +22)
+
+  // First, check the variable list to see if anything is at the specified
+  // location.
+  for (size_t vi = 0, ve = variables.GetSize(); vi != ve; ++vi) {
+    VariableSP var_sp = variables.GetVariableAtIndex(vi);
+    DWARFExpression &dwarf_expression = var_sp->LocationExpression();
+
+    const RegisterInfo *expression_reg;
+    int64_t expression_offset;
+    ExecutionContext exe_ctx;
+
+    if (dwarf_expression.IsDereferenceOfRegister(frame, expression_reg,
+                                                 expression_offset)) {
+      if ((reg == ConstString(expression_reg->name) ||
+           reg == ConstString(expression_reg->alt_name)) &&
+          expression_offset == offset) {
+        return frame.GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
+      }
+    }
+  }
+
+  bool is_in_return_register = false;
+  ABISP abi_sp = frame.CalculateProcess()->GetABI();
+  RegisterInfo return_register_info;
+
+  if (abi_sp) {
+    const char *return_register_name;
+    const RegisterInfo *reg_info = nullptr;
+    if (abi_sp->GetPointerReturnRegister(return_register_name) &&
+        reg == ConstString(return_register_name) &&
+        (reg_info = frame.GetRegisterContext()->GetRegisterInfoByName(
+             return_register_name))) {
+      is_in_return_register = true;
+      return_register_info = *reg_info;
+    }
+  }
+
+  const uint32_t current_inst =
+      disassembler.GetInstructionList().GetIndexOfInstructionAtAddress(pc);
+  if (current_inst == UINT32_MAX) {
+    return ValueObjectSP();
+  }
+
+  ValueObjectSP source_path;
+
+  for (uint32_t ii = current_inst - 1; ii != (uint32_t)-1; --ii) {
+    // This is not an exact algorithm, and it sacrifices accuracy for
+    // generality.
+    // Recognizing "mov" and "ld" instructions –– and which are their source and
+    // destination operands -- is something the disassembler should do for us.
+    InstructionSP instruction_sp =
+        disassembler.GetInstructionList().GetInstructionAtIndex(ii);
+
+    if (is_in_return_register && instruction_sp->IsCall()) {
+      llvm::SmallVector<Instruction::Operand, 1> operands;
+      if (!instruction_sp->ParseOperands(operands) || operands.size() != 1) {
+        continue;
+      }
+
+      switch (operands[0].m_type) {
+      default:
+        break;
+      case Instruction::Operand::Type::Immediate: {
+        SymbolContext sc;
+        Address load_address;
+        if (!frame.CalculateTarget()->ResolveLoadAddress(
+                operands[0].m_immediate, load_address)) {
+          break;
         }
-        
-        for (int ci = 0, ce = parent->GetNumChildren(); ci != ce; ++ci)
-        {
-            const bool can_create = true;
-            ValueObjectSP child_sp = parent->GetChildAtIndex(ci, can_create);
-            
-            if (!child_sp)
-            {
-                return ValueObjectSP();
-            }
-            
-            int64_t child_offset = child_sp->GetByteOffset();
-            int64_t child_size = child_sp->GetByteSize();
-            
-            if (offset >= child_offset &&
-                offset < (child_offset + child_size))
-            {
-                return GetValueForOffset(frame, child_sp, offset - child_offset);
-            }
+        frame.CalculateTarget()->GetImages().ResolveSymbolContextForAddress(
+            load_address, eSymbolContextFunction, sc);
+        if (!sc.function) {
+          break;
         }
-        
-        if (offset == 0)
-        {
-            return parent;
+        CompilerType function_type = sc.function->GetCompilerType();
+        if (!function_type.IsFunctionType()) {
+          break;
         }
-        else
-        {
-            return ValueObjectSP();
+        CompilerType return_type = function_type.GetFunctionReturnType();
+        RegisterValue return_value;
+        if (!frame.GetRegisterContext()->ReadRegister(&return_register_info,
+                                                      return_value)) {
+          break;
         }
+        std::string name_str(
+            sc.function->GetName().AsCString("<unknown function>"));
+        name_str.append("()");
+        Address return_value_address(return_value.GetAsUInt64());
+        ValueObjectSP return_value_sp = ValueObjectMemory::Create(
+            &frame, name_str.c_str(), return_value_address, return_type);
+        return GetValueForDereferincingOffset(frame, return_value_sp, offset);
+      }
+      }
+
+      continue;
     }
-    
-    ValueObjectSP
-    GetValueForDereferincingOffset(StackFrame &frame, ValueObjectSP &base, int64_t offset)
-    {
-        // base is a pointer to something
-        // offset is the thing to add to the pointer
-        // We return the most sensible ValueObject for the result of *(base+offset)
-
-        if (!base->IsPointerOrReferenceType())
-        {
-            return ValueObjectSP();
+
+    llvm::SmallVector<Instruction::Operand, 2> operands;
+    if (!instruction_sp->ParseOperands(operands) || operands.size() != 2) {
+      continue;
+    }
+
+    Instruction::Operand *register_operand = nullptr;
+    Instruction::Operand *origin_operand = nullptr;
+    if (operands[0].m_type == Instruction::Operand::Type::Register &&
+        operands[0].m_clobbered == true && operands[0].m_register == reg) {
+      register_operand = &operands[0];
+      origin_operand = &operands[1];
+    } else if (operands[1].m_type == Instruction::Operand::Type::Register &&
+               operands[1].m_clobbered == true &&
+               operands[1].m_register == reg) {
+      register_operand = &operands[1];
+      origin_operand = &operands[0];
+    } else {
+      continue;
+    }
+
+    // We have an origin operand.  Can we track its value down?
+    switch (origin_operand->m_type) {
+    default:
+      break;
+    case Instruction::Operand::Type::Register:
+      source_path =
+          DoGuessValueAt(frame, origin_operand->m_register, 0, disassembler,
+                         variables, instruction_sp->GetAddress());
+      break;
+    case Instruction::Operand::Type::Dereference: {
+      const Instruction::Operand &pointer = origin_operand->m_children[0];
+      switch (pointer.m_type) {
+      default:
+        break;
+      case Instruction::Operand::Type::Register:
+        source_path = DoGuessValueAt(frame, pointer.m_register, 0, disassembler,
+                                     variables, instruction_sp->GetAddress());
+        if (source_path) {
+          Error err;
+          source_path = source_path->Dereference(err);
+          if (!err.Success()) {
+            source_path.reset();
+          }
         }
-    
-        Error error;
-        ValueObjectSP pointee = base->Dereference(error);
-        
-        if (offset >= pointee->GetByteSize())
-        {
-            int64_t index = offset / pointee->GetByteSize();
-            offset = offset % pointee->GetByteSize();
-            const bool can_create = true;
-            pointee = base->GetSyntheticArrayMember(index, can_create);
+        break;
+      case Instruction::Operand::Type::Sum: {
+        const Instruction::Operand *origin_register = nullptr;
+        const Instruction::Operand *origin_offset = nullptr;
+        if (pointer.m_children.size() != 2) {
+          break;
         }
-        
-        if (!pointee || error.Fail())
-        {
-            return ValueObjectSP();
+        if (pointer.m_children[0].m_type ==
+                Instruction::Operand::Type::Register &&
+            pointer.m_children[1].m_type ==
+                Instruction::Operand::Type::Immediate) {
+          origin_register = &pointer.m_children[0];
+          origin_offset = &pointer.m_children[1];
+        } else if (pointer.m_children[1].m_type ==
+                       Instruction::Operand::Type::Register &&
+                   pointer.m_children[0].m_type ==
+                       Instruction::Operand::Type::Immediate) {
+          origin_register = &pointer.m_children[1];
+          origin_offset = &pointer.m_children[0];
         }
-        
-        return GetValueForOffset(frame, pointee, offset);
-    }
-    
-    //------------------------------------------------------------------
-    /// Attempt to reconstruct the ValueObject for the address contained in a
-    /// given register plus an offset.
-    ///
-    /// @params [in] frame
-    ///   The current stack frame.
-    ///
-    /// @params [in] reg
-    ///   The register.
-    ///
-    /// @params [in] offset
-    ///   The offset from the register.
-    ///
-    /// @param [in] disassembler
-    ///   A disassembler containing instructions valid up to the current PC.
-    ///
-    /// @param [in] variables
-    ///   The variable list from the current frame,
-    ///
-    /// @param [in] pc
-    ///   The program counter for the instruction considered the 'user'.
-    ///
-    /// @return
-    ///   A string describing the base for the ExpressionPath.  This could be a
-    ///     variable, a register value, an argument, or a function return value.
-    ///   The ValueObject if found.  If valid, it has a valid ExpressionPath.
-    //------------------------------------------------------------------
-    lldb::ValueObjectSP
-    DoGuessValueAt(StackFrame &frame, ConstString reg, int64_t offset, Disassembler &disassembler, VariableList &variables, const Address &pc)
-    {
-        // Example of operation for Intel:
-        //
-        // +14: movq   -0x8(%rbp), %rdi
-        // +18: movq   0x8(%rdi), %rdi
-        // +22: addl   0x4(%rdi), %eax
-        //
-        // f, a pointer to a struct, is known to be at -0x8(%rbp).
-        //
-        // DoGuessValueAt(frame, rdi, 4, dis, vars, 0x22) finds the instruction at +18 that assigns to rdi, and calls itself recursively for that dereference
-        //   DoGuessValueAt(frame, rdi, 8, dis, vars, 0x18) finds the instruction at +14 that assigns to rdi, and calls itself recursively for that derefernece
-        //     DoGuessValueAt(frame, rbp, -8, dis, vars, 0x14) finds "f" in the variable list.
-        //     Returns a ValueObject for f.  (That's what was stored at rbp-8 at +14)
-        //   Returns a ValueObject for *(f+8) or f->b (That's what was stored at rdi+8 at +18)
-        // Returns a ValueObject for *(f->b+4) or f->b->a (That's what was stored at rdi+4 at +22)
-        
-        // First, check the variable list to see if anything is at the specified location.
-        for (size_t vi = 0, ve = variables.GetSize(); vi != ve; ++vi)
-        {
-            VariableSP var_sp = variables.GetVariableAtIndex(vi);
-            DWARFExpression &dwarf_expression = var_sp->LocationExpression();
-            
-            const RegisterInfo *expression_reg;
-            int64_t expression_offset;
-            ExecutionContext exe_ctx;
-            
-            if (dwarf_expression.IsDereferenceOfRegister(frame, expression_reg, expression_offset))
-            {
-                if ((reg == ConstString(expression_reg->name) ||
-                     reg == ConstString(expression_reg->alt_name)) &&
-                    expression_offset == offset)
-                {
-                    return frame.GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
-                }
-            }
+        if (!origin_register) {
+          break;
         }
-        
-        bool is_in_return_register = false;
-        ABISP abi_sp = frame.CalculateProcess()->GetABI();
-        RegisterInfo return_register_info;
-
-        if (abi_sp)
-        {
-            const char *return_register_name;
-            const RegisterInfo *reg_info = nullptr;
-            if (abi_sp->GetPointerReturnRegister(return_register_name) &&
-                reg == ConstString(return_register_name) &&
-                (reg_info = frame.GetRegisterContext()->GetRegisterInfoByName(return_register_name)))
-            {
-                is_in_return_register = true;
-                return_register_info = *reg_info;
-            }
+        int64_t signed_origin_offset =
+            origin_offset->m_negative ? -((int64_t)origin_offset->m_immediate)
+                                      : origin_offset->m_immediate;
+        source_path = DoGuessValueAt(frame, origin_register->m_register,
+                                     signed_origin_offset, disassembler,
+                                     variables, instruction_sp->GetAddress());
+        if (!source_path) {
+          break;
         }
-        
-        const uint32_t current_inst = disassembler.GetInstructionList().GetIndexOfInstructionAtAddress(pc);
-        if (current_inst == UINT32_MAX)
-        {
-            return ValueObjectSP();
-        }
-        
-        ValueObjectSP source_path;
-        
-        for (uint32_t ii = current_inst - 1; ii != (uint32_t)-1; --ii)
-        {
-            // This is not an exact algorithm, and it sacrifices accuracy for generality.
-            // Recognizing "mov" and "ld" instructions –– and which are their source and
-            // destination operands -- is something the disassembler should do for us.
-            InstructionSP instruction_sp = disassembler.GetInstructionList().GetInstructionAtIndex(ii);
-            
-            if (is_in_return_register && instruction_sp->IsCall())
-            {
-                llvm::SmallVector<Instruction::Operand, 1> operands;
-                if (!instruction_sp->ParseOperands(operands) || operands.size() != 1)
-                {
-                    continue;
-                }
-                
-                switch (operands[0].m_type)
-                {
-                default:
-                    break;
-                case Instruction::Operand::Type::Immediate:
-                    {
-                        SymbolContext sc;
-                        Address load_address;
-                        if (!frame.CalculateTarget()->ResolveLoadAddress(operands[0].m_immediate, load_address))
-                        {
-                            break;
-                        }
-                        frame.CalculateTarget()->GetImages().ResolveSymbolContextForAddress(load_address, eSymbolContextFunction, sc);
-                        if (!sc.function)
-                        {
-                            break;
-                        }
-                        CompilerType function_type = sc.function->GetCompilerType();
-                        if (!function_type.IsFunctionType())
-                        {
-                            break;
-                        }
-                        CompilerType return_type = function_type.GetFunctionReturnType();
-                        RegisterValue return_value;
-                        if (!frame.GetRegisterContext()->ReadRegister(&return_register_info, return_value))
-                        {
-                            break;
-                        }
-                        std::string name_str(sc.function->GetName().AsCString("<unknown function>"));
-                        name_str.append("()");
-                        Address return_value_address(return_value.GetAsUInt64());
-                        ValueObjectSP return_value_sp = ValueObjectMemory::Create(&frame, name_str.c_str(), return_value_address, return_type);
-                        return GetValueForDereferincingOffset(frame, return_value_sp, offset);
-                    }
-                }
+        source_path =
+            GetValueForDereferincingOffset(frame, source_path, offset);
+        break;
+      }
+      }
+    }
+    }
 
-                continue;
-            }
-            
-            llvm::SmallVector<Instruction::Operand, 2> operands;
-            if (!instruction_sp->ParseOperands(operands) || operands.size() != 2)
-            {
-                continue;
-            }
-            
-            Instruction::Operand *register_operand = nullptr;
-            Instruction::Operand *origin_operand = nullptr;
-            if (operands[0].m_type == Instruction::Operand::Type::Register &&
-                operands[0].m_clobbered == true &&
-                operands[0].m_register == reg)
-            {
-                register_operand = &operands[0];
-                origin_operand = &operands[1];
-            }
-            else if (operands[1].m_type == Instruction::Operand::Type::Register &&
-                     operands[1].m_clobbered == true &&
-                     operands[1].m_register == reg)
-            {
-                register_operand = &operands[1];
-                origin_operand = &operands[0];
-            }
-            else
-            {
-                continue;
-            }
-            
-            // We have an origin operand.  Can we track its value down?
-            switch (origin_operand->m_type)
-            {
-            default:
-                break;
-            case Instruction::Operand::Type::Register:
-                source_path = DoGuessValueAt(frame, origin_operand->m_register, 0, disassembler, variables, instruction_sp->GetAddress());
-                break;
-            case Instruction::Operand::Type::Dereference:
-                {
-                    const Instruction::Operand &pointer = origin_operand->m_children[0];
-                    switch (pointer.m_type)
-                    {
-                    default:
-                        break;
-                    case Instruction::Operand::Type::Register:
-                        source_path = DoGuessValueAt(frame, pointer.m_register, 0, disassembler, variables, instruction_sp->GetAddress());
-                        if (source_path)
-                        {
-                            Error err;
-                            source_path = source_path->Dereference(err);
-                            if (!err.Success())
-                            {
-                                source_path.reset();
-                            }
-                        }
-                        break;
-                    case Instruction::Operand::Type::Sum:
-                        {
-                            const Instruction::Operand *origin_register = nullptr;
-                            const Instruction::Operand *origin_offset = nullptr;
-                            if (pointer.m_children.size() != 2)
-                            {
-                                break;
-                            }
-                            if (pointer.m_children[0].m_type == Instruction::Operand::Type::Register &&
-                                pointer.m_children[1].m_type == Instruction::Operand::Type::Immediate)
-                            {
-                                origin_register = &pointer.m_children[0];
-                                origin_offset = &pointer.m_children[1];
-                            }
-                            else if (pointer.m_children[1].m_type == Instruction::Operand::Type::Register &&
-                                     pointer.m_children[0].m_type == Instruction::Operand::Type::Immediate)
-                            {
-                                origin_register = &pointer.m_children[1];
-                                origin_offset = &pointer.m_children[0];
-                            }
-                            if (!origin_register)
-                            {
-                                break;
-                            }
-                            int64_t signed_origin_offset = origin_offset->m_negative ? -((int64_t)origin_offset->m_immediate) : origin_offset->m_immediate;
-                            source_path = DoGuessValueAt(frame, origin_register->m_register, signed_origin_offset, disassembler, variables, instruction_sp->GetAddress());
-                            if (!source_path)
-                            {
-                                break;
-                            }
-                            source_path = GetValueForDereferincingOffset(frame, source_path, offset);
-                            break;
-                        }
-                    }
-                }
-            }
-            
-            if (source_path)
-            {
-                return source_path;
-            }
-        }
-        
-        return ValueObjectSP();
+    if (source_path) {
+      return source_path;
     }
+  }
+
+  return ValueObjectSP();
+}
 }
 
-lldb::ValueObjectSP
-StackFrame::GuessValueForRegisterAndOffset(ConstString reg, int64_t offset)
-{
-    TargetSP target_sp = CalculateTarget();
-    
-    const ArchSpec &target_arch = target_sp->GetArchitecture();
+lldb::ValueObjectSP StackFrame::GuessValueForRegisterAndOffset(ConstString reg,
+                                                               int64_t offset) {
+  TargetSP target_sp = CalculateTarget();
 
-    Block *frame_block = GetFrameBlock();
-    
-    if (!frame_block)
-    {
-        return ValueObjectSP();
-    }
+  const ArchSpec &target_arch = target_sp->GetArchitecture();
 
-    Function *function = frame_block->CalculateSymbolContextFunction();
-    if (!function)
-    {
-        return ValueObjectSP();
-    }
-    
-    AddressRange pc_range = function->GetAddressRange();
+  Block *frame_block = GetFrameBlock();
 
-    if (GetFrameCodeAddress().GetFileAddress() < pc_range.GetBaseAddress().GetFileAddress() ||
-        GetFrameCodeAddress().GetFileAddress() - pc_range.GetBaseAddress().GetFileAddress() >= pc_range.GetByteSize())
-    {
-        return ValueObjectSP();
-    }
-    
-    ExecutionContext exe_ctx (shared_from_this());
-    
-    const char *plugin_name = nullptr;
-    const char *flavor = nullptr;
-    const bool prefer_file_cache = false;
-    DisassemblerSP disassembler_sp = Disassembler::DisassembleRange (target_arch,
-                                                                     plugin_name,
-                                                                     flavor,
-                                                                     exe_ctx,
-                                                                     pc_range,
-                                                                     prefer_file_cache);
-    
-    if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize())
-    {
-        return ValueObjectSP();
-    }
-    
-    const bool get_file_globals = false;
-    VariableList *variables = GetVariableList(get_file_globals);
-    
-    if (!variables)
-    {
-        return ValueObjectSP();
-    }
-    
-    return DoGuessValueAt(*this, reg, offset, *disassembler_sp, *variables, GetFrameCodeAddress());
-}
+  if (!frame_block) {
+    return ValueObjectSP();
+  }
 
-TargetSP
-StackFrame::CalculateTarget ()
-{
-    TargetSP target_sp;
-    ThreadSP thread_sp(GetThread());
-    if (thread_sp)
-    {
-        ProcessSP process_sp (thread_sp->CalculateProcess());
-        if (process_sp)
-            target_sp = process_sp->CalculateTarget();
-    }
-    return target_sp;
-}
+  Function *function = frame_block->CalculateSymbolContextFunction();
+  if (!function) {
+    return ValueObjectSP();
+  }
 
-ProcessSP
-StackFrame::CalculateProcess ()
-{
-    ProcessSP process_sp;
-    ThreadSP thread_sp(GetThread());
-    if (thread_sp)
-        process_sp = thread_sp->CalculateProcess();
-    return process_sp;
-}
+  AddressRange pc_range = function->GetAddressRange();
+
+  if (GetFrameCodeAddress().GetFileAddress() <
+          pc_range.GetBaseAddress().GetFileAddress() ||
+      GetFrameCodeAddress().GetFileAddress() -
+              pc_range.GetBaseAddress().GetFileAddress() >=
+          pc_range.GetByteSize()) {
+    return ValueObjectSP();
+  }
 
-ThreadSP
-StackFrame::CalculateThread ()
-{
-    return GetThread();
+  ExecutionContext exe_ctx(shared_from_this());
+
+  const char *plugin_name = nullptr;
+  const char *flavor = nullptr;
+  const bool prefer_file_cache = false;
+  DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
+      target_arch, plugin_name, flavor, exe_ctx, pc_range, prefer_file_cache);
+
+  if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
+    return ValueObjectSP();
+  }
+
+  const bool get_file_globals = false;
+  VariableList *variables = GetVariableList(get_file_globals);
+
+  if (!variables) {
+    return ValueObjectSP();
+  }
+
+  return DoGuessValueAt(*this, reg, offset, *disassembler_sp, *variables,
+                        GetFrameCodeAddress());
 }
 
-StackFrameSP
-StackFrame::CalculateStackFrame ()
-{
-    return shared_from_this();
+TargetSP StackFrame::CalculateTarget() {
+  TargetSP target_sp;
+  ThreadSP thread_sp(GetThread());
+  if (thread_sp) {
+    ProcessSP process_sp(thread_sp->CalculateProcess());
+    if (process_sp)
+      target_sp = process_sp->CalculateTarget();
+  }
+  return target_sp;
 }
 
-void
-StackFrame::CalculateExecutionContext (ExecutionContext &exe_ctx)
-{
-    exe_ctx.SetContext (shared_from_this());
+ProcessSP StackFrame::CalculateProcess() {
+  ProcessSP process_sp;
+  ThreadSP thread_sp(GetThread());
+  if (thread_sp)
+    process_sp = thread_sp->CalculateProcess();
+  return process_sp;
 }
 
-void
-StackFrame::DumpUsingSettingsFormat (Stream *strm, const char *frame_marker)
-{
-    if (strm == nullptr)
-        return;
+ThreadSP StackFrame::CalculateThread() { return GetThread(); }
 
-    GetSymbolContext(eSymbolContextEverything);
-    ExecutionContext exe_ctx (shared_from_this());
-    StreamString s;
-    
-    if (frame_marker)
-        s.PutCString(frame_marker);
+StackFrameSP StackFrame::CalculateStackFrame() { return shared_from_this(); }
 
-    const FormatEntity::Entry *frame_format = nullptr;
-    Target *target = exe_ctx.GetTargetPtr();
-    if (target)
-        frame_format = target->GetDebugger().GetFrameFormat();
-    if (frame_format && FormatEntity::Format(*frame_format, s, &m_sc, &exe_ctx, nullptr, nullptr, false, false))
-    {
-        strm->Write(s.GetData(), s.GetSize());
-    }
-    else
-    {
-        Dump (strm, true, false);
-        strm->EOL();
-    }
+void StackFrame::CalculateExecutionContext(ExecutionContext &exe_ctx) {
+  exe_ctx.SetContext(shared_from_this());
 }
 
-void
-StackFrame::Dump (Stream *strm, bool show_frame_index, bool show_fullpaths)
-{
-    if (strm == nullptr)
-        return;
-
-    if (show_frame_index)
-        strm->Printf("frame #%u: ", m_frame_index);
-    ExecutionContext exe_ctx (shared_from_this());
-    Target *target = exe_ctx.GetTargetPtr();
-    strm->Printf("0x%0*" PRIx64 " ",
-                 target ? (target->GetArchitecture().GetAddressByteSize() * 2) : 16,
-                 GetFrameCodeAddress().GetLoadAddress(target));
-    GetSymbolContext(eSymbolContextEverything);
-    const bool show_module = true;
-    const bool show_inline = true;
-    const bool show_function_arguments = true;
-    const bool show_function_name = true;
-    m_sc.DumpStopContext (strm, 
-                          exe_ctx.GetBestExecutionContextScope(), 
-                          GetFrameCodeAddress(), 
-                          show_fullpaths, 
-                          show_module, 
-                          show_inline,
-                          show_function_arguments,
-                          show_function_name);
+void StackFrame::DumpUsingSettingsFormat(Stream *strm,
+                                         const char *frame_marker) {
+  if (strm == nullptr)
+    return;
+
+  GetSymbolContext(eSymbolContextEverything);
+  ExecutionContext exe_ctx(shared_from_this());
+  StreamString s;
+
+  if (frame_marker)
+    s.PutCString(frame_marker);
+
+  const FormatEntity::Entry *frame_format = nullptr;
+  Target *target = exe_ctx.GetTargetPtr();
+  if (target)
+    frame_format = target->GetDebugger().GetFrameFormat();
+  if (frame_format && FormatEntity::Format(*frame_format, s, &m_sc, &exe_ctx,
+                                           nullptr, nullptr, false, false)) {
+    strm->Write(s.GetData(), s.GetSize());
+  } else {
+    Dump(strm, true, false);
+    strm->EOL();
+  }
 }
 
-void
-StackFrame::UpdateCurrentFrameFromPreviousFrame (StackFrame &prev_frame)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    assert (GetStackID() == prev_frame.GetStackID());    // TODO: remove this after some testing
-    m_variable_list_sp = prev_frame.m_variable_list_sp;
-    m_variable_list_value_objects.Swap (prev_frame.m_variable_list_value_objects);
-    if (!m_disassembly.GetString().empty())
-        m_disassembly.GetString().swap (m_disassembly.GetString());
+void StackFrame::Dump(Stream *strm, bool show_frame_index,
+                      bool show_fullpaths) {
+  if (strm == nullptr)
+    return;
+
+  if (show_frame_index)
+    strm->Printf("frame #%u: ", m_frame_index);
+  ExecutionContext exe_ctx(shared_from_this());
+  Target *target = exe_ctx.GetTargetPtr();
+  strm->Printf("0x%0*" PRIx64 " ",
+               target ? (target->GetArchitecture().GetAddressByteSize() * 2)
+                      : 16,
+               GetFrameCodeAddress().GetLoadAddress(target));
+  GetSymbolContext(eSymbolContextEverything);
+  const bool show_module = true;
+  const bool show_inline = true;
+  const bool show_function_arguments = true;
+  const bool show_function_name = true;
+  m_sc.DumpStopContext(strm, exe_ctx.GetBestExecutionContextScope(),
+                       GetFrameCodeAddress(), show_fullpaths, show_module,
+                       show_inline, show_function_arguments,
+                       show_function_name);
 }
 
-void
-StackFrame::UpdatePreviousFrameFromCurrentFrame (StackFrame &curr_frame)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    assert (GetStackID() == curr_frame.GetStackID());        // TODO: remove this after some testing
-    m_id.SetPC (curr_frame.m_id.GetPC());       // Update the Stack ID PC value
-    assert (GetThread() == curr_frame.GetThread());
-    m_frame_index = curr_frame.m_frame_index;
-    m_concrete_frame_index = curr_frame.m_concrete_frame_index;
-    m_reg_context_sp = curr_frame.m_reg_context_sp;
-    m_frame_code_addr = curr_frame.m_frame_code_addr;
-    assert (!m_sc.target_sp || !curr_frame.m_sc.target_sp || m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get());
-    assert (!m_sc.module_sp || !curr_frame.m_sc.module_sp || m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get());
-    assert (m_sc.comp_unit == nullptr || curr_frame.m_sc.comp_unit == nullptr || m_sc.comp_unit == curr_frame.m_sc.comp_unit);
-    assert (m_sc.function == nullptr || curr_frame.m_sc.function == nullptr || m_sc.function == curr_frame.m_sc.function);
-    m_sc = curr_frame.m_sc;
-    m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything);
-    m_flags.Set (m_sc.GetResolvedMask());
-    m_frame_base.Clear();
-    m_frame_base_error.Clear();
+void StackFrame::UpdateCurrentFrameFromPreviousFrame(StackFrame &prev_frame) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  assert(GetStackID() ==
+         prev_frame.GetStackID()); // TODO: remove this after some testing
+  m_variable_list_sp = prev_frame.m_variable_list_sp;
+  m_variable_list_value_objects.Swap(prev_frame.m_variable_list_value_objects);
+  if (!m_disassembly.GetString().empty())
+    m_disassembly.GetString().swap(m_disassembly.GetString());
 }
-    
-bool
-StackFrame::HasCachedData () const
-{
-    if (m_variable_list_sp)
-        return true;
-    if (m_variable_list_value_objects.GetSize() > 0)
-        return true;
-    if (!m_disassembly.GetString().empty())
-        return true;
-    return false;
+
+void StackFrame::UpdatePreviousFrameFromCurrentFrame(StackFrame &curr_frame) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  assert(GetStackID() ==
+         curr_frame.GetStackID());     // TODO: remove this after some testing
+  m_id.SetPC(curr_frame.m_id.GetPC()); // Update the Stack ID PC value
+  assert(GetThread() == curr_frame.GetThread());
+  m_frame_index = curr_frame.m_frame_index;
+  m_concrete_frame_index = curr_frame.m_concrete_frame_index;
+  m_reg_context_sp = curr_frame.m_reg_context_sp;
+  m_frame_code_addr = curr_frame.m_frame_code_addr;
+  assert(!m_sc.target_sp || !curr_frame.m_sc.target_sp ||
+         m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get());
+  assert(!m_sc.module_sp || !curr_frame.m_sc.module_sp ||
+         m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get());
+  assert(m_sc.comp_unit == nullptr || curr_frame.m_sc.comp_unit == nullptr ||
+         m_sc.comp_unit == curr_frame.m_sc.comp_unit);
+  assert(m_sc.function == nullptr || curr_frame.m_sc.function == nullptr ||
+         m_sc.function == curr_frame.m_sc.function);
+  m_sc = curr_frame.m_sc;
+  m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything);
+  m_flags.Set(m_sc.GetResolvedMask());
+  m_frame_base.Clear();
+  m_frame_base_error.Clear();
 }
 
-bool
-StackFrame::GetStatus (Stream& strm,
-                       bool show_frame_info,
-                       bool show_source,
-                       const char *frame_marker)
-{
-    
-    if (show_frame_info)
-    {
-        strm.Indent();
-        DumpUsingSettingsFormat (&strm, frame_marker);
-    }
-    
-    if (show_source)
-    {
-        ExecutionContext exe_ctx (shared_from_this());
-        bool have_source = false, have_debuginfo = false;
-        Debugger::StopDisassemblyType disasm_display = Debugger::eStopDisassemblyTypeNever;
-        Target *target = exe_ctx.GetTargetPtr();
-        if (target)
-        {
-            Debugger &debugger = target->GetDebugger();
-            const uint32_t source_lines_before = debugger.GetStopSourceLineCount(true);
-            const uint32_t source_lines_after = debugger.GetStopSourceLineCount(false);
-            disasm_display = debugger.GetStopDisassemblyDisplay ();
-
-            GetSymbolContext(eSymbolContextCompUnit | eSymbolContextLineEntry);
-            if (m_sc.comp_unit && m_sc.line_entry.IsValid())
-            {
-                have_debuginfo = true;
-                if (source_lines_before > 0 || source_lines_after > 0)
-                {
-                    size_t num_lines = target->GetSourceManager().DisplaySourceLinesWithLineNumbers (m_sc.line_entry.file,
-                                                                                      m_sc.line_entry.line,
-                                                                                      source_lines_before,
-                                                                                      source_lines_after,
-                                                                                      "->",
-                                                                                      &strm);
-                    if (num_lines != 0)
-                        have_source = true;
-                    // TODO: Give here a one time warning if source file is missing.
-                }
-            }
-            switch (disasm_display)
-            {
-            case Debugger::eStopDisassemblyTypeNever:
-                break;
+bool StackFrame::HasCachedData() const {
+  if (m_variable_list_sp)
+    return true;
+  if (m_variable_list_value_objects.GetSize() > 0)
+    return true;
+  if (!m_disassembly.GetString().empty())
+    return true;
+  return false;
+}
 
-            case Debugger::eStopDisassemblyTypeNoDebugInfo:
-                if (have_debuginfo)
-                    break;
-                LLVM_FALLTHROUGH;
+bool StackFrame::GetStatus(Stream &strm, bool show_frame_info, bool show_source,
+                           const char *frame_marker) {
 
-            case Debugger::eStopDisassemblyTypeNoSource:
-                if (have_source)
-                    break;
-                LLVM_FALLTHROUGH;
+  if (show_frame_info) {
+    strm.Indent();
+    DumpUsingSettingsFormat(&strm, frame_marker);
+  }
 
-            case Debugger::eStopDisassemblyTypeAlways:
-                if (target)
-                {
-                    const uint32_t disasm_lines = debugger.GetDisassemblyLineCount();
-                    if (disasm_lines > 0)
-                    {
-                        const ArchSpec &target_arch = target->GetArchitecture();
-                        AddressRange pc_range;
-                        pc_range.GetBaseAddress() = GetFrameCodeAddress();
-                        pc_range.SetByteSize(disasm_lines * target_arch.GetMaximumOpcodeByteSize());
-                        const char *plugin_name = nullptr;
-                        const char *flavor = nullptr;
-                        Disassembler::Disassemble (target->GetDebugger(),
-                                                   target_arch,
-                                                   plugin_name,
-                                                   flavor,
-                                                   exe_ctx,
-                                                   pc_range,
-                                                   disasm_lines,
-                                                   0,
-                                                   Disassembler::eOptionMarkPCAddress,
-                                                   strm);
-                    }
-                }
-                break;
-            }
+  if (show_source) {
+    ExecutionContext exe_ctx(shared_from_this());
+    bool have_source = false, have_debuginfo = false;
+    Debugger::StopDisassemblyType disasm_display =
+        Debugger::eStopDisassemblyTypeNever;
+    Target *target = exe_ctx.GetTargetPtr();
+    if (target) {
+      Debugger &debugger = target->GetDebugger();
+      const uint32_t source_lines_before =
+          debugger.GetStopSourceLineCount(true);
+      const uint32_t source_lines_after =
+          debugger.GetStopSourceLineCount(false);
+      disasm_display = debugger.GetStopDisassemblyDisplay();
+
+      GetSymbolContext(eSymbolContextCompUnit | eSymbolContextLineEntry);
+      if (m_sc.comp_unit && m_sc.line_entry.IsValid()) {
+        have_debuginfo = true;
+        if (source_lines_before > 0 || source_lines_after > 0) {
+          size_t num_lines =
+              target->GetSourceManager().DisplaySourceLinesWithLineNumbers(
+                  m_sc.line_entry.file, m_sc.line_entry.line,
+                  source_lines_before, source_lines_after, "->", &strm);
+          if (num_lines != 0)
+            have_source = true;
+          // TODO: Give here a one time warning if source file is missing.
+        }
+      }
+      switch (disasm_display) {
+      case Debugger::eStopDisassemblyTypeNever:
+        break;
+
+      case Debugger::eStopDisassemblyTypeNoDebugInfo:
+        if (have_debuginfo)
+          break;
+        LLVM_FALLTHROUGH;
+
+      case Debugger::eStopDisassemblyTypeNoSource:
+        if (have_source)
+          break;
+        LLVM_FALLTHROUGH;
+
+      case Debugger::eStopDisassemblyTypeAlways:
+        if (target) {
+          const uint32_t disasm_lines = debugger.GetDisassemblyLineCount();
+          if (disasm_lines > 0) {
+            const ArchSpec &target_arch = target->GetArchitecture();
+            AddressRange pc_range;
+            pc_range.GetBaseAddress() = GetFrameCodeAddress();
+            pc_range.SetByteSize(disasm_lines *
+                                 target_arch.GetMaximumOpcodeByteSize());
+            const char *plugin_name = nullptr;
+            const char *flavor = nullptr;
+            Disassembler::Disassemble(target->GetDebugger(), target_arch,
+                                      plugin_name, flavor, exe_ctx, pc_range,
+                                      disasm_lines, 0,
+                                      Disassembler::eOptionMarkPCAddress, strm);
+          }
         }
+        break;
+      }
     }
-    return true;
+  }
+  return true;
 }