lldb/source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.h

   1 //===-- RegisterContextDarwin_x86_64.h --------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTDARWIN_X86_64_H
  10 #define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTDARWIN_X86_64_H
  11
  12 #include "lldb/Target/RegisterContext.h"
  13 #include "lldb/lldb-private.h"
  14
  15 class RegisterContextDarwin_x86_64 : public lldb_private::RegisterContext {
  16 public:
  17   RegisterContextDarwin_x86_64(lldb_private::Thread &thread,
  18                                uint32_t concrete_frame_idx);
  19
  20   ~RegisterContextDarwin_x86_64() override;
  21
  22   void InvalidateAllRegisters() override;
  23
  24   size_t GetRegisterCount() override;
  25
  26   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
  27
  28   size_t GetRegisterSetCount() override;
  29
  30   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
  31
  32   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
  33                     lldb_private::RegisterValue &value) override;
  34
  35   bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
  36                      const lldb_private::RegisterValue &value) override;
  37
  38   bool ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) override;
  39
  40   bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
  41
  42   uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
  43                                                uint32_t num) override;
  44
  45   bool HardwareSingleStep(bool enable) override;
  46
  47   struct GPR {
  48     uint64_t rax;
  49     uint64_t rbx;
  50     uint64_t rcx;
  51     uint64_t rdx;
  52     uint64_t rdi;
  53     uint64_t rsi;
  54     uint64_t rbp;
  55     uint64_t rsp;
  56     uint64_t r8;
  57     uint64_t r9;
  58     uint64_t r10;
  59     uint64_t r11;
  60     uint64_t r12;
  61     uint64_t r13;
  62     uint64_t r14;
  63     uint64_t r15;
  64     uint64_t rip;
  65     uint64_t rflags;
  66     uint64_t cs;
  67     uint64_t fs;
  68     uint64_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; // "fctrl"
  83     uint16_t fsw; // "fstat"
  84     uint8_t ftw;  // "ftag"
  85     uint8_t pad1;
  86     uint16_t fop; // "fop"
  87     uint32_t ip;  // "fioff"
  88     uint16_t cs;  // "fiseg"
  89     uint16_t pad2;
  90     uint32_t dp; // "fooff"
  91     uint16_t ds; // "foseg"
  92     uint16_t pad3;
  93     uint32_t mxcsr;
  94     uint32_t mxcsrmask;
  95     MMSReg stmm[8];
  96     XMMReg xmm[16];
  97     uint8_t pad4[6 * 16];
  98     int pad5;
  99   };
 100
 101   struct EXC {
 102     uint32_t trapno;
 103     uint32_t err;
 104     uint64_t faultvaddr;
 105   };
 106
 107 protected:
 108   enum { GPRRegSet = 4, FPURegSet = 5, EXCRegSet = 6 };
 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 *format, ...);
 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 // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTDARWIN_X86_64_H