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