maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

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
This commit is contained in:
Jason Molenda 2013-11-02 02:23:02 +00:00
parent 30bfa3623b
commit f23bf7432c
102 changed files with 894 additions and 464 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lldb/include/lldb/API/SBFrame.h
View File

@ -216,7 +216,7 @@ public:
bool
GetDescription (lldb::SBStream &description);
SBFrame (const lldb::StackFrameSP &lldb_object_sp);
SBFrame (const lldb::FrameSP &lldb_object_sp);
protected:
@ -228,11 +228,11 @@ protected:
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;
};

23
lldb/include/lldb/Core/ValueObject.h
View File

@ -35,32 +35,33 @@ namespace lldb_private {
/// 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 @@ public:
return m_update_point.GetExecutionContextRef().GetThreadSP();
}
lldb::StackFrameSP
lldb::FrameSP
GetFrameSP() const
{
return m_update_point.GetExecutionContextRef().GetFrameSP();

2
lldb/include/lldb/DataFormatters/FormatNavigator.h
View File

@ -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 {

2
lldb/include/lldb/Expression/ClangUserExpression.h
View File

@ -394,7 +394,7 @@ private:
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.

2
lldb/include/lldb/Expression/DWARFExpression.h
View File

@ -310,7 +310,7 @@ public:
/// @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.
///

10
lldb/include/lldb/Expression/Materializer.h
View File

@ -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 @@ public:
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 @@ public:
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 @@ public:
{
}
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;

8
lldb/include/lldb/Interpreter/ScriptInterpreter.h
View File

@ -86,12 +86,12 @@ public:
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 @@ public:
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 @@ public:
virtual bool
RunScriptFormatKeyword (const char* impl_function,
StackFrame* frame,
Frame* frame,
std::string& output,
Error& error)
{

2
lldb/include/lldb/Interpreter/ScriptInterpreterPython.h
View File

@ -202,7 +202,7 @@ public:
virtual bool
RunScriptFormatKeyword (const char* impl_function,
StackFrame* frame,
Frame* frame,
std::string& output,
Error& error);

4
lldb/include/lldb/Symbol/Variable.h
View File

@ -124,10 +124,10 @@ public:
CalculateSymbolContext (SymbolContext *sc);
bool
IsInScope (StackFrame *frame);
IsInScope (Frame *frame);
bool
LocationIsValidForFrame (StackFrame *frame);
LocationIsValidForFrame (Frame *frame);
bool
LocationIsValidForAddress (const Address &address);

2
lldb/include/lldb/Target/ABI.h
View File

@ -53,7 +53,7 @@ public:
// 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.

28
lldb/include/lldb/Target/ExecutionContext.h
View File

@ -230,10 +230,10 @@ public:
/// 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 @@ public:
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 @@ public:
/// @returns
/// A shared pointer to a frame that is not guaranteed to be valid.
//------------------------------------------------------------------
lldb::StackFrameSP
lldb::FrameSP
GetFrameSP () const;
//------------------------------------------------------------------
@ -393,14 +393,14 @@ public:
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 @@ public:
//------------------------------------------------------------------
ExecutionContext (Process* process,
Thread *thread = NULL,
StackFrame * frame = NULL);
Frame * frame = NULL);
~ExecutionContext();
@ -522,7 +522,7 @@ public:
///
/// @see ExecutionContext::HasFrameScope() const
//------------------------------------------------------------------
StackFrame *
Frame *
GetFramePtr () const
{
return m_frame_sp.get();
@ -580,7 +580,7 @@ public:
///
/// @see ExecutionContext::HasFrameScope() const
//------------------------------------------------------------------
StackFrame &
Frame &
GetFrameRef () const;
//------------------------------------------------------------------
@ -621,7 +621,7 @@ public:
///
/// 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 @@ public:
/// 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 @@ public:
/// pointer.
//------------------------------------------------------------------
void
SetFramePtr (StackFrame *frame);
SetFramePtr (Frame *frame);
//------------------------------------------------------------------
// Set the execution context using a target shared pointer.
@ -717,7 +717,7 @@ public:
// 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 @@ protected:
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

6
lldb/include/lldb/Target/ExecutionContextScope.h
View File

@ -27,7 +27,7 @@ namespace lldb_private {
/// 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 @@ public:
virtual lldb::ThreadSP
CalculateThread () = 0;
virtual lldb::StackFrameSP
CalculateStackFrame () = 0;
virtual lldb::FrameSP
CalculateFrame () = 0;
//------------------------------------------------------------------
/// Reconstruct the object's execution context into \a sc.

421
lldb/include/lldb/Target/Frame.h Normal file
View File

@ -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_

6
lldb/include/lldb/Target/Process.h
View File

@ -3478,10 +3478,10 @@ public:
return lldb::ThreadSP();
}
virtual lldb::StackFrameSP
CalculateStackFrame ()
virtual lldb::FrameSP
CalculateFrame ()
{
return lldb::StackFrameSP();
return lldb::FrameSP();
}
virtual void

4
lldb/include/lldb/Target/RegisterContext.h
View File

@ -178,8 +178,8 @@ public:
virtual lldb::ThreadSP
CalculateThread ();
virtual lldb::StackFrameSP
CalculateStackFrame ();
virtual lldb::FrameSP
CalculateFrame ();
virtual void
CalculateExecutionContext (ExecutionContext &exe_ctx);

104
lldb/include/lldb/Target/StackFrame.h
View File

@ -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 @@ public:
// 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 &reg_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 &reg_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 &reg_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 &reg_context_sp,
lldb::addr_t cfa,
const Address& pc,
const SymbolContext *sc_ptr);
~StackFrame ();
lldb::ThreadSP
GetThread () const
@ -78,8 +85,8 @@ public:
const Address&
GetFrameCodeAddress();
void
bool
ChangePC (lldb::addr_t pc);
const SymbolContext&
@ -106,10 +113,9 @@ public:
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 @@ public:
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 @@ public:
{
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 @@ protected:
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

20
lldb/include/lldb/Target/StackFrameList.h
View File

@ -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 @@ public:
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 @@ public:
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 @@ public:
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 @@ protected:
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 @@ protected:
//------------------------------------------------------------------
// 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;

1
lldb/include/lldb/Target/StackID.h
View File

@ -109,6 +109,7 @@ public:
protected:
friend class Frame;
friend class StackFrame;
void

6
lldb/include/lldb/Target/Target.h
View File

@ -961,8 +961,8 @@ public:
virtual lldb::ThreadSP
CalculateThread ();
virtual lldb::StackFrameSP
CalculateStackFrame ();
virtual lldb::FrameSP
CalculateFrame ();
virtual void
CalculateExecutionContext (ExecutionContext &exe_ctx);
@ -984,7 +984,7 @@ public:
// in in th execution context.
ExecutionResults
EvaluateExpression (const char *expression,
StackFrame *frame,
Frame *frame,
lldb::ValueObjectSP &result_valobj_sp,
const EvaluateExpressionOptions& options = EvaluateExpressionOptions());

27
lldb/include/lldb/Target/Thread.h
View File

@ -109,7 +109,7 @@ public:
static StackID
GetStackIDFromEvent (const Event *event_ptr);
static lldb::StackFrameSP
static lldb::FrameSP
GetStackFrameFromEvent (const Event *event_ptr);
lldb::ThreadSP
@ -357,13 +357,13 @@ public:
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 @@ public:
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 @@ public:
return GetStackFrameList()->GetSelectedFrameIndex();
}
lldb::StackFrameSP
lldb::FrameSP
GetSelectedFrame ()
{
lldb::StackFrameListSP stack_frame_list_sp(GetStackFrameList());
@ -409,7 +409,7 @@ public:
}
uint32_t
SetSelectedFrame (lldb_private::StackFrame *frame, bool broadcast = false);
SetSelectedFrame (lldb_private::Frame *frame, bool broadcast = false);
bool
@ -428,7 +428,7 @@ public:
GetRegisterContext () = 0;
virtual lldb::RegisterContextSP
CreateRegisterContextForFrame (StackFrame *frame) = 0;
CreateRegisterContextForFrame (Frame *frame) = 0;
virtual void
ClearStackFrames ();
@ -914,14 +914,14 @@ public:
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 @@ protected:
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

4
lldb/include/lldb/Target/Unwind.h
View File

@ -79,7 +79,7 @@ public:
}
lldb::RegisterContextSP
CreateRegisterContextForFrame (StackFrame *frame)
CreateRegisterContextForFrame (Frame *frame)
{
Mutex::Locker locker(m_unwind_mutex);
return DoCreateRegisterContextForFrame (frame);
@ -107,7 +107,7 @@ protected:
lldb::addr_t& pc) = 0;
virtual lldb::RegisterContextSP
DoCreateRegisterContextForFrame (StackFrame *frame) = 0;
DoCreateRegisterContextForFrame (Frame *frame) = 0;
Thread &m_thread;
Mutex m_unwind_mutex;

7
lldb/include/lldb/lldb-forward.h
View File

@ -181,8 +181,7 @@ class SectionList;
class Settings;
class SourceManager;
class SourceManagerImpl;
class StackFrame;
class StackFrameImpl;
class Frame;
class StackFrameList;
class StackID;
class StopInfo;
@ -337,8 +336,8 @@ namespace lldb {
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;

6
lldb/scripts/Python/python-wrapper.swig
View File

@ -211,7 +211,7 @@ LLDBSwigPythonBreakpointCallbackFunction
(
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 @@ LLDBSwigPythonWatchpointCallbackFunction
(
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 @@ SWIGEXPORT bool
LLDBSWIGPythonRunScriptKeywordFrame
(const char* python_function_name,
const char* session_dictionary_name,
lldb::StackFrameSP& frame,
lldb::FrameSP& frame,
std::string& output)
{

4
lldb/source/API/SBBlock.cpp
View File

@ -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 @@ SBBlock::GetVariables (lldb::SBFrame& frame,
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)

6
lldb/source/API/SBCommandInterpreter.cpp
View File

@ -392,13 +392,13 @@ init_lldb(void);
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 @@ LLDBSWIGPythonRunScriptKeywordTarget (const char* python_function_name,
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*

76
lldb/source/API/SBFrame.cpp
View File

@ -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 () :
{
}
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 @@ SBFrame::~SBFrame()
{
}
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 @@ SBFrame::GetSymbolContext (uint32_t resolve_scope) const
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 @@ SBFrame::GetModule () const
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 @@ SBFrame::GetCompileUnit () const
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 @@ SBFrame::GetFunction () const
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 @@ SBFrame::GetSymbol () const
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 @@ SBFrame::GetBlock () const
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 @@ SBFrame::GetFrameBlock () const
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 @@ SBFrame::GetLineEntry () const
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 @@ SBFrame::GetFrameID () const
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 @@ SBFrame::GetPC () const
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 @@ SBFrame::SetPC (addr_t new_pc)
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 @@ SBFrame::GetSP () const
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 @@ SBFrame::GetFP () const
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 @@ SBFrame::GetPCAddress () const
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 @@ SBFrame::GetValueForVariablePath (const char *var_path)
{
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 @@ SBFrame::GetValueForVariablePath (const char *var_path, DynamicValueType use_dyn
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 @@ SBFrame::GetValueForVariablePath (const char *var_path, DynamicValueType use_dyn
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 @@ SBFrame::FindVariable (const char *name)
{
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 @@ SBFrame::FindVariable (const char *name, lldb::DynamicValueType use_dynamic)
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 @@ SBFrame::FindValue (const char *name, ValueType value_type)
{
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 @@ SBFrame::FindValue (const char *name, ValueType value_type, lldb::DynamicValueTy
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 @@ SBFrame::FindValue (const char *name, ValueType value_type, lldb::DynamicValueTy
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 @@ SBFrame::Disassemble () const
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 @@ SBFrame::GetVariables (bool arguments,
{
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 @@ SBFrame::GetVariables (bool arguments,
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 @@ SBFrame::GetRegisters ()
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 @@ SBFrame::FindRegister (const char *name)
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 @@ SBFrame::GetDescription (SBStream &description)
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 @@ SBFrame::EvaluateExpression (const char *expr)
{
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 @@ SBFrame::EvaluateExpression (const char *expr, const SBExpressionOptions &option
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 @@ SBFrame::IsInlined()
{
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 @@ SBFrame::GetFunctionName()
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)

4
lldb/source/API/SBInstruction.cpp
View File

@ -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 @@ SBInstruction::EmulateWithFrame (lldb::SBFrame &frame, uint32_t evaluate_options
{
if (m_opaque_sp)
{
lldb::StackFrameSP frame_sp (frame.GetFrameSP());
lldb::FrameSP frame_sp (frame.GetFrameSP());
if (frame_sp)
{

2
lldb/source/API/SBTarget.cpp
View File

@ -2644,7 +2644,7 @@ SBTarget::EvaluateExpression (const char *expr, const SBExpressionOptions &optio
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')

14
lldb/source/API/SBThread.cpp
View File

@ -594,7 +594,7 @@ SBThread::StepOver (lldb::RunMode stop_other_threads)
{
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 @@ SBThread::StepInto (const char *target_name, lldb::RunMode stop_other_threads)
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 @@ SBThread::StepOutOfFrame (lldb::SBFrame &sb_frame)
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 @@ SBThread::StepOverUntil (lldb::SBFrame &sb_frame,
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 @@ SBThread::GetFrameAtIndex (uint32_t idx)
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 @@ SBThread::GetSelectedFrame ()
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 @@ SBThread::SetSelectedFrame (uint32_t idx)
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);

8
lldb/source/API/SBValue.cpp
View File

@ -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 @@ public:
return ThreadSP();
}
StackFrameSP
FrameSP
GetFrameSP ()
{
if (m_valobj_sp)
return m_valobj_sp->GetFrameSP();
else
return StackFrameSP();
return FrameSP();
}
private:
@ -1252,7 +1252,7 @@ lldb::SBFrame
SBValue::GetFrame()
{
SBFrame sb_frame;
StackFrameSP frame_sp;
FrameSP frame_sp;
if (m_opaque_sp)
{
frame_sp = m_opaque_sp->GetFrameSP();

4
lldb/source/Commands/CommandObjectArgs.cpp
View File

@ -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 @@ CommandObjectArgs::DoExecute (Args& args, CommandReturnObject &result)
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.");

4
lldb/source/Commands/CommandObjectBreakpoint.cpp
View File

@ -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 @@ private:
// 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.");

4
lldb/source/Commands/CommandObjectDisassemble.cpp
View File

@ -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 @@ CommandObjectDisassemble::DoExecute (Args& command, CommandReturnObject &result)
else
{
AddressRange range;
StackFrame *frame = m_exe_ctx.GetFramePtr();
Frame *frame = m_exe_ctx.GetFramePtr();
if (m_options.frame_line)
{
if (frame == NULL)

2
lldb/source/Commands/CommandObjectExpression.cpp
View File

@ -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"

8
lldb/source/Commands/CommandObjectFrame.cpp
View File

@ -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 @@ protected:
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 @@ protected:
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,

4
lldb/source/Commands/CommandObjectMemory.cpp
View File

@ -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 @@ protected:
}
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);

8
lldb/source/Commands/CommandObjectTarget.cpp
View File

@ -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 @@ protected:
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 @@ public:
break;
}
StackFrameSP frame = m_exe_ctx.GetFrameSP();
FrameSP frame = m_exe_ctx.GetFrameSP();
if (!frame)
return false;
@ -4546,7 +4546,7 @@ protected:
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);

10
lldb/source/Commands/CommandObjectThread.cpp
View File

@ -465,7 +465,7 @@ protected:
if (m_step_type == eStepTypeInto)
{
StackFrame *frame = thread->GetStackFrameAtIndex(0).get();
Frame *frame = thread->GetStackFrameAtIndex(0).get();
if (frame->HasDebugInformation ())
{
@ -487,7 +487,7 @@ protected:
}
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 @@ protected:
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 @@ protected:
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 @@ protected:
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);

8
lldb/source/Commands/CommandObjectWatchpoint.cpp
View File

@ -989,7 +989,7 @@ protected:
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 @@ protected:
// 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 @@ protected:
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;

10
lldb/source/Core/Debugger.cpp
View File

@ -1137,7 +1137,7 @@ Debugger::FindDebuggerWithID (lldb::user_id_t id)
}
static void
TestPromptFormats (StackFrame *frame)
TestPromptFormats (Frame *frame)
{
if (frame == NULL)
return;
@ -1359,7 +1359,7 @@ static bool RunScriptFormatKeyword(Stream &s, ScriptInterpreter *script_interpre
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 @@ FormatPromptRecurse
{
if (exe_ctx)
{
StackFrame *frame = exe_ctx->GetFramePtr();
Frame *frame = exe_ctx->GetFramePtr();
if (frame)
{
var_name_begin += ::strlen ("frame.");
@ -2338,7 +2338,7 @@ FormatPromptRecurse
}
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 @@ FormatPromptRecurse
// 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)
{

6
lldb/source/Core/Disassembler.cpp
View File

@ -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 @@ Disassembler::PrintInstructions
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 @@ Disassembler::Disassemble
)
{
AddressRange range;
StackFrame *frame = exe_ctx.GetFramePtr();
Frame *frame = exe_ctx.GetFramePtr();
if (frame)
{
SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol));

8
lldb/source/Core/EmulateInstruction.cpp
View File

@ -292,7 +292,7 @@ EmulateInstruction::ReadMemoryFrame (EmulateInstruction *instruction,
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 @@ EmulateInstruction::WriteMemoryFrame (EmulateInstruction *instruction,
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 @@ EmulateInstruction::ReadRegisterFrame (EmulateInstruction *instruction,
if (!baton)
return false;
StackFrame *frame = (StackFrame *) baton;
Frame *frame = (Frame *) baton;
return frame->GetRegisterContext()->ReadRegister (reg_info, reg_value);
}
@ -349,7 +349,7 @@ EmulateInstruction::WriteRegisterFrame (EmulateInstruction *instruction,
if (!baton)
return false;
StackFrame *frame = (StackFrame *) baton;
Frame *frame = (Frame *) baton;
return frame->GetRegisterContext()->WriteRegister (reg_info, reg_value);
}

4
lldb/source/Core/ValueObject.cpp
View File

@ -3732,7 +3732,7 @@ ValueObject::EvaluationPoint::EvaluationPoint (ExecutionContextScope *exe_scope,
{
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 @@ ValueObject::EvaluationPoint::SyncWithProcessState()
{
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

6
lldb/source/Core/ValueObjectRegister.cpp
View File

@ -77,7 +77,7 @@ ValueObjectRegisterContext::UpdateValue ()
{
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 @@ ValueObjectRegisterSet::UpdateValue ()
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 @@ ValueObjectRegister::UpdateValue ()
{
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();

2
lldb/source/Core/ValueObjectVariable.cpp
View File

@ -263,7 +263,7 @@ ValueObjectVariable::IsInScope ()
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);

4
lldb/source/DataFormatters/CF.cpp
View File

@ -79,7 +79,7 @@ lldb_private::formatters::CFBagSummaryProvider (ValueObject& valobj, Stream& str
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 @@ lldb_private::formatters::CFBinaryHeapSummaryProvider (ValueObject& valobj, Stre
if (is_type_ok == false)
{
StackFrameSP frame_sp(valobj.GetFrameSP());
FrameSP frame_sp(valobj.GetFrameSP());
if (!frame_sp)
return false;
ValueObjectSP count_sp;

8
lldb/source/DataFormatters/CXXFormatterFunctions.cpp
View File

@ -44,7 +44,7 @@ lldb_private::formatters::ExtractValueFromObjCExpression (ValueObject &valobj,
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 @@ lldb_private::formatters::ExtractSummaryFromObjCExpression (ValueObject &valobj,
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 @@ lldb_private::formatters::CallSelectorOnObject (ValueObject &valobj,
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 @@ lldb_private::formatters::CallSelectorOnObject (ValueObject &valobj,
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;

2
lldb/source/DataFormatters/FormatClasses.cpp
View File

@ -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;

2
lldb/source/DataFormatters/TypeFormat.cpp
View File

@ -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;

4
lldb/source/DataFormatters/TypeSummary.cpp
View File

@ -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 @@ StringSummaryFormat::FormatObject (ValueObject *valobj,
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);

2
lldb/source/DataFormatters/TypeSynthetic.cpp
View File

@ -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;

14
lldb/source/Expression/ClangExpressionDeclMap.cpp
View File

@ -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 @@ ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context,
// 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 @@ ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context,
{
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);

24
lldb/source/Expression/ClangUserExpression.cpp
View File

@ -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 @@ ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err)
return;
}
StackFrame *frame = exe_ctx.GetFramePtr();
Frame *frame = exe_ctx.GetFramePtr();
if (frame == NULL)
{
if (log)
@ -329,7 +329,7 @@ ClangUserExpression::InstallContext (ExecutionContext &exe_ctx)
{
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 @@ bool
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 @@ ClangUserExpression::MatchesContext (ExecutionContext &exe_ctx)
{
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 @@ ClangUserExpression::Parse (Stream &error_stream,
}
static lldb::addr_t
GetObjectPointer (lldb::StackFrameSP frame_sp,
GetObjectPointer (lldb::FrameSP frame_sp,
ConstString &object_name,
Error &err)
{
@ -575,11 +575,11 @@ GetObjectPointer (lldb::StackFrameSP frame_sp,
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 @@ ClangUserExpression::PrepareToExecuteJITExpression (Stream &error_stream,
{
lldb::TargetSP target;
lldb::ProcessSP process;
lldb::StackFrameSP frame;
lldb::FrameSP frame;
if (!LockAndCheckContext(exe_ctx,
target,

6
lldb/source/Expression/DWARFExpression.cpp
View File

@ -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 @@ DWARFExpression::Evaluate
{
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 @@ DWARFExpression::Evaluate
std::vector<Value> stack;
Process *process = NULL;
StackFrame *frame = NULL;
Frame *frame = NULL;
if (exe_ctx)
{

2
lldb/source/Expression/IRDynamicChecks.cpp
View File

@ -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"

28
lldb/source/Expression/Materializer.cpp
View File

@ -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 @@ public:
}
}
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 @@ public:
}
}
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 @@ public:
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 @@ public:
}
}
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 @@ public:
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 @@ public:
}
}
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 @@ public:
}
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 @@ public:
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 @@ public:
}
}
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 @@ public:
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 @@ public:
}
}
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::~Materializer ()
}
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 @@ Materializer::Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb:
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)

2
lldb/source/Interpreter/Args.cpp
View File

@ -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"

8
lldb/source/Interpreter/ScriptInterpreterPython.cpp
View File

@ -2196,7 +2196,7 @@ ScriptInterpreterPython::BreakpointCallbackFunction
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 @@ ScriptInterpreterPython::WatchpointCallbackFunction
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 @@ ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
bool
ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
StackFrame* frame,
Frame* frame,
std::string& output,
Error& error)
{
@ -2682,7 +2682,7 @@ ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
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)

2
lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
View File

@ -504,7 +504,7 @@ ABIMacOSX_arm::GetReturnValueObjectImpl (Thread &thread,
}
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)

2
lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h
View File

@ -42,7 +42,7 @@ public:
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

2
lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp
View File

@ -676,7 +676,7 @@ ABIMacOSX_i386::GetArgumentValues (Thread &thread,
}
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)

2
lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h
View File

@ -52,7 +52,7 @@ public:
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

4
lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp
View File

@ -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 @@ ABISysV_x86_64::GetArgumentValues (Thread &thread,
}
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)

2
lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h
View File

@ -46,7 +46,7 @@ public:
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

2
lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
View File

@ -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"

2
lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
View File

@ -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"

6
lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
View File

@ -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 @@ DynamicLoaderMacOSXDYLD::ProcessDidExec ()
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 @@ ThreadPlanSP
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 &current_context = current_frame->GetSymbolContext(eSymbolContextSymbol);
Symbol *current_symbol = current_context.symbol;
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));

2
lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
View File

@ -379,7 +379,7 @@ DynamicLoaderPOSIXDYLD::GetStepThroughTrampolinePlan(Thread &thread, bool stop)
{
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;

4
lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp
View File

@ -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 @@ EmulationStateARM::~EmulationStateARM ()
}
bool
EmulationStateARM::LoadPseudoRegistersFromFrame (StackFrame &frame)
EmulationStateARM::LoadPseudoRegistersFromFrame (Frame &frame)
{
RegisterContext *reg_ctx = frame.GetRegisterContext().get();
bool success = true;

2
lldb/source/Plugins/Instruction/ARM/EmulationStateARM.h
View File

@ -42,7 +42,7 @@ public:
ClearPseudoMemory ();
bool
LoadPseudoRegistersFromFrame (lldb_private::StackFrame &frame);
LoadPseudoRegistersFromFrame (lldb_private::Frame &frame);
bool
LoadStateFromDictionary (lldb_private::OptionValueDictionary *test_data);

2
lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
View File

@ -873,7 +873,7 @@ AppleObjCTrampolineHandler::GetStepThroughDispatchPlan (Thread &thread, bool sto
// 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());

2
lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp
View File

@ -109,7 +109,7 @@ ThreadKDP::GetRegisterContext ()
}
lldb::RegisterContextSP
ThreadKDP::CreateRegisterContextForFrame (StackFrame *frame)
ThreadKDP::CreateRegisterContextForFrame (Frame *frame)
{
lldb::RegisterContextSP reg_ctx_sp;
uint32_t concrete_frame_idx = 0;

2
lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.h
View File

@ -39,7 +39,7 @@ public:
GetRegisterContext ();
virtual lldb::RegisterContextSP
CreateRegisterContextForFrame (lldb_private::StackFrame *frame);
CreateRegisterContextForFrame (lldb_private::Frame *frame);
void
Dump (lldb_private::Log *log, uint32_t index);

6
lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
View File

@ -109,7 +109,7 @@ bool lldb_private::InferiorCallMmap(Process *process, addr_t &allocated_addr,
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 @@ bool lldb_private::InferiorCallMunmap(Process *process, addr_t addr,
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 @@ bool lldb_private::InferiorCall(Process *process, const Address *address, addr_t
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;

2
lldb/source/Plugins/Process/Utility/RegisterContextDummy.cpp
View File

@ -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"

2
lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp
View File

@ -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"

2
lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp
View File

@ -335,7 +335,7 @@ StopInfoMachException::CreateStopReasonWithMachException
// {
// // 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;

2
lldb/source/Plugins/Process/Utility/ThreadMemory.cpp
View File

@ -78,7 +78,7 @@ ThreadMemory::GetRegisterContext ()
}
RegisterContextSP
ThreadMemory::CreateRegisterContextForFrame (StackFrame *frame)
ThreadMemory::CreateRegisterContextForFrame (Frame *frame)
{
RegisterContextSP reg_ctx_sp;
uint32_t concrete_frame_idx = 0;

2
lldb/source/Plugins/Process/Utility/ThreadMemory.h
View File

@ -37,7 +37,7 @@ public:
GetRegisterContext ();
virtual lldb::RegisterContextSP
CreateRegisterContextForFrame (lldb_private::StackFrame *frame);
CreateRegisterContextForFrame (lldb_private::Frame *frame);
virtual bool
CalculateStopInfo ();

2
lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp
View File

@ -220,7 +220,7 @@ UnwindLLDB::DoGetFrameInfoAtIndex (uint32_t idx, addr_t& cfa, addr_t& pc)
}
lldb::RegisterContextSP
UnwindLLDB::DoCreateRegisterContextForFrame (StackFrame *frame)
UnwindLLDB::DoCreateRegisterContextForFrame (Frame *frame)
{
lldb::RegisterContextSP reg_ctx_sp;
uint32_t idx = frame->GetConcreteFrameIndex ();

2
lldb/source/Plugins/Process/Utility/UnwindLLDB.h
View File

@ -75,7 +75,7 @@ protected:
lldb::addr_t& start_pc);
lldb::RegisterContextSP
DoCreateRegisterContextForFrame (lldb_private::StackFrame *frame);
DoCreateRegisterContextForFrame (lldb_private::Frame *frame);
typedef std::shared_ptr<RegisterContextLLDB> RegisterContextLLDBSP;

6
lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp
View File

@ -73,7 +73,7 @@ UnwindMacOSXFrameBackchain::DoGetFrameInfoAtIndex (uint32_t idx, addr_t& cfa, ad
}
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 @@ UnwindMacOSXFrameBackchain::GetStackFrameData_i386 (const ExecutionContext &exe_
{
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 @@ UnwindMacOSXFrameBackchain::GetStackFrameData_x86_64 (const ExecutionContext &ex
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;

2
lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h
View File

@ -46,7 +46,7 @@ protected:
lldb::addr_t& pc);
lldb::RegisterContextSP
DoCreateRegisterContextForFrame (lldb_private::StackFrame *frame);
DoCreateRegisterContextForFrame (lldb_private::Frame *frame);
friend class RegisterContextMacOSXFrameBackchain;

2
lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
View File

@ -187,7 +187,7 @@ ThreadGDBRemote::GetRegisterContext ()
}
lldb::RegisterContextSP
ThreadGDBRemote::CreateRegisterContextForFrame (StackFrame *frame)
ThreadGDBRemote::CreateRegisterContextForFrame (Frame *frame)
{
lldb::RegisterContextSP reg_ctx_sp;
uint32_t concrete_frame_idx = 0;

2
lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
View File

@ -45,7 +45,7 @@ public:
GetRegisterContext ();
virtual lldb::RegisterContextSP
CreateRegisterContextForFrame (lldb_private::StackFrame *frame);
CreateRegisterContextForFrame (lldb_private::Frame *frame);
void
Dump (lldb_private::Log *log, uint32_t index);

2
lldb/source/Plugins/Process/mach-core/ThreadMachCore.cpp
View File

@ -88,7 +88,7 @@ ThreadMachCore::GetRegisterContext ()
}
lldb::RegisterContextSP
ThreadMachCore::CreateRegisterContextForFrame (StackFrame *frame)
ThreadMachCore::CreateRegisterContextForFrame (Frame *frame)
{
lldb::RegisterContextSP reg_ctx_sp;
uint32_t concrete_frame_idx = 0;

2
lldb/source/Plugins/Process/mach-core/ThreadMachCore.h
View File

@ -35,7 +35,7 @@ public:
GetRegisterContext ();
virtual lldb::RegisterContextSP
CreateRegisterContextForFrame (lldb_private::StackFrame *frame);
CreateRegisterContextForFrame (lldb_private::Frame *frame);
static bool
ThreadIDIsValid (lldb::tid_t thread);

14
lldb/source/Symbol/Variable.cpp
View File

@ -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 @@ Variable::CalculateSymbolContext (SymbolContext *sc)
}
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 @@ Variable::LocationIsValidForAddress (const Address &address)
}
bool
Variable::IsInScope (StackFrame *frame)
Variable::IsInScope (Frame *frame)
{
switch (m_scope)
{
@ -520,7 +520,7 @@ Variable::DumpLocationForAddress (Stream *s, const Address &address)
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 @@ PrivateAutoComplete (StackFrame *frame,
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 @@ PrivateAutoCompleteMembers (StackFrame *frame,
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 @@ PrivateAutoCompleteMembers (StackFrame *frame,
}
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,

30
lldb/source/Target/ExecutionContext.cpp
View File

@ -11,7 +11,7 @@
#include "lldb/Core/State.h"
#include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Frame.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
@ -64,7 +64,7 @@ ExecutionContext::ExecutionContext (const lldb::ThreadSP &thread_sp) :
SetContext (thread_sp);
}
ExecutionContext::ExecutionContext (const lldb::StackFrameSP &frame_sp) :
ExecutionContext::ExecutionContext (const lldb::FrameSP &frame_sp) :
m_target_sp (),
m_process_sp (),
m_thread_sp (),
@ -107,13 +107,13 @@ ExecutionContext::ExecutionContext (const lldb::ThreadWP &thread_wp) :
SetContext (thread_sp);
}
ExecutionContext::ExecutionContext (const lldb::StackFrameWP &frame_wp) :
ExecutionContext::ExecutionContext (const lldb::FrameWP &frame_wp) :
m_target_sp (),
m_process_sp (),
m_thread_sp (),
m_frame_sp ()
{
lldb::StackFrameSP frame_sp(frame_wp.lock());
lldb::FrameSP frame_sp(frame_wp.lock());
if (frame_sp)
SetContext (frame_sp);
}
@ -136,7 +136,7 @@ ExecutionContext::ExecutionContext (Target* t, bool fill_current_process_thread_
}
}
ExecutionContext::ExecutionContext(Process* process, Thread *thread, StackFrame *frame) :
ExecutionContext::ExecutionContext(Process* process, Thread *thread, Frame *frame) :
m_target_sp (),
m_process_sp (process->shared_from_this()),
m_thread_sp (thread->shared_from_this()),
@ -320,7 +320,7 @@ ExecutionContext::GetThreadRef () const
return *m_thread_sp;
}
StackFrame &
Frame &
ExecutionContext::GetFrameRef () const
{
#if defined (LLDB_CONFIGURATION_DEBUG) || defined (LLDB_CONFIGURATION_RELEASE)
@ -348,7 +348,7 @@ ExecutionContext::SetThreadSP (const lldb::ThreadSP &thread_sp)
}
void
ExecutionContext::SetFrameSP (const lldb::StackFrameSP &frame_sp)
ExecutionContext::SetFrameSP (const lldb::FrameSP &frame_sp)
{
m_frame_sp = frame_sp;
}
@ -381,7 +381,7 @@ ExecutionContext::SetThreadPtr (Thread *thread)
}
void
ExecutionContext::SetFramePtr (StackFrame *frame)
ExecutionContext::SetFramePtr (Frame *frame)
{
if (frame)
m_frame_sp = frame->shared_from_this();
@ -434,7 +434,7 @@ ExecutionContext::SetContext (const lldb::ThreadSP &thread_sp)
}
void
ExecutionContext::SetContext (const lldb::StackFrameSP &frame_sp)
ExecutionContext::SetContext (const lldb::FrameSP &frame_sp)
{
m_frame_sp = frame_sp;
if (frame_sp)
@ -606,7 +606,7 @@ ExecutionContextRef::operator =(const ExecutionContext &exe_ctx)
m_tid = thread_sp->GetID();
else
m_tid = LLDB_INVALID_THREAD_ID;
lldb::StackFrameSP frame_sp (exe_ctx.GetFrameSP());
lldb::FrameSP frame_sp (exe_ctx.GetFrameSP());
if (frame_sp)
m_stack_id = frame_sp->GetStackID();
else
@ -666,7 +666,7 @@ ExecutionContextRef::SetThreadSP (const lldb::ThreadSP &thread_sp)
}
void
ExecutionContextRef::SetFrameSP (const lldb::StackFrameSP &frame_sp)
ExecutionContextRef::SetFrameSP (const lldb::FrameSP &frame_sp)
{
if (frame_sp)
{
@ -711,7 +711,7 @@ ExecutionContextRef::SetTargetPtr (Target* target, bool adopt_selected)
if (thread_sp)
{
SetThreadSP (thread_sp);
lldb::StackFrameSP frame_sp (thread_sp->GetSelectedFrame());
lldb::FrameSP frame_sp (thread_sp->GetSelectedFrame());
if (!frame_sp)
frame_sp = thread_sp->GetStackFrameAtIndex(0);
if (frame_sp)
@ -755,7 +755,7 @@ ExecutionContextRef::SetThreadPtr (Thread *thread)
}
void
ExecutionContextRef::SetFramePtr (StackFrame *frame)
ExecutionContextRef::SetFramePtr (Frame *frame)
{
if (frame)
SetFrameSP (frame->shared_from_this());
@ -811,7 +811,7 @@ ExecutionContextRef::GetThreadSP () const
return thread_sp;
}
lldb::StackFrameSP
lldb::FrameSP
ExecutionContextRef::GetFrameSP () const
{
if (m_stack_id.IsValid())
@ -820,7 +820,7 @@ ExecutionContextRef::GetFrameSP () const
if (thread_sp)
return thread_sp->GetFrameWithStackID (m_stack_id);
}
return lldb::StackFrameSP();
return lldb::FrameSP();
}
ExecutionContext

8
lldb/source/Target/Process.cpp
View File

@ -1808,7 +1808,7 @@ Process::LoadImage (const FileSpec &image_spec, Error &error)
if (thread_sp)
{
StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
FrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
if (frame_sp)
{
@ -1885,7 +1885,7 @@ Process::UnloadImage (uint32_t image_token)
if (thread_sp)
{
StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
FrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
if (frame_sp)
{
@ -4723,7 +4723,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx,
// Save the thread & frame from the exe_ctx for restoration after we run
const uint32_t thread_idx_id = thread->GetIndexID();
StackFrameSP selected_frame_sp = thread->GetSelectedFrame();
FrameSP selected_frame_sp = thread->GetSelectedFrame();
if (!selected_frame_sp)
{
thread->SetSelectedFrame(0);
@ -5451,7 +5451,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx,
{
// We were able to restore the selected thread, now restore the frame:
Mutex::Locker lock(GetThreadList().GetMutex());
StackFrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id);
FrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id);
if (old_frame_sp)
GetThreadList().GetSelectedThread()->SetSelectedFrame(old_frame_sp.get());
}

10
lldb/source/Target/RegisterContext.cpp
View File

@ -17,7 +17,7 @@
#include "lldb/Core/Scalar.h"
#include "lldb/Host/Endian.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Frame.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h"
@ -104,7 +104,7 @@ RegisterContext::SetPC(uint64_t pc)
bool success = WriteRegisterFromUnsigned (reg, pc);
if (success)
{
StackFrameSP frame_sp(m_thread.GetFrameWithConcreteFrameIndex (m_concrete_frame_idx));
FrameSP frame_sp(m_thread.GetFrameWithConcreteFrameIndex (m_concrete_frame_idx));
if (frame_sp)
frame_sp->ChangePC(pc);
else
@ -450,13 +450,13 @@ RegisterContext::CalculateThread ()
return m_thread.shared_from_this();
}
StackFrameSP
RegisterContext::CalculateStackFrame ()
FrameSP
RegisterContext::CalculateFrame ()
{
// Register contexts might belong to many frames if we have inlined
// functions inside a frame since all inlined functions share the
// same registers, so we can't definitively say which frame we come from...
return StackFrameSP();
return FrameSP();
}
void

72
lldb/source/Target/StackFrame.cpp
View File

@ -9,6 +9,7 @@
#include "lldb/lldb-python.h"
#include "lldb/Target/Frame.h"
#include "lldb/Target/StackFrame.h"
// C Includes
@ -204,7 +205,7 @@ StackFrame::GetFrameIndex () const
{
ThreadSP thread_sp = GetThread();
if (thread_sp)
return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(m_frame_index);
return thread_sp->GetStackFrameList()->GetVisibleFrameIndex(m_frame_index);
else
return m_frame_index;
}
@ -246,7 +247,7 @@ StackFrame::GetFrameCodeAddress()
return m_frame_code_addr;
}
void
bool
StackFrame::ChangePC (addr_t pc)
{
m_frame_code_addr.SetRawAddress(pc);
@ -255,6 +256,7 @@ StackFrame::ChangePC (addr_t pc)
ThreadSP thread_sp (GetThread());
if (thread_sp)
thread_sp->ClearStackFrames ();
return true;
}
const char *
@ -1261,8 +1263,8 @@ StackFrame::CalculateThread ()
return GetThread();
}
StackFrameSP
StackFrame::CalculateStackFrame ()
FrameSP
StackFrame::CalculateFrame ()
{
return shared_from_this();
}
@ -1327,50 +1329,46 @@ StackFrame::Dump (Stream *strm, bool show_frame_index, bool show_fullpaths)
}
void
StackFrame::UpdateCurrentFrameFromPreviousFrame (StackFrame &prev_frame)
StackFrame::UpdateCurrentFrameFromPreviousFrame (Frame &prev_frame)
{
assert (GetStackID() == prev_frame.GetStackID()); // TODO: remove this after some testing
m_variable_list_sp = prev_frame.m_variable_list_sp;
m_variable_list_value_objects.Swap (prev_frame.m_variable_list_value_objects);
if (!m_disassembly.GetString().empty())
m_disassembly.GetString().swap (m_disassembly.GetString());
if (strcmp (prev_frame.GetFrameType(), "StackFrame") == 0)
{
StackFrame &prev_stackframe = *static_cast<StackFrame*>(&prev_frame);
m_variable_list_sp = prev_stackframe.m_variable_list_sp;
m_variable_list_value_objects.Swap (prev_stackframe.m_variable_list_value_objects);
if (!m_disassembly.GetString().empty())
m_disassembly.GetString().swap (m_disassembly.GetString());
}
}
void
StackFrame::UpdatePreviousFrameFromCurrentFrame (StackFrame &curr_frame)
StackFrame::UpdatePreviousFrameFromCurrentFrame (Frame &curr_frame)
{
assert (GetStackID() == curr_frame.GetStackID()); // TODO: remove this after some testing
m_id.SetPC (curr_frame.m_id.GetPC()); // Update the Stack ID PC value
assert (GetThread() == curr_frame.GetThread());
m_frame_index = curr_frame.m_frame_index;
m_concrete_frame_index = curr_frame.m_concrete_frame_index;
m_reg_context_sp = curr_frame.m_reg_context_sp;
m_frame_code_addr = curr_frame.m_frame_code_addr;
assert (m_sc.target_sp.get() == NULL || curr_frame.m_sc.target_sp.get() == NULL || m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get());
assert (m_sc.module_sp.get() == NULL || curr_frame.m_sc.module_sp.get() == NULL || m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get());
assert (m_sc.comp_unit == NULL || curr_frame.m_sc.comp_unit == NULL || m_sc.comp_unit == curr_frame.m_sc.comp_unit);
assert (m_sc.function == NULL || curr_frame.m_sc.function == NULL || m_sc.function == curr_frame.m_sc.function);
m_sc = curr_frame.m_sc;
m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything);
m_flags.Set (m_sc.GetResolvedMask());
m_frame_base.Clear();
m_frame_base_error.Clear();
if (strcmp (curr_frame.GetFrameType(), "StackFrame") == 0)
{
StackFrame &curr_stackframe = *static_cast<StackFrame*>(&curr_frame);
m_id.SetPC (curr_stackframe.m_id.GetPC()); // Update the Stack ID PC value
assert (GetThread() == curr_stackframe.GetThread());
m_frame_index = curr_stackframe.m_frame_index;
m_concrete_frame_index = curr_stackframe.m_concrete_frame_index;
m_reg_context_sp = curr_stackframe.m_reg_context_sp;
m_frame_code_addr = curr_stackframe.m_frame_code_addr;
assert (m_sc.target_sp.get() == NULL || curr_stackframe.m_sc.target_sp.get() == NULL || m_sc.target_sp.get() == curr_stackframe.m_sc.target_sp.get());
assert (m_sc.module_sp.get() == NULL || curr_stackframe.m_sc.module_sp.get() == NULL || m_sc.module_sp.get() == curr_stackframe.m_sc.module_sp.get());
assert (m_sc.comp_unit == NULL || curr_stackframe.m_sc.comp_unit == NULL || m_sc.comp_unit == curr_stackframe.m_sc.comp_unit);
assert (m_sc.function == NULL || curr_stackframe.m_sc.function == NULL || m_sc.function == curr_stackframe.m_sc.function);
m_sc = curr_stackframe.m_sc;
m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything);
m_flags.Set (m_sc.GetResolvedMask());
m_frame_base.Clear();
m_frame_base_error.Clear();
}
}
bool
StackFrame::HasCachedData () const
{
if (m_variable_list_sp.get())
return true;
if (m_variable_list_value_objects.GetSize() > 0)
return true;
if (!m_disassembly.GetString().empty())
return true;
return false;
}
bool
StackFrame::GetStatus (Stream& strm,
bool show_frame_info,

53
lldb/source/Target/StackFrameList.cpp
View File

@ -23,6 +23,7 @@
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Frame.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h"
@ -284,7 +285,7 @@ StackFrameList::GetFramesUpTo(uint32_t end_idx)
}
}
StackFrameSP unwind_frame_sp;
FrameSP unwind_frame_sp;
do
{
uint32_t idx = m_concrete_frames_fetched++;
@ -324,7 +325,7 @@ StackFrameList::GetFramesUpTo(uint32_t end_idx)
else
{
unwind_frame_sp = m_frames.front();
cfa = unwind_frame_sp->m_id.GetCallFrameAddress();
cfa = unwind_frame_sp->GetStackID().GetCallFrameAddress();
}
}
else
@ -358,7 +359,7 @@ StackFrameList::GetFramesUpTo(uint32_t end_idx)
while (unwind_sc.GetParentOfInlinedScope(curr_frame_address, next_frame_sc, next_frame_address))
{
StackFrameSP frame_sp(new StackFrame (m_thread.shared_from_this(),
FrameSP frame_sp(new StackFrame (m_thread.shared_from_this(),
m_frames.size(),
idx,
unwind_frame_sp->GetRegisterContextSP (),
@ -398,8 +399,8 @@ StackFrameList::GetFramesUpTo(uint32_t end_idx)
{
const size_t curr_frame_idx = curr_frame_num-1;
const size_t prev_frame_idx = prev_frame_num-1;
StackFrameSP curr_frame_sp (curr_frames->m_frames[curr_frame_idx]);
StackFrameSP prev_frame_sp (prev_frames->m_frames[prev_frame_idx]);
FrameSP curr_frame_sp (curr_frames->m_frames[curr_frame_idx]);
FrameSP prev_frame_sp (prev_frames->m_frames[prev_frame_idx]);
#if defined (DEBUG_STACK_FRAMES)
s.Printf("\n\nCurr frame #%u ", curr_frame_idx);
@ -414,8 +415,8 @@ StackFrameList::GetFramesUpTo(uint32_t end_idx)
s.PutCString("NULL");
#endif
StackFrame *curr_frame = curr_frame_sp.get();
StackFrame *prev_frame = prev_frame_sp.get();
Frame *curr_frame = curr_frame_sp.get();
Frame *prev_frame = prev_frame_sp.get();
if (curr_frame == NULL || prev_frame == NULL)
break;
@ -484,7 +485,7 @@ StackFrameList::Dump (Stream *s)
const_iterator pos, begin = m_frames.begin(), end = m_frames.end();
for (pos = begin; pos != end; ++pos)
{
StackFrame *frame = (*pos).get();
Frame *frame = (*pos).get();
s->Printf("%p: ", frame);
if (frame)
{
@ -498,10 +499,10 @@ StackFrameList::Dump (Stream *s)
s->EOL();
}
StackFrameSP
FrameSP
StackFrameList::GetFrameAtIndex (uint32_t idx)
{
StackFrameSP frame_sp;
FrameSP frame_sp;
Mutex::Locker locker (m_mutex);
uint32_t original_idx = idx;
@ -575,7 +576,7 @@ StackFrameList::GetFrameAtIndex (uint32_t idx)
return frame_sp;
}
StackFrameSP
FrameSP
StackFrameList::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
{
// First try assuming the unwind index is the same as the frame index. The
@ -585,7 +586,7 @@ StackFrameList::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
// frames after we make all the inlined frames. Most of the time the unwind
// frame index (or the concrete frame index) is the same as the frame index.
uint32_t frame_idx = unwind_idx;
StackFrameSP frame_sp (GetFrameAtIndex (frame_idx));
FrameSP frame_sp (GetFrameAtIndex (frame_idx));
while (frame_sp)
{
if (frame_sp->GetFrameIndex() == unwind_idx)
@ -596,15 +597,15 @@ StackFrameList::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
}
static bool
CompareStackID (const StackFrameSP &stack_sp, const StackID &stack_id)
CompareStackID (const FrameSP &stack_sp, const StackID &stack_id)
{
return stack_sp->GetStackID() < stack_id;
}
StackFrameSP
FrameSP
StackFrameList::GetFrameWithStackID (const StackID &stack_id)
{
StackFrameSP frame_sp;
FrameSP frame_sp;
if (stack_id.IsValid())
{
@ -635,7 +636,7 @@ StackFrameList::GetFrameWithStackID (const StackID &stack_id)
}
bool
StackFrameList::SetFrameAtIndex (uint32_t idx, StackFrameSP &frame_sp)
StackFrameList::SetFrameAtIndex (uint32_t idx, FrameSP &frame_sp)
{
if (idx >= m_frames.size())
m_frames.resize(idx + 1);
@ -657,7 +658,7 @@ StackFrameList::GetSelectedFrameIndex () const
uint32_t
StackFrameList::SetSelectedFrame (lldb_private::StackFrame *frame)
StackFrameList::SetSelectedFrame (lldb_private::Frame *frame)
{
Mutex::Locker locker (m_mutex);
const_iterator pos;
@ -684,7 +685,7 @@ bool
StackFrameList::SetSelectedFrameByIndex (uint32_t idx)
{
Mutex::Locker locker (m_mutex);
StackFrameSP frame_sp (GetFrameAtIndex (idx));
FrameSP frame_sp (GetFrameAtIndex (idx));
if (frame_sp)
{
SetSelectedFrame(frame_sp.get());
@ -699,7 +700,7 @@ StackFrameList::SetDefaultFileAndLineToSelectedFrame()
{
if (m_thread.GetID() == m_thread.GetProcess()->GetThreadList().GetSelectedThread()->GetID())
{
StackFrameSP frame_sp (GetFrameAtIndex (GetSelectedFrameIndex()));
FrameSP frame_sp (GetFrameAtIndex (GetSelectedFrameIndex()));
if (frame_sp)
{
SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextLineEntry);
@ -799,8 +800,8 @@ StackFrameList::Merge (std::unique_ptr<StackFrameList>& curr_ap, lldb::StackFram
return;
}
StackFrameSP prev_frame_zero_sp(prev_sp->GetFrameAtIndex (0));
StackFrameSP curr_frame_zero_sp(curr_ap->GetFrameAtIndex (0));
FrameSP prev_frame_zero_sp(prev_sp->GetFrameAtIndex (0));
FrameSP curr_frame_zero_sp(curr_ap->GetFrameAtIndex (0));
StackID curr_stack_id (curr_frame_zero_sp->GetStackID());
StackID prev_stack_id (prev_frame_zero_sp->GetStackID());
@ -839,13 +840,13 @@ StackFrameList::Merge (std::unique_ptr<StackFrameList>& curr_ap, lldb::StackFram
}
lldb::StackFrameSP
StackFrameList::GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr)
lldb::FrameSP
StackFrameList::GetFrameSPForFramePtr (Frame *stack_frame_ptr)
{
const_iterator pos;
const_iterator begin = m_frames.begin();
const_iterator end = m_frames.end();
lldb::StackFrameSP ret_sp;
lldb::FrameSP ret_sp;
for (pos = begin; pos != end; ++pos)
{
@ -871,7 +872,7 @@ StackFrameList::GetStatus (Stream& strm,
if (num_frames == 0)
return 0;
StackFrameSP frame_sp;
FrameSP frame_sp;
uint32_t frame_idx = 0;
uint32_t last_frame;
@ -881,7 +882,7 @@ StackFrameList::GetStatus (Stream& strm,
else
last_frame = first_frame + num_frames;
StackFrameSP selected_frame_sp = m_thread.GetSelectedFrame();
FrameSP selected_frame_sp = m_thread.GetSelectedFrame();
const char *unselected_marker = NULL;
std::string buffer;
if (selected_frame_marker)

12
lldb/source/Target/Target.cpp
View File

@ -42,7 +42,7 @@
#include "lldb/lldb-private-log.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Frame.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h"
@ -1699,10 +1699,10 @@ Target::CalculateThread ()
return ThreadSP();
}
StackFrameSP
Target::CalculateStackFrame ()
FrameSP
Target::CalculateFrame ()
{
return StackFrameSP();
return FrameSP();
}
void
@ -1832,7 +1832,7 @@ ExecutionResults
Target::EvaluateExpression
(
const char *expr_cstr,
StackFrame *frame,
Frame *frame,
lldb::ValueObjectSP &result_valobj_sp,
const EvaluateExpressionOptions& options
)
@ -2086,7 +2086,7 @@ Target::RunStopHooks ()
lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex (i);
if (cur_thread_sp->ThreadStoppedForAReason())
{
lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0);
lldb::FrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0);
exc_ctx_with_reasons.push_back(ExecutionContext(m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get()));
sym_ctx_with_reasons.push_back(cur_frame_sp->GetSymbolContext(eSymbolContextEverything));
}

42
lldb/source/Target/Thread.cpp
View File

@ -211,11 +211,11 @@ Thread::ThreadEventData::GetStackIDFromEvent (const Event *event_ptr)
return stack_id;
}
StackFrameSP
FrameSP
Thread::ThreadEventData::GetStackFrameFromEvent (const Event *event_ptr)
{
const ThreadEventData *event_data = GetEventDataFromEvent (event_ptr);
StackFrameSP frame_sp;
FrameSP frame_sp;
if (event_data)
{
ThreadSP thread_sp = event_data->GetThread();
@ -321,7 +321,7 @@ Thread::BroadcastSelectedFrameChange(StackID &new_frame_id)
}
uint32_t
Thread::SetSelectedFrame (lldb_private::StackFrame *frame, bool broadcast)
Thread::SetSelectedFrame (lldb_private::Frame *frame, bool broadcast)
{
uint32_t ret_value = GetStackFrameList()->SetSelectedFrame(frame);
if (broadcast)
@ -332,7 +332,7 @@ Thread::SetSelectedFrame (lldb_private::StackFrame *frame, bool broadcast)
bool
Thread::SetSelectedFrameByIndex (uint32_t frame_idx, bool broadcast)
{
StackFrameSP frame_sp(GetStackFrameList()->GetFrameAtIndex (frame_idx));
FrameSP frame_sp(GetStackFrameList()->GetFrameAtIndex (frame_idx));
if (frame_sp)
{
GetStackFrameList()->SetSelectedFrame(frame_sp.get());
@ -351,7 +351,7 @@ Thread::SetSelectedFrameByIndexNoisily (uint32_t frame_idx, Stream &output_strea
bool success = SetSelectedFrameByIndex (frame_idx, broadcast);
if (success)
{
StackFrameSP frame_sp = GetSelectedFrame();
FrameSP frame_sp = GetSelectedFrame();
if (frame_sp)
{
bool already_shown = false;
@ -1591,10 +1591,10 @@ Thread::CalculateThread ()
return shared_from_this();
}
StackFrameSP
Thread::CalculateStackFrame ()
FrameSP
Thread::CalculateFrame ()
{
return StackFrameSP();
return FrameSP();
}
void
@ -1638,7 +1638,7 @@ Thread::ClearStackFrames ()
m_curr_frames_sp.reset();
}
lldb::StackFrameSP
lldb::FrameSP
Thread::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
{
return GetStackFrameList()->GetFrameWithConcreteFrameIndex (unwind_idx);
@ -1648,7 +1648,7 @@ Thread::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
Error
Thread::ReturnFromFrameWithIndex (uint32_t frame_idx, lldb::ValueObjectSP return_value_sp, bool broadcast)
{
StackFrameSP frame_sp = GetStackFrameAtIndex (frame_idx);
FrameSP frame_sp = GetStackFrameAtIndex (frame_idx);
Error return_error;
if (!frame_sp)
@ -1660,7 +1660,7 @@ Thread::ReturnFromFrameWithIndex (uint32_t frame_idx, lldb::ValueObjectSP return
}
Error
Thread::ReturnFromFrame (lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return_value_sp, bool broadcast)
Thread::ReturnFromFrame (lldb::FrameSP frame_sp, lldb::ValueObjectSP return_value_sp, bool broadcast)
{
Error return_error;
@ -1672,7 +1672,7 @@ Thread::ReturnFromFrame (lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return
Thread *thread = frame_sp->GetThread().get();
uint32_t older_frame_idx = frame_sp->GetFrameIndex() + 1;
StackFrameSP older_frame_sp = thread->GetStackFrameAtIndex(older_frame_idx);
FrameSP older_frame_sp = thread->GetStackFrameAtIndex(older_frame_idx);
if (!older_frame_sp)
{
return_error.SetErrorString("No older frame to return to.");
@ -1720,7 +1720,7 @@ Thread::ReturnFromFrame (lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return
// Note, we can't use ReadAllRegisterValues->WriteAllRegisterValues, since the read & write
// cook their data
StackFrameSP youngest_frame_sp = thread->GetStackFrameAtIndex(0);
FrameSP youngest_frame_sp = thread->GetStackFrameAtIndex(0);
if (youngest_frame_sp)
{
lldb::RegisterContextSP reg_ctx_sp (youngest_frame_sp->GetRegisterContext());
@ -1768,7 +1768,7 @@ Thread::JumpToLine (const FileSpec &file, uint32_t line, bool can_leave_function
Target *target = exe_ctx.GetTargetPtr();
TargetSP target_sp = exe_ctx.GetTargetSP();
RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
StackFrame *frame = exe_ctx.GetFramePtr();
Frame *frame = exe_ctx.GetFramePtr();
const SymbolContext &sc = frame->GetSymbolContext(eSymbolContextFunction);
// Find candidate locations.
@ -1832,7 +1832,7 @@ Thread::DumpUsingSettingsFormat (Stream &strm, uint32_t frame_idx)
if (process == NULL)
return;
StackFrameSP frame_sp;
FrameSP frame_sp;
SymbolContext frame_sc;
if (frame_idx != LLDB_INVALID_INDEX32)
{
@ -1881,10 +1881,10 @@ Thread::GetThreadLocalData (const ModuleSP module)
return LLDB_INVALID_ADDRESS;
}
lldb::StackFrameSP
Thread::GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr)
lldb::FrameSP
Thread::GetFrameSPForFramePtr (Frame *stack_frame_ptr)
{
return GetStackFrameList()->GetStackFrameSPForStackFramePtr (stack_frame_ptr);
return GetStackFrameList()->GetFrameSPForFramePtr (stack_frame_ptr);
}
const char *
@ -1942,7 +1942,7 @@ Thread::GetStatus (Stream &strm, uint32_t start_frame, uint32_t num_frames, uint
strm.Printf("%c ", is_selected ? '*' : ' ');
if (target && target->GetDebugger().GetUseExternalEditor())
{
StackFrameSP frame_sp = GetStackFrameAtIndex(start_frame);
FrameSP frame_sp = GetStackFrameAtIndex(start_frame);
if (frame_sp)
{
SymbolContext frame_sc(frame_sp->GetSymbolContext (eSymbolContextLineEntry));
@ -1997,7 +1997,7 @@ Thread::GetStackFrameStatus (Stream& strm,
bool
Thread::SaveFrameZeroState (RegisterCheckpoint &checkpoint)
{
lldb::StackFrameSP frame_sp(GetStackFrameAtIndex (0));
lldb::FrameSP frame_sp(GetStackFrameAtIndex (0));
if (frame_sp)
{
checkpoint.SetStackID(frame_sp->GetStackID());
@ -2017,7 +2017,7 @@ Thread::RestoreSaveFrameZero (const RegisterCheckpoint &checkpoint)
bool
Thread::ResetFrameZeroRegisters (lldb::DataBufferSP register_data_sp)
{
lldb::StackFrameSP frame_sp(GetStackFrameAtIndex (0));
lldb::FrameSP frame_sp(GetStackFrameAtIndex (0));
if (frame_sp)
{
lldb::RegisterContextSP reg_ctx_sp (frame_sp->GetRegisterContext());

6
lldb/source/Target/ThreadPlanStepInRange.cpp
View File

@ -202,7 +202,7 @@ ThreadPlanStepInRange::ShouldStop (Event *event_ptr)
if (!m_sub_plan_sp && frame_order == eFrameCompareYounger && m_step_past_prologue)
{
lldb::StackFrameSP curr_frame = m_thread.GetStackFrameAtIndex(0);
lldb::FrameSP curr_frame = m_thread.GetStackFrameAtIndex(0);
if (curr_frame)
{
size_t bytes_to_skip = 0;
@ -275,7 +275,7 @@ ThreadPlanStepInRange::SetDefaultFlagValue (uint32_t new_value)
bool
ThreadPlanStepInRange::FrameMatchesAvoidRegexp ()
{
StackFrame *frame = GetThread().GetStackFrameAtIndex(0).get();
Frame *frame = GetThread().GetStackFrameAtIndex(0).get();
const RegularExpression *avoid_regexp_to_use = m_avoid_regexp_ap.get();
if (avoid_regexp_to_use == NULL)
@ -321,7 +321,7 @@ ThreadPlanSP
ThreadPlanStepInRange::DefaultShouldStopHereCallback (ThreadPlan *current_plan, Flags &flags, void *baton)
{
bool should_step_out = false;
StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
Frame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
if (flags.Test(eAvoidNoDebug))

6
lldb/source/Target/ThreadPlanStepInstruction.cpp
View File

@ -44,12 +44,12 @@ ThreadPlanStepInstruction::ThreadPlanStepInstruction
m_step_over (step_over)
{
m_instruction_addr = m_thread.GetRegisterContext()->GetPC(0);
StackFrameSP m_start_frame_sp(m_thread.GetStackFrameAtIndex(0));
FrameSP m_start_frame_sp(m_thread.GetStackFrameAtIndex(0));
m_stack_id = m_start_frame_sp->GetStackID();
m_start_has_symbol = m_start_frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol != NULL;
StackFrameSP parent_frame_sp = m_thread.GetStackFrameAtIndex(1);
FrameSP parent_frame_sp = m_thread.GetStackFrameAtIndex(1);
if (parent_frame_sp)
m_parent_frame_id = parent_frame_sp->GetStackID();
}
@ -127,7 +127,7 @@ ThreadPlanStepInstruction::ShouldStop (Event *event_ptr)
else
{
// We've stepped in, step back out again:
StackFrame *return_frame = m_thread.GetStackFrameAtIndex(1).get();
Frame *return_frame = m_thread.GetStackFrameAtIndex(1).get();
if (return_frame)
{
if (return_frame->GetStackID() != m_parent_frame_id || m_start_has_symbol)

6
lldb/source/Target/ThreadPlanStepOut.cpp
View File

@ -57,8 +57,8 @@ ThreadPlanStepOut::ThreadPlanStepOut
{
m_step_from_insn = m_thread.GetRegisterContext()->GetPC(0);
StackFrameSP return_frame_sp (m_thread.GetStackFrameAtIndex(frame_idx + 1));
StackFrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (frame_idx));
FrameSP return_frame_sp (m_thread.GetStackFrameAtIndex(frame_idx + 1));
FrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (frame_idx));
if (!return_frame_sp || !immediate_return_from_sp)
return; // we can't do anything here. ValidatePlan() will return false.
@ -401,7 +401,7 @@ ThreadPlanStepOut::QueueInlinedStepPlan (bool queue_now)
// Now figure out the range of this inlined block, and set up a "step through range"
// plan for that. If we've been provided with a context, then use the block in that
// context.
StackFrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (0));
FrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (0));
if (!immediate_return_from_sp)
return false;

6
lldb/source/Target/ThreadPlanStepOverRange.cpp
View File

@ -137,7 +137,7 @@ ThreadPlanStepOverRange::ShouldStop (Event *event_ptr)
// start function really is our start function...
for(uint32_t i = 1;; ++i)
{
StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(i);
FrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(i);
if (!older_frame_sp) {
// We can't unwind the next frame we should just get out of here & stop...
break;
@ -192,7 +192,7 @@ ThreadPlanStepOverRange::ShouldStop (Event *event_ptr)
if (m_addr_context.line_entry.IsValid())
{
SymbolContext sc;
StackFrameSP frame_sp = m_thread.GetStackFrameAtIndex(0);
FrameSP frame_sp = m_thread.GetStackFrameAtIndex(0);
sc = frame_sp->GetSymbolContext (eSymbolContextEverything);
if (sc.line_entry.IsValid())
{
@ -357,7 +357,7 @@ ThreadPlanStepOverRange::DoWillResume (lldb::StateType resume_state, bool curren
if (log)
log->Printf ("ThreadPlanStepInRange::DoWillResume: adjusting range to the frame at inlined depth %d.",
m_thread.GetCurrentInlinedDepth());
StackFrameSP stack_sp = m_thread.GetStackFrameAtIndex(0);
FrameSP stack_sp = m_thread.GetStackFrameAtIndex(0);
if (stack_sp)
{
Block *frame_block = stack_sp->GetFrameBlock();

2
lldb/source/Target/ThreadPlanStepRange.cpp
View File

@ -148,7 +148,7 @@ ThreadPlanStepRange::InRange ()
if (!ret_value)
{
// See if we've just stepped to another part of the same line number...
StackFrame *frame = m_thread.GetStackFrameAtIndex(0).get();
Frame *frame = m_thread.GetStackFrameAtIndex(0).get();
SymbolContext new_context(frame->GetSymbolContext(eSymbolContextEverything));
if (m_addr_context.line_entry.IsValid() && new_context.line_entry.IsValid())

Some files were not shown because too many files have changed in this diff Show More