contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.h

   1 //===-- RegisterContextDarwin_x86_64.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 #ifndef liblldb_RegisterContextDarwin_x86_64_h_
  11 #define liblldb_RegisterContextDarwin_x86_64_h_
  12
  13 // C Includes
  14 // C++ Includes
  15 // Other libraries and framework includes
  16 // Project includes
  17 #include "lldb/Target/RegisterContext.h"
  18 #include "lldb/lldb-private.h"
  19
  20 class RegisterContextDarwin_x86_64 : public lldb_private::RegisterContext {
  21 public:
  22   RegisterContextDarwin_x86_64(lldb_private::Thread &thread,
  23                                uint32_t concrete_frame_idx);
  24
  25   ~RegisterContextDarwin_x86_64() override;
  26
  27   void InvalidateAllRegisters() override;
  28
  29   size_t GetRegisterCount() override;
  30
  31   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
  32
  33   size_t GetRegisterSetCount() override;
  34
  35   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
  36
  37   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
  38                     lldb_private::RegisterValue &value) override;
  39
  40   bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
  41                      const lldb_private::RegisterValue &value) override;
  42
  43   bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
  44
  45   bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
  46
  47   uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
  48                                                uint32_t num) override;
  49
  50   bool HardwareSingleStep(bool enable) override;
  51
  52   struct GPR {
  53     uint64_t rax;
  54     uint64_t rbx;
  55     uint64_t rcx;
  56     uint64_t rdx;
  57     uint64_t rdi;
  58     uint64_t rsi;
  59     uint64_t rbp;
  60     uint64_t rsp;
  61     uint64_t r8;
  62     uint64_t r9;
  63     uint64_t r10;
  64     uint64_t r11;
  65     uint64_t r12;
  66     uint64_t r13;
  67     uint64_t r14;
  68     uint64_t r15;
  69     uint64_t rip;
  70     uint64_t rflags;
  71     uint64_t cs;
  72     uint64_t fs;
  73     uint64_t gs;
  74   };
  75
  76   struct MMSReg {
  77     uint8_t bytes[10];
  78     uint8_t pad[6];
  79   };
  80
  81   struct XMMReg {
  82     uint8_t bytes[16];
  83   };
  84
  85   struct FPU {
  86     uint32_t pad[2];
  87     uint16_t fcw; // "fctrl"
  88     uint16_t fsw; // "fstat"
  89     uint8_t ftw;  // "ftag"
  90     uint8_t pad1;
  91     uint16_t fop; // "fop"
  92     uint32_t ip;  // "fioff"
  93     uint16_t cs;  // "fiseg"
  94     uint16_t pad2;
  95     uint32_t dp; // "fooff"
  96     uint16_t ds; // "foseg"
  97     uint16_t pad3;
  98     uint32_t mxcsr;
  99     uint32_t mxcsrmask;
 100     MMSReg stmm[8];
 101     XMMReg xmm[16];
 102     uint8_t pad4[6 * 16];
 103     int pad5;
 104   };
 105
 106   struct EXC {
 107     uint32_t trapno;
 108     uint32_t err;
 109     uint64_t faultvaddr;
 110   };
 111
 112 protected:
 113   enum { GPRRegSet = 4, FPURegSet = 5, EXCRegSet = 6 };
 114
 115   enum {
 116     GPRWordCount = sizeof(GPR) / sizeof(uint32_t),
 117     FPUWordCount = sizeof(FPU) / sizeof(uint32_t),
 118     EXCWordCount = sizeof(EXC) / sizeof(uint32_t)
 119   };
 120
 121   enum { Read = 0, Write = 1, kNumErrors = 2 };
 122
 123   GPR gpr;
 124   FPU fpu;
 125   EXC exc;
 126   int gpr_errs[2]; // Read/Write errors
 127   int fpu_errs[2]; // Read/Write errors
 128   int exc_errs[2]; // Read/Write errors
 129
 130   void InvalidateAllRegisterStates() {
 131     SetError(GPRRegSet, Read, -1);
 132     SetError(FPURegSet, Read, -1);
 133     SetError(EXCRegSet, Read, -1);
 134   }
 135
 136   int GetError(int flavor, uint32_t err_idx) const {
 137     if (err_idx < kNumErrors) {
 138       switch (flavor) {
 139       // When getting all errors, just OR all values together to see if
 140       // we got any kind of error.
 141       case GPRRegSet:
 142         return gpr_errs[err_idx];
 143       case FPURegSet:
 144         return fpu_errs[err_idx];
 145       case EXCRegSet:
 146         return exc_errs[err_idx];
 147       default:
 148         break;
 149       }
 150     }
 151     return -1;
 152   }
 153
 154   bool SetError(int flavor, uint32_t err_idx, int err) {
 155     if (err_idx < kNumErrors) {
 156       switch (flavor) {
 157       case GPRRegSet:
 158         gpr_errs[err_idx] = err;
 159         return true;
 160
 161       case FPURegSet:
 162         fpu_errs[err_idx] = err;
 163         return true;
 164
 165       case EXCRegSet:
 166         exc_errs[err_idx] = err;
 167         return true;
 168
 169       default:
 170         break;
 171       }
 172     }
 173     return false;
 174   }
 175
 176   bool RegisterSetIsCached(int set) const { return GetError(set, Read) == 0; }
 177
 178   void LogGPR(lldb_private::Log *log, const char *format, ...);
 179
 180   int ReadGPR(bool force);
 181
 182   int ReadFPU(bool force);
 183
 184   int ReadEXC(bool force);
 185
 186   int WriteGPR();
 187
 188   int WriteFPU();
 189
 190   int WriteEXC();
 191
 192   // Subclasses override these to do the actual reading.
 193   virtual int DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) = 0;
 194
 195   virtual int DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) = 0;
 196
 197   virtual int DoReadEXC(lldb::tid_t tid, int flavor, EXC &exc) = 0;
 198
 199   virtual int DoWriteGPR(lldb::tid_t tid, int flavor, const GPR &gpr) = 0;
 200
 201   virtual int DoWriteFPU(lldb::tid_t tid, int flavor, const FPU &fpu) = 0;
 202
 203   virtual int DoWriteEXC(lldb::tid_t tid, int flavor, const EXC &exc) = 0;
 204
 205   int ReadRegisterSet(uint32_t set, bool force);
 206
 207   int WriteRegisterSet(uint32_t set);
 208
 209   static uint32_t GetRegisterNumber(uint32_t reg_kind, uint32_t reg_num);
 210
 211   static int GetSetForNativeRegNum(int reg_num);
 212
 213   static size_t GetRegisterInfosCount();
 214
 215   static const lldb_private::RegisterInfo *GetRegisterInfos();
 216 };
 217
 218 #endif // liblldb_RegisterContextDarwin_x86_64_h_