1 //===-- StackID.h -----------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef liblldb_StackID_h_ 11 #define liblldb_StackID_h_ 12 13 // C Includes 14 // C++ Includes 15 // Other libraries and framework includes 16 // Project includes 17 #include "lldb/lldb-private.h" 18 #include "lldb/Core/AddressRange.h" 19 20 namespace lldb_private { 21 22 class StackID 23 { 24 public: 25 //------------------------------------------------------------------ 26 // Constructors and Destructors 27 //------------------------------------------------------------------ StackID()28 StackID () : 29 m_pc (LLDB_INVALID_ADDRESS), 30 m_cfa (LLDB_INVALID_ADDRESS), 31 m_symbol_scope (NULL) 32 { 33 } 34 35 explicit StackID(lldb::addr_t pc,lldb::addr_t cfa,SymbolContextScope * symbol_scope)36 StackID (lldb::addr_t pc, lldb::addr_t cfa, SymbolContextScope *symbol_scope) : 37 m_pc (pc), 38 m_cfa (cfa), 39 m_symbol_scope (symbol_scope) 40 { 41 } 42 StackID(const StackID & rhs)43 StackID (const StackID& rhs) : 44 m_pc (rhs.m_pc), 45 m_cfa (rhs.m_cfa), 46 m_symbol_scope (rhs.m_symbol_scope) 47 { 48 } 49 ~StackID()50 ~StackID() 51 { 52 } 53 54 lldb::addr_t GetPC()55 GetPC() const 56 { 57 return m_pc; 58 } 59 60 lldb::addr_t GetCallFrameAddress()61 GetCallFrameAddress() const 62 { 63 return m_cfa; 64 } 65 66 SymbolContextScope * GetSymbolContextScope()67 GetSymbolContextScope () const 68 { 69 return m_symbol_scope; 70 } 71 72 void SetSymbolContextScope(SymbolContextScope * symbol_scope)73 SetSymbolContextScope (SymbolContextScope *symbol_scope) 74 { 75 m_symbol_scope = symbol_scope; 76 } 77 78 void Clear()79 Clear () 80 { 81 m_pc = LLDB_INVALID_ADDRESS; 82 m_cfa = LLDB_INVALID_ADDRESS; 83 m_symbol_scope = NULL; 84 } 85 86 bool IsValid()87 IsValid () const 88 { 89 return m_pc != LLDB_INVALID_ADDRESS || m_cfa != LLDB_INVALID_ADDRESS; 90 } 91 92 void 93 Dump (Stream *s); 94 95 //------------------------------------------------------------------ 96 // Operators 97 //------------------------------------------------------------------ 98 const StackID& 99 operator=(const StackID& rhs) 100 { 101 if (this != &rhs) 102 { 103 m_pc = rhs.m_pc; 104 m_cfa = rhs.m_cfa; 105 m_symbol_scope = rhs.m_symbol_scope; 106 } 107 return *this; 108 } 109 110 protected: 111 112 friend class StackFrame; 113 114 void SetPC(lldb::addr_t pc)115 SetPC (lldb::addr_t pc) 116 { 117 m_pc = pc; 118 } 119 120 121 //------------------------------------------------------------------ 122 // Classes that inherit from StackID can see and modify these 123 //------------------------------------------------------------------ 124 lldb::addr_t m_pc; // The pc value for the function/symbol for this frame. This will 125 // only get used if the symbol scope is NULL (the code where we are 126 // stopped is not represented by any function or symbol in any 127 // shared library). 128 lldb::addr_t m_cfa; // The call frame address (stack pointer) value 129 // at the beginning of the function that uniquely 130 // identifies this frame (along with m_symbol_scope below) 131 SymbolContextScope *m_symbol_scope; // If NULL, there is no block or symbol for this frame. 132 // If not NULL, this will either be the scope for the 133 // lexical block for the frame, or the scope 134 // for the symbol. Symbol context scopes are 135 // always be unique pointers since the are part 136 // of the Block and Symbol objects and can easily 137 // be used to tell if a stack ID is the same as 138 // another. 139 }; 140 141 bool operator== (const StackID& lhs, const StackID& rhs); 142 bool operator!= (const StackID& lhs, const StackID& rhs); 143 144 // frame_id_1 < frame_id_2 means "frame_id_1 is YOUNGER than frame_id_2" 145 bool operator< (const StackID& lhs, const StackID& rhs); 146 147 } // namespace lldb_private 148 149 #endif // liblldb_StackID_h_ 150