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

   1 //===-- RegisterContextDarwin_arm64.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_arm64_h_
  11 #define liblldb_RegisterContextDarwin_arm64_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 // Break only in privileged or user mode
  21 #define S_RSVD                  ((uint32_t)(0u << 1))
  22 #define S_PRIV                  ((uint32_t)(1u << 1))
  23 #define S_USER                  ((uint32_t)(2u << 1))
  24 #define S_PRIV_USER             ((S_PRIV) | (S_USER))
  25
  26 #define WCR_ENABLE              ((uint32_t)(1u))
  27
  28 // Watchpoint load/store
  29 #define WCR_LOAD                ((uint32_t)(1u << 3))
  30 #define WCR_STORE               ((uint32_t)(1u << 4))
  31
  32 class RegisterContextDarwin_arm64 : public lldb_private::RegisterContext
  33 {
  34 public:
  35     RegisterContextDarwin_arm64(lldb_private::Thread &thread, uint32_t concrete_frame_idx);
  36
  37     ~RegisterContextDarwin_arm64() override;
  38
  39     void
  40     InvalidateAllRegisters() override;
  41
  42     size_t
  43     GetRegisterCount() override;
  44
  45     const lldb_private::RegisterInfo *
  46     GetRegisterInfoAtIndex(size_t reg) override;
  47
  48     size_t
  49     GetRegisterSetCount() override;
  50
  51     const lldb_private::RegisterSet *
  52     GetRegisterSet(size_t set) override;
  53
  54     bool
  55     ReadRegister(const lldb_private::RegisterInfo *reg_info,
  56                  lldb_private::RegisterValue &reg_value) override;
  57
  58     bool
  59     WriteRegister(const lldb_private::RegisterInfo *reg_info,
  60                   const lldb_private::RegisterValue &reg_value) override;
  61
  62     bool
  63     ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
  64
  65     bool
  66     WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
  67
  68     uint32_t
  69     ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num) override;
  70
  71     uint32_t
  72     NumSupportedHardwareWatchpoints() override;
  73
  74     uint32_t
  75     SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write) override;
  76
  77     bool
  78     ClearHardwareWatchpoint(uint32_t hw_index) override;
  79
  80     // mirrors <mach/arm/thread_status.h> arm_thread_state64_t
  81     struct GPR
  82     {
  83         uint64_t    x[29];  // x0-x28
  84         uint64_t    fp;     // x29
  85         uint64_t    lr;     // x30
  86         uint64_t    sp;     // x31
  87         uint64_t    pc;     // pc
  88         uint32_t    cpsr;   // cpsr
  89     };
  90
  91     struct VReg
  92     {
  93         uint8_t bytes[16];
  94     };
  95
  96     // mirrors <mach/arm/thread_status.h> arm_neon_state64_t
  97     struct FPU
  98     {
  99         VReg        v[32];
 100         uint32_t    fpsr;
 101         uint32_t    fpcr;
 102     };
 103
 104     // mirrors <mach/arm/thread_status.h> arm_exception_state64_t
 105     struct EXC
 106     {
 107         uint64_t    far;       // Virtual Fault Address
 108         uint32_t    esr;       // Exception syndrome
 109         uint32_t    exception; // number of arm exception token
 110     };
 111
 112     // mirrors <mach/arm/thread_status.h> arm_debug_state64_t
 113     struct DBG
 114     {
 115         uint64_t bvr[16];
 116         uint64_t bcr[16];
 117         uint64_t wvr[16];
 118         uint64_t wcr[16];
 119         uint64_t mdscr_el1;
 120     };
 121
 122     static void
 123     LogDBGRegisters (lldb_private::Log *log, const DBG& dbg);
 124
 125 protected:
 126     enum
 127     {
 128         GPRRegSet = 6,  // ARM_THREAD_STATE64
 129         FPURegSet = 17, // ARM_NEON_STATE64
 130         EXCRegSet = 7,  // ARM_EXCEPTION_STATE64
 131         DBGRegSet = 15  // ARM_DEBUG_STATE64
 132     };
 133
 134     enum
 135     {
 136         GPRWordCount = sizeof(GPR)/sizeof(uint32_t),  // ARM_THREAD_STATE64_COUNT
 137         FPUWordCount = sizeof(FPU)/sizeof(uint32_t),  // ARM_NEON_STATE64_COUNT
 138         EXCWordCount = sizeof(EXC)/sizeof(uint32_t),  // ARM_EXCEPTION_STATE64_COUNT
 139         DBGWordCount = sizeof(DBG)/sizeof(uint32_t)   // ARM_DEBUG_STATE64_COUNT
 140     };
 141
 142     enum
 143     {
 144         Read = 0,
 145         Write = 1,
 146         kNumErrors = 2
 147     };
 148
 149     GPR gpr;
 150     FPU fpu;
 151     EXC exc;
 152     DBG dbg;
 153     int gpr_errs[2]; // Read/Write errors
 154     int fpu_errs[2]; // Read/Write errors
 155     int exc_errs[2]; // Read/Write errors
 156     int dbg_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             case DBGRegSet:    return dbg_errs[err_idx];
 179             default: break;
 180             }
 181         }
 182         return -1;
 183     }
 184
 185     bool
 186     SetError (int flavor, uint32_t err_idx, int err)
 187     {
 188         if (err_idx < kNumErrors)
 189         {
 190             switch (flavor)
 191             {
 192             case GPRRegSet:
 193                 gpr_errs[err_idx] = err;
 194                 return true;
 195
 196             case FPURegSet:
 197                 fpu_errs[err_idx] = err;
 198                 return true;
 199
 200             case EXCRegSet:
 201                 exc_errs[err_idx] = err;
 202                 return true;
 203
 204             case DBGRegSet:
 205                 exc_errs[err_idx] = err;
 206                 return true;
 207
 208             default: break;
 209             }
 210         }
 211         return false;
 212     }
 213
 214     bool
 215     RegisterSetIsCached (int set) const
 216     {
 217         return GetError(set, Read) == 0;
 218     }
 219
 220     int
 221     ReadGPR (bool force);
 222
 223     int
 224     ReadFPU (bool force);
 225
 226     int
 227     ReadEXC (bool force);
 228
 229     int
 230     ReadDBG (bool force);
 231
 232     int
 233     WriteGPR ();
 234
 235     int
 236     WriteFPU ();
 237
 238     int
 239     WriteEXC ();
 240
 241     int
 242     WriteDBG ();
 243
 244
 245     // Subclasses override these to do the actual reading.
 246     virtual int
 247     DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
 248     {
 249         return -1;
 250     }
 251
 252     virtual int
 253     DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu) = 0;
 254
 255     virtual int
 256     DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc) = 0;
 257
 258     virtual int
 259     DoReadDBG (lldb::tid_t tid, int flavor, DBG &dbg) = 0;
 260
 261     virtual int
 262     DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr) = 0;
 263
 264     virtual int
 265     DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu) = 0;
 266
 267     virtual int
 268     DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc) = 0;
 269
 270     virtual int
 271     DoWriteDBG (lldb::tid_t tid, int flavor, const DBG &dbg) = 0;
 272
 273     int
 274     ReadRegisterSet (uint32_t set, bool force);
 275
 276     int
 277     WriteRegisterSet (uint32_t set);
 278
 279     static uint32_t
 280     GetRegisterNumber (uint32_t reg_kind, uint32_t reg_num);
 281
 282     static int
 283     GetSetForNativeRegNum (int reg_num);
 284
 285     static size_t
 286     GetRegisterInfosCount ();
 287
 288     static const lldb_private::RegisterInfo *
 289     GetRegisterInfos ();
 290 };
 291
 292 #endif // liblldb_RegisterContextDarwin_arm64_h_