tools/debugserver/source/MacOSX/ppc/DNBArchImpl.h

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