RegisterContext.h revision 263367 
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
20namespace lldb_private {
21
22class RegisterContext :
23    public std::enable_shared_from_this<RegisterContext>,
24    public ExecutionContextScope
25{
26public:
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
214protected:
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
221private:
222    //------------------------------------------------------------------
223    // For RegisterContext only
224    //------------------------------------------------------------------
225    DISALLOW_COPY_AND_ASSIGN (RegisterContext);
226};
227
228} // namespace lldb_private
229
230#endif  // liblldb_RegisterContext_h_
231