source/Plugins/Process/Utility/RegisterContextDarwin_i386.h

   1 //===-- RegisterContextDarwin_i386.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_i386_h_
  11 #define liblldb_RegisterContextDarwin_i386_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_i386 : public lldb_private::RegisterContext {
  21 public:
  22   RegisterContextDarwin_i386(lldb_private::Thread &thread,
  23                              uint32_t concrete_frame_idx);
  24
  25   ~RegisterContextDarwin_i386() 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     uint32_t eax;
  54     uint32_t ebx;
  55     uint32_t ecx;
  56     uint32_t edx;
  57     uint32_t edi;
  58     uint32_t esi;
  59     uint32_t ebp;
  60     uint32_t esp;
  61     uint32_t ss;
  62     uint32_t eflags;
  63     uint32_t eip;
  64     uint32_t cs;
  65     uint32_t ds;
  66     uint32_t es;
  67     uint32_t fs;
  68     uint32_t gs;
  69   };
  70
  71   struct MMSReg {
  72     uint8_t bytes[10];
  73     uint8_t pad[6];
  74   };
  75
  76   struct XMMReg {
  77     uint8_t bytes[16];
  78   };
  79
  80   struct FPU {
  81     uint32_t pad[2];
  82     uint16_t fcw;
  83     uint16_t fsw;
  84     uint8_t ftw;
  85     uint8_t pad1;
  86     uint16_t fop;
  87     uint32_t ip;
  88     uint16_t cs;
  89     uint16_t pad2;
  90     uint32_t dp;
  91     uint16_t ds;
  92     uint16_t pad3;
  93     uint32_t mxcsr;
  94     uint32_t mxcsrmask;
  95     MMSReg stmm[8];
  96     XMMReg xmm[8];
  97     uint8_t pad4[14 * 16];
  98     int pad5;
  99   };
 100
 101   struct EXC {
 102     uint32_t trapno;
 103     uint32_t err;
 104     uint32_t faultvaddr;
 105   };
 106
 107 protected:
 108   enum { GPRRegSet = 1, FPURegSet = 2, EXCRegSet = 3 };
 109
 110   enum {
 111     GPRWordCount = sizeof(GPR) / sizeof(uint32_t),
 112     FPUWordCount = sizeof(FPU) / sizeof(uint32_t),
 113     EXCWordCount = sizeof(EXC) / sizeof(uint32_t)
 114   };
 115
 116   enum { Read = 0, Write = 1, kNumErrors = 2 };
 117
 118   GPR gpr;
 119   FPU fpu;
 120   EXC exc;
 121   int gpr_errs[2]; // Read/Write errors
 122   int fpu_errs[2]; // Read/Write errors
 123   int exc_errs[2]; // Read/Write errors
 124
 125   void InvalidateAllRegisterStates() {
 126     SetError(GPRRegSet, Read, -1);
 127     SetError(FPURegSet, Read, -1);
 128     SetError(EXCRegSet, Read, -1);
 129   }
 130
 131   int GetError(int flavor, uint32_t err_idx) const {
 132     if (err_idx < kNumErrors) {
 133       switch (flavor) {
 134       // When getting all errors, just OR all values together to see if
 135       // we got any kind of error.
 136       case GPRRegSet:
 137         return gpr_errs[err_idx];
 138       case FPURegSet:
 139         return fpu_errs[err_idx];
 140       case EXCRegSet:
 141         return exc_errs[err_idx];
 142       default:
 143         break;
 144       }
 145     }
 146     return -1;
 147   }
 148
 149   bool SetError(int flavor, uint32_t err_idx, int err) {
 150     if (err_idx < kNumErrors) {
 151       switch (flavor) {
 152       case GPRRegSet:
 153         gpr_errs[err_idx] = err;
 154         return true;
 155
 156       case FPURegSet:
 157         fpu_errs[err_idx] = err;
 158         return true;
 159
 160       case EXCRegSet:
 161         exc_errs[err_idx] = err;
 162         return true;
 163
 164       default:
 165         break;
 166       }
 167     }
 168     return false;
 169   }
 170
 171   bool RegisterSetIsCached(int set) const { return GetError(set, Read) == 0; }
 172
 173   void LogGPR(lldb_private::Log *log, const char *title);
 174
 175   int ReadGPR(bool force);
 176
 177   int ReadFPU(bool force);
 178
 179   int ReadEXC(bool force);
 180
 181   int WriteGPR();
 182
 183   int WriteFPU();
 184
 185   int WriteEXC();
 186
 187   // Subclasses override these to do the actual reading.
 188   virtual int DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) = 0;
 189
 190   virtual int DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) = 0;
 191
 192   virtual int DoReadEXC(lldb::tid_t tid, int flavor, EXC &exc) = 0;
 193
 194   virtual int DoWriteGPR(lldb::tid_t tid, int flavor, const GPR &gpr) = 0;
 195
 196   virtual int DoWriteFPU(lldb::tid_t tid, int flavor, const FPU &fpu) = 0;
 197
 198   virtual int DoWriteEXC(lldb::tid_t tid, int flavor, const EXC &exc) = 0;
 199
 200   int ReadRegisterSet(uint32_t set, bool force);
 201
 202   int WriteRegisterSet(uint32_t set);
 203
 204   static uint32_t GetRegisterNumber(uint32_t reg_kind, uint32_t reg_num);
 205
 206   static int GetSetForNativeRegNum(int reg_num);
 207
 208   static size_t GetRegisterInfosCount();
 209
 210   static const lldb_private::RegisterInfo *GetRegisterInfos();
 211 };
 212
 213 #endif // liblldb_RegisterContextDarwin_i386_h_