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