1 | //===-- NativeRegisterContext.h ---------------------------------*- C++ -*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #ifndef LLDB_HOST_COMMON_NATIVEREGISTERCONTEXT_H |
10 | #define LLDB_HOST_COMMON_NATIVEREGISTERCONTEXT_H |
11 | |
12 | #include "lldb/Host/common/NativeWatchpointList.h" |
13 | #include "lldb/lldb-private.h" |
14 | |
15 | namespace lldb_private { |
16 | |
17 | class NativeThreadProtocol; |
18 | |
19 | enum class ExpeditedRegs { Minimal, Full }; |
20 | |
21 | class NativeRegisterContext |
22 | : public std::enable_shared_from_this<NativeRegisterContext> { |
23 | public: |
24 | // Constructors and Destructors |
25 | NativeRegisterContext(NativeThreadProtocol &thread); |
26 | |
27 | virtual ~NativeRegisterContext(); |
28 | |
29 | // void |
30 | // InvalidateIfNeeded (bool force); |
31 | |
32 | // Subclasses must override these functions |
33 | // virtual void |
34 | // InvalidateAllRegisters () = 0; |
35 | |
36 | virtual uint32_t GetRegisterCount() const = 0; |
37 | |
38 | virtual uint32_t GetUserRegisterCount() const = 0; |
39 | |
40 | virtual const RegisterInfo *GetRegisterInfoAtIndex(uint32_t reg) const = 0; |
41 | |
42 | const char *GetRegisterSetNameForRegisterAtIndex(uint32_t reg_index) const; |
43 | |
44 | virtual uint32_t GetRegisterSetCount() const = 0; |
45 | |
46 | virtual const RegisterSet *GetRegisterSet(uint32_t set_index) const = 0; |
47 | |
48 | virtual Status ReadRegister(const RegisterInfo *reg_info, |
49 | RegisterValue ®_value) = 0; |
50 | |
51 | virtual Status WriteRegister(const RegisterInfo *reg_info, |
52 | const RegisterValue ®_value) = 0; |
53 | |
54 | virtual Status ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) = 0; |
55 | |
56 | virtual Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) = 0; |
57 | |
58 | uint32_t ConvertRegisterKindToRegisterNumber(uint32_t kind, |
59 | uint32_t num) const; |
60 | |
61 | // Subclasses can override these functions if desired |
62 | virtual uint32_t NumSupportedHardwareBreakpoints(); |
63 | |
64 | virtual uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size); |
65 | |
66 | virtual bool ClearHardwareBreakpoint(uint32_t hw_idx); |
67 | |
68 | virtual Status ClearAllHardwareBreakpoints(); |
69 | |
70 | virtual Status GetHardwareBreakHitIndex(uint32_t &bp_index, |
71 | lldb::addr_t trap_addr); |
72 | |
73 | virtual uint32_t NumSupportedHardwareWatchpoints(); |
74 | |
75 | virtual uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, |
76 | uint32_t watch_flags); |
77 | |
78 | virtual bool ClearHardwareWatchpoint(uint32_t hw_index); |
79 | |
80 | virtual Status ClearWatchpointHit(uint32_t hw_index); |
81 | |
82 | virtual Status ClearAllHardwareWatchpoints(); |
83 | |
84 | virtual Status IsWatchpointHit(uint32_t wp_index, bool &is_hit); |
85 | |
86 | virtual Status GetWatchpointHitIndex(uint32_t &wp_index, |
87 | lldb::addr_t trap_addr); |
88 | |
89 | virtual Status IsWatchpointVacant(uint32_t wp_index, bool &is_vacant); |
90 | |
91 | virtual lldb::addr_t GetWatchpointAddress(uint32_t wp_index); |
92 | |
93 | // MIPS Linux kernel returns a masked address (last 3bits are masked) |
94 | // when a HW watchpoint is hit. However user may not have set a watchpoint on |
95 | // this address. This function emulates the instruction at PC and finds the |
96 | // base address used in the load/store instruction. This gives the exact |
97 | // address used to read/write the variable being watched. For example: 'n' is |
98 | // at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is set at 'm', |
99 | // then watch exception is generated even when 'n' is read/written. This |
100 | // function returns address of 'n' so that client can check whether a |
101 | // watchpoint is set on this address or not. |
102 | virtual lldb::addr_t GetWatchpointHitAddress(uint32_t wp_index); |
103 | |
104 | virtual bool HardwareSingleStep(bool enable); |
105 | |
106 | virtual Status |
107 | ReadRegisterValueFromMemory(const lldb_private::RegisterInfo *reg_info, |
108 | lldb::addr_t src_addr, size_t src_len, |
109 | RegisterValue ®_value); |
110 | |
111 | virtual Status |
112 | WriteRegisterValueToMemory(const lldb_private::RegisterInfo *reg_info, |
113 | lldb::addr_t dst_addr, size_t dst_len, |
114 | const RegisterValue ®_value); |
115 | |
116 | // Subclasses should not override these |
117 | virtual lldb::tid_t GetThreadID() const; |
118 | |
119 | virtual NativeThreadProtocol &GetThread() { return m_thread; } |
120 | |
121 | virtual std::vector<uint32_t> |
122 | GetExpeditedRegisters(ExpeditedRegs expType) const; |
123 | |
124 | virtual bool RegisterOffsetIsDynamic() const { return false; } |
125 | |
126 | const RegisterInfo *GetRegisterInfoByName(llvm::StringRef reg_name, |
127 | uint32_t start_idx = 0); |
128 | |
129 | const RegisterInfo *GetRegisterInfo(uint32_t reg_kind, uint32_t reg_num); |
130 | |
131 | lldb::addr_t GetPC(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS); |
132 | |
133 | virtual lldb::addr_t |
134 | GetPCfromBreakpointLocation(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS); |
135 | |
136 | Status SetPC(lldb::addr_t pc); |
137 | |
138 | lldb::addr_t GetSP(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS); |
139 | |
140 | Status SetSP(lldb::addr_t sp); |
141 | |
142 | lldb::addr_t GetFP(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS); |
143 | |
144 | Status SetFP(lldb::addr_t fp); |
145 | |
146 | const char *GetRegisterName(uint32_t reg); |
147 | |
148 | lldb::addr_t GetReturnAddress(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS); |
149 | |
150 | lldb::addr_t GetFlags(lldb::addr_t fail_value = 0); |
151 | |
152 | lldb::addr_t ReadRegisterAsUnsigned(uint32_t reg, lldb::addr_t fail_value); |
153 | |
154 | lldb::addr_t ReadRegisterAsUnsigned(const RegisterInfo *reg_info, |
155 | lldb::addr_t fail_value); |
156 | |
157 | Status WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval); |
158 | |
159 | Status WriteRegisterFromUnsigned(const RegisterInfo *reg_info, uint64_t uval); |
160 | |
161 | // uint32_t |
162 | // GetStopID () const |
163 | // { |
164 | // return m_stop_id; |
165 | // } |
166 | |
167 | // void |
168 | // SetStopID (uint32_t stop_id) |
169 | // { |
170 | // m_stop_id = stop_id; |
171 | // } |
172 | |
173 | protected: |
174 | // Classes that inherit from RegisterContext can see and modify these |
175 | NativeThreadProtocol |
176 | &m_thread; // The thread that this register context belongs to. |
177 | // uint32_t m_stop_id; // The stop ID that any data in this |
178 | // context is valid for |
179 | |
180 | private: |
181 | // For RegisterContext only |
182 | NativeRegisterContext(const NativeRegisterContext &) = delete; |
183 | const NativeRegisterContext & |
184 | operator=(const NativeRegisterContext &) = delete; |
185 | }; |
186 | |
187 | } // namespace lldb_private |
188 | |
189 | #endif // LLDB_HOST_COMMON_NATIVEREGISTERCONTEXT_H |
190 | |