1254721Semaste//===-- StackFrame.h --------------------------------------------*- C++ -*-===// 2254721Semaste// 3254721Semaste// The LLVM Compiler Infrastructure 4254721Semaste// 5254721Semaste// This file is distributed under the University of Illinois Open Source 6254721Semaste// License. See LICENSE.TXT for details. 7254721Semaste// 8254721Semaste//===----------------------------------------------------------------------===// 9254721Semaste 10254721Semaste#ifndef liblldb_StackFrame_h_ 11254721Semaste#define liblldb_StackFrame_h_ 12254721Semaste 13254721Semaste// C Includes 14254721Semaste// C++ Includes 15254721Semaste// Other libraries and framework includes 16254721Semaste// Project includes 17254721Semaste#include "lldb/Core/Error.h" 18254721Semaste#include "lldb/Core/Flags.h" 19254721Semaste#include "lldb/Core/Scalar.h" 20254721Semaste#include "lldb/Core/StreamString.h" 21254721Semaste#include "lldb/Core/UserID.h" 22254721Semaste#include "lldb/Core/ValueObjectList.h" 23254721Semaste#include "lldb/Symbol/SymbolContext.h" 24254721Semaste#include "lldb/Target/ExecutionContextScope.h" 25254721Semaste#include "lldb/Target/StackID.h" 26254721Semaste 27254721Semastenamespace lldb_private { 28254721Semaste 29263363Semaste/// @class StackFrame StackFrame.h "lldb/Target/StackFrame.h" 30263363Semaste/// 31263363Semaste/// @brief This base class provides an interface to stack frames. 32263363Semaste/// 33263363Semaste/// StackFrames may have a Canonical Frame Address (CFA) or not. 34263363Semaste/// A frame may have a plain pc value or it may have a pc value + stop_id 35263363Semaste/// to indicate a specific point in the debug session so the correct section 36263363Semaste/// load list is used for symbolication. 37263363Semaste/// 38263363Semaste/// Local variables may be available, or not. A register context may be 39263363Semaste/// available, or not. 40263363Semaste 41254721Semasteclass StackFrame : 42263363Semaste public ExecutionContextScope, 43263363Semaste public std::enable_shared_from_this<StackFrame> 44254721Semaste{ 45254721Semastepublic: 46254721Semaste enum ExpressionPathOption 47254721Semaste { 48254721Semaste eExpressionPathOptionCheckPtrVsMember = (1u << 0), 49254721Semaste eExpressionPathOptionsNoFragileObjcIvar = (1u << 1), 50254721Semaste eExpressionPathOptionsNoSyntheticChildren = (1u << 2), 51254721Semaste eExpressionPathOptionsNoSyntheticArrayRange = (1u << 3), 52254721Semaste eExpressionPathOptionsAllowDirectIVarAccess = (1u << 4) 53254721Semaste }; 54263363Semaste 55254721Semaste //------------------------------------------------------------------ 56263363Semaste /// Construct a StackFrame object without supplying a RegisterContextSP. 57263363Semaste /// 58263363Semaste /// This is the one constructor that doesn't take a RegisterContext 59263363Semaste /// parameter. This ctor may be called when creating a history StackFrame; 60263363Semaste /// these are used if we've collected a stack trace of pc addresses at 61263363Semaste /// some point in the past. We may only have pc values. We may have pc 62263363Semaste /// values and the stop_id when the stack trace was recorded. We may have a 63263363Semaste /// CFA, or more likely, we won't. 64263363Semaste /// 65263363Semaste /// @param [in] thread_sp 66263363Semaste /// The Thread that this frame belongs to. 67263363Semaste /// 68263363Semaste /// @param [in] frame_idx 69263363Semaste /// This StackFrame's frame index number in the Thread. If inlined stack 70263363Semaste /// frames are being created, this may differ from the concrete_frame_idx 71263363Semaste /// which is the frame index without any inlined stack frames. 72263363Semaste /// 73263363Semaste /// @param [in] concrete_frame_idx 74263363Semaste /// The StackFrame's frame index number in the Thread without any inlined 75263363Semaste /// stack frames being included in the index. 76263363Semaste /// 77263363Semaste /// @param [in] cfa 78263363Semaste /// The Canonical Frame Address (this terminology from DWARF) for this 79263363Semaste /// stack frame. The CFA for a stack frame does not change over the 80263363Semaste /// span of the stack frame's existence. It is often the value of the 81263363Semaste /// caller's stack pointer before the call instruction into this frame's 82263363Semaste /// function. It is usually not the same as the frame pointer register's 83263363Semaste /// value. 84263363Semaste /// 85263363Semaste /// @param [in] cfa_is_valid 86263363Semaste /// A history stack frame may not have a CFA value collected. We want to 87263363Semaste /// distinguish between "no CFA available" and a CFA of 88263363Semaste /// LLDB_INVALID_ADDRESS. 89263363Semaste /// 90263363Semaste /// @param [in] pc 91263363Semaste /// The current pc value of this stack frame. 92263363Semaste /// 93263363Semaste /// @param [in] stop_id 94263363Semaste /// The stop_id which should be used when looking up symbols for the pc value, 95263363Semaste /// if appropriate. This argument is ignored if stop_id_is_valid is false. 96263363Semaste /// 97263363Semaste /// @param [in] stop_id_is_valid 98263363Semaste /// If the stop_id argument provided is not needed for this StackFrame, this 99263363Semaste /// should be false. If this is a history stack frame and we know the stop_id 100263363Semaste /// when the pc value was collected, that stop_id should be provided and this 101263363Semaste /// will be true. 102263363Semaste /// 103263363Semaste /// @param [in] is_history_frame 104263363Semaste /// If this is a historical stack frame -- possibly without CFA or registers or 105263363Semaste /// local variables -- then this should be set to true. 106263363Semaste /// 107263363Semaste /// @param [in] sc_ptr 108263363Semaste /// Optionally seed the StackFrame with the SymbolContext information that has 109263363Semaste /// already been discovered. 110254721Semaste //------------------------------------------------------------------ 111254721Semaste StackFrame (const lldb::ThreadSP &thread_sp, 112254721Semaste lldb::user_id_t frame_idx, 113254721Semaste lldb::user_id_t concrete_frame_idx, 114254721Semaste lldb::addr_t cfa, 115263363Semaste bool cfa_is_valid, 116254721Semaste lldb::addr_t pc, 117263363Semaste uint32_t stop_id, 118263363Semaste bool stop_id_is_valid, 119263363Semaste bool is_history_frame, 120254721Semaste const SymbolContext *sc_ptr); 121254721Semaste 122254721Semaste StackFrame (const lldb::ThreadSP &thread_sp, 123254721Semaste lldb::user_id_t frame_idx, 124254721Semaste lldb::user_id_t concrete_frame_idx, 125254721Semaste const lldb::RegisterContextSP ®_context_sp, 126254721Semaste lldb::addr_t cfa, 127254721Semaste lldb::addr_t pc, 128254721Semaste const SymbolContext *sc_ptr); 129254721Semaste 130254721Semaste StackFrame (const lldb::ThreadSP &thread_sp, 131254721Semaste lldb::user_id_t frame_idx, 132254721Semaste lldb::user_id_t concrete_frame_idx, 133254721Semaste const lldb::RegisterContextSP ®_context_sp, 134254721Semaste lldb::addr_t cfa, 135254721Semaste const Address& pc, 136254721Semaste const SymbolContext *sc_ptr); 137254721Semaste 138254721Semaste virtual ~StackFrame (); 139254721Semaste 140254721Semaste lldb::ThreadSP 141254721Semaste GetThread () const 142254721Semaste { 143254721Semaste return m_thread_wp.lock(); 144254721Semaste } 145254721Semaste 146254721Semaste StackID& 147254721Semaste GetStackID(); 148254721Semaste 149263363Semaste //------------------------------------------------------------------ 150263363Semaste /// Get an Address for the current pc value in this StackFrame. 151263363Semaste /// 152263363Semaste /// May not be the same as the actual PC value for inlined stack frames. 153263363Semaste /// 154263363Semaste /// @return 155263363Semaste /// The Address object set to the current PC value. 156263363Semaste //------------------------------------------------------------------ 157254721Semaste const Address& 158254721Semaste GetFrameCodeAddress(); 159263363Semaste 160263363Semaste //------------------------------------------------------------------ 161263363Semaste /// Change the pc value for a given thread. 162263363Semaste /// 163263363Semaste /// Change the current pc value for the frame on this thread. 164263363Semaste /// 165263363Semaste /// @param[in] pc 166263363Semaste /// The load address that the pc will be set to. 167263363Semaste /// 168263363Semaste /// @return 169263363Semaste /// true if the pc was changed. false if this failed -- possibly 170263363Semaste /// because this frame is not a live StackFrame. 171263363Semaste //------------------------------------------------------------------ 172263363Semaste bool 173254721Semaste ChangePC (lldb::addr_t pc); 174254721Semaste 175263363Semaste //------------------------------------------------------------------ 176263363Semaste /// Provide a SymbolContext for this StackFrame's current pc value. 177263363Semaste /// 178263363Semaste /// The StackFrame maintains this SymbolContext and adds additional information 179263363Semaste /// to it on an as-needed basis. This helps to avoid different functions 180263363Semaste /// looking up symbolic information for a given pc value multple times. 181263363Semaste /// 182263363Semaste /// @params [in] resolve_scope 183263363Semaste /// Flags from the SymbolContextItem enumerated type which specify what 184263363Semaste /// type of symbol context is needed by this caller. 185263363Semaste /// 186263363Semaste /// @return 187263363Semaste /// A SymbolContext reference which includes the types of information 188263363Semaste /// requested by resolve_scope, if they are available. 189263363Semaste //------------------------------------------------------------------ 190254721Semaste const SymbolContext& 191254721Semaste GetSymbolContext (uint32_t resolve_scope); 192254721Semaste 193263363Semaste //------------------------------------------------------------------ 194263363Semaste /// Return the Canonical Frame Address (DWARF term) for this frame. 195263363Semaste /// 196263363Semaste /// The CFA is typically the value of the stack pointer register before 197263363Semaste /// the call invocation is made. It will not change during the lifetime 198263363Semaste /// of a stack frame. It is often not the same thing as the frame pointer 199263363Semaste /// register value. 200263363Semaste /// 201263363Semaste /// Live StackFrames will always have a CFA but other types of frames may 202263363Semaste /// not be able to supply one. 203263363Semaste /// 204263363Semaste /// @param [out] value 205263363Semaste /// The address of the CFA for this frame, if available. 206263363Semaste /// 207263363Semaste /// @param [out] error_ptr 208263363Semaste /// If there is an error determining the CFA address, this may contain a 209263363Semaste /// string explaining the failure. 210263363Semaste /// 211263363Semaste /// @return 212263363Semaste /// Returns true if the CFA value was successfully set in value. Some 213263363Semaste /// frames may be unable to provide this value; they will return false. 214263363Semaste //------------------------------------------------------------------ 215254721Semaste bool 216254721Semaste GetFrameBaseValue(Scalar &value, Error *error_ptr); 217254721Semaste 218263363Semaste //------------------------------------------------------------------ 219263363Semaste /// Get the current lexical scope block for this StackFrame, if possible. 220263363Semaste /// 221263363Semaste /// If debug information is available for this stack frame, return a 222263363Semaste /// pointer to the innermost lexical Block that the frame is currently 223263363Semaste /// executing. 224263363Semaste /// 225263363Semaste /// @return 226263363Semaste /// A pointer to the current Block. NULL is returned if this can 227263363Semaste /// not be provided. 228263363Semaste //------------------------------------------------------------------ 229254721Semaste Block * 230254721Semaste GetFrameBlock (); 231254721Semaste 232263363Semaste //------------------------------------------------------------------ 233263363Semaste /// Get the RegisterContext for this frame, if possible. 234263363Semaste /// 235263363Semaste /// Returns a shared pointer to the RegisterContext for this stack frame. 236263363Semaste /// Only a live StackFrame object will be able to return a RegisterContext - 237263363Semaste /// callers must be prepared for an empty shared pointer being returned. 238263363Semaste /// 239263363Semaste /// Even a live StackFrame RegisterContext may not be able to provide all 240263363Semaste /// registers. Only the currently executing frame (frame 0) can reliably 241263363Semaste /// provide every register in the register context. 242263363Semaste /// 243263363Semaste /// @return 244263363Semaste /// The RegisterContext shared point for this frame. 245263363Semaste //------------------------------------------------------------------ 246254721Semaste lldb::RegisterContextSP 247254721Semaste GetRegisterContext (); 248254721Semaste 249254721Semaste const lldb::RegisterContextSP & 250254721Semaste GetRegisterContextSP () const 251254721Semaste { 252254721Semaste return m_reg_context_sp; 253254721Semaste } 254254721Semaste 255263363Semaste //------------------------------------------------------------------ 256263363Semaste /// Retrieve the list of variables that are in scope at this StackFrame's pc. 257263363Semaste /// 258263363Semaste /// A frame that is not live may return an empty VariableList for a given 259263363Semaste /// pc value even though variables would be available at this point if 260263363Semaste /// it were a live stack frame. 261263363Semaste /// 262263363Semaste /// @param[in] get_file_globals 263263363Semaste /// Whether to also retrieve compilation-unit scoped variables 264263363Semaste /// that are visisble to the entire compilation unit (e.g. file 265263363Semaste /// static in C, globals that are homed in this CU). 266263363Semaste /// 267263363Semaste /// @return 268263363Semaste /// A pointer to a list of variables. 269263363Semaste //------------------------------------------------------------------ 270254721Semaste VariableList * 271254721Semaste GetVariableList (bool get_file_globals); 272254721Semaste 273263363Semaste //------------------------------------------------------------------ 274263363Semaste /// Retrieve the list of variables that are in scope at this StackFrame's pc. 275263363Semaste /// 276263363Semaste /// A frame that is not live may return an empty VariableListSP for a 277263363Semaste /// given pc value even though variables would be available at this point 278263363Semaste /// if it were a live stack frame. 279263363Semaste /// 280263363Semaste /// @param[in] get_file_globals 281263363Semaste /// Whether to also retrieve compilation-unit scoped variables 282263363Semaste /// that are visisble to the entire compilation unit (e.g. file 283263363Semaste /// static in C, globals that are homed in this CU). 284263363Semaste /// 285263363Semaste /// @return 286263363Semaste /// A pointer to a list of variables. 287263363Semaste //------------------------------------------------------------------ 288254721Semaste lldb::VariableListSP 289254721Semaste GetInScopeVariableList (bool get_file_globals); 290254721Semaste 291263363Semaste //------------------------------------------------------------------ 292263363Semaste /// Create a ValueObject for a variable name / pathname, possibly 293263363Semaste /// including simple dereference/child selection syntax. 294263363Semaste /// 295263363Semaste /// @param[in] var_expr 296263363Semaste /// The string specifying a variable to base the VariableObject off 297263363Semaste /// of. 298263363Semaste /// 299263363Semaste /// @param[in] use_dynamic 300263363Semaste /// Whether the correct dynamic type of an object pointer should be 301263363Semaste /// determined before creating the object, or if the static type is 302263363Semaste /// sufficient. One of the DynamicValueType enumerated values. 303263363Semaste /// 304263363Semaste /// @param[in] options 305263363Semaste /// An unsigned integer of flags, values from StackFrame::ExpressionPathOption 306263363Semaste /// enum. 307263363Semaste /// @param[in] var_sp 308263363Semaste /// A VariableSP that will be set to the variable described in the 309263363Semaste /// var_expr path. 310263363Semaste /// 311263363Semaste /// @param[in] error 312263363Semaste /// Record any errors encountered while evaluating var_expr. 313263363Semaste /// 314263363Semaste /// @return 315263363Semaste /// A shared pointer to the ValueObject described by var_expr. 316263363Semaste //------------------------------------------------------------------ 317254721Semaste lldb::ValueObjectSP 318263363Semaste GetValueForVariableExpressionPath (const char *var_expr, 319263363Semaste lldb::DynamicValueType use_dynamic, 320254721Semaste uint32_t options, 321254721Semaste lldb::VariableSP &var_sp, 322254721Semaste Error &error); 323254721Semaste 324263363Semaste //------------------------------------------------------------------ 325263363Semaste /// Determine whether this StackFrame has debug information available or not 326263363Semaste /// 327263363Semaste /// @return 328263363Semaste // true if debug information is available for this frame (function, 329263363Semaste // compilation unit, block, etc.) 330263363Semaste //------------------------------------------------------------------ 331254721Semaste bool 332254721Semaste HasDebugInformation (); 333254721Semaste 334263363Semaste //------------------------------------------------------------------ 335263363Semaste /// Return the disassembly for the instructions of this StackFrame's function 336263363Semaste /// as a single C string. 337263363Semaste /// 338263363Semaste /// @return 339263363Semaste // C string with the assembly instructions for this function. 340263363Semaste //------------------------------------------------------------------ 341254721Semaste const char * 342254721Semaste Disassemble (); 343254721Semaste 344263363Semaste //------------------------------------------------------------------ 345263363Semaste /// Print a description for this frame using the frame-format formatter settings. 346263363Semaste /// 347263363Semaste /// @param [in] strm 348263363Semaste /// The Stream to print the description to. 349263363Semaste /// 350263363Semaste /// @param [in] frame_marker 351263363Semaste /// Optional string that will be prepended to the frame output description. 352263363Semaste //------------------------------------------------------------------ 353254721Semaste void 354263363Semaste DumpUsingSettingsFormat (Stream *strm, const char *frame_marker = NULL); 355263363Semaste 356263363Semaste //------------------------------------------------------------------ 357263363Semaste /// Print a description for this frame using a default format. 358263363Semaste /// 359263363Semaste /// @param [in] strm 360263363Semaste /// The Stream to print the description to. 361263363Semaste /// 362263363Semaste /// @param [in] show_frame_index 363263363Semaste /// Whether to print the frame number or not. 364263363Semaste /// 365263363Semaste /// @param [in] show_fullpaths 366263363Semaste /// Whether to print the full source paths or just the file base name. 367263363Semaste //------------------------------------------------------------------ 368254721Semaste void 369254721Semaste Dump (Stream *strm, bool show_frame_index, bool show_fullpaths); 370263363Semaste 371263363Semaste //------------------------------------------------------------------ 372263363Semaste /// Print a description of this stack frame and/or the source context/assembly 373263363Semaste /// for this stack frame. 374263363Semaste /// 375263363Semaste /// @param[in] strm 376263363Semaste /// The Stream to send the output to. 377263363Semaste /// 378263363Semaste /// @param[in] show_frame_info 379263363Semaste /// If true, print the frame info by calling DumpUsingSettingsFormat(). 380263363Semaste /// 381263363Semaste /// @param[in] show_source 382263363Semaste /// If true, print source or disassembly as per the user's settings. 383263363Semaste /// 384263363Semaste /// @param[in] frame_marker 385263363Semaste /// Passed to DumpUsingSettingsFormat() for the frame info printing. 386263363Semaste /// 387263363Semaste /// @return 388263363Semaste /// Returns true if successful. 389263363Semaste //------------------------------------------------------------------ 390254721Semaste bool 391263363Semaste GetStatus (Stream &strm, 392263363Semaste bool show_frame_info, 393263363Semaste bool show_source, 394263363Semaste const char *frame_marker = NULL); 395263363Semaste 396263363Semaste //------------------------------------------------------------------ 397263363Semaste /// Query whether this frame is a concrete frame on the call stack, 398263363Semaste /// or if it is an inlined frame derived from the debug information 399263363Semaste /// and presented by the debugger. 400263363Semaste /// 401263363Semaste /// @return 402263363Semaste /// true if this is an inlined frame. 403263363Semaste //------------------------------------------------------------------ 404263363Semaste bool 405254721Semaste IsInlined (); 406254721Semaste 407263363Semaste //------------------------------------------------------------------ 408263363Semaste /// Query this frame to find what frame it is in this Thread's StackFrameList. 409263363Semaste /// 410263363Semaste /// @return 411263363Semaste /// StackFrame index 0 indicates the currently-executing function. Inline 412263363Semaste /// frames are included in this frame index count. 413263363Semaste //------------------------------------------------------------------ 414254721Semaste uint32_t 415254721Semaste GetFrameIndex () const; 416254721Semaste 417263363Semaste //------------------------------------------------------------------ 418263363Semaste /// Query this frame to find what frame it is in this Thread's StackFrameList, 419263363Semaste /// not counting inlined frames. 420263363Semaste /// 421263363Semaste /// @return 422263363Semaste /// StackFrame index 0 indicates the currently-executing function. Inline 423263363Semaste /// frames are not included in this frame index count; their concrete 424263363Semaste /// frame index will be the same as the concrete frame that they are 425263363Semaste /// derived from. 426263363Semaste //------------------------------------------------------------------ 427254721Semaste uint32_t 428254721Semaste GetConcreteFrameIndex () const 429254721Semaste { 430254721Semaste return m_concrete_frame_index; 431254721Semaste } 432263363Semaste 433263363Semaste //------------------------------------------------------------------ 434263363Semaste /// Create a ValueObject for a given Variable in this StackFrame. 435263363Semaste /// 436263363Semaste /// @params [in] variable_sp 437263363Semaste /// The Variable to base this ValueObject on 438263363Semaste /// 439263363Semaste /// @params [in] use_dynamic 440263363Semaste /// Whether the correct dynamic type of the variable should be 441263363Semaste /// determined before creating the ValueObject, or if the static type 442263363Semaste /// is sufficient. One of the DynamicValueType enumerated values. 443263363Semaste /// 444263363Semaste /// @return 445263363Semaste // A ValueObject for this variable. 446263363Semaste //------------------------------------------------------------------ 447254721Semaste lldb::ValueObjectSP 448254721Semaste GetValueObjectForFrameVariable (const lldb::VariableSP &variable_sp, lldb::DynamicValueType use_dynamic); 449254721Semaste 450263363Semaste //------------------------------------------------------------------ 451263363Semaste /// Add an arbitrary Variable object (e.g. one that specifics a global or static) 452263363Semaste /// to a StackFrame's list of ValueObjects. 453263363Semaste /// 454263363Semaste /// @params [in] variable_sp 455263363Semaste /// The Variable to base this ValueObject on 456263363Semaste /// 457263363Semaste /// @params [in] use_dynamic 458263363Semaste /// Whether the correct dynamic type of the variable should be 459263363Semaste /// determined before creating the ValueObject, or if the static type 460263363Semaste /// is sufficient. One of the DynamicValueType enumerated values. 461263363Semaste /// 462263363Semaste /// @return 463263363Semaste // A ValueObject for this variable. 464263363Semaste //------------------------------------------------------------------ 465254721Semaste lldb::ValueObjectSP 466254721Semaste TrackGlobalVariable (const lldb::VariableSP &variable_sp, lldb::DynamicValueType use_dynamic); 467263363Semaste 468254721Semaste //------------------------------------------------------------------ 469254721Semaste // lldb::ExecutionContextScope pure virtual functions 470254721Semaste //------------------------------------------------------------------ 471254721Semaste virtual lldb::TargetSP 472254721Semaste CalculateTarget (); 473263363Semaste 474254721Semaste virtual lldb::ProcessSP 475254721Semaste CalculateProcess (); 476263363Semaste 477254721Semaste virtual lldb::ThreadSP 478254721Semaste CalculateThread (); 479263363Semaste 480254721Semaste virtual lldb::StackFrameSP 481254721Semaste CalculateStackFrame (); 482254721Semaste 483263363Semaste void 484254721Semaste CalculateExecutionContext (ExecutionContext &exe_ctx); 485263363Semaste 486254721Semasteprotected: 487254721Semaste friend class StackFrameList; 488254721Semaste 489254721Semaste void 490254721Semaste SetSymbolContextScope (SymbolContextScope *symbol_scope); 491254721Semaste 492254721Semaste void 493254721Semaste UpdateCurrentFrameFromPreviousFrame (StackFrame &prev_frame); 494263363Semaste 495254721Semaste void 496254721Semaste UpdatePreviousFrameFromCurrentFrame (StackFrame &curr_frame); 497254721Semaste 498254721Semaste bool 499254721Semaste HasCachedData () const; 500254721Semaste 501254721Semasteprivate: 502254721Semaste //------------------------------------------------------------------ 503254721Semaste // For StackFrame only 504254721Semaste //------------------------------------------------------------------ 505254721Semaste lldb::ThreadWP m_thread_wp; 506254721Semaste uint32_t m_frame_index; 507254721Semaste uint32_t m_concrete_frame_index; 508254721Semaste lldb::RegisterContextSP m_reg_context_sp; 509254721Semaste StackID m_id; 510254721Semaste Address m_frame_code_addr; // The frame code address (might not be the same as the actual PC for inlined frames) as a section/offset address 511254721Semaste SymbolContext m_sc; 512254721Semaste Flags m_flags; 513254721Semaste Scalar m_frame_base; 514254721Semaste Error m_frame_base_error; 515263363Semaste bool m_cfa_is_valid; // Does this frame have a CFA? Different from CFA == LLDB_INVALID_ADDRESS 516263363Semaste uint32_t m_stop_id; 517263363Semaste bool m_stop_id_is_valid; // Does this frame have a stop_id? Use it when referring to the m_frame_code_addr. 518263363Semaste bool m_is_history_frame; 519254721Semaste lldb::VariableListSP m_variable_list_sp; 520254721Semaste ValueObjectList m_variable_list_value_objects; // Value objects for each variable in m_variable_list_sp 521254721Semaste StreamString m_disassembly; 522254721Semaste DISALLOW_COPY_AND_ASSIGN (StackFrame); 523254721Semaste}; 524254721Semaste 525254721Semaste} // namespace lldb_private 526254721Semaste 527254721Semaste#endif // liblldb_StackFrame_h_ 528