tools/debugserver/source/MacOSX/i386/DNBArchImplI386.h

   1 //===-- DNBArchImplI386.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 __DNBArchImplI386_h__
  15 #define __DNBArchImplI386_h__
  16
  17 #if defined (__i386__) || defined (__x86_64__)
  18
  19 #include "DNBArch.h"
  20 #include "../HasAVX.h"
  21 #include "MachRegisterStatesI386.h"
  22
  23 #include <map>
  24
  25 class MachThread;
  26
  27 class DNBArchImplI386 : public DNBArchProtocol
  28 {
  29 public:
  30     DNBArchImplI386(MachThread *thread) :
  31         DNBArchProtocol(),
  32         m_thread(thread),
  33         m_state(),
  34         m_2pc_dbg_checkpoint(),
  35         m_2pc_trans_state(Trans_Done),
  36         m_saved_register_states()
  37     {
  38     }
  39     virtual ~DNBArchImplI386()
  40     {
  41     }
  42
  43     static  void            Initialize();
  44
  45     virtual bool            GetRegisterValue(uint32_t set, uint32_t reg, DNBRegisterValue *value);
  46     virtual bool            SetRegisterValue(uint32_t set, uint32_t reg, const DNBRegisterValue *value);
  47     virtual nub_size_t      GetRegisterContext (void *buf, nub_size_t buf_len);
  48     virtual nub_size_t      SetRegisterContext (const void *buf, nub_size_t buf_len);
  49     virtual uint32_t        SaveRegisterState ();
  50     virtual bool            RestoreRegisterState (uint32_t save_id);
  51
  52     virtual kern_return_t   GetRegisterState  (int set, bool force);
  53     virtual kern_return_t   SetRegisterState  (int set);
  54     virtual bool            RegisterSetStateIsValid (int set) const;
  55
  56     virtual uint64_t        GetPC(uint64_t failValue);    // Get program counter
  57     virtual kern_return_t   SetPC(uint64_t value);
  58     virtual uint64_t        GetSP(uint64_t failValue);    // Get stack pointer
  59     virtual void            ThreadWillResume();
  60     virtual bool            ThreadDidStop();
  61     virtual bool            NotifyException(MachException::Data& exc);
  62
  63     virtual uint32_t        NumSupportedHardwareWatchpoints();
  64     virtual uint32_t        EnableHardwareWatchpoint (nub_addr_t addr, nub_size_t size, bool read, bool write, bool also_set_on_task);
  65     virtual bool            DisableHardwareWatchpoint (uint32_t hw_break_index, bool also_set_on_task);
  66     virtual uint32_t        GetHardwareWatchpointHit(nub_addr_t &addr);
  67
  68 protected:
  69     kern_return_t           EnableHardwareSingleStep (bool enable);
  70
  71     typedef __i386_thread_state_t GPR;
  72     typedef __i386_float_state_t FPU;
  73     typedef __i386_exception_state_t EXC;
  74     typedef __i386_avx_state_t AVX;
  75     typedef __i386_debug_state_t DBG;
  76
  77     static const DNBRegisterInfo g_gpr_registers[];
  78     static const DNBRegisterInfo g_fpu_registers_no_avx[];
  79     static const DNBRegisterInfo g_fpu_registers_avx[];
  80     static const DNBRegisterInfo g_exc_registers[];
  81     static const DNBRegisterSetInfo g_reg_sets_no_avx[];
  82     static const DNBRegisterSetInfo g_reg_sets_avx[];
  83     static const size_t k_num_gpr_registers;
  84     static const size_t k_num_fpu_registers_no_avx;
  85     static const size_t k_num_fpu_registers_avx;
  86     static const size_t k_num_exc_registers;
  87     static const size_t k_num_all_registers_no_avx;
  88     static const size_t k_num_all_registers_avx;
  89     static const size_t k_num_register_sets;
  90
  91     typedef enum RegisterSetTag
  92     {
  93         e_regSetALL = REGISTER_SET_ALL,
  94         e_regSetGPR,
  95         e_regSetFPU,
  96         e_regSetEXC,
  97         e_regSetDBG,
  98         kNumRegisterSets
  99     } RegisterSet;
 100
 101     typedef enum RegisterSetWordSizeTag
 102     {
 103         e_regSetWordSizeGPR = sizeof(GPR) / sizeof(int),
 104         e_regSetWordSizeFPU = sizeof(FPU) / sizeof(int),
 105         e_regSetWordSizeEXC = sizeof(EXC) / sizeof(int),
 106         e_regSetWordSizeAVX = sizeof(AVX) / sizeof(int),
 107         e_regSetWordSizeDBG = sizeof(DBG) / sizeof(int)
 108     } RegisterSetWordSize;
 109
 110     enum
 111     {
 112         Read = 0,
 113         Write = 1,
 114         kNumErrors = 2
 115     };
 116
 117     struct Context
 118     {
 119         GPR gpr;
 120         union {
 121             FPU no_avx;
 122             AVX avx;
 123         } fpu;
 124         EXC exc;
 125         DBG dbg;
 126     };
 127
 128     struct State
 129     {
 130         Context context;
 131         kern_return_t gpr_errs[2];    // Read/Write errors
 132         kern_return_t fpu_errs[2];    // Read/Write errors
 133         kern_return_t exc_errs[2];    // Read/Write errors
 134         kern_return_t dbg_errs[2];    // Read/Write errors
 135
 136         State()
 137         {
 138             uint32_t i;
 139             for (i=0; i<kNumErrors; i++)
 140             {
 141                 gpr_errs[i] = -1;
 142                 fpu_errs[i] = -1;
 143                 exc_errs[i] = -1;
 144                 dbg_errs[i] = -1;
 145             }
 146         }
 147         void InvalidateAllRegisterStates()
 148         {
 149             SetError (e_regSetALL, Read, -1);
 150         }
 151         kern_return_t GetError (int flavor, uint32_t err_idx) const
 152         {
 153             if (err_idx < kNumErrors)
 154             {
 155                 switch (flavor)
 156                 {
 157                 // When getting all errors, just OR all values together to see if
 158                 // we got any kind of error.
 159                 case e_regSetALL:    return gpr_errs[err_idx] |
 160                                             fpu_errs[err_idx] |
 161                                             exc_errs[err_idx];
 162                 case e_regSetGPR:    return gpr_errs[err_idx];
 163                 case e_regSetFPU:    return fpu_errs[err_idx];
 164                 case e_regSetEXC:    return exc_errs[err_idx];
 165                 case e_regSetDBG:    return dbg_errs[err_idx];
 166                 default: break;
 167                 }
 168             }
 169             return -1;
 170         }
 171         bool SetError (int flavor, uint32_t err_idx, kern_return_t err)
 172         {
 173             if (err_idx < kNumErrors)
 174             {
 175                 switch (flavor)
 176                 {
 177                 case e_regSetALL:
 178                     gpr_errs[err_idx] =
 179                     fpu_errs[err_idx] =
 180                     exc_errs[err_idx] =
 181                     dbg_errs[err_idx] = err;
 182                     return true;
 183
 184                 case e_regSetGPR:
 185                     gpr_errs[err_idx] = err;
 186                     return true;
 187
 188                 case e_regSetFPU:
 189                     fpu_errs[err_idx] = err;
 190                     return true;
 191
 192                 case e_regSetEXC:
 193                     exc_errs[err_idx] = err;
 194                     return true;
 195
 196                 case e_regSetDBG:
 197                     dbg_errs[err_idx] = err;
 198                     return true;
 199
 200                 default: break;
 201                 }
 202             }
 203             return false;
 204         }
 205         bool RegsAreValid (int flavor) const
 206         {
 207             return GetError(flavor, Read) == KERN_SUCCESS;
 208         }
 209     };
 210
 211     kern_return_t GetGPRState (bool force);
 212     kern_return_t GetFPUState (bool force);
 213     kern_return_t GetEXCState (bool force);
 214     kern_return_t GetDBGState (bool force);
 215
 216     kern_return_t SetGPRState ();
 217     kern_return_t SetFPUState ();
 218     kern_return_t SetEXCState ();
 219     kern_return_t SetDBGState (bool also_set_on_task);
 220
 221     static DNBArchProtocol *
 222     Create (MachThread *thread);
 223
 224     static const uint8_t *
 225     SoftwareBreakpointOpcode (nub_size_t byte_size);
 226
 227     static const DNBRegisterSetInfo *
 228     GetRegisterSetInfo(nub_size_t *num_reg_sets);
 229
 230     static uint32_t
 231     GetRegisterContextSize();
 232
 233     // Helper functions for watchpoint manipulations.
 234     static void SetWatchpoint(DBG &debug_state, uint32_t hw_index, nub_addr_t addr, nub_size_t size, bool read, bool write);
 235     static void ClearWatchpoint(DBG &debug_state, uint32_t hw_index);
 236     static bool IsWatchpointVacant(const DBG &debug_state, uint32_t hw_index);
 237     static void ClearWatchpointHits(DBG &debug_state);
 238     static bool IsWatchpointHit(const DBG &debug_state, uint32_t hw_index);
 239     static nub_addr_t GetWatchAddress(const DBG &debug_state, uint32_t hw_index);
 240
 241     virtual bool StartTransForHWP();
 242     virtual bool RollbackTransForHWP();
 243     virtual bool FinishTransForHWP();
 244     DBG GetDBGCheckpoint();
 245
 246     MachThread *m_thread;
 247     State       m_state;
 248     DBG         m_2pc_dbg_checkpoint;
 249     uint32_t    m_2pc_trans_state; // Is transaction of DBG state change: Pedning (0), Done (1), or Rolled Back (2)?
 250     typedef std::map<uint32_t, Context> SaveRegisterStates;
 251     SaveRegisterStates m_saved_register_states;
 252 };
 253
 254 #endif    // #if defined (__i386__) || defined (__x86_64__)
 255 #endif    // #ifndef __DNBArchImplI386_h__