Add a new base class, Frame. It is a pure virtual function which
defines a protocol that all subclasses will implement. StackFrame
is currently the only subclass and the methods that Frame vends are
nearly identical to StackFrame's old methods.
Update all callers to use Frame*/Frame& instead of pointers to
StackFrames.
This is almost entirely a mechanical change that touches a lot of
the code base so I'm committing it alone. No new functionality is
added with this patch, no new subclasses of Frame exist yet.
I'll probably need to tweak some of the separation, possibly moving
some of StackFrame's methods up in to Frame, but this is a good
starting point.
<rdar://problem/15314068>
llvm-svn: 193907
diff --git a/lldb/include/lldb/API/SBFrame.h b/lldb/include/lldb/API/SBFrame.h
index 4ae38c1..c888e8b 100644
--- a/lldb/include/lldb/API/SBFrame.h
+++ b/lldb/include/lldb/API/SBFrame.h
@@ -216,7 +216,7 @@
bool
GetDescription (lldb::SBStream &description);
- SBFrame (const lldb::StackFrameSP &lldb_object_sp);
+ SBFrame (const lldb::FrameSP &lldb_object_sp);
protected:
@@ -228,11 +228,11 @@
friend class lldb_private::ScriptInterpreterPython;
#endif
- lldb::StackFrameSP
+ lldb::FrameSP
GetFrameSP() const;
void
- SetFrameSP (const lldb::StackFrameSP &lldb_object_sp);
+ SetFrameSP (const lldb::FrameSP &lldb_object_sp);
lldb::ExecutionContextRefSP m_opaque_sp;
};
diff --git a/lldb/include/lldb/Core/ValueObject.h b/lldb/include/lldb/Core/ValueObject.h
index 1ef4216..6cf6712 100644
--- a/lldb/include/lldb/Core/ValueObject.h
+++ b/lldb/include/lldb/Core/ValueObject.h
@@ -35,32 +35,33 @@
/// ValueObject:
///
/// This abstract class provides an interface to a particular value, be it a register, a local or global variable,
-/// that is evaluated in some particular scope. The ValueObject also has the capibility of being the "child" of
+/// that is evaluated in some particular scope. The ValueObject also has the capability of being the "child" of
/// some other variable object, and in turn of having children.
/// If a ValueObject is a root variable object - having no parent - then it must be constructed with respect to some
/// particular ExecutionContextScope. If it is a child, it inherits the ExecutionContextScope from its parent.
/// The ValueObject will update itself if necessary before fetching its value, summary, object description, etc.
/// But it will always update itself in the ExecutionContextScope with which it was originally created.
-
+///
/// A brief note on life cycle management for ValueObjects. This is a little tricky because a ValueObject can contain
/// various other ValueObjects - the Dynamic Value, its children, the dereference value, etc. Any one of these can be
-/// handed out as a shared pointer, but for that contained value object to be valid, the root object and potentially other
-/// of the value objects need to stay around.
+/// handed out as a shared pointer, but for that contained value object to be valid, the root object and potentially
+/// other of the value objects need to stay around.
/// We solve this problem by handing out shared pointers to the Value Object and any of its dependents using a shared
/// ClusterManager. This treats each shared pointer handed out for the entire cluster as a reference to the whole
/// cluster. The whole cluster will stay around until the last reference is released.
///
/// The ValueObject mostly handle this automatically, if a value object is made with a Parent ValueObject, then it adds
/// itself to the ClusterManager of the parent.
-
-/// It does mean that external to the ValueObjects we should only ever make available ValueObjectSP's, never ValueObjects
-/// or pointers to them. So all the "Root level" ValueObject derived constructors should be private, and
-/// should implement a Create function that new's up object and returns a Shared Pointer that it gets from the GetSP() method.
+///
+/// It does mean that external to the ValueObjects we should only ever make available ValueObjectSP's, never
+/// ValueObjects or pointers to them. So all the "Root level" ValueObject derived constructors should be private, and
+/// should implement a Create function that new's up object and returns a Shared Pointer that it gets from the GetSP()
+/// method.
///
/// However, if you are making an derived ValueObject that will be contained in a parent value object, you should just
/// hold onto a pointer to it internally, and by virtue of passing the parent ValueObject into its constructor, it will
-/// be added to the ClusterManager for the parent. Then if you ever hand out a Shared Pointer to the contained ValueObject,
-/// just do so by calling GetSP() on the contained object.
+/// be added to the ClusterManager for the parent. Then if you ever hand out a Shared Pointer to the contained
+/// ValueObject, just do so by calling GetSP() on the contained object.
class ValueObject : public UserID
{
@@ -361,7 +362,7 @@
return m_update_point.GetExecutionContextRef().GetThreadSP();
}
- lldb::StackFrameSP
+ lldb::FrameSP
GetFrameSP() const
{
return m_update_point.GetExecutionContextRef().GetFrameSP();
diff --git a/lldb/include/lldb/DataFormatters/FormatNavigator.h b/lldb/include/lldb/DataFormatters/FormatNavigator.h
index cd5f682..c9397fd 100644
--- a/lldb/include/lldb/DataFormatters/FormatNavigator.h
+++ b/lldb/include/lldb/DataFormatters/FormatNavigator.h
@@ -32,7 +32,7 @@
#include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/TargetList.h"
namespace lldb_private {
diff --git a/lldb/include/lldb/Expression/ClangUserExpression.h b/lldb/include/lldb/Expression/ClangUserExpression.h
index 47bfebb..cc38683 100644
--- a/lldb/include/lldb/Expression/ClangUserExpression.h
+++ b/lldb/include/lldb/Expression/ClangUserExpression.h
@@ -394,7 +394,7 @@
LockAndCheckContext (ExecutionContext &exe_ctx,
lldb::TargetSP &target_sp,
lldb::ProcessSP &process_sp,
- lldb::StackFrameSP &frame_sp);
+ lldb::FrameSP &frame_sp);
lldb::ProcessWP m_process_wp; ///< The process used as the context for the expression.
Address m_address; ///< The address the process is stopped in.
diff --git a/lldb/include/lldb/Expression/DWARFExpression.h b/lldb/include/lldb/Expression/DWARFExpression.h
index 5ecdf7f..e84043d 100644
--- a/lldb/include/lldb/Expression/DWARFExpression.h
+++ b/lldb/include/lldb/Expression/DWARFExpression.h
@@ -310,7 +310,7 @@
/// @param[in] reg_ctx
/// An optional parameter which provides a RegisterContext for use
/// when evaluating the expression (i.e. for fetching register values).
- /// Normally this will come from the ExecutionContext's StackFrame but
+ /// Normally this will come from the ExecutionContext's Frame but
/// in the case where an expression needs to be evaluated while building
/// the stack frame list, this short-cut is available.
///
diff --git a/lldb/include/lldb/Expression/Materializer.h b/lldb/include/lldb/Expression/Materializer.h
index 208a081..6a25da4 100644
--- a/lldb/include/lldb/Expression/Materializer.h
+++ b/lldb/include/lldb/Expression/Materializer.h
@@ -15,7 +15,7 @@
#include "lldb/Expression/IRMemoryMap.h"
#include "lldb/Host/Mutex.h"
#include "lldb/Symbol/SymbolContext.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include <vector>
@@ -58,7 +58,7 @@
friend class Materializer;
Dematerializer (Materializer &materializer,
- lldb::StackFrameSP &frame_sp,
+ lldb::FrameSP &frame_sp,
IRMemoryMap &map,
lldb::addr_t process_address) :
m_materializer(&materializer),
@@ -82,7 +82,7 @@
typedef std::shared_ptr<Dematerializer> DematerializerSP;
typedef std::weak_ptr<Dematerializer> DematerializerWP;
- DematerializerSP Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err);
+ DematerializerSP Materialize (lldb::FrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err);
uint32_t AddPersistentVariable (lldb::ClangExpressionVariableSP &persistent_variable_sp, Error &err);
uint32_t AddVariable (lldb::VariableSP &variable_sp, Error &err);
@@ -122,8 +122,8 @@
{
}
- virtual void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err) = 0;
- virtual void Dematerialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address,
+ virtual void Materialize (lldb::FrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err) = 0;
+ virtual void Dematerialize (lldb::FrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address,
lldb::addr_t frame_top, lldb::addr_t frame_bottom, Error &err) = 0;
virtual void DumpToLog (IRMemoryMap &map, lldb::addr_t process_address, Log *log) = 0;
virtual void Wipe (IRMemoryMap &map, lldb::addr_t process_address) = 0;
diff --git a/lldb/include/lldb/Interpreter/ScriptInterpreter.h b/lldb/include/lldb/Interpreter/ScriptInterpreter.h
index 9f529b8..cc414cf 100644
--- a/lldb/include/lldb/Interpreter/ScriptInterpreter.h
+++ b/lldb/include/lldb/Interpreter/ScriptInterpreter.h
@@ -86,12 +86,12 @@
typedef bool (*SWIGBreakpointCallbackFunction) (const char *python_function_name,
const char *session_dictionary_name,
- const lldb::StackFrameSP& frame_sp,
+ const lldb::FrameSP& frame_sp,
const lldb::BreakpointLocationSP &bp_loc_sp);
typedef bool (*SWIGWatchpointCallbackFunction) (const char *python_function_name,
const char *session_dictionary_name,
- const lldb::StackFrameSP& frame_sp,
+ const lldb::FrameSP& frame_sp,
const lldb::WatchpointSP &wp_sp);
typedef bool (*SWIGPythonTypeScriptCallbackFunction) (const char *python_function_name,
@@ -143,7 +143,7 @@
typedef bool (*SWIGPythonScriptKeyword_Frame) (const char* python_function_name,
const char* session_dictionary_name,
- lldb::StackFrameSP& frame,
+ lldb::FrameSP& frame,
std::string& output);
typedef void* (*SWIGPython_GetDynamicSetting) (void* module,
@@ -468,7 +468,7 @@
virtual bool
RunScriptFormatKeyword (const char* impl_function,
- StackFrame* frame,
+ Frame* frame,
std::string& output,
Error& error)
{
diff --git a/lldb/include/lldb/Interpreter/ScriptInterpreterPython.h b/lldb/include/lldb/Interpreter/ScriptInterpreterPython.h
index 4b3dc61..a32f6e1 100644
--- a/lldb/include/lldb/Interpreter/ScriptInterpreterPython.h
+++ b/lldb/include/lldb/Interpreter/ScriptInterpreterPython.h
@@ -202,7 +202,7 @@
virtual bool
RunScriptFormatKeyword (const char* impl_function,
- StackFrame* frame,
+ Frame* frame,
std::string& output,
Error& error);
diff --git a/lldb/include/lldb/Symbol/Variable.h b/lldb/include/lldb/Symbol/Variable.h
index 07295d0..3e45fda 100644
--- a/lldb/include/lldb/Symbol/Variable.h
+++ b/lldb/include/lldb/Symbol/Variable.h
@@ -124,10 +124,10 @@
CalculateSymbolContext (SymbolContext *sc);
bool
- IsInScope (StackFrame *frame);
+ IsInScope (Frame *frame);
bool
- LocationIsValidForFrame (StackFrame *frame);
+ LocationIsValidForFrame (Frame *frame);
bool
LocationIsValidForAddress (const Address &address);
diff --git a/lldb/include/lldb/Target/ABI.h b/lldb/include/lldb/Target/ABI.h
index 16f8ee7..8de9219 100644
--- a/lldb/include/lldb/Target/ABI.h
+++ b/lldb/include/lldb/Target/ABI.h
@@ -53,7 +53,7 @@
// Set the Return value object in the current frame as though a function with
virtual Error
- SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value) = 0;
+ SetReturnValueObject(lldb::FrameSP &frame_sp, lldb::ValueObjectSP &new_value) = 0;
protected:
// This is the method the ABI will call to actually calculate the return value.
diff --git a/lldb/include/lldb/Target/ExecutionContext.h b/lldb/include/lldb/Target/ExecutionContext.h
index 4038e70..f0f9c9b 100644
--- a/lldb/include/lldb/Target/ExecutionContext.h
+++ b/lldb/include/lldb/Target/ExecutionContext.h
@@ -230,10 +230,10 @@
/// context to make a weak reference to the frame's thread, process
/// and target, use the ExecutionContextRef::SetContext() functions.
///
- /// @see ExecutionContextRef::SetContext(const lldb::StackFrameSP &)
+ /// @see ExecutionContextRef::SetContext(const lldb::FrameSP &)
//------------------------------------------------------------------
void
- SetFrameSP (const lldb::StackFrameSP &frame_sp);
+ SetFrameSP (const lldb::FrameSP &frame_sp);
void
SetTargetPtr (Target* target, bool adopt_selected);
@@ -245,7 +245,7 @@
SetThreadPtr (Thread *thread);
void
- SetFramePtr (StackFrame *frame);
+ SetFramePtr (Frame *frame);
//------------------------------------------------------------------
/// Get accessor that creates a strong reference from the weak target
@@ -284,7 +284,7 @@
/// @returns
/// A shared pointer to a frame that is not guaranteed to be valid.
//------------------------------------------------------------------
- lldb::StackFrameSP
+ lldb::FrameSP
GetFrameSP () const;
//------------------------------------------------------------------
@@ -393,14 +393,14 @@
ExecutionContext (const lldb::TargetSP &target_sp, bool get_process);
ExecutionContext (const lldb::ProcessSP &process_sp);
ExecutionContext (const lldb::ThreadSP &thread_sp);
- ExecutionContext (const lldb::StackFrameSP &frame_sp);
+ ExecutionContext (const lldb::FrameSP &frame_sp);
//------------------------------------------------------------------
// Create execution contexts from weak pointers
//------------------------------------------------------------------
ExecutionContext (const lldb::TargetWP &target_wp, bool get_process);
ExecutionContext (const lldb::ProcessWP &process_wp);
ExecutionContext (const lldb::ThreadWP &thread_wp);
- ExecutionContext (const lldb::StackFrameWP &frame_wp);
+ ExecutionContext (const lldb::FrameWP &frame_wp);
ExecutionContext (const ExecutionContextRef &exe_ctx_ref);
ExecutionContext (const ExecutionContextRef *exe_ctx_ref);
@@ -440,7 +440,7 @@
//------------------------------------------------------------------
ExecutionContext (Process* process,
Thread *thread = NULL,
- StackFrame * frame = NULL);
+ Frame * frame = NULL);
~ExecutionContext();
@@ -522,7 +522,7 @@
///
/// @see ExecutionContext::HasFrameScope() const
//------------------------------------------------------------------
- StackFrame *
+ Frame *
GetFramePtr () const
{
return m_frame_sp.get();
@@ -580,7 +580,7 @@
///
/// @see ExecutionContext::HasFrameScope() const
//------------------------------------------------------------------
- StackFrame &
+ Frame &
GetFrameRef () const;
//------------------------------------------------------------------
@@ -621,7 +621,7 @@
///
/// The returned shared pointer is not guaranteed to be valid.
//------------------------------------------------------------------
- const lldb::StackFrameSP &
+ const lldb::FrameSP &
GetFrameSP () const
{
return m_frame_sp;
@@ -649,7 +649,7 @@
/// Set accessor to set only the frame shared pointer.
//------------------------------------------------------------------
void
- SetFrameSP (const lldb::StackFrameSP &frame_sp);
+ SetFrameSP (const lldb::FrameSP &frame_sp);
//------------------------------------------------------------------
/// Set accessor to set only the target shared pointer from a target
@@ -677,7 +677,7 @@
/// pointer.
//------------------------------------------------------------------
void
- SetFramePtr (StackFrame *frame);
+ SetFramePtr (Frame *frame);
//------------------------------------------------------------------
// Set the execution context using a target shared pointer.
@@ -717,7 +717,7 @@
// If "frame_sp" is not valid, all shared pointers are reset.
//------------------------------------------------------------------
void
- SetContext (const lldb::StackFrameSP &frame_sp);
+ SetContext (const lldb::FrameSP &frame_sp);
//------------------------------------------------------------------
/// Returns true the ExecutionContext object contains a valid
@@ -774,7 +774,7 @@
lldb::TargetSP m_target_sp; ///< The target that owns the process/thread/frame
lldb::ProcessSP m_process_sp; ///< The process that owns the thread/frame
lldb::ThreadSP m_thread_sp; ///< The thread that owns the frame
- lldb::StackFrameSP m_frame_sp; ///< The stack frame in thread.
+ lldb::FrameSP m_frame_sp; ///< The stack frame in thread.
};
} // namespace lldb_private
diff --git a/lldb/include/lldb/Target/ExecutionContextScope.h b/lldb/include/lldb/Target/ExecutionContextScope.h
index 7ba4097..60ef1a2 100644
--- a/lldb/include/lldb/Target/ExecutionContextScope.h
+++ b/lldb/include/lldb/Target/ExecutionContextScope.h
@@ -27,7 +27,7 @@
/// objects can inherit from this pure virtual class can reconstruct
/// their execution context without having to keep a complete
/// ExecutionContext object in the object state. Examples of these
-/// objects include: Process, Thread, RegisterContext and StackFrame.
+/// objects include: Process, Thread, RegisterContext and Frame.
///
/// Bbjects can contain a valid pointer to an instance of this so they
/// can reconstruct the execution context.
@@ -51,8 +51,8 @@
virtual lldb::ThreadSP
CalculateThread () = 0;
- virtual lldb::StackFrameSP
- CalculateStackFrame () = 0;
+ virtual lldb::FrameSP
+ CalculateFrame () = 0;
//------------------------------------------------------------------
/// Reconstruct the object's execution context into \a sc.
diff --git a/lldb/include/lldb/Target/Frame.h b/lldb/include/lldb/Target/Frame.h
new file mode 100644
index 0000000..ee52356
--- /dev/null
+++ b/lldb/include/lldb/Target/Frame.h
@@ -0,0 +1,421 @@
+//===-- Frame.h --------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_Frame_h_
+#define liblldb_Frame_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Flags.h"
+#include "lldb/Core/Scalar.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Core/UserID.h"
+#include "lldb/Core/ValueObjectList.h"
+#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Target/ExecutionContextScope.h"
+#include "lldb/Target/StackID.h"
+
+namespace lldb_private {
+
+/// @class Frame Frame.h "lldb/Target/Frame.h"
+///
+/// @brief This base class provides an interface to stack frames.
+///
+/// Frame is a pure virtual class, instances of the subclasses should be
+/// created depending on the type of frame -- a live frame on a thread's
+/// stack, an inlined code frame, a historical frame.
+///
+/// Frames may have a Canonical Frame Address (CFA) or not. A frame may
+/// have a plain pc value or it may have a pc value + stop_id to indicate
+/// a specific point in the debug session so the correct section load list
+/// is used for symbolication.
+///
+/// Local variables may be available, or not. A register context may be
+/// available, or not.
+
+class Frame :
+ public ExecutionContextScope,
+ public std::enable_shared_from_this<Frame>
+{
+public:
+ enum ExpressionPathOption
+ {
+ eExpressionPathOptionCheckPtrVsMember = (1u << 0),
+ eExpressionPathOptionsNoFragileObjcIvar = (1u << 1),
+ eExpressionPathOptionsNoSyntheticChildren = (1u << 2),
+ eExpressionPathOptionsNoSyntheticArrayRange = (1u << 3),
+ eExpressionPathOptionsAllowDirectIVarAccess = (1u << 4)
+ };
+
+ virtual
+ ~Frame () {}
+
+ virtual lldb::ThreadSP
+ GetThread () const = 0;
+
+ virtual StackID&
+ GetStackID() = 0;
+
+ //------------------------------------------------------------------
+ /// Get an Address for the current pc value in this Frame.
+ ///
+ /// May not be the same as the actual PC value for inlined stack frames.
+ ///
+ /// @return
+ /// The Address object set to the current PC value.
+ //------------------------------------------------------------------
+ virtual const Address&
+ GetFrameCodeAddress() = 0;
+
+ //------------------------------------------------------------------
+ /// Change the pc value for a given thread.
+ ///
+ /// Change the current pc value for the frame on this thread.
+ ///
+ /// @param[in] pc
+ /// The load address that the pc will be set to.
+ ///
+ /// @return
+ /// true if the pc was changed. false if this failed -- possibly
+ /// because this frame is not a live Frame.
+ //------------------------------------------------------------------
+ virtual bool
+ ChangePC (lldb::addr_t pc) = 0;
+
+ //------------------------------------------------------------------
+ /// Provide a SymbolContext for this Frame's current pc value.
+ ///
+ /// The Frame maintains this SymbolContext and adds additional information
+ /// to it on an as-needed basis. This helps to avoid different functions
+ /// looking up symbolic information for a given pc value multple times.
+ ///
+ /// @params [in] resolve_scope
+ /// Flags from the SymbolContextItem enumerated type which specify what
+ /// type of symbol context is needed by this caller.
+ ///
+ /// @return
+ /// A SymbolContext reference which includes the types of information
+ /// requested by resolve_scope, if they are available.
+ //------------------------------------------------------------------
+ virtual const SymbolContext&
+ GetSymbolContext (uint32_t resolve_scope) = 0;
+
+ //------------------------------------------------------------------
+ /// Return the Canonical Frame Address (DWARF term) for this frame.
+ ///
+ /// The CFA is typically the value of the stack pointer register before
+ /// the call invocation is made. It will not change during the lifetime
+ /// of a stack frame. It is often not the same thing as the frame pointer
+ /// register value.
+ ///
+ /// Live Frames will always have a CFA but other types of frames may
+ /// not be able to supply one.
+ ///
+ /// @param [out] value
+ /// The address of the CFA for this frame, if available.
+ ///
+ /// @param [out] error_ptr
+ /// If there is an error determining the CFA address, this may contain a
+ /// string explaining the failure.
+ ///
+ /// @return
+ /// Returns true if the CFA value was successfully set in value. Some
+ /// frames may be unable to provide this value; they will return false.
+ //------------------------------------------------------------------
+ virtual bool
+ GetFrameBaseValue(Scalar &value, Error *error_ptr) = 0;
+
+ //------------------------------------------------------------------
+ /// Get the current lexical scope block for this Frame, if possible.
+ ///
+ /// If debug information is available for this stack frame, return a
+ /// pointer to the innermost lexical Block that the frame is currently
+ /// executing.
+ ///
+ /// @return
+ /// A pointer to the current Block. NULL is returned if this can
+ /// not be provided.
+ //------------------------------------------------------------------
+ virtual Block *
+ GetFrameBlock () = 0;
+
+ //------------------------------------------------------------------
+ /// Get the RegisterContext for this frame, if possible.
+ ///
+ /// Returns a shared pointer to the RegisterContext for this stack frame.
+ /// Only a live Frame object will be able to return a RegisterContext -
+ /// callers must be prepared for an empty shared pointer being returned.
+ ///
+ /// Even a live Frame RegisterContext may not be able to provide all
+ /// registers. Only the currently executing frame (frame 0) can reliably
+ /// provide every register in the register context.
+ ///
+ /// @return
+ /// The RegisterContext shared point for this frame.
+ //------------------------------------------------------------------
+ virtual lldb::RegisterContextSP
+ GetRegisterContext () = 0;
+
+ virtual const lldb::RegisterContextSP &
+ GetRegisterContextSP () const = 0;
+
+ //------------------------------------------------------------------
+ /// Retrieve the list of variables that are in scope at this Frame's pc.
+ ///
+ /// A frame that is not live may return an empty VariableList for a given
+ /// pc value even though variables would be available at this point if
+ /// it were a live stack frame.
+ ///
+ /// @param[in] get_file_globals
+ /// Whether to also retrieve compilation-unit scoped variables
+ /// that are visisble to the entire compilation unit (e.g. file
+ /// static in C, globals that are homed in this CU).
+ ///
+ /// @return
+ /// A pointer to a list of variables.
+ //------------------------------------------------------------------
+ virtual VariableList *
+ GetVariableList (bool get_file_globals) = 0;
+
+ //------------------------------------------------------------------
+ /// Retrieve the list of variables that are in scope at this Frame's pc.
+ ///
+ /// A frame that is not live may return an empty VariableListSP for a
+ /// given pc value even though variables would be available at this point
+ /// if it were a live stack frame.
+ ///
+ /// @param[in] get_file_globals
+ /// Whether to also retrieve compilation-unit scoped variables
+ /// that are visisble to the entire compilation unit (e.g. file
+ /// static in C, globals that are homed in this CU).
+ ///
+ /// @return
+ /// A pointer to a list of variables.
+ //------------------------------------------------------------------
+ virtual lldb::VariableListSP
+ GetInScopeVariableList (bool get_file_globals) = 0;
+
+ //------------------------------------------------------------------
+ /// Create a ValueObject for a variable name / pathname, possibly
+ /// including simple dereference/child selection syntax.
+ ///
+ /// @param[in] var_expr
+ /// The string specifying a variable to base the VariableObject off
+ /// of.
+ ///
+ /// @param[in] use_dynamic
+ /// Whether the correct dynamic type of an object pointer should be
+ /// determined before creating the object, or if the static type is
+ /// sufficient. One of the DynamicValueType enumerated values.
+ ///
+ /// @param[in] options
+ /// An unsigned integer of flags, values from Frame::ExpressionPathOption
+ /// enum.
+ /// @param[in] var_sp
+ /// A VariableSP that will be set to the variable described in the
+ /// var_expr path.
+ ///
+ /// @param[in] error
+ /// Record any errors encountered while evaluating var_expr.
+ ///
+ /// @return
+ /// A shared pointer to the ValueObject described by var_expr.
+ //------------------------------------------------------------------
+ virtual lldb::ValueObjectSP
+ GetValueForVariableExpressionPath (const char *var_expr,
+ lldb::DynamicValueType use_dynamic,
+ uint32_t options,
+ lldb::VariableSP &var_sp,
+ Error &error) = 0;
+
+ //------------------------------------------------------------------
+ /// Determine whether this Frame has debug information available or not
+ ///
+ /// @return
+ // true if debug information is available for this frame (function,
+ // compilation unit, block, etc.)
+ //------------------------------------------------------------------
+ virtual bool
+ HasDebugInformation () = 0;
+
+ //------------------------------------------------------------------
+ /// Return the disassembly for the instructions of this Frame's function
+ /// as a single C string.
+ ///
+ /// @return
+ // C string with the assembly instructions for this function.
+ //------------------------------------------------------------------
+ virtual const char *
+ Disassemble () = 0;
+
+ //------------------------------------------------------------------
+ /// Print a description for this frame using the frame-format formatter settings.
+ ///
+ /// @param [in] strm
+ /// The Stream to print the description to.
+ ///
+ /// @param [in] frame_marker
+ /// Optional string that will be prepended to the frame output description.
+ //------------------------------------------------------------------
+ virtual void
+ DumpUsingSettingsFormat (Stream *strm, const char *frame_marker = NULL) = 0;
+
+ //------------------------------------------------------------------
+ /// Print a description for this frame using a default format.
+ ///
+ /// @param [in] strm
+ /// The Stream to print the description to.
+ ///
+ /// @param [in] show_frame_index
+ /// Whether to print the frame number or not.
+ ///
+ /// @param [in] show_fullpaths
+ /// Whether to print the full source paths or just the file base name.
+ //------------------------------------------------------------------
+ virtual void
+ Dump (Stream *strm, bool show_frame_index, bool show_fullpaths) = 0;
+
+ //------------------------------------------------------------------
+ /// Print a description of this stack frame and/or the source context/assembly
+ /// for this stack frame.
+ ///
+ /// @param[in] strm
+ /// The Stream to send the output to.
+ ///
+ /// @param[in] show_frame_info
+ /// If true, print the frame info by calling DumpUsingSettingsFormat().
+ ///
+ /// @param[in] show_source
+ /// If true, print source or disassembly as per the user's settings.
+ ///
+ /// @param[in] frame_marker
+ /// Passed to DumpUsingSettingsFormat() for the frame info printing.
+ ///
+ /// @return
+ /// Returns true if successful.
+ //------------------------------------------------------------------
+ virtual bool
+ GetStatus (Stream &strm,
+ bool show_frame_info,
+ bool show_source,
+ const char *frame_marker = NULL) = 0;
+
+ //------------------------------------------------------------------
+ /// Query whether this frame is a concrete frame on the call stack,
+ /// or if it is an inlined frame derived from the debug information
+ /// and presented by the debugger.
+ ///
+ /// @return
+ /// true if this is an inlined frame.
+ //------------------------------------------------------------------
+ virtual bool
+ IsInlined () = 0;
+
+ //------------------------------------------------------------------
+ /// Query this frame to find what frame it is in this Thread's StackFrameList.
+ ///
+ /// @return
+ /// Frame index 0 indicates the currently-executing function. Inline
+ /// frames are included in this frame index count.
+ //------------------------------------------------------------------
+ virtual uint32_t
+ GetFrameIndex () const = 0;
+
+ //------------------------------------------------------------------
+ /// Query this frame to find what frame it is in this Thread's StackFrameList,
+ /// not counting inlined frames.
+ ///
+ /// @return
+ /// Frame index 0 indicates the currently-executing function. Inline
+ /// frames are not included in this frame index count; their concrete
+ /// frame index will be the same as the concrete frame that they are
+ /// derived from.
+ //------------------------------------------------------------------
+ virtual uint32_t
+ GetConcreteFrameIndex () const = 0;
+
+ //------------------------------------------------------------------
+ /// Create a ValueObject for a given Variable in this Frame.
+ ///
+ /// @params [in] variable_sp
+ /// The Variable to base this ValueObject on
+ ///
+ /// @params [in] use_dynamic
+ /// Whether the correct dynamic type of the variable should be
+ /// determined before creating the ValueObject, or if the static type
+ /// is sufficient. One of the DynamicValueType enumerated values.
+ ///
+ /// @return
+ // A ValueObject for this variable.
+ //------------------------------------------------------------------
+ virtual lldb::ValueObjectSP
+ GetValueObjectForFrameVariable (const lldb::VariableSP &variable_sp, lldb::DynamicValueType use_dynamic) = 0;
+
+ //------------------------------------------------------------------
+ /// Add an arbitrary Variable object (e.g. one that specifics a global or static)
+ /// to a Frame's list of ValueObjects.
+ ///
+ /// @params [in] variable_sp
+ /// The Variable to base this ValueObject on
+ ///
+ /// @params [in] use_dynamic
+ /// Whether the correct dynamic type of the variable should be
+ /// determined before creating the ValueObject, or if the static type
+ /// is sufficient. One of the DynamicValueType enumerated values.
+ ///
+ /// @return
+ // A ValueObject for this variable.
+ //------------------------------------------------------------------
+ virtual lldb::ValueObjectSP
+ TrackGlobalVariable (const lldb::VariableSP &variable_sp, lldb::DynamicValueType use_dynamic) = 0;
+
+ //------------------------------------------------------------------
+ // lldb::ExecutionContextScope pure virtual functions
+ //------------------------------------------------------------------
+ virtual lldb::TargetSP
+ CalculateTarget () = 0;
+
+ virtual lldb::ProcessSP
+ CalculateProcess () = 0;
+
+ virtual lldb::ThreadSP
+ CalculateThread () = 0;
+
+ virtual lldb::FrameSP
+ CalculateFrame () = 0;
+
+ virtual void
+ CalculateExecutionContext (ExecutionContext &exe_ctx) = 0;
+
+protected:
+ friend class StackFrameList;
+ friend class StackFrame;
+
+ virtual void
+ SetSymbolContextScope (SymbolContextScope *symbol_scope) = 0;
+
+ virtual void
+ UpdateCurrentFrameFromPreviousFrame (Frame &prev_frame) = 0;
+
+ virtual void
+ UpdatePreviousFrameFromCurrentFrame (Frame &curr_frame) = 0;
+
+ virtual const char *
+ GetFrameType ()
+ {
+ return "Frame";
+ }
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_Frame_h_
diff --git a/lldb/include/lldb/Target/Process.h b/lldb/include/lldb/Target/Process.h
index 65c7328..d8467f8 100644
--- a/lldb/include/lldb/Target/Process.h
+++ b/lldb/include/lldb/Target/Process.h
@@ -3478,10 +3478,10 @@
return lldb::ThreadSP();
}
- virtual lldb::StackFrameSP
- CalculateStackFrame ()
+ virtual lldb::FrameSP
+ CalculateFrame ()
{
- return lldb::StackFrameSP();
+ return lldb::FrameSP();
}
virtual void
diff --git a/lldb/include/lldb/Target/RegisterContext.h b/lldb/include/lldb/Target/RegisterContext.h
index bc24cf9..067e22c 100644
--- a/lldb/include/lldb/Target/RegisterContext.h
+++ b/lldb/include/lldb/Target/RegisterContext.h
@@ -178,8 +178,8 @@
virtual lldb::ThreadSP
CalculateThread ();
- virtual lldb::StackFrameSP
- CalculateStackFrame ();
+ virtual lldb::FrameSP
+ CalculateFrame ();
virtual void
CalculateExecutionContext (ExecutionContext &exe_ctx);
diff --git a/lldb/include/lldb/Target/StackFrame.h b/lldb/include/lldb/Target/StackFrame.h
index c7b7e37..c580317 100644
--- a/lldb/include/lldb/Target/StackFrame.h
+++ b/lldb/include/lldb/Target/StackFrame.h
@@ -22,13 +22,20 @@
#include "lldb/Core/ValueObjectList.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/ExecutionContextScope.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/StackID.h"
namespace lldb_private {
+/// StackFrame:
+///
+/// This class provides an interface to a stack frame in a process/thread.
+///
+/// This class is used for a live stack frame in a live process at the current point in time.
+/// It may represent either an actual stack frame or a synthesized inlined function frame.
+
class StackFrame :
- public std::enable_shared_from_this<StackFrame>,
- public ExecutionContextScope
+ public Frame
{
public:
enum ExpressionPathOption
@@ -43,29 +50,29 @@
// Constructors and Destructors
//------------------------------------------------------------------
StackFrame (const lldb::ThreadSP &thread_sp,
- lldb::user_id_t frame_idx,
- lldb::user_id_t concrete_frame_idx,
- lldb::addr_t cfa,
- lldb::addr_t pc,
+ lldb::user_id_t frame_idx,
+ lldb::user_id_t concrete_frame_idx,
+ lldb::addr_t cfa,
+ lldb::addr_t pc,
const SymbolContext *sc_ptr);
StackFrame (const lldb::ThreadSP &thread_sp,
- lldb::user_id_t frame_idx,
- lldb::user_id_t concrete_frame_idx,
- const lldb::RegisterContextSP ®_context_sp,
- lldb::addr_t cfa,
- lldb::addr_t pc,
- const SymbolContext *sc_ptr);
-
- StackFrame (const lldb::ThreadSP &thread_sp,
- lldb::user_id_t frame_idx,
- lldb::user_id_t concrete_frame_idx,
- const lldb::RegisterContextSP ®_context_sp,
- lldb::addr_t cfa,
- const Address& pc,
+ lldb::user_id_t frame_idx,
+ lldb::user_id_t concrete_frame_idx,
+ const lldb::RegisterContextSP ®_context_sp,
+ lldb::addr_t cfa,
+ lldb::addr_t pc,
const SymbolContext *sc_ptr);
- virtual ~StackFrame ();
+ StackFrame (const lldb::ThreadSP &thread_sp,
+ lldb::user_id_t frame_idx,
+ lldb::user_id_t concrete_frame_idx,
+ const lldb::RegisterContextSP ®_context_sp,
+ lldb::addr_t cfa,
+ const Address& pc,
+ const SymbolContext *sc_ptr);
+
+ ~StackFrame ();
lldb::ThreadSP
GetThread () const
@@ -78,8 +85,8 @@
const Address&
GetFrameCodeAddress();
-
- void
+
+ bool
ChangePC (lldb::addr_t pc);
const SymbolContext&
@@ -106,10 +113,9 @@
lldb::VariableListSP
GetInScopeVariableList (bool get_file_globals);
- // See ExpressionPathOption enumeration for "options" values
lldb::ValueObjectSP
- GetValueForVariableExpressionPath (const char *var_expr,
- lldb::DynamicValueType use_dynamic,
+ GetValueForVariableExpressionPath (const char *var_expr,
+ lldb::DynamicValueType use_dynamic,
uint32_t options,
lldb::VariableSP &var_sp,
Error &error);
@@ -122,10 +128,16 @@
void
DumpUsingSettingsFormat (Stream *strm, const char *frame_marker = NULL);
-
+
void
Dump (Stream *strm, bool show_frame_index, bool show_fullpaths);
-
+
+ bool
+ GetStatus (Stream &strm,
+ bool show_frame_info,
+ bool show_source,
+ const char *frame_marker = NULL);
+
bool
IsInlined ();
@@ -137,37 +149,31 @@
{
return m_concrete_frame_index;
}
-
+
lldb::ValueObjectSP
GetValueObjectForFrameVariable (const lldb::VariableSP &variable_sp, lldb::DynamicValueType use_dynamic);
lldb::ValueObjectSP
TrackGlobalVariable (const lldb::VariableSP &variable_sp, lldb::DynamicValueType use_dynamic);
-
+
//------------------------------------------------------------------
// lldb::ExecutionContextScope pure virtual functions
//------------------------------------------------------------------
virtual lldb::TargetSP
CalculateTarget ();
-
+
virtual lldb::ProcessSP
CalculateProcess ();
-
+
virtual lldb::ThreadSP
CalculateThread ();
-
- virtual lldb::StackFrameSP
- CalculateStackFrame ();
+
+ virtual lldb::FrameSP
+ CalculateFrame ();
virtual void
CalculateExecutionContext (ExecutionContext &exe_ctx);
-
- bool
- GetStatus (Stream &strm,
- bool show_frame_info,
- bool show_source,
- const char *frame_marker = NULL);
-
+
protected:
friend class StackFrameList;
@@ -175,14 +181,16 @@
SetSymbolContextScope (SymbolContextScope *symbol_scope);
void
- UpdateCurrentFrameFromPreviousFrame (StackFrame &prev_frame);
-
- void
- UpdatePreviousFrameFromCurrentFrame (StackFrame &curr_frame);
+ UpdateCurrentFrameFromPreviousFrame (Frame &prev_frame);
- bool
- HasCachedData () const;
-
+ void
+ UpdatePreviousFrameFromCurrentFrame (Frame &curr_frame);
+
+ virtual const char *
+ GetFrameType ()
+ {
+ return "StackFrame";
+ }
private:
//------------------------------------------------------------------
// For StackFrame only
diff --git a/lldb/include/lldb/Target/StackFrameList.h b/lldb/include/lldb/Target/StackFrameList.h
index 2680be3..2f67bc0 100644
--- a/lldb/include/lldb/Target/StackFrameList.h
+++ b/lldb/include/lldb/Target/StackFrameList.h
@@ -17,7 +17,7 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Host/Mutex.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
namespace lldb_private {
@@ -36,18 +36,18 @@
uint32_t
GetNumFrames (bool can_create = true);
- lldb::StackFrameSP
+ lldb::FrameSP
GetFrameAtIndex (uint32_t idx);
- lldb::StackFrameSP
+ lldb::FrameSP
GetFrameWithConcreteFrameIndex (uint32_t unwind_idx);
- lldb::StackFrameSP
+ lldb::FrameSP
GetFrameWithStackID (const StackID &stack_id);
// Mark a stack frame as the current frame
uint32_t
- SetSelectedFrame (lldb_private::StackFrame *frame);
+ SetSelectedFrame (lldb_private::Frame *frame);
uint32_t
GetSelectedFrameIndex () const;
@@ -57,7 +57,7 @@
SetSelectedFrameByIndex (uint32_t idx);
uint32_t
- GetVisibleStackFrameIndex(uint32_t idx)
+ GetVisibleFrameIndex(uint32_t idx)
{
if (m_current_inlined_depth < UINT32_MAX)
return idx - m_current_inlined_depth;
@@ -80,8 +80,8 @@
void
Dump (Stream *s);
- lldb::StackFrameSP
- GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr);
+ lldb::FrameSP
+ GetFrameSPForFramePtr (Frame *stack_frame_ptr);
size_t
GetStatus (Stream &strm,
@@ -96,7 +96,7 @@
friend class Thread;
bool
- SetFrameAtIndex (uint32_t idx, lldb::StackFrameSP &frame_sp);
+ SetFrameAtIndex (uint32_t idx, lldb::FrameSP &frame_sp);
static void
Merge (std::unique_ptr<StackFrameList>& curr_ap,
@@ -132,7 +132,7 @@
//------------------------------------------------------------------
// Classes that inherit from StackFrameList can see and modify these
//------------------------------------------------------------------
- typedef std::vector<lldb::StackFrameSP> collection;
+ typedef std::vector<lldb::FrameSP> collection;
typedef collection::iterator iterator;
typedef collection::const_iterator const_iterator;
diff --git a/lldb/include/lldb/Target/StackID.h b/lldb/include/lldb/Target/StackID.h
index 7e713c7..32e7853 100644
--- a/lldb/include/lldb/Target/StackID.h
+++ b/lldb/include/lldb/Target/StackID.h
@@ -109,6 +109,7 @@
protected:
+ friend class Frame;
friend class StackFrame;
void
diff --git a/lldb/include/lldb/Target/Target.h b/lldb/include/lldb/Target/Target.h
index a7609d3..77e5aff 100644
--- a/lldb/include/lldb/Target/Target.h
+++ b/lldb/include/lldb/Target/Target.h
@@ -961,8 +961,8 @@
virtual lldb::ThreadSP
CalculateThread ();
- virtual lldb::StackFrameSP
- CalculateStackFrame ();
+ virtual lldb::FrameSP
+ CalculateFrame ();
virtual void
CalculateExecutionContext (ExecutionContext &exe_ctx);
@@ -984,7 +984,7 @@
// in in th execution context.
ExecutionResults
EvaluateExpression (const char *expression,
- StackFrame *frame,
+ Frame *frame,
lldb::ValueObjectSP &result_valobj_sp,
const EvaluateExpressionOptions& options = EvaluateExpressionOptions());
diff --git a/lldb/include/lldb/Target/Thread.h b/lldb/include/lldb/Target/Thread.h
index 7dac37c..228e175 100644
--- a/lldb/include/lldb/Target/Thread.h
+++ b/lldb/include/lldb/Target/Thread.h
@@ -109,7 +109,7 @@
static StackID
GetStackIDFromEvent (const Event *event_ptr);
- static lldb::StackFrameSP
+ static lldb::FrameSP
GetStackFrameFromEvent (const Event *event_ptr);
lldb::ThreadSP
@@ -357,13 +357,13 @@
return GetStackFrameList()->GetNumFrames();
}
- virtual lldb::StackFrameSP
+ virtual lldb::FrameSP
GetStackFrameAtIndex (uint32_t idx)
{
return GetStackFrameList()->GetFrameAtIndex(idx);
}
- virtual lldb::StackFrameSP
+ virtual lldb::FrameSP
GetFrameWithConcreteFrameIndex (uint32_t unwind_idx);
bool
@@ -382,17 +382,17 @@
ReturnFromFrameWithIndex (uint32_t frame_idx, lldb::ValueObjectSP return_value_sp, bool broadcast = false);
Error
- ReturnFromFrame (lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return_value_sp, bool broadcast = false);
+ ReturnFromFrame (lldb::FrameSP frame_sp, lldb::ValueObjectSP return_value_sp, bool broadcast = false);
Error
JumpToLine (const FileSpec &file, uint32_t line, bool can_leave_function, std::string *warnings = NULL);
- virtual lldb::StackFrameSP
+ virtual lldb::FrameSP
GetFrameWithStackID (const StackID &stack_id)
{
if (stack_id.IsValid())
return GetStackFrameList()->GetFrameWithStackID (stack_id);
- return lldb::StackFrameSP();
+ return lldb::FrameSP();
}
uint32_t
@@ -401,7 +401,7 @@
return GetStackFrameList()->GetSelectedFrameIndex();
}
- lldb::StackFrameSP
+ lldb::FrameSP
GetSelectedFrame ()
{
lldb::StackFrameListSP stack_frame_list_sp(GetStackFrameList());
@@ -409,7 +409,7 @@
}
uint32_t
- SetSelectedFrame (lldb_private::StackFrame *frame, bool broadcast = false);
+ SetSelectedFrame (lldb_private::Frame *frame, bool broadcast = false);
bool
@@ -428,7 +428,7 @@
GetRegisterContext () = 0;
virtual lldb::RegisterContextSP
- CreateRegisterContextForFrame (StackFrame *frame) = 0;
+ CreateRegisterContextForFrame (Frame *frame) = 0;
virtual void
ClearStackFrames ();
@@ -914,14 +914,14 @@
virtual lldb::ThreadSP
CalculateThread ();
- virtual lldb::StackFrameSP
- CalculateStackFrame ();
+ virtual lldb::FrameSP
+ CalculateFrame ();
virtual void
CalculateExecutionContext (ExecutionContext &exe_ctx);
- lldb::StackFrameSP
- GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr);
+ lldb::FrameSP
+ GetFrameSPForFramePtr (Frame *stack_frame_ptr);
size_t
GetStatus (Stream &strm,
@@ -1008,6 +1008,7 @@
friend class ThreadEventData;
friend class StackFrameList;
friend class StackFrame;
+ friend class Frame;
friend class OperatingSystem;
// This is necessary to make sure thread assets get destroyed while the thread is still in good shape
diff --git a/lldb/include/lldb/Target/Unwind.h b/lldb/include/lldb/Target/Unwind.h
index 7cda4ae..5e9e754 100644
--- a/lldb/include/lldb/Target/Unwind.h
+++ b/lldb/include/lldb/Target/Unwind.h
@@ -79,7 +79,7 @@
}
lldb::RegisterContextSP
- CreateRegisterContextForFrame (StackFrame *frame)
+ CreateRegisterContextForFrame (Frame *frame)
{
Mutex::Locker locker(m_unwind_mutex);
return DoCreateRegisterContextForFrame (frame);
@@ -107,7 +107,7 @@
lldb::addr_t& pc) = 0;
virtual lldb::RegisterContextSP
- DoCreateRegisterContextForFrame (StackFrame *frame) = 0;
+ DoCreateRegisterContextForFrame (Frame *frame) = 0;
Thread &m_thread;
Mutex m_unwind_mutex;
diff --git a/lldb/include/lldb/lldb-forward.h b/lldb/include/lldb/lldb-forward.h
index ee59e0e..ff01ca7 100644
--- a/lldb/include/lldb/lldb-forward.h
+++ b/lldb/include/lldb/lldb-forward.h
@@ -181,8 +181,7 @@
class Settings;
class SourceManager;
class SourceManagerImpl;
-class StackFrame;
-class StackFrameImpl;
+class Frame;
class StackFrameList;
class StackID;
class StopInfo;
@@ -337,8 +336,8 @@
typedef std::weak_ptr<lldb_private::Section> SectionWP;
typedef std::shared_ptr<lldb_private::SearchFilter> SearchFilterSP;
typedef std::shared_ptr<lldb_private::Settings> SettingsSP;
- typedef std::shared_ptr<lldb_private::StackFrame> StackFrameSP;
- typedef std::weak_ptr<lldb_private::StackFrame> StackFrameWP;
+ typedef std::shared_ptr<lldb_private::Frame> FrameSP;
+ typedef std::weak_ptr<lldb_private::Frame> FrameWP;
typedef std::shared_ptr<lldb_private::StackFrameList> StackFrameListSP;
typedef std::shared_ptr<lldb_private::StopInfo> StopInfoSP;
typedef std::shared_ptr<lldb_private::StoppointLocation> StoppointLocationSP;
diff --git a/lldb/scripts/Python/python-wrapper.swig b/lldb/scripts/Python/python-wrapper.swig
index 4a3ad31..70948a0 100644
--- a/lldb/scripts/Python/python-wrapper.swig
+++ b/lldb/scripts/Python/python-wrapper.swig
@@ -211,7 +211,7 @@
(
const char *python_function_name,
const char *session_dictionary_name,
- const lldb::StackFrameSP& frame_sp,
+ const lldb::FrameSP& frame_sp,
const lldb::BreakpointLocationSP& bp_loc_sp
)
{
@@ -251,7 +251,7 @@
(
const char *python_function_name,
const char *session_dictionary_name,
- const lldb::StackFrameSP& frame_sp,
+ const lldb::FrameSP& frame_sp,
const lldb::WatchpointSP& wp_sp
)
{
@@ -855,7 +855,7 @@
LLDBSWIGPythonRunScriptKeywordFrame
(const char* python_function_name,
const char* session_dictionary_name,
-lldb::StackFrameSP& frame,
+lldb::FrameSP& frame,
std::string& output)
{
diff --git a/lldb/source/API/SBBlock.cpp b/lldb/source/API/SBBlock.cpp
index c8a665f..86215e6 100644
--- a/lldb/source/API/SBBlock.cpp
+++ b/lldb/source/API/SBBlock.cpp
@@ -20,7 +20,7 @@
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/VariableList.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
using namespace lldb;
@@ -264,7 +264,7 @@
SBValueList value_list;
if (block)
{
- StackFrameSP frame_sp(frame.GetFrameSP());
+ FrameSP frame_sp(frame.GetFrameSP());
VariableListSP variable_list_sp (block->GetBlockVariableList (true));
if (variable_list_sp)
diff --git a/lldb/source/API/SBCommandInterpreter.cpp b/lldb/source/API/SBCommandInterpreter.cpp
index ac77e2e..bc662c9 100644
--- a/lldb/source/API/SBCommandInterpreter.cpp
+++ b/lldb/source/API/SBCommandInterpreter.cpp
@@ -392,13 +392,13 @@
extern "C" bool
LLDBSwigPythonBreakpointCallbackFunction (const char *python_function_name,
const char *session_dictionary_name,
- const lldb::StackFrameSP& sb_frame,
+ const lldb::FrameSP& sb_frame,
const lldb::BreakpointLocationSP& sb_bp_loc);
extern "C" bool
LLDBSwigPythonWatchpointCallbackFunction (const char *python_function_name,
const char *session_dictionary_name,
- const lldb::StackFrameSP& sb_frame,
+ const lldb::FrameSP& sb_frame,
const lldb::WatchpointSP& sb_wp);
extern "C" bool
@@ -473,7 +473,7 @@
extern "C" bool
LLDBSWIGPythonRunScriptKeywordFrame (const char* python_function_name,
const char* session_dictionary_name,
- lldb::StackFrameSP& frame,
+ lldb::FrameSP& frame,
std::string& output);
extern "C" void*
diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp
index 1a1a63b..02307c4 100644
--- a/lldb/source/API/SBFrame.cpp
+++ b/lldb/source/API/SBFrame.cpp
@@ -33,7 +33,7 @@
#include "lldb/Target/Target.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/StackID.h"
#include "lldb/Target/Thread.h"
@@ -54,7 +54,7 @@
{
}
-SBFrame::SBFrame (const StackFrameSP &lldb_object_sp) :
+SBFrame::SBFrame (const FrameSP &lldb_object_sp) :
m_opaque_sp (new ExecutionContextRef (lldb_object_sp))
{
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
@@ -86,16 +86,16 @@
{
}
-StackFrameSP
+FrameSP
SBFrame::GetFrameSP() const
{
if (m_opaque_sp)
return m_opaque_sp->GetFrameSP();
- return StackFrameSP();
+ return FrameSP();
}
void
-SBFrame::SetFrameSP (const StackFrameSP &lldb_object_sp)
+SBFrame::SetFrameSP (const FrameSP &lldb_object_sp)
{
return m_opaque_sp->SetFrameSP(lldb_object_sp);
}
@@ -114,7 +114,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -156,7 +156,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -198,7 +198,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -238,7 +238,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -278,7 +278,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -317,7 +317,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -355,7 +355,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Process *process = exe_ctx.GetProcessPtr();
@@ -395,7 +395,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -432,7 +432,7 @@
uint32_t frame_idx = UINT32_MAX;
ExecutionContext exe_ctx(m_opaque_sp.get());
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
if (frame)
frame_idx = frame->GetFrameIndex ();
@@ -451,7 +451,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -491,7 +491,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -532,7 +532,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -572,7 +572,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -612,7 +612,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -653,7 +653,7 @@
{
SBValue sb_value;
ExecutionContext exe_ctx(m_opaque_sp.get());
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (frame && target)
{
@@ -678,7 +678,7 @@
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -693,7 +693,7 @@
Error error;
ValueObjectSP value_sp (frame->GetValueForVariableExpressionPath (var_path,
eNoDynamicValues,
- StackFrame::eExpressionPathOptionCheckPtrVsMember | StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
+ Frame::eExpressionPathOptionCheckPtrVsMember | Frame::eExpressionPathOptionsAllowDirectIVarAccess,
var_sp,
error));
sb_value.SetSP(value_sp, use_dynamic);
@@ -718,7 +718,7 @@
{
SBValue value;
ExecutionContext exe_ctx(m_opaque_sp.get());
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (frame && target)
{
@@ -747,7 +747,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -807,7 +807,7 @@
{
SBValue value;
ExecutionContext exe_ctx(m_opaque_sp.get());
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (frame && target)
{
@@ -834,7 +834,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -967,8 +967,8 @@
bool
SBFrame::IsEqual (const SBFrame &that) const
{
- lldb::StackFrameSP this_sp = GetFrameSP();
- lldb::StackFrameSP that_sp = that.GetFrameSP();
+ lldb::FrameSP this_sp = GetFrameSP();
+ lldb::FrameSP that_sp = that.GetFrameSP();
return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
}
@@ -1014,7 +1014,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -1055,7 +1055,7 @@
{
SBValueList value_list;
ExecutionContext exe_ctx(m_opaque_sp.get());
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (frame && target)
{
@@ -1078,7 +1078,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
if (log)
@@ -1174,7 +1174,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -1224,7 +1224,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -1281,7 +1281,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrame *frame;
+ Frame *frame;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -1318,7 +1318,7 @@
{
SBValue result;
ExecutionContext exe_ctx(m_opaque_sp.get());
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (frame && target)
{
@@ -1374,7 +1374,7 @@
if (log)
log->Printf ("SBFrame()::EvaluateExpression (expr=\"%s\")...", expr);
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
@@ -1436,7 +1436,7 @@
{
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
ExecutionContext exe_ctx(m_opaque_sp.get());
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
@@ -1474,7 +1474,7 @@
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
const char *name = NULL;
ExecutionContext exe_ctx(m_opaque_sp.get());
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process)
diff --git a/lldb/source/API/SBInstruction.cpp b/lldb/source/API/SBInstruction.cpp
index 2334cc0..d879470 100644
--- a/lldb/source/API/SBInstruction.cpp
+++ b/lldb/source/API/SBInstruction.cpp
@@ -22,7 +22,7 @@
#include "lldb/Core/EmulateInstruction.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
using namespace lldb;
@@ -196,7 +196,7 @@
{
if (m_opaque_sp)
{
- lldb::StackFrameSP frame_sp (frame.GetFrameSP());
+ lldb::FrameSP frame_sp (frame.GetFrameSP());
if (frame_sp)
{
diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp
index cff6e4e..bb69755 100644
--- a/lldb/source/API/SBTarget.cpp
+++ b/lldb/source/API/SBTarget.cpp
@@ -2644,7 +2644,7 @@
ExecutionResults exe_results = eExecutionSetupError;
ValueObjectSP expr_value_sp;
TargetSP target_sp(GetSP());
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
if (target_sp)
{
if (expr == NULL || expr[0] == '\0')
diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp
index 0c3a17e..c972ce8 100644
--- a/lldb/source/API/SBThread.cpp
+++ b/lldb/source/API/SBThread.cpp
@@ -594,7 +594,7 @@
{
Thread *thread = exe_ctx.GetThreadPtr();
bool abort_other_plans = false;
- StackFrameSP frame_sp(thread->GetStackFrameAtIndex (0));
+ FrameSP frame_sp(thread->GetStackFrameAtIndex (0));
ThreadPlanSP new_plan_sp;
if (frame_sp)
@@ -645,7 +645,7 @@
bool abort_other_plans = false;
Thread *thread = exe_ctx.GetThreadPtr();
- StackFrameSP frame_sp(thread->GetStackFrameAtIndex (0));
+ FrameSP frame_sp(thread->GetStackFrameAtIndex (0));
ThreadPlanSP new_plan_sp;
if (frame_sp && frame_sp->HasDebugInformation ())
@@ -711,7 +711,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrameSP frame_sp (sb_frame.GetFrameSP());
+ FrameSP frame_sp (sb_frame.GetFrameSP());
if (log)
{
SBStream frame_desc_strm;
@@ -801,7 +801,7 @@
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
- StackFrameSP frame_sp (sb_frame.GetFrameSP());
+ FrameSP frame_sp (sb_frame.GetFrameSP());
if (log)
{
@@ -1112,7 +1112,7 @@
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBFrame sb_frame;
- StackFrameSP frame_sp;
+ FrameSP frame_sp;
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
@@ -1148,7 +1148,7 @@
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBFrame sb_frame;
- StackFrameSP frame_sp;
+ FrameSP frame_sp;
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
@@ -1184,7 +1184,7 @@
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBFrame sb_frame;
- StackFrameSP frame_sp;
+ FrameSP frame_sp;
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp
index 51b6790..993ffe4 100644
--- a/lldb/source/API/SBValue.cpp
+++ b/lldb/source/API/SBValue.cpp
@@ -38,7 +38,7 @@
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
@@ -199,13 +199,13 @@
return ThreadSP();
}
- StackFrameSP
+ FrameSP
GetFrameSP ()
{
if (m_valobj_sp)
return m_valobj_sp->GetFrameSP();
else
- return StackFrameSP();
+ return FrameSP();
}
private:
@@ -1252,7 +1252,7 @@
SBValue::GetFrame()
{
SBFrame sb_frame;
- StackFrameSP frame_sp;
+ FrameSP frame_sp;
if (m_opaque_sp)
{
frame_sp = m_opaque_sp->GetFrameSP();
diff --git a/lldb/source/Commands/CommandObjectArgs.cpp b/lldb/source/Commands/CommandObjectArgs.cpp
index 3b919d1..d75bf81 100644
--- a/lldb/source/Commands/CommandObjectArgs.cpp
+++ b/lldb/source/Commands/CommandObjectArgs.cpp
@@ -30,7 +30,7 @@
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
using namespace lldb;
using namespace lldb_private;
@@ -139,7 +139,7 @@
return false;
}
- lldb::StackFrameSP thread_cur_frame = thread->GetSelectedFrame ();
+ lldb::FrameSP thread_cur_frame = thread->GetSelectedFrame ();
if (!thread_cur_frame)
{
result.AppendError ("The current thread has no current frame.");
diff --git a/lldb/source/Commands/CommandObjectBreakpoint.cpp b/lldb/source/Commands/CommandObjectBreakpoint.cpp
index c20da7f..7887380 100644
--- a/lldb/source/Commands/CommandObjectBreakpoint.cpp
+++ b/lldb/source/Commands/CommandObjectBreakpoint.cpp
@@ -26,7 +26,7 @@
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Target.h"
#include "lldb/Interpreter/CommandCompletions.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h"
@@ -581,7 +581,7 @@
// Then use the current stack frame's file.
if (!target->GetSourceManager().GetDefaultFileAndLine(file, default_line))
{
- StackFrame *cur_frame = m_exe_ctx.GetFramePtr();
+ Frame *cur_frame = m_exe_ctx.GetFramePtr();
if (cur_frame == NULL)
{
result.AppendError ("No selected frame to use to find the default file.");
diff --git a/lldb/source/Commands/CommandObjectDisassemble.cpp b/lldb/source/Commands/CommandObjectDisassemble.cpp
index fc148b1..376bf4d 100644
--- a/lldb/source/Commands/CommandObjectDisassemble.cpp
+++ b/lldb/source/Commands/CommandObjectDisassemble.cpp
@@ -27,7 +27,7 @@
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
#define DEFAULT_DISASM_BYTE_SIZE 32
@@ -370,7 +370,7 @@
else
{
AddressRange range;
- StackFrame *frame = m_exe_ctx.GetFramePtr();
+ Frame *frame = m_exe_ctx.GetFramePtr();
if (m_options.frame_line)
{
if (frame == NULL)
diff --git a/lldb/source/Commands/CommandObjectExpression.cpp b/lldb/source/Commands/CommandObjectExpression.cpp
index 8b04da6..89edf42 100644
--- a/lldb/source/Commands/CommandObjectExpression.cpp
+++ b/lldb/source/Commands/CommandObjectExpression.cpp
@@ -32,7 +32,7 @@
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "llvm/ADT/StringRef.h"
diff --git a/lldb/source/Commands/CommandObjectFrame.cpp b/lldb/source/Commands/CommandObjectFrame.cpp
index 2e852d0..a380692 100644
--- a/lldb/source/Commands/CommandObjectFrame.cpp
+++ b/lldb/source/Commands/CommandObjectFrame.cpp
@@ -42,7 +42,7 @@
#include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/Target.h"
@@ -378,7 +378,7 @@
DoExecute (Args& command, CommandReturnObject &result)
{
// No need to check "frame" for validity as eFlagRequiresFrame ensures it is valid
- StackFrame *frame = m_exe_ctx.GetFramePtr();
+ Frame *frame = m_exe_ctx.GetFramePtr();
Stream &s = result.GetOutputStream();
@@ -470,8 +470,8 @@
else // No regex, either exact variable names or variable expressions.
{
Error error;
- uint32_t expr_path_options = StackFrame::eExpressionPathOptionCheckPtrVsMember |
- StackFrame::eExpressionPathOptionsAllowDirectIVarAccess;
+ uint32_t expr_path_options = Frame::eExpressionPathOptionCheckPtrVsMember |
+ Frame::eExpressionPathOptionsAllowDirectIVarAccess;
lldb::VariableSP var_sp;
valobj_sp = frame->GetValueForVariableExpressionPath (name_cstr,
m_varobj_options.use_dynamic,
diff --git a/lldb/source/Commands/CommandObjectMemory.cpp b/lldb/source/Commands/CommandObjectMemory.cpp
index 2ee275e..dd59aae 100644
--- a/lldb/source/Commands/CommandObjectMemory.cpp
+++ b/lldb/source/Commands/CommandObjectMemory.cpp
@@ -34,7 +34,7 @@
#include "lldb/Interpreter/OptionValueString.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
using namespace lldb;
using namespace lldb_private;
@@ -502,7 +502,7 @@
}
ConstString lookup_type_name(type_str.c_str());
- StackFrame *frame = m_exe_ctx.GetFramePtr();
+ Frame *frame = m_exe_ctx.GetFramePtr();
if (frame)
{
sc = frame->GetSymbolContext (eSymbolContextModule);
diff --git a/lldb/source/Commands/CommandObjectTarget.cpp b/lldb/source/Commands/CommandObjectTarget.cpp
index ef431e2..d5cb1df 100644
--- a/lldb/source/Commands/CommandObjectTarget.cpp
+++ b/lldb/source/Commands/CommandObjectTarget.cpp
@@ -49,7 +49,7 @@
#include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Symbol/VariableList.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"
@@ -909,7 +909,7 @@
if (num_compile_units == 0 && num_shlibs == 0)
{
bool success = false;
- StackFrame *frame = m_exe_ctx.GetFramePtr();
+ Frame *frame = m_exe_ctx.GetFramePtr();
CompileUnit *comp_unit = NULL;
if (frame)
{
@@ -3957,7 +3957,7 @@
break;
}
- StackFrameSP frame = m_exe_ctx.GetFrameSP();
+ FrameSP frame = m_exe_ctx.GetFrameSP();
if (!frame)
return false;
@@ -4546,7 +4546,7 @@
const StateType process_state = process->GetState();
if (StateIsStoppedState (process_state, true))
{
- StackFrame *frame = m_exe_ctx.GetFramePtr();
+ Frame *frame = m_exe_ctx.GetFramePtr();
if (frame)
{
ModuleSP frame_module_sp (frame->GetSymbolContext(eSymbolContextModule).module_sp);
diff --git a/lldb/source/Commands/CommandObjectThread.cpp b/lldb/source/Commands/CommandObjectThread.cpp
index f46a221..ca64f4b 100644
--- a/lldb/source/Commands/CommandObjectThread.cpp
+++ b/lldb/source/Commands/CommandObjectThread.cpp
@@ -465,7 +465,7 @@
if (m_step_type == eStepTypeInto)
{
- StackFrame *frame = thread->GetStackFrameAtIndex(0).get();
+ Frame *frame = thread->GetStackFrameAtIndex(0).get();
if (frame->HasDebugInformation ())
{
@@ -487,7 +487,7 @@
}
else if (m_step_type == eStepTypeOver)
{
- StackFrame *frame = thread->GetStackFrameAtIndex(0).get();
+ Frame *frame = thread->GetStackFrameAtIndex(0).get();
if (frame->HasDebugInformation())
new_plan_sp = thread->QueueThreadPlanForStepOverRange (abort_other_plans,
@@ -999,7 +999,7 @@
const bool abort_other_plans = false;
- StackFrame *frame = thread->GetStackFrameAtIndex(m_options.m_frame_idx).get();
+ Frame *frame = thread->GetStackFrameAtIndex(m_options.m_frame_idx).get();
if (frame == NULL)
{
@@ -1411,7 +1411,7 @@
ValueObjectSP return_valobj_sp;
- StackFrameSP frame_sp = m_exe_ctx.GetFrameSP();
+ FrameSP frame_sp = m_exe_ctx.GetFrameSP();
uint32_t frame_idx = frame_sp->GetFrameIndex();
if (frame_sp->IsInlined())
@@ -1588,7 +1588,7 @@
bool DoExecute (Args& args, CommandReturnObject &result)
{
RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext();
- StackFrame *frame = m_exe_ctx.GetFramePtr();
+ Frame *frame = m_exe_ctx.GetFramePtr();
Thread *thread = m_exe_ctx.GetThreadPtr();
Target *target = m_exe_ctx.GetTargetPtr();
const SymbolContext &sym_ctx = frame->GetSymbolContext (eSymbolContextLineEntry);
diff --git a/lldb/source/Commands/CommandObjectWatchpoint.cpp b/lldb/source/Commands/CommandObjectWatchpoint.cpp
index ae490e3..4a570d8 100644
--- a/lldb/source/Commands/CommandObjectWatchpoint.cpp
+++ b/lldb/source/Commands/CommandObjectWatchpoint.cpp
@@ -989,7 +989,7 @@
DoExecute (Args& command, CommandReturnObject &result)
{
Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
- StackFrame *frame = m_exe_ctx.GetFramePtr();
+ Frame *frame = m_exe_ctx.GetFramePtr();
// If no argument is present, issue an error message. There's no way to set a watchpoint.
if (command.GetArgumentCount() <= 0)
@@ -1024,8 +1024,8 @@
// Things have checked out ok...
Error error;
- uint32_t expr_path_options = StackFrame::eExpressionPathOptionCheckPtrVsMember |
- StackFrame::eExpressionPathOptionsAllowDirectIVarAccess;
+ uint32_t expr_path_options = Frame::eExpressionPathOptionCheckPtrVsMember |
+ Frame::eExpressionPathOptionsAllowDirectIVarAccess;
valobj_sp = frame->GetValueForVariableExpressionPath (command.GetArgumentAtIndex(0),
eNoDynamicValues,
expr_path_options,
@@ -1188,7 +1188,7 @@
m_option_group.NotifyOptionParsingStarting(); // This is a raw command, so notify the option group
Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
- StackFrame *frame = m_exe_ctx.GetFramePtr();
+ Frame *frame = m_exe_ctx.GetFramePtr();
Args command(raw_command);
const char *expr = NULL;
diff --git a/lldb/source/Core/Debugger.cpp b/lldb/source/Core/Debugger.cpp
index 3941d82..ea947a6 100644
--- a/lldb/source/Core/Debugger.cpp
+++ b/lldb/source/Core/Debugger.cpp
@@ -1137,7 +1137,7 @@
}
static void
-TestPromptFormats (StackFrame *frame)
+TestPromptFormats (Frame *frame)
{
if (frame == NULL)
return;
@@ -1359,7 +1359,7 @@
static ValueObjectSP
ExpandIndexedExpression (ValueObject* valobj,
size_t index,
- StackFrame* frame,
+ Frame* frame,
bool deref_pointer)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
@@ -2112,7 +2112,7 @@
{
if (exe_ctx)
{
- StackFrame *frame = exe_ctx->GetFramePtr();
+ Frame *frame = exe_ctx->GetFramePtr();
if (frame)
{
var_name_begin += ::strlen ("frame.");
@@ -2338,7 +2338,7 @@
}
else if (IsToken (var_name_begin, "pc-offset}"))
{
- StackFrame *frame = exe_ctx->GetFramePtr();
+ Frame *frame = exe_ctx->GetFramePtr();
var_success = frame != NULL;
if (var_success)
{
@@ -2397,7 +2397,7 @@
// If format addr is valid, then we need to print an address
if (reg_num != LLDB_INVALID_REGNUM)
{
- StackFrame *frame = exe_ctx->GetFramePtr();
+ Frame *frame = exe_ctx->GetFramePtr();
// We have a register value to display...
if (reg_num == LLDB_REGNUM_GENERIC_PC && reg_kind == eRegisterKindGeneric)
{
diff --git a/lldb/source/Core/Disassembler.cpp b/lldb/source/Core/Disassembler.cpp
index 7f830ac..b82d5ca 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -35,7 +35,7 @@
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
#define DEFAULT_DISASM_BYTE_SIZE 32
@@ -410,7 +410,7 @@
AddressRange sc_range;
const Address *pc_addr_ptr = NULL;
ExecutionContextScope *exe_scope = exe_ctx.GetBestExecutionContextScope();
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
TargetSP target_sp (exe_ctx.GetTargetSP());
SourceManager &source_manager = target_sp ? target_sp->GetSourceManager() : debugger.GetSourceManager();
@@ -518,7 +518,7 @@
)
{
AddressRange range;
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
if (frame)
{
SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol));
diff --git a/lldb/source/Core/EmulateInstruction.cpp b/lldb/source/Core/EmulateInstruction.cpp
index bf6c6d8..28c4396 100644
--- a/lldb/source/Core/EmulateInstruction.cpp
+++ b/lldb/source/Core/EmulateInstruction.cpp
@@ -292,7 +292,7 @@
if (!baton || dst == NULL || dst_len == 0)
return 0;
- StackFrame *frame = (StackFrame *) baton;
+ Frame *frame = (Frame *) baton;
ProcessSP process_sp (frame->CalculateProcess());
if (process_sp)
@@ -314,7 +314,7 @@
if (!baton || src == NULL || src_len == 0)
return 0;
- StackFrame *frame = (StackFrame *) baton;
+ Frame *frame = (Frame *) baton;
ProcessSP process_sp (frame->CalculateProcess());
if (process_sp)
@@ -335,7 +335,7 @@
if (!baton)
return false;
- StackFrame *frame = (StackFrame *) baton;
+ Frame *frame = (Frame *) baton;
return frame->GetRegisterContext()->ReadRegister (reg_info, reg_value);
}
@@ -349,7 +349,7 @@
if (!baton)
return false;
- StackFrame *frame = (StackFrame *) baton;
+ Frame *frame = (Frame *) baton;
return frame->GetRegisterContext()->WriteRegister (reg_info, reg_value);
}
diff --git a/lldb/source/Core/ValueObject.cpp b/lldb/source/Core/ValueObject.cpp
index d39d21a..25fa4c2 100644
--- a/lldb/source/Core/ValueObject.cpp
+++ b/lldb/source/Core/ValueObject.cpp
@@ -3732,7 +3732,7 @@
{
m_exe_ctx_ref.SetThreadSP(thread_sp);
- StackFrameSP frame_sp (exe_ctx.GetFrameSP());
+ FrameSP frame_sp (exe_ctx.GetFrameSP());
if (!frame_sp)
{
if (use_selected)
@@ -3816,7 +3816,7 @@
{
if (m_exe_ctx_ref.HasFrameRef())
{
- StackFrameSP frame_sp (m_exe_ctx_ref.GetFrameSP());
+ FrameSP frame_sp (m_exe_ctx_ref.GetFrameSP());
if (!frame_sp)
{
// We used to have a frame, but now it is gone
diff --git a/lldb/source/Core/ValueObjectRegister.cpp b/lldb/source/Core/ValueObjectRegister.cpp
index 4f21457..ad7a81b 100644
--- a/lldb/source/Core/ValueObjectRegister.cpp
+++ b/lldb/source/Core/ValueObjectRegister.cpp
@@ -77,7 +77,7 @@
{
m_error.Clear();
ExecutionContext exe_ctx(GetExecutionContextRef());
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
if (frame)
m_reg_ctx_sp = frame->GetRegisterContext();
else
@@ -177,7 +177,7 @@
m_error.Clear();
SetValueDidChange (false);
ExecutionContext exe_ctx(GetExecutionContextRef());
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
if (frame == NULL)
m_reg_ctx_sp.reset();
else
@@ -346,7 +346,7 @@
{
m_error.Clear();
ExecutionContext exe_ctx(GetExecutionContextRef());
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
if (frame == NULL)
{
m_reg_ctx_sp.reset();
diff --git a/lldb/source/Core/ValueObjectVariable.cpp b/lldb/source/Core/ValueObjectVariable.cpp
index 3d8b07a..f0e88e6 100644
--- a/lldb/source/Core/ValueObjectVariable.cpp
+++ b/lldb/source/Core/ValueObjectVariable.cpp
@@ -263,7 +263,7 @@
if (exe_ctx_ref.HasFrameRef())
{
ExecutionContext exe_ctx (exe_ctx_ref);
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
if (frame)
{
return m_variable_sp->IsInScope (frame);
diff --git a/lldb/source/DataFormatters/CF.cpp b/lldb/source/DataFormatters/CF.cpp
index a4b7a12..116017c 100644
--- a/lldb/source/DataFormatters/CF.cpp
+++ b/lldb/source/DataFormatters/CF.cpp
@@ -79,7 +79,7 @@
if (is_type_ok == false)
{
- StackFrameSP frame_sp(valobj.GetFrameSP());
+ FrameSP frame_sp(valobj.GetFrameSP());
if (!frame_sp)
return false;
ValueObjectSP count_sp;
@@ -273,7 +273,7 @@
if (is_type_ok == false)
{
- StackFrameSP frame_sp(valobj.GetFrameSP());
+ FrameSP frame_sp(valobj.GetFrameSP());
if (!frame_sp)
return false;
ValueObjectSP count_sp;
diff --git a/lldb/source/DataFormatters/CXXFormatterFunctions.cpp b/lldb/source/DataFormatters/CXXFormatterFunctions.cpp
index e004135..d96a9da 100644
--- a/lldb/source/DataFormatters/CXXFormatterFunctions.cpp
+++ b/lldb/source/DataFormatters/CXXFormatterFunctions.cpp
@@ -44,7 +44,7 @@
ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
lldb::ValueObjectSP result_sp;
Target* target = exe_ctx.GetTargetPtr();
- StackFrame* stack_frame = exe_ctx.GetFramePtr();
+ Frame* stack_frame = exe_ctx.GetFramePtr();
if (!target || !stack_frame)
return false;
@@ -78,7 +78,7 @@
ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
lldb::ValueObjectSP result_sp;
Target* target = exe_ctx.GetTargetPtr();
- StackFrame* stack_frame = exe_ctx.GetFramePtr();
+ Frame* stack_frame = exe_ctx.GetFramePtr();
if (!target || !stack_frame)
return false;
@@ -116,7 +116,7 @@
ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
lldb::ValueObjectSP result_sp;
Target* target = exe_ctx.GetTargetPtr();
- StackFrame* stack_frame = exe_ctx.GetFramePtr();
+ Frame* stack_frame = exe_ctx.GetFramePtr();
if (!target || !stack_frame)
return valobj_sp;
@@ -153,7 +153,7 @@
ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
lldb::ValueObjectSP result_sp;
Target* target = exe_ctx.GetTargetPtr();
- StackFrame* stack_frame = exe_ctx.GetFramePtr();
+ Frame* stack_frame = exe_ctx.GetFramePtr();
if (!target || !stack_frame)
return valobj_sp;
diff --git a/lldb/source/DataFormatters/FormatClasses.cpp b/lldb/source/DataFormatters/FormatClasses.cpp
index c67f86a7..ca38423 100644
--- a/lldb/source/DataFormatters/FormatClasses.cpp
+++ b/lldb/source/DataFormatters/FormatClasses.cpp
@@ -25,7 +25,7 @@
#include "lldb/DataFormatters/FormatClasses.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/ClangASTType.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
using namespace lldb;
diff --git a/lldb/source/DataFormatters/TypeFormat.cpp b/lldb/source/DataFormatters/TypeFormat.cpp
index 7f18dde..2e5fd63 100644
--- a/lldb/source/DataFormatters/TypeFormat.cpp
+++ b/lldb/source/DataFormatters/TypeFormat.cpp
@@ -25,7 +25,7 @@
#include "lldb/DataFormatters/TypeFormat.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/ClangASTType.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
using namespace lldb;
diff --git a/lldb/source/DataFormatters/TypeSummary.cpp b/lldb/source/DataFormatters/TypeSummary.cpp
index 4c75b4b..fb51fa0 100644
--- a/lldb/source/DataFormatters/TypeSummary.cpp
+++ b/lldb/source/DataFormatters/TypeSummary.cpp
@@ -26,7 +26,7 @@
#include "lldb/DataFormatters/ValueObjectPrinter.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/ClangASTType.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
#include "lldb/Host/Host.h"
@@ -62,7 +62,7 @@
StreamString s;
ExecutionContext exe_ctx (valobj->GetExecutionContextRef());
SymbolContext sc;
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
if (frame)
sc = frame->GetSymbolContext(lldb::eSymbolContextEverything);
diff --git a/lldb/source/DataFormatters/TypeSynthetic.cpp b/lldb/source/DataFormatters/TypeSynthetic.cpp
index 972be48..c5be3ed 100644
--- a/lldb/source/DataFormatters/TypeSynthetic.cpp
+++ b/lldb/source/DataFormatters/TypeSynthetic.cpp
@@ -24,7 +24,7 @@
#include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/ClangASTType.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
using namespace lldb;
diff --git a/lldb/source/Expression/ClangExpressionDeclMap.cpp b/lldb/source/Expression/ClangExpressionDeclMap.cpp
index 87c984d..172d111 100644
--- a/lldb/source/Expression/ClangExpressionDeclMap.cpp
+++ b/lldb/source/Expression/ClangExpressionDeclMap.cpp
@@ -45,7 +45,7 @@
#include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
@@ -967,7 +967,7 @@
// Only look for functions by name out in our symbols if the function
// doesn't start with our phony prefix of '$'
Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
- StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
+ Frame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
if (name_unique_cstr[0] == '$' && !namespace_decl)
{
static ConstString g_lldb_class_name ("$__lldb_class");
@@ -1293,11 +1293,11 @@
{
valobj = frame->GetValueForVariableExpressionPath(name_unique_cstr,
eNoDynamicValues,
- StackFrame::eExpressionPathOptionCheckPtrVsMember ||
- StackFrame::eExpressionPathOptionsAllowDirectIVarAccess ||
- StackFrame::eExpressionPathOptionsNoFragileObjcIvar ||
- StackFrame::eExpressionPathOptionsNoSyntheticChildren ||
- StackFrame::eExpressionPathOptionsNoSyntheticArrayRange,
+ Frame::eExpressionPathOptionCheckPtrVsMember ||
+ Frame::eExpressionPathOptionsAllowDirectIVarAccess ||
+ Frame::eExpressionPathOptionsNoFragileObjcIvar ||
+ Frame::eExpressionPathOptionsNoSyntheticChildren ||
+ Frame::eExpressionPathOptionsNoSyntheticArrayRange,
var,
err);
diff --git a/lldb/source/Expression/ClangUserExpression.cpp b/lldb/source/Expression/ClangUserExpression.cpp
index c919653..e097eb0 100644
--- a/lldb/source/Expression/ClangUserExpression.cpp
+++ b/lldb/source/Expression/ClangUserExpression.cpp
@@ -41,7 +41,7 @@
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanCallUserExpression.h"
@@ -119,7 +119,7 @@
return;
}
- StackFrame *frame = exe_ctx.GetFramePtr();
+ Frame *frame = exe_ctx.GetFramePtr();
if (frame == NULL)
{
if (log)
@@ -329,7 +329,7 @@
{
m_process_wp = exe_ctx.GetProcessSP();
- lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();
+ lldb::FrameSP frame_sp = exe_ctx.GetFrameSP();
if (frame_sp)
m_address = frame_sp->GetFrameCodeAddress();
@@ -339,7 +339,7 @@
ClangUserExpression::LockAndCheckContext (ExecutionContext &exe_ctx,
lldb::TargetSP &target_sp,
lldb::ProcessSP &process_sp,
- lldb::StackFrameSP &frame_sp)
+ lldb::FrameSP &frame_sp)
{
lldb::ProcessSP expected_process_sp = m_process_wp.lock();
process_sp = exe_ctx.GetProcessSP();
@@ -367,7 +367,7 @@
{
lldb::TargetSP target_sp;
lldb::ProcessSP process_sp;
- lldb::StackFrameSP frame_sp;
+ lldb::FrameSP frame_sp;
return LockAndCheckContext(exe_ctx, target_sp, process_sp, frame_sp);
}
@@ -558,7 +558,7 @@
}
static lldb::addr_t
-GetObjectPointer (lldb::StackFrameSP frame_sp,
+GetObjectPointer (lldb::FrameSP frame_sp,
ConstString &object_name,
Error &err)
{
@@ -575,11 +575,11 @@
valobj_sp = frame_sp->GetValueForVariableExpressionPath(object_name.AsCString(),
lldb::eNoDynamicValues,
- StackFrame::eExpressionPathOptionCheckPtrVsMember ||
- StackFrame::eExpressionPathOptionsAllowDirectIVarAccess ||
- StackFrame::eExpressionPathOptionsNoFragileObjcIvar ||
- StackFrame::eExpressionPathOptionsNoSyntheticChildren ||
- StackFrame::eExpressionPathOptionsNoSyntheticArrayRange,
+ Frame::eExpressionPathOptionCheckPtrVsMember ||
+ Frame::eExpressionPathOptionsAllowDirectIVarAccess ||
+ Frame::eExpressionPathOptionsNoFragileObjcIvar ||
+ Frame::eExpressionPathOptionsNoSyntheticChildren ||
+ Frame::eExpressionPathOptionsNoSyntheticArrayRange,
var_sp,
err);
@@ -606,7 +606,7 @@
{
lldb::TargetSP target;
lldb::ProcessSP process;
- lldb::StackFrameSP frame;
+ lldb::FrameSP frame;
if (!LockAndCheckContext(exe_ctx,
target,
diff --git a/lldb/source/Expression/DWARFExpression.cpp b/lldb/source/Expression/DWARFExpression.cpp
index b36be8e..6c54f94 100644
--- a/lldb/source/Expression/DWARFExpression.cpp
+++ b/lldb/source/Expression/DWARFExpression.cpp
@@ -36,7 +36,7 @@
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/StackID.h"
#include "lldb/Target/Thread.h"
@@ -1240,7 +1240,7 @@
{
lldb::offset_t offset = 0;
addr_t pc;
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
if (reg_ctx)
pc = reg_ctx->GetPC();
else
@@ -1327,7 +1327,7 @@
std::vector<Value> stack;
Process *process = NULL;
- StackFrame *frame = NULL;
+ Frame *frame = NULL;
if (exe_ctx)
{
diff --git a/lldb/source/Expression/IRDynamicChecks.cpp b/lldb/source/Expression/IRDynamicChecks.cpp
index 4030f14..09b3d71 100644
--- a/lldb/source/Expression/IRDynamicChecks.cpp
+++ b/lldb/source/Expression/IRDynamicChecks.cpp
@@ -15,7 +15,7 @@
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/IR/Constants.h"
diff --git a/lldb/source/Expression/Materializer.cpp b/lldb/source/Expression/Materializer.cpp
index fb9522f..0576ea0 100644
--- a/lldb/source/Expression/Materializer.cpp
+++ b/lldb/source/Expression/Materializer.cpp
@@ -19,7 +19,7 @@
#include "lldb/Symbol/Variable.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
@@ -146,7 +146,7 @@
}
}
- void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
+ void Materialize (lldb::FrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
@@ -191,7 +191,7 @@
}
}
- void Dematerialize (lldb::StackFrameSP &frame_sp,
+ void Dematerialize (lldb::FrameSP &frame_sp,
IRMemoryMap &map,
lldb::addr_t process_address,
lldb::addr_t frame_top,
@@ -418,7 +418,7 @@
m_is_reference = m_variable_sp->GetType()->GetClangForwardType().IsReferenceType();
}
- void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
+ void Materialize (lldb::FrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
@@ -533,7 +533,7 @@
}
}
- void Dematerialize (lldb::StackFrameSP &frame_sp,
+ void Dematerialize (lldb::FrameSP &frame_sp,
IRMemoryMap &map,
lldb::addr_t process_address,
lldb::addr_t frame_top,
@@ -720,7 +720,7 @@
m_alignment = 8;
}
- void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
+ void Materialize (lldb::FrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
{
if (!m_is_program_reference)
{
@@ -758,7 +758,7 @@
}
}
- void Dematerialize (lldb::StackFrameSP &frame_sp,
+ void Dematerialize (lldb::FrameSP &frame_sp,
IRMemoryMap &map,
lldb::addr_t process_address,
lldb::addr_t frame_top,
@@ -769,7 +769,7 @@
}
void Dematerialize (lldb::ClangExpressionVariableSP &result_variable_sp,
- lldb::StackFrameSP &frame_sp,
+ lldb::FrameSP &frame_sp,
IRMemoryMap &map,
lldb::addr_t process_address,
lldb::addr_t frame_top,
@@ -987,7 +987,7 @@
m_alignment = 8;
}
- void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
+ void Materialize (lldb::FrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
@@ -1031,7 +1031,7 @@
}
}
- void Dematerialize (lldb::StackFrameSP &frame_sp,
+ void Dematerialize (lldb::FrameSP &frame_sp,
IRMemoryMap &map,
lldb::addr_t process_address,
lldb::addr_t frame_top,
@@ -1115,7 +1115,7 @@
m_alignment = m_register_info.byte_size;
}
- void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
+ void Materialize (lldb::FrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
@@ -1171,7 +1171,7 @@
}
}
- void Dematerialize (lldb::StackFrameSP &frame_sp,
+ void Dematerialize (lldb::FrameSP &frame_sp,
IRMemoryMap &map,
lldb::addr_t process_address,
lldb::addr_t frame_top,
@@ -1298,7 +1298,7 @@
}
Materializer::DematerializerSP
-Materializer::Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &error)
+Materializer::Materialize (lldb::FrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &error)
{
ExecutionContextScope *exe_scope = frame_sp.get();
@@ -1344,7 +1344,7 @@
void
Materializer::Dematerializer::Dematerialize (Error &error, lldb::ClangExpressionVariableSP &result_sp, lldb::addr_t frame_bottom, lldb::addr_t frame_top)
{
- lldb::StackFrameSP frame_sp;
+ lldb::FrameSP frame_sp;
lldb::ThreadSP thread_sp = m_thread_wp.lock();
if (thread_sp)
diff --git a/lldb/source/Interpreter/Args.cpp b/lldb/source/Interpreter/Args.cpp
index ff94e0f..2a051b1 100644
--- a/lldb/source/Interpreter/Args.cpp
+++ b/lldb/source/Interpreter/Args.cpp
@@ -23,7 +23,7 @@
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Process.h"
//#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
//#include "lldb/Target/Thread.h"
diff --git a/lldb/source/Interpreter/ScriptInterpreterPython.cpp b/lldb/source/Interpreter/ScriptInterpreterPython.cpp
index fc76f04..87afd3f 100644
--- a/lldb/source/Interpreter/ScriptInterpreterPython.cpp
+++ b/lldb/source/Interpreter/ScriptInterpreterPython.cpp
@@ -2196,7 +2196,7 @@
if (python_function_name != NULL
&& python_function_name[0] != '\0')
{
- const StackFrameSP stop_frame_sp (exe_ctx.GetFrameSP());
+ const FrameSP stop_frame_sp (exe_ctx.GetFrameSP());
BreakpointSP breakpoint_sp = target->GetBreakpointByID (break_id);
if (breakpoint_sp)
{
@@ -2251,7 +2251,7 @@
if (python_function_name != NULL
&& python_function_name[0] != '\0')
{
- const StackFrameSP stop_frame_sp (exe_ctx.GetFrameSP());
+ const FrameSP stop_frame_sp (exe_ctx.GetFrameSP());
WatchpointSP wp_sp = target->GetWatchpointList().FindByID (watch_id);
if (wp_sp)
{
@@ -2661,7 +2661,7 @@
bool
ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
- StackFrame* frame,
+ Frame* frame,
std::string& output,
Error& error)
{
@@ -2682,7 +2682,7 @@
return false;
}
{
- StackFrameSP frame_sp(frame->shared_from_this());
+ FrameSP frame_sp(frame->shared_from_this());
Locker py_lock(this);
ret_val = g_swig_run_script_keyword_frame (impl_function, m_dictionary_name.c_str(), frame_sp, output);
if (!ret_val)
diff --git a/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp b/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
index f27c294..d3d6f06 100644
--- a/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
+++ b/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
@@ -504,7 +504,7 @@
}
Error
-ABIMacOSX_arm::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
+ABIMacOSX_arm::SetReturnValueObject(lldb::FrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
{
Error error;
if (!new_value_sp)
diff --git a/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h b/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h
index 27cea85..97315fb 100644
--- a/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h
+++ b/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h
@@ -42,7 +42,7 @@
lldb_private::ValueList &values) const;
virtual lldb_private::Error
- SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value);
+ SetReturnValueObject(lldb::FrameSP &frame_sp, lldb::ValueObjectSP &new_value);
protected:
virtual lldb::ValueObjectSP
diff --git a/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp b/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp
index c64623f..6ad3b85 100644
--- a/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp
+++ b/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp
@@ -676,7 +676,7 @@
}
Error
-ABIMacOSX_i386::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
+ABIMacOSX_i386::SetReturnValueObject(lldb::FrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
{
Error error;
if (!new_value_sp)
diff --git a/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h b/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h
index 5428d0c..95e5245 100644
--- a/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h
+++ b/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h
@@ -52,7 +52,7 @@
lldb_private::ValueList &values) const;
virtual lldb_private::Error
- SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value);
+ SetReturnValueObject(lldb::FrameSP &frame_sp, lldb::ValueObjectSP &new_value);
protected:
virtual lldb::ValueObjectSP
diff --git a/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp b/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp
index 7d8dc9f..e178da8 100644
--- a/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp
+++ b/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp
@@ -25,7 +25,7 @@
#include "lldb/Target/Target.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Thread.h"
#include "llvm/ADT/Triple.h"
@@ -557,7 +557,7 @@
}
Error
-ABISysV_x86_64::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
+ABISysV_x86_64::SetReturnValueObject(lldb::FrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
{
Error error;
if (!new_value_sp)
diff --git a/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h b/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h
index d9d6fd7..ac41971 100644
--- a/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h
+++ b/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h
@@ -46,7 +46,7 @@
lldb_private::ValueList &values) const;
virtual lldb_private::Error
- SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value);
+ SetReturnValueObject(lldb::FrameSP &frame_sp, lldb::ValueObjectSP &new_value);
protected:
lldb::ValueObjectSP
diff --git a/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp b/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
index 61c3c64..b1aea0c 100644
--- a/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
+++ b/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
@@ -36,7 +36,7 @@
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Core/RegularExpression.h"
diff --git a/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp b/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
index 1b2a1f6..0a5ee88 100644
--- a/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
+++ b/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
@@ -22,7 +22,7 @@
#include "lldb/Host/Symbols.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlanRunToAddress.h"
diff --git a/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
index f29a481..ebe1aa9 100644
--- a/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
+++ b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
@@ -26,7 +26,7 @@
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlanRunToAddress.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "DynamicLoaderMacOSXDYLD.h"
@@ -216,7 +216,7 @@
ThreadSP thread_sp (m_process->GetThreadList().GetThreadAtIndex(0));
if (thread_sp)
{
- lldb::StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex(0));
+ lldb::FrameSP frame_sp (thread_sp->GetStackFrameAtIndex(0));
if (frame_sp)
{
const Symbol *symbol = frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol;
@@ -1604,7 +1604,7 @@
DynamicLoaderMacOSXDYLD::GetStepThroughTrampolinePlan (Thread &thread, bool stop_others)
{
ThreadPlanSP thread_plan_sp;
- StackFrame *current_frame = thread.GetStackFrameAtIndex(0).get();
+ Frame *current_frame = thread.GetStackFrameAtIndex(0).get();
const SymbolContext ¤t_context = current_frame->GetSymbolContext(eSymbolContextSymbol);
Symbol *current_symbol = current_context.symbol;
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
diff --git a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
index 8e8314f..a2d3ce6 100644
--- a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
+++ b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
@@ -379,7 +379,7 @@
{
ThreadPlanSP thread_plan_sp;
- StackFrame *frame = thread.GetStackFrameAtIndex(0).get();
+ Frame *frame = thread.GetStackFrameAtIndex(0).get();
const SymbolContext &context = frame->GetSymbolContext(eSymbolContextSymbol);
Symbol *sym = context.symbol;
diff --git a/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp b/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp
index bad4118..761ab70 100644
--- a/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp
+++ b/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp
@@ -13,7 +13,7 @@
#include "lldb/Core/Scalar.h"
#include "lldb/Interpreter/OptionValueArray.h"
#include "lldb/Interpreter/OptionValueDictionary.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/RegisterContext.h"
#include "Utility/ARM_DWARF_Registers.h"
@@ -34,7 +34,7 @@
}
bool
-EmulationStateARM::LoadPseudoRegistersFromFrame (StackFrame &frame)
+EmulationStateARM::LoadPseudoRegistersFromFrame (Frame &frame)
{
RegisterContext *reg_ctx = frame.GetRegisterContext().get();
bool success = true;
diff --git a/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.h b/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.h
index ad596a3..9eee7c3 100644
--- a/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.h
+++ b/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.h
@@ -42,7 +42,7 @@
ClearPseudoMemory ();
bool
- LoadPseudoRegistersFromFrame (lldb_private::StackFrame &frame);
+ LoadPseudoRegistersFromFrame (lldb_private::Frame &frame);
bool
LoadStateFromDictionary (lldb_private::OptionValueDictionary *test_data);
diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
index 1bcbb4e..be9e968 100644
--- a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
+++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
@@ -873,7 +873,7 @@
// We are decoding a method dispatch.
// First job is to pull the arguments out:
- lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
+ lldb::FrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
const ABI *abi = NULL;
ProcessSP process_sp (thread.CalculateProcess());
diff --git a/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp b/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp
index bb7e8a3..3bef486 100644
--- a/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp
+++ b/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp
@@ -109,7 +109,7 @@
}
lldb::RegisterContextSP
-ThreadKDP::CreateRegisterContextForFrame (StackFrame *frame)
+ThreadKDP::CreateRegisterContextForFrame (Frame *frame)
{
lldb::RegisterContextSP reg_ctx_sp;
uint32_t concrete_frame_idx = 0;
diff --git a/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.h b/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.h
index 7dc373f..eda801c 100644
--- a/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.h
+++ b/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.h
@@ -39,7 +39,7 @@
GetRegisterContext ();
virtual lldb::RegisterContextSP
- CreateRegisterContextForFrame (lldb_private::StackFrame *frame);
+ CreateRegisterContextForFrame (lldb_private::Frame *frame);
void
Dump (lldb_private::Log *log, uint32_t index);
diff --git a/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp b/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
index 8b22d64..b020db8 100644
--- a/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
+++ b/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
@@ -109,7 +109,7 @@
call_plan_sp->SetIsMasterPlan (true);
call_plan_sp->SetOkayToDiscard(true);
- StackFrame *frame = thread->GetStackFrameAtIndex (0).get();
+ Frame *frame = thread->GetStackFrameAtIndex (0).get();
if (frame)
{
ExecutionContext exe_ctx;
@@ -195,7 +195,7 @@
call_plan_sp->SetIsMasterPlan (true);
call_plan_sp->SetOkayToDiscard(true);
- StackFrame *frame = thread->GetStackFrameAtIndex (0).get();
+ Frame *frame = thread->GetStackFrameAtIndex (0).get();
if (frame)
{
ExecutionContext exe_ctx;
@@ -249,7 +249,7 @@
call_plan_sp->SetIsMasterPlan (true);
call_plan_sp->SetOkayToDiscard(true);
- StackFrame *frame = thread->GetStackFrameAtIndex (0).get();
+ Frame *frame = thread->GetStackFrameAtIndex (0).get();
if (frame)
{
ExecutionContext exe_ctx;
diff --git a/lldb/source/Plugins/Process/Utility/RegisterContextDummy.cpp b/lldb/source/Plugins/Process/Utility/RegisterContextDummy.cpp
index 1e282ce..08be777 100644
--- a/lldb/source/Plugins/Process/Utility/RegisterContextDummy.cpp
+++ b/lldb/source/Plugins/Process/Utility/RegisterContextDummy.cpp
@@ -25,7 +25,7 @@
#include "lldb/Target/ABI.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/DynamicLoader.h"
diff --git a/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp b/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp
index c19aec3..92ec99f 100644
--- a/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp
+++ b/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp
@@ -26,7 +26,7 @@
#include "lldb/Target/ABI.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/DynamicLoader.h"
diff --git a/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp b/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp
index 51d2052..52d7f17 100644
--- a/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp
+++ b/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp
@@ -335,7 +335,7 @@
// {
// // We have a SIGTRAP, make sure we didn't exec by checking
// // for the PC being at "_dyld_start"...
-// lldb::StackFrameSP frame_sp (thread.GetStackFrameAtIndex(0));
+// lldb::FrameSP frame_sp (thread.GetStackFrameAtIndex(0));
// if (frame_sp)
// {
// const Symbol *symbol = frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol;
diff --git a/lldb/source/Plugins/Process/Utility/ThreadMemory.cpp b/lldb/source/Plugins/Process/Utility/ThreadMemory.cpp
index 56e5a9a..9ab437d 100644
--- a/lldb/source/Plugins/Process/Utility/ThreadMemory.cpp
+++ b/lldb/source/Plugins/Process/Utility/ThreadMemory.cpp
@@ -78,7 +78,7 @@
}
RegisterContextSP
-ThreadMemory::CreateRegisterContextForFrame (StackFrame *frame)
+ThreadMemory::CreateRegisterContextForFrame (Frame *frame)
{
RegisterContextSP reg_ctx_sp;
uint32_t concrete_frame_idx = 0;
diff --git a/lldb/source/Plugins/Process/Utility/ThreadMemory.h b/lldb/source/Plugins/Process/Utility/ThreadMemory.h
index 07eb45d..a45c056 100644
--- a/lldb/source/Plugins/Process/Utility/ThreadMemory.h
+++ b/lldb/source/Plugins/Process/Utility/ThreadMemory.h
@@ -37,7 +37,7 @@
GetRegisterContext ();
virtual lldb::RegisterContextSP
- CreateRegisterContextForFrame (lldb_private::StackFrame *frame);
+ CreateRegisterContextForFrame (lldb_private::Frame *frame);
virtual bool
CalculateStopInfo ();
diff --git a/lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp b/lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp
index 552ae50..111c5d8 100644
--- a/lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp
+++ b/lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp
@@ -220,7 +220,7 @@
}
lldb::RegisterContextSP
-UnwindLLDB::DoCreateRegisterContextForFrame (StackFrame *frame)
+UnwindLLDB::DoCreateRegisterContextForFrame (Frame *frame)
{
lldb::RegisterContextSP reg_ctx_sp;
uint32_t idx = frame->GetConcreteFrameIndex ();
diff --git a/lldb/source/Plugins/Process/Utility/UnwindLLDB.h b/lldb/source/Plugins/Process/Utility/UnwindLLDB.h
index 5725654..23f04be 100644
--- a/lldb/source/Plugins/Process/Utility/UnwindLLDB.h
+++ b/lldb/source/Plugins/Process/Utility/UnwindLLDB.h
@@ -75,7 +75,7 @@
lldb::addr_t& start_pc);
lldb::RegisterContextSP
- DoCreateRegisterContextForFrame (lldb_private::StackFrame *frame);
+ DoCreateRegisterContextForFrame (lldb_private::Frame *frame);
typedef std::shared_ptr<RegisterContextLLDB> RegisterContextLLDBSP;
diff --git a/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp b/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp
index d011314..fa76d6d 100644
--- a/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp
+++ b/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp
@@ -73,7 +73,7 @@
}
lldb::RegisterContextSP
-UnwindMacOSXFrameBackchain::DoCreateRegisterContextForFrame (StackFrame *frame)
+UnwindMacOSXFrameBackchain::DoCreateRegisterContextForFrame (Frame *frame)
{
lldb::RegisterContextSP reg_ctx_sp;
uint32_t concrete_idx = frame->GetConcreteFrameIndex ();
@@ -88,7 +88,7 @@
{
m_cursors.clear();
- StackFrame *first_frame = exe_ctx.GetFramePtr();
+ Frame *first_frame = exe_ctx.GetFramePtr();
Process *process = exe_ctx.GetProcessPtr();
if (process == NULL)
@@ -191,7 +191,7 @@
if (process == NULL)
return 0;
- StackFrame *first_frame = exe_ctx.GetFramePtr();
+ Frame *first_frame = exe_ctx.GetFramePtr();
std::pair<lldb::addr_t, lldb::addr_t> fp_pc_pair;
diff --git a/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h b/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h
index 2695376..501c9ea 100644
--- a/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h
+++ b/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h
@@ -46,7 +46,7 @@
lldb::addr_t& pc);
lldb::RegisterContextSP
- DoCreateRegisterContextForFrame (lldb_private::StackFrame *frame);
+ DoCreateRegisterContextForFrame (lldb_private::Frame *frame);
friend class RegisterContextMacOSXFrameBackchain;
diff --git a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
index 4e475c8..86c63e1 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
@@ -187,7 +187,7 @@
}
lldb::RegisterContextSP
-ThreadGDBRemote::CreateRegisterContextForFrame (StackFrame *frame)
+ThreadGDBRemote::CreateRegisterContextForFrame (Frame *frame)
{
lldb::RegisterContextSP reg_ctx_sp;
uint32_t concrete_frame_idx = 0;
diff --git a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
index dd4cc03..783e2cf 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
+++ b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
@@ -45,7 +45,7 @@
GetRegisterContext ();
virtual lldb::RegisterContextSP
- CreateRegisterContextForFrame (lldb_private::StackFrame *frame);
+ CreateRegisterContextForFrame (lldb_private::Frame *frame);
void
Dump (lldb_private::Log *log, uint32_t index);
diff --git a/lldb/source/Plugins/Process/mach-core/ThreadMachCore.cpp b/lldb/source/Plugins/Process/mach-core/ThreadMachCore.cpp
index 85a7a20..bd404d7 100644
--- a/lldb/source/Plugins/Process/mach-core/ThreadMachCore.cpp
+++ b/lldb/source/Plugins/Process/mach-core/ThreadMachCore.cpp
@@ -88,7 +88,7 @@
}
lldb::RegisterContextSP
-ThreadMachCore::CreateRegisterContextForFrame (StackFrame *frame)
+ThreadMachCore::CreateRegisterContextForFrame (Frame *frame)
{
lldb::RegisterContextSP reg_ctx_sp;
uint32_t concrete_frame_idx = 0;
diff --git a/lldb/source/Plugins/Process/mach-core/ThreadMachCore.h b/lldb/source/Plugins/Process/mach-core/ThreadMachCore.h
index 756a04a..701def6 100644
--- a/lldb/source/Plugins/Process/mach-core/ThreadMachCore.h
+++ b/lldb/source/Plugins/Process/mach-core/ThreadMachCore.h
@@ -35,7 +35,7 @@
GetRegisterContext ();
virtual lldb::RegisterContextSP
- CreateRegisterContextForFrame (lldb_private::StackFrame *frame);
+ CreateRegisterContextForFrame (lldb_private::Frame *frame);
static bool
ThreadIDIsValid (lldb::tid_t thread);
diff --git a/lldb/source/Symbol/Variable.cpp b/lldb/source/Symbol/Variable.cpp
index 7276e0a..b864523 100644
--- a/lldb/source/Symbol/Variable.cpp
+++ b/lldb/source/Symbol/Variable.cpp
@@ -22,7 +22,7 @@
#include "lldb/Target/ABI.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Frame.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/Target.h"
@@ -207,7 +207,7 @@
}
bool
-Variable::LocationIsValidForFrame (StackFrame *frame)
+Variable::LocationIsValidForFrame (Frame *frame)
{
// Is the variable is described by a single location?
if (!m_location.IsLocationList())
@@ -271,7 +271,7 @@
}
bool
-Variable::IsInScope (StackFrame *frame)
+Variable::IsInScope (Frame *frame)
{
switch (m_scope)
{
@@ -520,7 +520,7 @@
static void
-PrivateAutoComplete (StackFrame *frame,
+PrivateAutoComplete (Frame *frame,
const std::string &partial_path,
const std::string &prefix_path, // Anything that has been resolved already will be in here
const ClangASTType& clang_type,
@@ -528,7 +528,7 @@
bool &word_complete);
static void
-PrivateAutoCompleteMembers (StackFrame *frame,
+PrivateAutoCompleteMembers (Frame *frame,
const std::string &partial_member_name,
const std::string &partial_path,
const std::string &prefix_path, // Anything that has been resolved already will be in here
@@ -537,7 +537,7 @@
bool &word_complete);
static void
-PrivateAutoCompleteMembers (StackFrame *frame,
+PrivateAutoCompleteMembers (Frame *frame,
const std::string &partial_member_name,
const std::string &partial_path,
const std::string &prefix_path, // Anything that has been resolved already will be in here
@@ -616,7 +616,7 @@
}
static void
-PrivateAutoComplete (StackFrame *frame,
+PrivateAutoComplete (Frame *frame,
const std::string &partial_path,
const std::string &prefix_path, // Anything that has been resolved already will be in here
const ClangASTType& clang_type,
diff --git a/lldb/source/Target/ExecutionContext.cpp b/lldb/source/Target/ExecutionContext.cpp
index 7a8b601..ee42e84 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 @@
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 @@
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(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 @@
return *m_thread_sp;
}
-StackFrame &
+Frame &
ExecutionContext::GetFrameRef () const
{
#if defined (LLDB_CONFIGURATION_DEBUG) || defined (LLDB_CONFIGURATION_RELEASE)
@@ -348,7 +348,7 @@
}
void
-ExecutionContext::SetFrameSP (const lldb::StackFrameSP &frame_sp)
+ExecutionContext::SetFrameSP (const lldb::FrameSP &frame_sp)
{
m_frame_sp = frame_sp;
}
@@ -381,7 +381,7 @@
}
void
-ExecutionContext::SetFramePtr (StackFrame *frame)
+ExecutionContext::SetFramePtr (Frame *frame)
{
if (frame)
m_frame_sp = frame->shared_from_this();
@@ -434,7 +434,7 @@
}
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 @@
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 @@
}
void
-ExecutionContextRef::SetFrameSP (const lldb::StackFrameSP &frame_sp)
+ExecutionContextRef::SetFrameSP (const lldb::FrameSP &frame_sp)
{
if (frame_sp)
{
@@ -711,7 +711,7 @@
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 @@
}
void
-ExecutionContextRef::SetFramePtr (StackFrame *frame)
+ExecutionContextRef::SetFramePtr (Frame *frame)
{
if (frame)
SetFrameSP (frame->shared_from_this());
@@ -811,7 +811,7 @@
return thread_sp;
}
-lldb::StackFrameSP
+lldb::FrameSP
ExecutionContextRef::GetFrameSP () const
{
if (m_stack_id.IsValid())
@@ -820,7 +820,7 @@
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 738ed5f..15a5506 100644
--- a/lldb/source/Target/Process.cpp
+++ b/lldb/source/Target/Process.cpp
@@ -1808,7 +1808,7 @@
if (thread_sp)
{
- StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
+ FrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
if (frame_sp)
{
@@ -1885,7 +1885,7 @@
if (thread_sp)
{
- StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
+ FrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
if (frame_sp)
{
@@ -4723,7 +4723,7 @@
// 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 @@
{
// 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 2fd1e73..0eab584 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 @@
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 @@
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 a05c03d..7d730b8 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 @@
{
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 @@
return m_frame_code_addr;
}
-void
+bool
StackFrame::ChangePC (addr_t pc)
{
m_frame_code_addr.SetRawAddress(pc);
@@ -255,6 +256,7 @@
ThreadSP thread_sp (GetThread());
if (thread_sp)
thread_sp->ClearStackFrames ();
+ return true;
}
const char *
@@ -1261,8 +1263,8 @@
return GetThread();
}
-StackFrameSP
-StackFrame::CalculateStackFrame ()
+FrameSP
+StackFrame::CalculateFrame ()
{
return shared_from_this();
}
@@ -1327,51 +1329,47 @@
}
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 d95ab97..61c8bae 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 @@
}
}
- StackFrameSP unwind_frame_sp;
+ FrameSP unwind_frame_sp;
do
{
uint32_t idx = m_concrete_frames_fetched++;
@@ -324,7 +325,7 @@
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 @@
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
}
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 @@
}
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 @@
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 @@
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 @@
{
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 @@
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 @@
}
-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 @@
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 @@
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 c92a2cc..6545fb2 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 @@
return ThreadSP();
}
-StackFrameSP
-Target::CalculateStackFrame ()
+FrameSP
+Target::CalculateFrame ()
{
- return StackFrameSP();
+ return FrameSP();
}
void
@@ -1832,7 +1832,7 @@
Target::EvaluateExpression
(
const char *expr_cstr,
- StackFrame *frame,
+ Frame *frame,
lldb::ValueObjectSP &result_valobj_sp,
const EvaluateExpressionOptions& options
)
@@ -2086,7 +2086,7 @@
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 98c2601..e6a3440 100644
--- a/lldb/source/Target/Thread.cpp
+++ b/lldb/source/Target/Thread.cpp
@@ -211,11 +211,11 @@
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 @@
}
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 @@
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 @@
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 @@
return shared_from_this();
}
-StackFrameSP
-Thread::CalculateStackFrame ()
+FrameSP
+Thread::CalculateFrame ()
{
- return StackFrameSP();
+ return FrameSP();
}
void
@@ -1638,7 +1638,7 @@
m_curr_frames_sp.reset();
}
-lldb::StackFrameSP
+lldb::FrameSP
Thread::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
{
return GetStackFrameList()->GetFrameWithConcreteFrameIndex (unwind_idx);
@@ -1648,7 +1648,7 @@
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 @@
}
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 *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 @@
// 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 @@
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 @@
if (process == NULL)
return;
- StackFrameSP frame_sp;
+ FrameSP frame_sp;
SymbolContext frame_sc;
if (frame_idx != LLDB_INVALID_INDEX32)
{
@@ -1881,10 +1881,10 @@
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 @@
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 @@
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 @@
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 c1f14bd..70634f1 100644
--- a/lldb/source/Target/ThreadPlanStepInRange.cpp
+++ b/lldb/source/Target/ThreadPlanStepInRange.cpp
@@ -202,7 +202,7 @@
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 @@
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 @@
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 f644ee8..e95f403 100644
--- a/lldb/source/Target/ThreadPlanStepInstruction.cpp
+++ b/lldb/source/Target/ThreadPlanStepInstruction.cpp
@@ -44,12 +44,12 @@
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 @@
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 c5efb55..6e45957 100644
--- a/lldb/source/Target/ThreadPlanStepOut.cpp
+++ b/lldb/source/Target/ThreadPlanStepOut.cpp
@@ -57,8 +57,8 @@
{
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 @@
// 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 2d8108b..5c7e460 100644
--- a/lldb/source/Target/ThreadPlanStepOverRange.cpp
+++ b/lldb/source/Target/ThreadPlanStepOverRange.cpp
@@ -137,7 +137,7 @@
// 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 @@
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 @@
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 309f773..409b87a 100644
--- a/lldb/source/Target/ThreadPlanStepRange.cpp
+++ b/lldb/source/Target/ThreadPlanStepRange.cpp
@@ -148,7 +148,7 @@
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 37cd03c..ed9c23a 100644
--- a/lldb/source/Target/ThreadPlanStepThrough.cpp
+++ b/lldb/source/Target/ThreadPlanStepThrough.cpp
@@ -51,7 +51,7 @@
// 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 62e05c7..a80e031 100644
--- a/lldb/source/Target/ThreadPlanStepUntil.cpp
+++ b/lldb/source/Target/ThreadPlanStepUntil.cpp
@@ -54,7 +54,7 @@
// 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 @@
// 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 @@
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)