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     // These two functions are used to implement "push" and "pop" of register states.  They are used primarily
  63     // for expression evaluation, where we need to push a new state (storing the old one in data_sp) and then
  64     // restoring the original state by passing the data_sp we got from ReadAllRegisters to WriteAllRegisterValues.
  65     // ReadAllRegisters will do what is necessary to return a coherent set of register values for this thread, which
  66     // may mean e.g. interrupting a thread that is sitting in a kernel trap.  That is a somewhat disruptive operation,
  67     // so these API's should only be used when this behavior is needed.
  68
  69     virtual bool
  70     ReadAllRegisterValues (lldb::DataBufferSP &data_sp) = 0;
  71
  72     virtual bool
  73     WriteAllRegisterValues (const lldb::DataBufferSP &data_sp) = 0;
  74
  75     bool
  76     CopyFromRegisterContext (lldb::RegisterContextSP context);
  77
  78     virtual uint32_t
  79     ConvertRegisterKindToRegisterNumber (uint32_t kind, uint32_t num) = 0;
  80
  81     //------------------------------------------------------------------
  82     // Subclasses can override these functions if desired
  83     //------------------------------------------------------------------
  84     virtual uint32_t
  85     NumSupportedHardwareBreakpoints ();
  86
  87     virtual uint32_t
  88     SetHardwareBreakpoint (lldb::addr_t addr, size_t size);
  89
  90     virtual bool
  91     ClearHardwareBreakpoint (uint32_t hw_idx);
  92
  93     virtual uint32_t
  94     NumSupportedHardwareWatchpoints ();
  95
  96     virtual uint32_t
  97     SetHardwareWatchpoint (lldb::addr_t addr, size_t size, bool read, bool write);
  98
  99     virtual bool
 100     ClearHardwareWatchpoint (uint32_t hw_index);
 101
 102     virtual bool
 103     HardwareSingleStep (bool enable);
 104
 105     virtual Error
 106     ReadRegisterValueFromMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t src_addr, uint32_t src_len, RegisterValue &reg_value);
 107
 108     virtual Error
 109     WriteRegisterValueToMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len, const RegisterValue &reg_value);
 110
 111     //------------------------------------------------------------------
 112     // Subclasses should not override these
 113     //------------------------------------------------------------------
 114     virtual lldb::tid_t
 115     GetThreadID() const;
 116
 117     virtual Thread &
 118     GetThread ()
 119     {
 120         return m_thread;
 121     }
 122
 123     const RegisterInfo *
 124     GetRegisterInfoByName (const char *reg_name, uint32_t start_idx = 0);
 125
 126     uint64_t
 127     GetPC (uint64_t fail_value = LLDB_INVALID_ADDRESS);
 128
 129     bool
 130     SetPC (uint64_t pc);
 131
 132     uint64_t
 133     GetSP (uint64_t fail_value = LLDB_INVALID_ADDRESS);
 134
 135     bool
 136     SetSP (uint64_t sp);
 137
 138     uint64_t
 139     GetFP (uint64_t fail_value = LLDB_INVALID_ADDRESS);
 140
 141     bool
 142     SetFP (uint64_t fp);
 143
 144     const char *
 145     GetRegisterName (uint32_t reg);
 146
 147     uint64_t
 148     GetReturnAddress (uint64_t fail_value = LLDB_INVALID_ADDRESS);
 149
 150     uint64_t
 151     GetFlags (uint64_t fail_value = 0);
 152
 153     uint64_t
 154     ReadRegisterAsUnsigned (uint32_t reg, uint64_t fail_value);
 155
 156     uint64_t
 157     ReadRegisterAsUnsigned (const RegisterInfo *reg_info, uint64_t fail_value);
 158
 159     bool
 160     WriteRegisterFromUnsigned (uint32_t reg, uint64_t uval);
 161
 162     bool
 163     WriteRegisterFromUnsigned (const RegisterInfo *reg_info, uint64_t uval);
 164     bool
 165     ConvertBetweenRegisterKinds (int source_rk, uint32_t source_regnum, int target_rk, uint32_t& target_regnum);
 166
 167     //------------------------------------------------------------------
 168     // lldb::ExecutionContextScope pure virtual functions
 169     //------------------------------------------------------------------
 170     virtual lldb::TargetSP
 171     CalculateTarget ();
 172
 173     virtual lldb::ProcessSP
 174     CalculateProcess ();
 175
 176     virtual lldb::ThreadSP
 177     CalculateThread ();
 178
 179     virtual lldb::StackFrameSP
 180     CalculateStackFrame ();
 181
 182     virtual void
 183     CalculateExecutionContext (ExecutionContext &exe_ctx);
 184
 185     uint32_t
 186     GetStopID () const
 187     {
 188         return m_stop_id;
 189     }
 190
 191     void
 192     SetStopID (uint32_t stop_id)
 193     {
 194         m_stop_id = stop_id;
 195     }
 196
 197 protected:
 198     //------------------------------------------------------------------
 199     // Classes that inherit from RegisterContext can see and modify these
 200     //------------------------------------------------------------------
 201     Thread &m_thread;               // The thread that this register context belongs to.
 202     uint32_t m_concrete_frame_idx;    // The concrete frame index for this register context
 203     uint32_t m_stop_id;             // The stop ID that any data in this context is valid for
 204 private:
 205     //------------------------------------------------------------------
 206     // For RegisterContext only
 207     //------------------------------------------------------------------
 208     DISALLOW_COPY_AND_ASSIGN (RegisterContext);
 209 };
 210
 211 } // namespace lldb_private
 212
 213 #endif  // liblldb_RegisterContext_h_