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 __DebugNubArchMachPPC_h__ 15 #define __DebugNubArchMachPPC_h__ 16 17 #if defined (__powerpc__) || defined (__ppc__) || defined (__ppc64__) 18 19 #include "DNBArch.h" 20 21 class MachThread; 22 23 class DNBArchMachPPC : public DNBArchProtocol 24 { 25 public: DNBArchMachPPC(MachThread * thread)26 DNBArchMachPPC(MachThread *thread) : 27 m_thread(thread), 28 m_state() 29 { 30 } 31 ~DNBArchMachPPC()32 virtual ~DNBArchMachPPC() 33 { 34 } 35 36 virtual const DNBRegisterSetInfo * 37 GetRegisterSetInfo(nub_size_t *num_reg_sets) const; 38 virtual bool GetRegisterValue(int set, int reg, DNBRegisterValue *value) const; 39 virtual kern_return_t GetRegisterState (int set, bool force); 40 virtual kern_return_t SetRegisterState (int set); 41 virtual bool RegisterSetStateIsValid (int set) const; 42 43 virtual uint64_t GetPC(uint64_t failValue); // Get program counter 44 virtual kern_return_t SetPC(uint64_t value); 45 virtual uint64_t GetSP(uint64_t failValue); // Get stack pointer 46 virtual bool ThreadWillResume(); 47 virtual bool ThreadDidStop(); 48 49 static const uint8_t * const SoftwareBreakpointOpcode (nub_size_t byte_size); 50 static uint32_t GetCPUType(); 51 52 protected: 53 54 55 kern_return_t EnableHardwareSingleStep (bool enable); 56 57 typedef enum RegisterSetTag 58 { 59 e_regSetALL = REGISTER_SET_ALL, 60 e_regSetGPR, 61 e_regSetFPR, 62 e_regSetEXC, 63 e_regSetVEC, 64 kNumRegisterSets 65 } RegisterSet; 66 67 typedef enum RegisterSetWordSizeTag 68 { 69 e_regSetWordSizeGPR = PPC_THREAD_STATE_COUNT, 70 e_regSetWordSizeFPR = PPC_FLOAT_STATE_COUNT, 71 e_regSetWordSizeEXC = PPC_EXCEPTION_STATE_COUNT, 72 e_regSetWordSizeVEC = PPC_VECTOR_STATE_COUNT 73 } RegisterSetWordSize; 74 75 enum 76 { 77 Read = 0, 78 Write = 1, 79 kNumErrors = 2 80 }; 81 82 struct State 83 { 84 ppc_thread_state_t gpr; 85 ppc_float_state_t fpr; 86 ppc_exception_state_t exc; 87 ppc_vector_state_t vec; 88 kern_return_t gpr_errs[2]; // Read/Write errors 89 kern_return_t fpr_errs[2]; // Read/Write errors 90 kern_return_t exc_errs[2]; // Read/Write errors 91 kern_return_t vec_errs[2]; // Read/Write errors 92 StateState93 State() 94 { 95 uint32_t i; 96 for (i=0; i<kNumErrors; i++) 97 { 98 gpr_errs[i] = -1; 99 fpr_errs[i] = -1; 100 exc_errs[i] = -1; 101 vec_errs[i] = -1; 102 } 103 } InvalidateAllRegisterStatesState104 void InvalidateAllRegisterStates() 105 { 106 SetError (e_regSetALL, Read, -1); 107 } GetErrorState108 kern_return_t GetError (int set, uint32_t err_idx) const 109 { 110 if (err_idx < kNumErrors) 111 { 112 switch (set) 113 { 114 // When getting all errors, just OR all values together to see if 115 // we got any kind of error. 116 case e_regSetALL: return gpr_errs[err_idx] | fpr_errs[err_idx] | exc_errs[err_idx] | vec_errs[err_idx]; 117 case e_regSetGPR: return gpr_errs[err_idx]; 118 case e_regSetFPR: return fpr_errs[err_idx]; 119 case e_regSetEXC: return exc_errs[err_idx]; 120 case e_regSetVEC: return vec_errs[err_idx]; 121 default: break; 122 } 123 } 124 return -1; 125 } SetErrorState126 bool SetError (int set, uint32_t err_idx, kern_return_t err) 127 { 128 if (err_idx < kNumErrors) 129 { 130 switch (set) 131 { 132 case e_regSetALL: 133 gpr_errs[err_idx] = fpr_errs[err_idx] = exc_errs[err_idx] = vec_errs[err_idx] = err; 134 return true; 135 136 case e_regSetGPR: 137 gpr_errs[err_idx] = err; 138 return true; 139 140 case e_regSetFPR: 141 fpr_errs[err_idx] = err; 142 return true; 143 144 case e_regSetEXC: 145 exc_errs[err_idx] = err; 146 return true; 147 148 case e_regSetVEC: 149 vec_errs[err_idx] = err; 150 return true; 151 152 default: break; 153 } 154 } 155 return false; 156 } RegsAreValidState157 bool RegsAreValid (int set) const 158 { 159 return GetError(set, Read) == KERN_SUCCESS; 160 } 161 }; 162 163 kern_return_t GetGPRState (bool force); 164 kern_return_t GetFPRState (bool force); 165 kern_return_t GetEXCState (bool force); 166 kern_return_t GetVECState (bool force); 167 168 kern_return_t SetGPRState (); 169 kern_return_t SetFPRState (); 170 kern_return_t SetEXCState (); 171 kern_return_t SetVECState (); 172 173 protected: 174 MachThread * m_thread; 175 State m_state; 176 }; 177 178 #endif // #if defined (__powerpc__) || defined (__ppc__) || defined (__ppc64__) 179 #endif // #ifndef __DebugNubArchMachPPC_h__ 180