contrib/llvm/tools/lldb/include/lldb/Target/StackID.h

   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     //------------------------------------------------------------------
  28     StackID () :
  29         m_pc (LLDB_INVALID_ADDRESS),
  30         m_cfa (LLDB_INVALID_ADDRESS),
  31         m_symbol_scope (NULL)
  32     {
  33     }
  34
  35     explicit
  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
  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
  50     ~StackID()
  51     {
  52     }
  53
  54     lldb::addr_t
  55     GetPC() const
  56     {
  57         return m_pc;
  58     }
  59
  60     lldb::addr_t
  61     GetCallFrameAddress() const
  62     {
  63         return m_cfa;
  64     }
  65
  66     SymbolContextScope *
  67     GetSymbolContextScope () const
  68     {
  69         return m_symbol_scope;
  70     }
  71
  72     void
  73     SetSymbolContextScope (SymbolContextScope *symbol_scope)
  74     {
  75         m_symbol_scope = symbol_scope;
  76     }
  77
  78     void
  79     Clear ()
  80     {
  81         m_pc = LLDB_INVALID_ADDRESS;
  82         m_cfa = LLDB_INVALID_ADDRESS;
  83         m_symbol_scope = NULL;
  84     }
  85
  86     bool
  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
 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_