14 files changed, 130 insertions, 131 deletions

diff --git a/lldb/source/Target/ExecutionContext.cpp b/lldb/source/Target/ExecutionContext.cpp
index 7a8b60189bc..ee42e845f14 100644
--- a/lldb/source/Target/ExecutionContext.cpp
+++ b/lldb/source/Target/ExecutionContext.cpp
@@ -11,7 +11,7 @@
 
 #include "lldb/Core/State.h"
 #include "lldb/Target/ExecutionContextScope.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
@@ -64,7 +64,7 @@ ExecutionContext::ExecutionContext (const lldb::ThreadSP &thread_sp) :
         SetContext (thread_sp);
 }
 
-ExecutionContext::ExecutionContext (const lldb::StackFrameSP &frame_sp) :
+ExecutionContext::ExecutionContext (const lldb::FrameSP &frame_sp) :
     m_target_sp (),
     m_process_sp (),
     m_thread_sp (),
@@ -107,13 +107,13 @@ ExecutionContext::ExecutionContext (const lldb::ThreadWP &thread_wp) :
         SetContext (thread_sp);
 }
 
-ExecutionContext::ExecutionContext (const lldb::StackFrameWP &frame_wp) :
+ExecutionContext::ExecutionContext (const lldb::FrameWP &frame_wp) :
     m_target_sp (),
     m_process_sp (),
     m_thread_sp (),
     m_frame_sp ()
 {
-    lldb::StackFrameSP frame_sp(frame_wp.lock());
+    lldb::FrameSP frame_sp(frame_wp.lock());
     if (frame_sp)
         SetContext (frame_sp);
 }
@@ -136,7 +136,7 @@ ExecutionContext::ExecutionContext (Target* t, bool fill_current_process_thread_
     }
 }
 
-ExecutionContext::ExecutionContext(Process* process, Thread *thread, StackFrame *frame) :
+ExecutionContext::ExecutionContext(Process* process, Thread *thread, Frame *frame) :
     m_target_sp (),
     m_process_sp (process->shared_from_this()),
     m_thread_sp (thread->shared_from_this()),
@@ -320,7 +320,7 @@ ExecutionContext::GetThreadRef () const
     return *m_thread_sp;
 }
 
-StackFrame &
+Frame &
 ExecutionContext::GetFrameRef () const
 {
 #if defined (LLDB_CONFIGURATION_DEBUG) || defined (LLDB_CONFIGURATION_RELEASE)
@@ -348,7 +348,7 @@ ExecutionContext::SetThreadSP (const lldb::ThreadSP &thread_sp)
 }
 
 void
-ExecutionContext::SetFrameSP (const lldb::StackFrameSP &frame_sp)
+ExecutionContext::SetFrameSP (const lldb::FrameSP &frame_sp)
 {
     m_frame_sp = frame_sp;
 }
@@ -381,7 +381,7 @@ ExecutionContext::SetThreadPtr (Thread *thread)
 }
 
 void
-ExecutionContext::SetFramePtr (StackFrame *frame)
+ExecutionContext::SetFramePtr (Frame *frame)
 {
     if (frame)
         m_frame_sp = frame->shared_from_this();
@@ -434,7 +434,7 @@ ExecutionContext::SetContext (const lldb::ThreadSP &thread_sp)
 }
 
 void
-ExecutionContext::SetContext (const lldb::StackFrameSP &frame_sp)
+ExecutionContext::SetContext (const lldb::FrameSP &frame_sp)
 {
     m_frame_sp = frame_sp;
     if (frame_sp)
@@ -606,7 +606,7 @@ ExecutionContextRef::operator =(const ExecutionContext &exe_ctx)
         m_tid = thread_sp->GetID();
     else
         m_tid = LLDB_INVALID_THREAD_ID;
-    lldb::StackFrameSP frame_sp (exe_ctx.GetFrameSP());
+    lldb::FrameSP frame_sp (exe_ctx.GetFrameSP());
     if (frame_sp)
         m_stack_id = frame_sp->GetStackID();
     else
@@ -666,7 +666,7 @@ ExecutionContextRef::SetThreadSP (const lldb::ThreadSP &thread_sp)
 }
 
 void
-ExecutionContextRef::SetFrameSP (const lldb::StackFrameSP &frame_sp)
+ExecutionContextRef::SetFrameSP (const lldb::FrameSP &frame_sp)
 {
     if (frame_sp)
     {
@@ -711,7 +711,7 @@ ExecutionContextRef::SetTargetPtr (Target* target, bool adopt_selected)
                             if (thread_sp)
                             {
                                 SetThreadSP (thread_sp);
-                                lldb::StackFrameSP frame_sp (thread_sp->GetSelectedFrame());
+                                lldb::FrameSP frame_sp (thread_sp->GetSelectedFrame());
                                 if (!frame_sp)
                                     frame_sp = thread_sp->GetStackFrameAtIndex(0);
                                 if (frame_sp)
@@ -755,7 +755,7 @@ ExecutionContextRef::SetThreadPtr (Thread *thread)
 }
 
 void
-ExecutionContextRef::SetFramePtr (StackFrame *frame)
+ExecutionContextRef::SetFramePtr (Frame *frame)
 {
     if (frame)
         SetFrameSP (frame->shared_from_this());
@@ -811,7 +811,7 @@ ExecutionContextRef::GetThreadSP () const
     return thread_sp;
 }
 
-lldb::StackFrameSP
+lldb::FrameSP
 ExecutionContextRef::GetFrameSP () const
 {
     if (m_stack_id.IsValid())
@@ -820,7 +820,7 @@ ExecutionContextRef::GetFrameSP () const
         if (thread_sp)
             return thread_sp->GetFrameWithStackID (m_stack_id);
     }
-    return lldb::StackFrameSP();
+    return lldb::FrameSP();
 }
 
 ExecutionContext
diff --git a/lldb/source/Target/Process.cpp b/lldb/source/Target/Process.cpp
index 738ed5f9fee..15a5506dc6f 100644
--- a/lldb/source/Target/Process.cpp
+++ b/lldb/source/Target/Process.cpp
@@ -1808,7 +1808,7 @@ Process::LoadImage (const FileSpec &image_spec, Error &error)
         
         if (thread_sp)
         {
-            StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
+            FrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
             
             if (frame_sp)
             {
@@ -1885,7 +1885,7 @@ Process::UnloadImage (uint32_t image_token)
                 
                 if (thread_sp)
                 {
-                    StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
+                    FrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
                     
                     if (frame_sp)
                     {
@@ -4723,7 +4723,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx,
     
     // Save the thread & frame from the exe_ctx for restoration after we run
     const uint32_t thread_idx_id = thread->GetIndexID();
-    StackFrameSP selected_frame_sp = thread->GetSelectedFrame();
+    FrameSP selected_frame_sp = thread->GetSelectedFrame();
     if (!selected_frame_sp)
     {
         thread->SetSelectedFrame(0);
@@ -5451,7 +5451,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx,
             {
                 // We were able to restore the selected thread, now restore the frame:
                 Mutex::Locker lock(GetThreadList().GetMutex());
-                StackFrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id);
+                FrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id);
                 if (old_frame_sp)
                     GetThreadList().GetSelectedThread()->SetSelectedFrame(old_frame_sp.get());
             }
diff --git a/lldb/source/Target/RegisterContext.cpp b/lldb/source/Target/RegisterContext.cpp
index 2fd1e73ebdc..0eab5847519 100644
--- a/lldb/source/Target/RegisterContext.cpp
+++ b/lldb/source/Target/RegisterContext.cpp
@@ -17,7 +17,7 @@
 #include "lldb/Core/Scalar.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 
@@ -104,7 +104,7 @@ RegisterContext::SetPC(uint64_t pc)
     bool success = WriteRegisterFromUnsigned (reg, pc);
     if (success)
     {
-        StackFrameSP frame_sp(m_thread.GetFrameWithConcreteFrameIndex (m_concrete_frame_idx));
+        FrameSP frame_sp(m_thread.GetFrameWithConcreteFrameIndex (m_concrete_frame_idx));
         if (frame_sp)
             frame_sp->ChangePC(pc);
         else
@@ -450,13 +450,13 @@ RegisterContext::CalculateThread ()
     return m_thread.shared_from_this();
 }
 
-StackFrameSP
-RegisterContext::CalculateStackFrame ()
+FrameSP
+RegisterContext::CalculateFrame ()
 {
     // Register contexts might belong to many frames if we have inlined 
     // functions inside a frame since all inlined functions share the
     // same registers, so we can't definitively say which frame we come from...
-    return StackFrameSP();
+    return FrameSP();
 }
 
 void
diff --git a/lldb/source/Target/StackFrame.cpp b/lldb/source/Target/StackFrame.cpp
index a05c03db1ba..7d730b802d1 100644
--- a/lldb/source/Target/StackFrame.cpp
+++ b/lldb/source/Target/StackFrame.cpp
@@ -9,6 +9,7 @@
 
 #include "lldb/lldb-python.h"
 
+#include "lldb/Target/Frame.h"
 #include "lldb/Target/StackFrame.h"
 
 // C Includes
@@ -204,7 +205,7 @@ StackFrame::GetFrameIndex () const
 {
     ThreadSP thread_sp = GetThread();
     if (thread_sp)
-        return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(m_frame_index);
+        return thread_sp->GetStackFrameList()->GetVisibleFrameIndex(m_frame_index);
     else
         return m_frame_index;
 }
@@ -246,7 +247,7 @@ StackFrame::GetFrameCodeAddress()
     return m_frame_code_addr;
 }
 
-void
+bool
 StackFrame::ChangePC (addr_t pc)
 {
     m_frame_code_addr.SetRawAddress(pc);
@@ -255,6 +256,7 @@ StackFrame::ChangePC (addr_t pc)
     ThreadSP thread_sp (GetThread());
     if (thread_sp)
         thread_sp->ClearStackFrames ();
+    return true;
 }
 
 const char *
@@ -1261,8 +1263,8 @@ StackFrame::CalculateThread ()
     return GetThread();
 }
 
-StackFrameSP
-StackFrame::CalculateStackFrame ()
+FrameSP
+StackFrame::CalculateFrame ()
 {
     return shared_from_this();
 }
@@ -1327,51 +1329,47 @@ StackFrame::Dump (Stream *strm, bool show_frame_index, bool show_fullpaths)
 }
 
 void
-StackFrame::UpdateCurrentFrameFromPreviousFrame (StackFrame &prev_frame)
+StackFrame::UpdateCurrentFrameFromPreviousFrame (Frame &prev_frame)
 {
     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());
+    if (strcmp (prev_frame.GetFrameType(), "StackFrame") == 0)
+    {
+        StackFrame &prev_stackframe = *static_cast<StackFrame*>(&prev_frame);
+        m_variable_list_sp = prev_stackframe.m_variable_list_sp;
+        m_variable_list_value_objects.Swap (prev_stackframe.m_variable_list_value_objects);
+        if (!m_disassembly.GetString().empty())
+            m_disassembly.GetString().swap (m_disassembly.GetString());
+    }
 }
     
 
 void
-StackFrame::UpdatePreviousFrameFromCurrentFrame (StackFrame &curr_frame)
+StackFrame::UpdatePreviousFrameFromCurrentFrame (Frame &curr_frame)
 {
     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.get() == NULL || curr_frame.m_sc.target_sp.get() == NULL || m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get());
-    assert (m_sc.module_sp.get() == NULL || curr_frame.m_sc.module_sp.get() == NULL || m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get());
-    assert (m_sc.comp_unit == NULL || curr_frame.m_sc.comp_unit == NULL || m_sc.comp_unit == curr_frame.m_sc.comp_unit);
-    assert (m_sc.function == NULL || curr_frame.m_sc.function == NULL || 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();
+    if (strcmp (curr_frame.GetFrameType(), "StackFrame") == 0)
+    {
+        StackFrame &curr_stackframe = *static_cast<StackFrame*>(&curr_frame);
+        m_id.SetPC (curr_stackframe.m_id.GetPC());       // Update the Stack ID PC value
+        assert (GetThread() == curr_stackframe.GetThread());
+        m_frame_index = curr_stackframe.m_frame_index;
+        m_concrete_frame_index = curr_stackframe.m_concrete_frame_index;
+        m_reg_context_sp = curr_stackframe.m_reg_context_sp;
+        m_frame_code_addr = curr_stackframe.m_frame_code_addr;
+        assert (m_sc.target_sp.get() == NULL || curr_stackframe.m_sc.target_sp.get() == NULL || m_sc.target_sp.get() == curr_stackframe.m_sc.target_sp.get());
+        assert (m_sc.module_sp.get() == NULL || curr_stackframe.m_sc.module_sp.get() == NULL || m_sc.module_sp.get() == curr_stackframe.m_sc.module_sp.get());
+        assert (m_sc.comp_unit == NULL || curr_stackframe.m_sc.comp_unit == NULL || m_sc.comp_unit == curr_stackframe.m_sc.comp_unit);
+        assert (m_sc.function == NULL || curr_stackframe.m_sc.function == NULL || m_sc.function == curr_stackframe.m_sc.function);
+        m_sc = curr_stackframe.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::HasCachedData () const
-{
-    if (m_variable_list_sp.get())
-        return true;
-    if (m_variable_list_value_objects.GetSize() > 0)
-        return true;
-    if (!m_disassembly.GetString().empty())
-        return true;
-    return false;
-}
-
-bool
 StackFrame::GetStatus (Stream& strm,
                        bool show_frame_info,
                        bool show_source,
diff --git a/lldb/source/Target/StackFrameList.cpp b/lldb/source/Target/StackFrameList.cpp
index d95ab972a7a..61c8bae40cc 100644
--- a/lldb/source/Target/StackFrameList.cpp
+++ b/lldb/source/Target/StackFrameList.cpp
@@ -23,6 +23,7 @@
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Frame.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
@@ -284,7 +285,7 @@ StackFrameList::GetFramesUpTo(uint32_t end_idx)
             }
         }
         
-        StackFrameSP unwind_frame_sp;
+        FrameSP unwind_frame_sp;
         do
         {
             uint32_t idx = m_concrete_frames_fetched++;
@@ -324,7 +325,7 @@ StackFrameList::GetFramesUpTo(uint32_t end_idx)
                 else
                 {
                     unwind_frame_sp = m_frames.front();
-                    cfa = unwind_frame_sp->m_id.GetCallFrameAddress();
+                    cfa = unwind_frame_sp->GetStackID().GetCallFrameAddress();
                 }
             }
             else
@@ -358,7 +359,7 @@ StackFrameList::GetFramesUpTo(uint32_t end_idx)
                 
                 while (unwind_sc.GetParentOfInlinedScope(curr_frame_address, next_frame_sc, next_frame_address))
                 {
-                        StackFrameSP frame_sp(new StackFrame (m_thread.shared_from_this(),
+                        FrameSP frame_sp(new StackFrame (m_thread.shared_from_this(),
                                                               m_frames.size(),
                                                               idx,
                                                               unwind_frame_sp->GetRegisterContextSP (),
@@ -398,8 +399,8 @@ StackFrameList::GetFramesUpTo(uint32_t end_idx)
             {
                 const size_t curr_frame_idx = curr_frame_num-1;
                 const size_t prev_frame_idx = prev_frame_num-1;
-                StackFrameSP curr_frame_sp (curr_frames->m_frames[curr_frame_idx]);
-                StackFrameSP prev_frame_sp (prev_frames->m_frames[prev_frame_idx]);
+                FrameSP curr_frame_sp (curr_frames->m_frames[curr_frame_idx]);
+                FrameSP prev_frame_sp (prev_frames->m_frames[prev_frame_idx]);
 
 #if defined (DEBUG_STACK_FRAMES)
                 s.Printf("\n\nCurr frame #%u ", curr_frame_idx);
@@ -414,8 +415,8 @@ StackFrameList::GetFramesUpTo(uint32_t end_idx)
                     s.PutCString("NULL");
 #endif
 
-                StackFrame *curr_frame = curr_frame_sp.get();
-                StackFrame *prev_frame = prev_frame_sp.get();
+                Frame *curr_frame = curr_frame_sp.get();
+                Frame *prev_frame = prev_frame_sp.get();
                 
                 if (curr_frame == NULL || prev_frame == NULL)
                     break;
@@ -484,7 +485,7 @@ StackFrameList::Dump (Stream *s)
     const_iterator pos, begin = m_frames.begin(), end = m_frames.end();
     for (pos = begin; pos != end; ++pos)
     {
-        StackFrame *frame = (*pos).get();
+        Frame *frame = (*pos).get();
         s->Printf("%p: ", frame);
         if (frame)
         {
@@ -498,10 +499,10 @@ StackFrameList::Dump (Stream *s)
     s->EOL();
 }
 
-StackFrameSP
+FrameSP
 StackFrameList::GetFrameAtIndex (uint32_t idx)
 {
-    StackFrameSP frame_sp;
+    FrameSP frame_sp;
     Mutex::Locker locker (m_mutex);
     uint32_t original_idx = idx;
     
@@ -575,7 +576,7 @@ StackFrameList::GetFrameAtIndex (uint32_t idx)
     return frame_sp;
 }
 
-StackFrameSP
+FrameSP
 StackFrameList::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
 {
     // First try assuming the unwind index is the same as the frame index. The 
@@ -585,7 +586,7 @@ StackFrameList::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
     // frames after we make all the inlined frames. Most of the time the unwind
     // frame index (or the concrete frame index) is the same as the frame index.
     uint32_t frame_idx = unwind_idx;
-    StackFrameSP frame_sp (GetFrameAtIndex (frame_idx));
+    FrameSP frame_sp (GetFrameAtIndex (frame_idx));
     while (frame_sp)
     {
         if (frame_sp->GetFrameIndex() == unwind_idx)
@@ -596,15 +597,15 @@ StackFrameList::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
 }
 
 static bool
-CompareStackID (const StackFrameSP &stack_sp, const StackID &stack_id)
+CompareStackID (const FrameSP &stack_sp, const StackID &stack_id)
 {
     return stack_sp->GetStackID() < stack_id;
 }
 
-StackFrameSP
+FrameSP
 StackFrameList::GetFrameWithStackID (const StackID &stack_id)
 {
-    StackFrameSP frame_sp;
+    FrameSP frame_sp;
     
     if (stack_id.IsValid())
     {
@@ -635,7 +636,7 @@ StackFrameList::GetFrameWithStackID (const StackID &stack_id)
 }
 
 bool
-StackFrameList::SetFrameAtIndex (uint32_t idx, StackFrameSP &frame_sp)
+StackFrameList::SetFrameAtIndex (uint32_t idx, FrameSP &frame_sp)
 {
     if (idx >= m_frames.size())
         m_frames.resize(idx + 1);
@@ -657,7 +658,7 @@ StackFrameList::GetSelectedFrameIndex () const
 
 
 uint32_t
-StackFrameList::SetSelectedFrame (lldb_private::StackFrame *frame)
+StackFrameList::SetSelectedFrame (lldb_private::Frame *frame)
 {
     Mutex::Locker locker (m_mutex);
     const_iterator pos;
@@ -684,7 +685,7 @@ bool
 StackFrameList::SetSelectedFrameByIndex (uint32_t idx)
 {
     Mutex::Locker locker (m_mutex);
-    StackFrameSP frame_sp (GetFrameAtIndex (idx));
+    FrameSP frame_sp (GetFrameAtIndex (idx));
     if (frame_sp)
     {
         SetSelectedFrame(frame_sp.get());
@@ -699,7 +700,7 @@ StackFrameList::SetDefaultFileAndLineToSelectedFrame()
 {
     if (m_thread.GetID() == m_thread.GetProcess()->GetThreadList().GetSelectedThread()->GetID())
     {
-        StackFrameSP frame_sp (GetFrameAtIndex (GetSelectedFrameIndex()));
+        FrameSP frame_sp (GetFrameAtIndex (GetSelectedFrameIndex()));
         if (frame_sp)
         {
             SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextLineEntry);
@@ -799,8 +800,8 @@ StackFrameList::Merge (std::unique_ptr<StackFrameList>& curr_ap, lldb::StackFram
         return;
     }
 
-    StackFrameSP prev_frame_zero_sp(prev_sp->GetFrameAtIndex (0));
-    StackFrameSP curr_frame_zero_sp(curr_ap->GetFrameAtIndex (0));
+    FrameSP prev_frame_zero_sp(prev_sp->GetFrameAtIndex (0));
+    FrameSP curr_frame_zero_sp(curr_ap->GetFrameAtIndex (0));
     StackID curr_stack_id (curr_frame_zero_sp->GetStackID());
     StackID prev_stack_id (prev_frame_zero_sp->GetStackID());
 
@@ -839,13 +840,13 @@ StackFrameList::Merge (std::unique_ptr<StackFrameList>& curr_ap, lldb::StackFram
 
 }
 
-lldb::StackFrameSP
-StackFrameList::GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr)
+lldb::FrameSP
+StackFrameList::GetFrameSPForFramePtr (Frame *stack_frame_ptr)
 {
     const_iterator pos;
     const_iterator begin = m_frames.begin();
     const_iterator end = m_frames.end();
-    lldb::StackFrameSP ret_sp;
+    lldb::FrameSP ret_sp;
     
     for (pos = begin; pos != end; ++pos)
     {
@@ -871,7 +872,7 @@ StackFrameList::GetStatus (Stream& strm,
     if (num_frames == 0)
         return 0;
     
-    StackFrameSP frame_sp;
+    FrameSP frame_sp;
     uint32_t frame_idx = 0;
     uint32_t last_frame;
     
@@ -881,7 +882,7 @@ StackFrameList::GetStatus (Stream& strm,
     else
         last_frame = first_frame + num_frames;
     
-    StackFrameSP selected_frame_sp = m_thread.GetSelectedFrame();
+    FrameSP selected_frame_sp = m_thread.GetSelectedFrame();
     const char *unselected_marker = NULL;
     std::string buffer;
     if (selected_frame_marker)
diff --git a/lldb/source/Target/Target.cpp b/lldb/source/Target/Target.cpp
index c92a2cc3a4a..6545fb2200a 100644
--- a/lldb/source/Target/Target.cpp
+++ b/lldb/source/Target/Target.cpp
@@ -42,7 +42,7 @@
 #include "lldb/lldb-private-log.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
 
@@ -1699,10 +1699,10 @@ Target::CalculateThread ()
     return ThreadSP();
 }
 
-StackFrameSP
-Target::CalculateStackFrame ()
+FrameSP
+Target::CalculateFrame ()
 {
-    return StackFrameSP();
+    return FrameSP();
 }
 
 void
@@ -1832,7 +1832,7 @@ ExecutionResults
 Target::EvaluateExpression
 (
     const char *expr_cstr,
-    StackFrame *frame,
+    Frame *frame,
     lldb::ValueObjectSP &result_valobj_sp,
     const EvaluateExpressionOptions& options
 )
@@ -2086,7 +2086,7 @@ Target::RunStopHooks ()
         lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex (i);
         if (cur_thread_sp->ThreadStoppedForAReason())
         {
-            lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0);
+            lldb::FrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0);
             exc_ctx_with_reasons.push_back(ExecutionContext(m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get()));
             sym_ctx_with_reasons.push_back(cur_frame_sp->GetSymbolContext(eSymbolContextEverything));
         }
diff --git a/lldb/source/Target/Thread.cpp b/lldb/source/Target/Thread.cpp
index 98c26019b4a..e6a34404647 100644
--- a/lldb/source/Target/Thread.cpp
+++ b/lldb/source/Target/Thread.cpp
@@ -211,11 +211,11 @@ Thread::ThreadEventData::GetStackIDFromEvent (const Event *event_ptr)
     return stack_id;
 }
 
-StackFrameSP
+FrameSP
 Thread::ThreadEventData::GetStackFrameFromEvent (const Event *event_ptr)
 {
     const ThreadEventData *event_data = GetEventDataFromEvent (event_ptr);
-    StackFrameSP frame_sp;
+    FrameSP frame_sp;
     if (event_data)
     {
         ThreadSP thread_sp = event_data->GetThread();
@@ -321,7 +321,7 @@ Thread::BroadcastSelectedFrameChange(StackID &new_frame_id)
 }
 
 uint32_t
-Thread::SetSelectedFrame (lldb_private::StackFrame *frame, bool broadcast)
+Thread::SetSelectedFrame (lldb_private::Frame *frame, bool broadcast)
 {
     uint32_t ret_value = GetStackFrameList()->SetSelectedFrame(frame);
     if (broadcast)
@@ -332,7 +332,7 @@ Thread::SetSelectedFrame (lldb_private::StackFrame *frame, bool broadcast)
 bool
 Thread::SetSelectedFrameByIndex (uint32_t frame_idx, bool broadcast)
 {
-    StackFrameSP frame_sp(GetStackFrameList()->GetFrameAtIndex (frame_idx));
+    FrameSP frame_sp(GetStackFrameList()->GetFrameAtIndex (frame_idx));
     if (frame_sp)
     {
         GetStackFrameList()->SetSelectedFrame(frame_sp.get());
@@ -351,7 +351,7 @@ Thread::SetSelectedFrameByIndexNoisily (uint32_t frame_idx, Stream &output_strea
     bool success = SetSelectedFrameByIndex (frame_idx, broadcast);
     if (success)
     {
-        StackFrameSP frame_sp = GetSelectedFrame();
+        FrameSP frame_sp = GetSelectedFrame();
         if (frame_sp)
         {
             bool already_shown = false;
@@ -1591,10 +1591,10 @@ Thread::CalculateThread ()
     return shared_from_this();
 }
 
-StackFrameSP
-Thread::CalculateStackFrame ()
+FrameSP
+Thread::CalculateFrame ()
 {
-    return StackFrameSP();
+    return FrameSP();
 }
 
 void
@@ -1638,7 +1638,7 @@ Thread::ClearStackFrames ()
     m_curr_frames_sp.reset();
 }
 
-lldb::StackFrameSP
+lldb::FrameSP
 Thread::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
 {
     return GetStackFrameList()->GetFrameWithConcreteFrameIndex (unwind_idx);
@@ -1648,7 +1648,7 @@ Thread::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
 Error
 Thread::ReturnFromFrameWithIndex (uint32_t frame_idx, lldb::ValueObjectSP return_value_sp, bool broadcast)
 {
-    StackFrameSP frame_sp = GetStackFrameAtIndex (frame_idx);
+    FrameSP frame_sp = GetStackFrameAtIndex (frame_idx);
     Error return_error;
     
     if (!frame_sp)
@@ -1660,7 +1660,7 @@ Thread::ReturnFromFrameWithIndex (uint32_t frame_idx, lldb::ValueObjectSP return
 }
 
 Error
-Thread::ReturnFromFrame (lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return_value_sp, bool broadcast)
+Thread::ReturnFromFrame (lldb::FrameSP frame_sp, lldb::ValueObjectSP return_value_sp, bool broadcast)
 {
     Error return_error;
     
@@ -1672,7 +1672,7 @@ Thread::ReturnFromFrame (lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return
     
     Thread *thread = frame_sp->GetThread().get();
     uint32_t older_frame_idx = frame_sp->GetFrameIndex() + 1;
-    StackFrameSP older_frame_sp = thread->GetStackFrameAtIndex(older_frame_idx);
+    FrameSP older_frame_sp = thread->GetStackFrameAtIndex(older_frame_idx);
     if (!older_frame_sp)
     {
         return_error.SetErrorString("No older frame to return to.");
@@ -1720,7 +1720,7 @@ Thread::ReturnFromFrame (lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return
     // Note, we can't use ReadAllRegisterValues->WriteAllRegisterValues, since the read & write
     // cook their data
     
-    StackFrameSP youngest_frame_sp = thread->GetStackFrameAtIndex(0);
+    FrameSP youngest_frame_sp = thread->GetStackFrameAtIndex(0);
     if (youngest_frame_sp)
     {
         lldb::RegisterContextSP reg_ctx_sp (youngest_frame_sp->GetRegisterContext());
@@ -1768,7 +1768,7 @@ Thread::JumpToLine (const FileSpec &file, uint32_t line, bool can_leave_function
     Target *target = exe_ctx.GetTargetPtr();
     TargetSP target_sp = exe_ctx.GetTargetSP();
     RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
-    StackFrame *frame = exe_ctx.GetFramePtr();
+    Frame *frame = exe_ctx.GetFramePtr();
     const SymbolContext &sc = frame->GetSymbolContext(eSymbolContextFunction);
 
     // Find candidate locations.
@@ -1832,7 +1832,7 @@ Thread::DumpUsingSettingsFormat (Stream &strm, uint32_t frame_idx)
     if (process == NULL)
         return;
 
-    StackFrameSP frame_sp;
+    FrameSP frame_sp;
     SymbolContext frame_sc;
     if (frame_idx != LLDB_INVALID_INDEX32)
     {
@@ -1881,10 +1881,10 @@ Thread::GetThreadLocalData (const ModuleSP module)
         return LLDB_INVALID_ADDRESS;
 }
 
-lldb::StackFrameSP
-Thread::GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr)
+lldb::FrameSP
+Thread::GetFrameSPForFramePtr (Frame *stack_frame_ptr)
 {
-    return GetStackFrameList()->GetStackFrameSPForStackFramePtr (stack_frame_ptr);
+    return GetStackFrameList()->GetFrameSPForFramePtr (stack_frame_ptr);
 }
 
 const char *
@@ -1942,7 +1942,7 @@ Thread::GetStatus (Stream &strm, uint32_t start_frame, uint32_t num_frames, uint
     strm.Printf("%c ", is_selected ? '*' : ' ');
     if (target && target->GetDebugger().GetUseExternalEditor())
     {
-        StackFrameSP frame_sp = GetStackFrameAtIndex(start_frame);
+        FrameSP frame_sp = GetStackFrameAtIndex(start_frame);
         if (frame_sp)
         {
             SymbolContext frame_sc(frame_sp->GetSymbolContext (eSymbolContextLineEntry));
@@ -1997,7 +1997,7 @@ Thread::GetStackFrameStatus (Stream& strm,
 bool
 Thread::SaveFrameZeroState (RegisterCheckpoint &checkpoint)
 {
-    lldb::StackFrameSP frame_sp(GetStackFrameAtIndex (0));
+    lldb::FrameSP frame_sp(GetStackFrameAtIndex (0));
     if (frame_sp)
     {
         checkpoint.SetStackID(frame_sp->GetStackID());
@@ -2017,7 +2017,7 @@ Thread::RestoreSaveFrameZero (const RegisterCheckpoint &checkpoint)
 bool
 Thread::ResetFrameZeroRegisters (lldb::DataBufferSP register_data_sp)
 {
-    lldb::StackFrameSP frame_sp(GetStackFrameAtIndex (0));
+    lldb::FrameSP frame_sp(GetStackFrameAtIndex (0));
     if (frame_sp)
     {
         lldb::RegisterContextSP reg_ctx_sp (frame_sp->GetRegisterContext());
diff --git a/lldb/source/Target/ThreadPlanStepInRange.cpp b/lldb/source/Target/ThreadPlanStepInRange.cpp
index c1f14bd216d..70634f1398c 100644
--- a/lldb/source/Target/ThreadPlanStepInRange.cpp
+++ b/lldb/source/Target/ThreadPlanStepInRange.cpp
@@ -202,7 +202,7 @@ ThreadPlanStepInRange::ShouldStop (Event *event_ptr)
         
         if (!m_sub_plan_sp && frame_order == eFrameCompareYounger && m_step_past_prologue)
         {
-            lldb::StackFrameSP curr_frame = m_thread.GetStackFrameAtIndex(0);
+            lldb::FrameSP curr_frame = m_thread.GetStackFrameAtIndex(0);
             if (curr_frame)
             {
                 size_t bytes_to_skip = 0;
@@ -275,7 +275,7 @@ ThreadPlanStepInRange::SetDefaultFlagValue (uint32_t new_value)
 bool
 ThreadPlanStepInRange::FrameMatchesAvoidRegexp ()
 {
-    StackFrame *frame = GetThread().GetStackFrameAtIndex(0).get();
+    Frame *frame = GetThread().GetStackFrameAtIndex(0).get();
 
     const RegularExpression *avoid_regexp_to_use = m_avoid_regexp_ap.get();
     if (avoid_regexp_to_use == NULL)
@@ -321,7 +321,7 @@ ThreadPlanSP
 ThreadPlanStepInRange::DefaultShouldStopHereCallback (ThreadPlan *current_plan, Flags &flags, void *baton)
 {
     bool should_step_out = false;
-    StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
+    Frame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
 
     if (flags.Test(eAvoidNoDebug))
diff --git a/lldb/source/Target/ThreadPlanStepInstruction.cpp b/lldb/source/Target/ThreadPlanStepInstruction.cpp
index f644ee88f70..e95f40353bb 100644
--- a/lldb/source/Target/ThreadPlanStepInstruction.cpp
+++ b/lldb/source/Target/ThreadPlanStepInstruction.cpp
@@ -44,12 +44,12 @@ ThreadPlanStepInstruction::ThreadPlanStepInstruction
     m_step_over (step_over)
 {
     m_instruction_addr = m_thread.GetRegisterContext()->GetPC(0);
-    StackFrameSP m_start_frame_sp(m_thread.GetStackFrameAtIndex(0));
+    FrameSP m_start_frame_sp(m_thread.GetStackFrameAtIndex(0));
     m_stack_id = m_start_frame_sp->GetStackID();
     
     m_start_has_symbol = m_start_frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol != NULL;
     
-    StackFrameSP parent_frame_sp = m_thread.GetStackFrameAtIndex(1);
+    FrameSP parent_frame_sp = m_thread.GetStackFrameAtIndex(1);
     if (parent_frame_sp)
         m_parent_frame_id = parent_frame_sp->GetStackID();
 }
@@ -127,7 +127,7 @@ ThreadPlanStepInstruction::ShouldStop (Event *event_ptr)
         else
         {
             // We've stepped in, step back out again:
-            StackFrame *return_frame = m_thread.GetStackFrameAtIndex(1).get();
+            Frame *return_frame = m_thread.GetStackFrameAtIndex(1).get();
             if (return_frame)
             {
                 if (return_frame->GetStackID() != m_parent_frame_id || m_start_has_symbol)
diff --git a/lldb/source/Target/ThreadPlanStepOut.cpp b/lldb/source/Target/ThreadPlanStepOut.cpp
index c5efb558152..6e45957c486 100644
--- a/lldb/source/Target/ThreadPlanStepOut.cpp
+++ b/lldb/source/Target/ThreadPlanStepOut.cpp
@@ -57,8 +57,8 @@ ThreadPlanStepOut::ThreadPlanStepOut
 {
     m_step_from_insn = m_thread.GetRegisterContext()->GetPC(0);
 
-    StackFrameSP return_frame_sp (m_thread.GetStackFrameAtIndex(frame_idx + 1));
-    StackFrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (frame_idx));
+    FrameSP return_frame_sp (m_thread.GetStackFrameAtIndex(frame_idx + 1));
+    FrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (frame_idx));
     
     if (!return_frame_sp || !immediate_return_from_sp)
         return; // we can't do anything here.  ValidatePlan() will return false.
@@ -401,7 +401,7 @@ ThreadPlanStepOut::QueueInlinedStepPlan (bool queue_now)
     // Now figure out the range of this inlined block, and set up a "step through range"
     // plan for that.  If we've been provided with a context, then use the block in that
     // context.  
-    StackFrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (0));
+    FrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (0));
     if (!immediate_return_from_sp)
         return false;
         
diff --git a/lldb/source/Target/ThreadPlanStepOverRange.cpp b/lldb/source/Target/ThreadPlanStepOverRange.cpp
index 2d8108bf9b7..5c7e460075f 100644
--- a/lldb/source/Target/ThreadPlanStepOverRange.cpp
+++ b/lldb/source/Target/ThreadPlanStepOverRange.cpp
@@ -137,7 +137,7 @@ ThreadPlanStepOverRange::ShouldStop (Event *event_ptr)
         // start function really is our start function...
         for(uint32_t i = 1;; ++i)
         {
-            StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(i);
+            FrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(i);
             if (!older_frame_sp) {
                 // We can't unwind the next frame we should just get out of here & stop...
                 break;
@@ -192,7 +192,7 @@ ThreadPlanStepOverRange::ShouldStop (Event *event_ptr)
             if (m_addr_context.line_entry.IsValid())
             {
                 SymbolContext sc;
-                StackFrameSP frame_sp = m_thread.GetStackFrameAtIndex(0);
+                FrameSP frame_sp = m_thread.GetStackFrameAtIndex(0);
                 sc = frame_sp->GetSymbolContext (eSymbolContextEverything);
                 if (sc.line_entry.IsValid())
                 {
@@ -357,7 +357,7 @@ ThreadPlanStepOverRange::DoWillResume (lldb::StateType resume_state, bool curren
                 if (log)
                     log->Printf ("ThreadPlanStepInRange::DoWillResume: adjusting range to the frame at inlined depth %d.",
                                  m_thread.GetCurrentInlinedDepth());
-                StackFrameSP stack_sp = m_thread.GetStackFrameAtIndex(0);
+                FrameSP stack_sp = m_thread.GetStackFrameAtIndex(0);
                 if (stack_sp)
                 {
                     Block *frame_block = stack_sp->GetFrameBlock();
diff --git a/lldb/source/Target/ThreadPlanStepRange.cpp b/lldb/source/Target/ThreadPlanStepRange.cpp
index 309f773c505..409b87a6ff3 100644
--- a/lldb/source/Target/ThreadPlanStepRange.cpp
+++ b/lldb/source/Target/ThreadPlanStepRange.cpp
@@ -148,7 +148,7 @@ ThreadPlanStepRange::InRange ()
     if (!ret_value)
     {
         // See if we've just stepped to another part of the same line number...
-        StackFrame *frame = m_thread.GetStackFrameAtIndex(0).get();
+        Frame *frame = m_thread.GetStackFrameAtIndex(0).get();
         
         SymbolContext new_context(frame->GetSymbolContext(eSymbolContextEverything));
         if (m_addr_context.line_entry.IsValid() && new_context.line_entry.IsValid())
diff --git a/lldb/source/Target/ThreadPlanStepThrough.cpp b/lldb/source/Target/ThreadPlanStepThrough.cpp
index 37cd03c6986..ed9c23a8413 100644
--- a/lldb/source/Target/ThreadPlanStepThrough.cpp
+++ b/lldb/source/Target/ThreadPlanStepThrough.cpp
@@ -51,7 +51,7 @@ ThreadPlanStepThrough::ThreadPlanStepThrough (Thread &thread, StackID &m_stack_i
         // We are going to return back to the concrete frame 1, we might pass by some inlined code that we're in 
         // the middle of by doing this, but it's easier than trying to figure out where the inlined code might return to.
             
-        StackFrameSP return_frame_sp = m_thread.GetFrameWithStackID (m_stack_id);
+        FrameSP return_frame_sp = m_thread.GetFrameWithStackID (m_stack_id);
         
         if (return_frame_sp)
         {
diff --git a/lldb/source/Target/ThreadPlanStepUntil.cpp b/lldb/source/Target/ThreadPlanStepUntil.cpp
index 62e05c7fe34..a80e0310cc6 100644
--- a/lldb/source/Target/ThreadPlanStepUntil.cpp
+++ b/lldb/source/Target/ThreadPlanStepUntil.cpp
@@ -54,7 +54,7 @@ ThreadPlanStepUntil::ThreadPlanStepUntil
     // Stash away our "until" addresses:
     TargetSP target_sp (m_thread.CalculateTarget());
 
-    StackFrameSP frame_sp (m_thread.GetStackFrameAtIndex (frame_idx));
+    FrameSP frame_sp (m_thread.GetStackFrameAtIndex (frame_idx));
     if (frame_sp)
     {
         m_step_from_insn = frame_sp->GetStackID().GetPC();
@@ -63,7 +63,7 @@ ThreadPlanStepUntil::ThreadPlanStepUntil
         // Find the return address and set a breakpoint there:
         // FIXME - can we do this more securely if we know first_insn?
 
-        StackFrameSP return_frame_sp (m_thread.GetStackFrameAtIndex(frame_idx + 1));
+        FrameSP return_frame_sp (m_thread.GetStackFrameAtIndex(frame_idx + 1));
         if (return_frame_sp)
         {
             // TODO: add inline functionality
@@ -247,7 +247,7 @@ ThreadPlanStepUntil::AnalyzeStop()
                                 done = false;
                             else
                             {
-                                StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(1);
+                                FrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(1);
         
                                 // But if we can't even unwind one frame we should just get out of here & stop...
                                 if (older_frame_sp)