RegisterContext.h revision 263363 
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    // 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    const RegisterInfo *
127    GetRegisterInfo (uint32_t reg_kind, uint32_t reg_num);
128
129    uint64_t
130    GetPC (uint64_t fail_value = LLDB_INVALID_ADDRESS);
131
132    bool
133    SetPC (uint64_t pc);
134
135    bool SetPC (Address addr);
136
137    uint64_t
138    GetSP (uint64_t fail_value = LLDB_INVALID_ADDRESS);
139
140    bool
141    SetSP (uint64_t sp);
142
143    uint64_t
144    GetFP (uint64_t fail_value = LLDB_INVALID_ADDRESS);
145
146    bool
147    SetFP (uint64_t fp);
148
149    const char *
150    GetRegisterName (uint32_t reg);
151
152    uint64_t
153    GetReturnAddress (uint64_t fail_value = LLDB_INVALID_ADDRESS);
154
155    uint64_t
156    GetFlags (uint64_t fail_value = 0);
157
158    uint64_t
159    ReadRegisterAsUnsigned (uint32_t reg, uint64_t fail_value);
160
161    uint64_t
162    ReadRegisterAsUnsigned (const RegisterInfo *reg_info, uint64_t fail_value);
163
164    bool
165    WriteRegisterFromUnsigned (uint32_t reg, uint64_t uval);
166
167    bool
168    WriteRegisterFromUnsigned (const RegisterInfo *reg_info, uint64_t uval);
169    bool
170    ConvertBetweenRegisterKinds (int source_rk, uint32_t source_regnum, int target_rk, uint32_t& target_regnum);
171
172    //------------------------------------------------------------------
173    // lldb::ExecutionContextScope pure virtual functions
174    //------------------------------------------------------------------
175    virtual lldb::TargetSP
176    CalculateTarget ();
177
178    virtual lldb::ProcessSP
179    CalculateProcess ();
180
181    virtual lldb::ThreadSP
182    CalculateThread ();
183
184    virtual lldb::StackFrameSP
185    CalculateStackFrame ();
186
187    virtual void
188    CalculateExecutionContext (ExecutionContext &exe_ctx);
189
190    uint32_t
191    GetStopID () const
192    {
193        return m_stop_id;
194    }
195
196    void
197    SetStopID (uint32_t stop_id)
198    {
199        m_stop_id = stop_id;
200    }
201
202protected:
203    //------------------------------------------------------------------
204    // Classes that inherit from RegisterContext can see and modify these
205    //------------------------------------------------------------------
206    Thread &m_thread;               // The thread that this register context belongs to.
207    uint32_t m_concrete_frame_idx;    // The concrete frame index for this register context
208    uint32_t m_stop_id;             // The stop ID that any data in this context is valid for
209private:
210    //------------------------------------------------------------------
211    // For RegisterContext only
212    //------------------------------------------------------------------
213    DISALLOW_COPY_AND_ASSIGN (RegisterContext);
214};
215
216} // namespace lldb_private
217
218#endif  // liblldb_RegisterContext_h_
219