1 //===-- DNBArchImpl.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 //  Created by Greg Clayton on 6/25/07.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef __DebugNubArchMachARM_h__
15 #define __DebugNubArchMachARM_h__
16 
17 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
18 
19 #include "DNBArch.h"
20 
21 #include <map>
22 
23 class MachThread;
24 
25 class DNBArchMachARM : public DNBArchProtocol {
26 public:
27   enum { kMaxNumThumbITBreakpoints = 4 };
28 
29   DNBArchMachARM(MachThread *thread)
30       : m_thread(thread), m_state(), m_disabled_watchpoints(),
31         m_hw_single_chained_step_addr(INVALID_NUB_ADDRESS),
32         m_last_decode_pc(INVALID_NUB_ADDRESS), m_watchpoint_hw_index(-1),
33         m_watchpoint_did_occur(false),
34         m_watchpoint_resume_single_step_enabled(false),
35         m_saved_register_states() {
36     m_disabled_watchpoints.resize(16);
37     memset(&m_dbg_save, 0, sizeof(m_dbg_save));
38 #if defined(USE_ARM_DISASSEMBLER_FRAMEWORK)
39     ThumbStaticsInit(&m_last_decode_thumb);
40 #endif
41   }
42 
43   virtual ~DNBArchMachARM() {}
44 
45   static void Initialize();
46   static const DNBRegisterSetInfo *GetRegisterSetInfo(nub_size_t *num_reg_sets);
47 
48   virtual bool GetRegisterValue(uint32_t set, uint32_t reg,
49                                 DNBRegisterValue *value);
50   virtual bool SetRegisterValue(uint32_t set, uint32_t reg,
51                                 const DNBRegisterValue *value);
52   virtual nub_size_t GetRegisterContext(void *buf, nub_size_t buf_len);
53   virtual nub_size_t SetRegisterContext(const void *buf, nub_size_t buf_len);
54   virtual uint32_t SaveRegisterState();
55   virtual bool RestoreRegisterState(uint32_t save_id);
56 
57   virtual kern_return_t GetRegisterState(int set, bool force);
58   virtual kern_return_t SetRegisterState(int set);
59   virtual bool RegisterSetStateIsValid(int set) const;
60 
61   virtual uint64_t GetPC(uint64_t failValue); // Get program counter
62   virtual kern_return_t SetPC(uint64_t value);
63   virtual uint64_t GetSP(uint64_t failValue); // Get stack pointer
64   virtual void ThreadWillResume();
65   virtual bool ThreadDidStop();
66   virtual bool NotifyException(MachException::Data &exc);
67 
68   static DNBArchProtocol *Create(MachThread *thread);
69   static const uint8_t *SoftwareBreakpointOpcode(nub_size_t byte_size);
70   static uint32_t GetCPUType();
71 
72   virtual uint32_t NumSupportedHardwareBreakpoints();
73   virtual uint32_t NumSupportedHardwareWatchpoints();
74   virtual uint32_t EnableHardwareBreakpoint(nub_addr_t addr, nub_size_t size);
75   virtual bool DisableHardwareBreakpoint(uint32_t hw_break_index);
76 
77   virtual uint32_t EnableHardwareWatchpoint(nub_addr_t addr, nub_size_t size,
78                                             bool read, bool write,
79                                             bool also_set_on_task);
80   virtual bool DisableHardwareWatchpoint(uint32_t hw_break_index,
81                                          bool also_set_on_task);
82   virtual bool DisableHardwareWatchpoint_helper(uint32_t hw_break_index,
83                                                 bool also_set_on_task);
84   virtual bool ReenableHardwareWatchpoint(uint32_t hw_break_index);
85   virtual bool ReenableHardwareWatchpoint_helper(uint32_t hw_break_index);
86 
87   virtual bool StepNotComplete();
88   virtual uint32_t GetHardwareWatchpointHit(nub_addr_t &addr);
89 
90 #if defined(ARM_DEBUG_STATE32) && (defined(__arm64__) || defined(__aarch64__))
91   typedef arm_debug_state32_t DBG;
92 #else
93   typedef arm_debug_state_t DBG;
94 #endif
95 
96 protected:
97   kern_return_t EnableHardwareSingleStep(bool enable);
98   kern_return_t SetSingleStepSoftwareBreakpoints();
99 
100   bool ConditionPassed(uint8_t condition, uint32_t cpsr);
101 #if defined(USE_ARM_DISASSEMBLER_FRAMEWORK)
102   bool ComputeNextPC(nub_addr_t currentPC,
103                      arm_decoded_instruction_t decodedInstruction,
104                      bool currentPCIsThumb, nub_addr_t *targetPC);
105   arm_error_t DecodeInstructionUsingDisassembler(
106       nub_addr_t curr_pc, uint32_t curr_cpsr,
107       arm_decoded_instruction_t *decodedInstruction,
108       thumb_static_data_t *thumbStaticData, nub_addr_t *next_pc);
109   void DecodeITBlockInstructions(nub_addr_t curr_pc);
110 #endif
111   void EvaluateNextInstructionForSoftwareBreakpointSetup(nub_addr_t currentPC,
112                                                          uint32_t cpsr,
113                                                          bool currentPCIsThumb,
114                                                          nub_addr_t *nextPC,
115                                                          bool *nextPCIsThumb);
116 
117   typedef enum RegisterSetTag {
118     e_regSetALL = REGISTER_SET_ALL,
119     e_regSetGPR, // ARM_THREAD_STATE
120     e_regSetVFP, // ARM_VFP_STATE (ARM_NEON_STATE if defined __arm64__)
121     e_regSetEXC, // ARM_EXCEPTION_STATE
122     e_regSetDBG, // ARM_DEBUG_STATE (ARM_DEBUG_STATE32 if defined __arm64__)
123     kNumRegisterSets
124   } RegisterSet;
125 
126   enum { Read = 0, Write = 1, kNumErrors = 2 };
127 
128   typedef arm_thread_state_t GPR;
129 #if defined(__arm64__) || defined(__aarch64__)
130   typedef arm_neon_state_t FPU;
131 #else
132   typedef arm_vfp_state_t FPU;
133 #endif
134   typedef arm_exception_state_t EXC;
135 
136   static const DNBRegisterInfo g_gpr_registers[];
137   static const DNBRegisterInfo g_vfp_registers[];
138   static const DNBRegisterInfo g_exc_registers[];
139   static const DNBRegisterSetInfo g_reg_sets[];
140 
141   static const size_t k_num_gpr_registers;
142   static const size_t k_num_vfp_registers;
143   static const size_t k_num_exc_registers;
144   static const size_t k_num_all_registers;
145   static const size_t k_num_register_sets;
146 
147   struct Context {
148     GPR gpr;
149     FPU vfp;
150     EXC exc;
151   };
152 
153   struct State {
154     Context context;
155     DBG dbg;
156     kern_return_t gpr_errs[2]; // Read/Write errors
157     kern_return_t vfp_errs[2]; // Read/Write errors
158     kern_return_t exc_errs[2]; // Read/Write errors
159     kern_return_t dbg_errs[2]; // Read/Write errors
160     State() {
161       uint32_t i;
162       for (i = 0; i < kNumErrors; i++) {
163         gpr_errs[i] = -1;
164         vfp_errs[i] = -1;
165         exc_errs[i] = -1;
166         dbg_errs[i] = -1;
167       }
168     }
169     void InvalidateRegisterSetState(int set) { SetError(set, Read, -1); }
170     kern_return_t GetError(int set, uint32_t err_idx) const {
171       if (err_idx < kNumErrors) {
172         switch (set) {
173         // When getting all errors, just OR all values together to see if
174         // we got any kind of error.
175         case e_regSetALL:
176           return gpr_errs[err_idx] | vfp_errs[err_idx] | exc_errs[err_idx] |
177                  dbg_errs[err_idx];
178         case e_regSetGPR:
179           return gpr_errs[err_idx];
180         case e_regSetVFP:
181           return vfp_errs[err_idx];
182         case e_regSetEXC:
183           return exc_errs[err_idx];
184         case e_regSetDBG:
185           return dbg_errs[err_idx];
186         default:
187           break;
188         }
189       }
190       return -1;
191     }
192     bool SetError(int set, uint32_t err_idx, kern_return_t err) {
193       if (err_idx < kNumErrors) {
194         switch (set) {
195         case e_regSetALL:
196           gpr_errs[err_idx] = err;
197           vfp_errs[err_idx] = err;
198           dbg_errs[err_idx] = err;
199           exc_errs[err_idx] = err;
200           return true;
201 
202         case e_regSetGPR:
203           gpr_errs[err_idx] = err;
204           return true;
205 
206         case e_regSetVFP:
207           vfp_errs[err_idx] = err;
208           return true;
209 
210         case e_regSetEXC:
211           exc_errs[err_idx] = err;
212           return true;
213 
214         case e_regSetDBG:
215           dbg_errs[err_idx] = err;
216           return true;
217         default:
218           break;
219         }
220       }
221       return false;
222     }
223     bool RegsAreValid(int set) const {
224       return GetError(set, Read) == KERN_SUCCESS;
225     }
226   };
227 
228   kern_return_t GetGPRState(bool force);
229   kern_return_t GetVFPState(bool force);
230   kern_return_t GetEXCState(bool force);
231   kern_return_t GetDBGState(bool force);
232 
233   kern_return_t SetGPRState();
234   kern_return_t SetVFPState();
235   kern_return_t SetEXCState();
236   kern_return_t SetDBGState(bool also_set_on_task);
237 
238   bool IsWatchpointEnabled(const DBG &debug_state, uint32_t hw_index);
239   nub_addr_t GetWatchpointAddressByIndex(uint32_t hw_index);
240   nub_addr_t GetWatchAddress(const DBG &debug_state, uint32_t hw_index);
241 
242   class disabled_watchpoint {
243   public:
244     disabled_watchpoint() {
245       addr = 0;
246       control = 0;
247     }
248     nub_addr_t addr;
249     uint32_t control;
250   };
251 
252 protected:
253   MachThread *m_thread;
254   State m_state;
255   DBG m_dbg_save;
256 
257   // armv8 doesn't keep the disabled watchpoint values in the debug register
258   // context like armv7;
259   // we need to save them aside when we disable them temporarily.
260   std::vector<disabled_watchpoint> m_disabled_watchpoints;
261 
262   nub_addr_t m_hw_single_chained_step_addr;
263   nub_addr_t m_last_decode_pc;
264 
265   // The following member variables should be updated atomically.
266   int32_t m_watchpoint_hw_index;
267   bool m_watchpoint_did_occur;
268   bool m_watchpoint_resume_single_step_enabled;
269 
270   typedef std::map<uint32_t, Context> SaveRegisterStates;
271   SaveRegisterStates m_saved_register_states;
272 };
273 
274 #endif // #if defined (__arm__)
275 #endif // #ifndef __DebugNubArchMachARM_h__
276