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

   1 //===-- RegisterContext.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_RegisterContext_h_
  11 #define liblldb_RegisterContext_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/Target/ExecutionContextScope.h"
  19
  20 namespace lldb_private {
  21
  22 class RegisterContext :
  23     public std::enable_shared_from_this<RegisterContext>,
  24     public ExecutionContextScope
  25 {
  26 public:
  27     //------------------------------------------------------------------
  28     // Constructors and Destructors
  29     //------------------------------------------------------------------
  30     RegisterContext (Thread &thread, uint32_t concrete_frame_idx);
  31
  32     virtual
  33     ~RegisterContext ();
  34
  35     void
  36     InvalidateIfNeeded (bool force);
  37
  38     //------------------------------------------------------------------
  39     // Subclasses must override these functions
  40     //------------------------------------------------------------------
  41     virtual void
  42     InvalidateAllRegisters () = 0;
  43
  44     virtual size_t
  45     GetRegisterCount () = 0;
  46
  47     virtual const RegisterInfo *
  48     GetRegisterInfoAtIndex (size_t reg) = 0;
  49
  50     virtual size_t
  51     GetRegisterSetCount () = 0;
  52
  53     virtual const RegisterSet *
  54     GetRegisterSet (size_t reg_set) = 0;
  55
  56     virtual bool
  57     ReadRegister (const RegisterInfo *reg_info, RegisterValue &reg_value) = 0;
  58
  59     virtual bool
  60     WriteRegister (const RegisterInfo *reg_info, const RegisterValue &reg_value) = 0;
  61
  62     virtual bool
  63     ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
  64     {
  65         return false;
  66     }
  67
  68     virtual bool
  69     WriteAllRegisterValues (const lldb::DataBufferSP &data_sp)
  70     {
  71         return false;
  72     }
  73
  74     // These two functions are used to implement "push" and "pop" of register states.  They are used primarily
  75     // for expression evaluation, where we need to push a new state (storing the old one in data_sp) and then
  76     // restoring the original state by passing the data_sp we got from ReadAllRegisters to WriteAllRegisterValues.
  77     // ReadAllRegisters will do what is necessary to return a coherent set of register values for this thread, which
  78     // may mean e.g. interrupting a thread that is sitting in a kernel trap.  That is a somewhat disruptive operation,
  79     // so these API's should only be used when this behavior is needed.
  80
  81     virtual bool
  82     ReadAllRegisterValues (lldb_private::RegisterCheckpoint &reg_checkpoint);
  83
  84     virtual bool
  85     WriteAllRegisterValues (const lldb_private::RegisterCheckpoint &reg_checkpoint);
  86
  87     bool
  88     CopyFromRegisterContext (lldb::RegisterContextSP context);
  89
  90     virtual uint32_t
  91     ConvertRegisterKindToRegisterNumber (uint32_t kind, uint32_t num) = 0;
  92
  93     //------------------------------------------------------------------
  94     // Subclasses can override these functions if desired
  95     //------------------------------------------------------------------
  96     virtual uint32_t
  97     NumSupportedHardwareBreakpoints ();
  98
  99     virtual uint32_t
 100     SetHardwareBreakpoint (lldb::addr_t addr, size_t size);
 101
 102     virtual bool
 103     ClearHardwareBreakpoint (uint32_t hw_idx);
 104
 105     virtual uint32_t
 106     NumSupportedHardwareWatchpoints ();
 107
 108     virtual uint32_t
 109     SetHardwareWatchpoint (lldb::addr_t addr, size_t size, bool read, bool write);
 110
 111     virtual bool
 112     ClearHardwareWatchpoint (uint32_t hw_index);
 113
 114     virtual bool
 115     HardwareSingleStep (bool enable);
 116
 117     virtual Error
 118     ReadRegisterValueFromMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t src_addr, uint32_t src_len, RegisterValue &reg_value);
 119
 120     virtual Error
 121     WriteRegisterValueToMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len, const RegisterValue &reg_value);
 122
 123     //------------------------------------------------------------------
 124     // Subclasses should not override these
 125     //------------------------------------------------------------------
 126     virtual lldb::tid_t
 127     GetThreadID() const;
 128
 129     virtual Thread &
 130     GetThread ()
 131     {
 132         return m_thread;
 133     }
 134
 135     const RegisterInfo *
 136     GetRegisterInfoByName (const char *reg_name, uint32_t start_idx = 0);
 137
 138     const RegisterInfo *
 139     GetRegisterInfo (uint32_t reg_kind, uint32_t reg_num);
 140
 141     uint64_t
 142     GetPC (uint64_t fail_value = LLDB_INVALID_ADDRESS);
 143
 144     bool
 145     SetPC (uint64_t pc);
 146
 147     bool SetPC (Address addr);
 148
 149     uint64_t
 150     GetSP (uint64_t fail_value = LLDB_INVALID_ADDRESS);
 151
 152     bool
 153     SetSP (uint64_t sp);
 154
 155     uint64_t
 156     GetFP (uint64_t fail_value = LLDB_INVALID_ADDRESS);
 157
 158     bool
 159     SetFP (uint64_t fp);
 160
 161     const char *
 162     GetRegisterName (uint32_t reg);
 163
 164     uint64_t
 165     GetReturnAddress (uint64_t fail_value = LLDB_INVALID_ADDRESS);
 166
 167     uint64_t
 168     GetFlags (uint64_t fail_value = 0);
 169
 170     uint64_t
 171     ReadRegisterAsUnsigned (uint32_t reg, uint64_t fail_value);
 172
 173     uint64_t
 174     ReadRegisterAsUnsigned (const RegisterInfo *reg_info, uint64_t fail_value);
 175
 176     bool
 177     WriteRegisterFromUnsigned (uint32_t reg, uint64_t uval);
 178
 179     bool
 180     WriteRegisterFromUnsigned (const RegisterInfo *reg_info, uint64_t uval);
 181     bool
 182     ConvertBetweenRegisterKinds (int source_rk, uint32_t source_regnum, int target_rk, uint32_t& target_regnum);
 183
 184     //------------------------------------------------------------------
 185     // lldb::ExecutionContextScope pure virtual functions
 186     //------------------------------------------------------------------
 187     virtual lldb::TargetSP
 188     CalculateTarget ();
 189
 190     virtual lldb::ProcessSP
 191     CalculateProcess ();
 192
 193     virtual lldb::ThreadSP
 194     CalculateThread ();
 195
 196     virtual lldb::StackFrameSP
 197     CalculateStackFrame ();
 198
 199     virtual void
 200     CalculateExecutionContext (ExecutionContext &exe_ctx);
 201
 202     uint32_t
 203     GetStopID () const
 204     {
 205         return m_stop_id;
 206     }
 207
 208     void
 209     SetStopID (uint32_t stop_id)
 210     {
 211         m_stop_id = stop_id;
 212     }
 213
 214 protected:
 215     //------------------------------------------------------------------
 216     // Classes that inherit from RegisterContext can see and modify these
 217     //------------------------------------------------------------------
 218     Thread &m_thread;               // The thread that this register context belongs to.
 219     uint32_t m_concrete_frame_idx;    // The concrete frame index for this register context
 220     uint32_t m_stop_id;             // The stop ID that any data in this context is valid for
 221 private:
 222     //------------------------------------------------------------------
 223     // For RegisterContext only
 224     //------------------------------------------------------------------
 225     DISALLOW_COPY_AND_ASSIGN (RegisterContext);
 226 };
 227
 228 } // namespace lldb_private
 229
 230 #endif  // liblldb_RegisterContext_h_