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

   1 //===-- RegisterContextDarwin_arm.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_arm_h_
  11 #define liblldb_RegisterContextDarwin_arm_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 // BCR address match type
  21 #define BCR_M_IMVA_MATCH        ((uint32_t)(0u << 21))
  22 #define BCR_M_CONTEXT_ID_MATCH  ((uint32_t)(1u << 21))
  23 #define BCR_M_IMVA_MISMATCH     ((uint32_t)(2u << 21))
  24 #define BCR_M_RESERVED          ((uint32_t)(3u << 21))
  25
  26 // Link a BVR/BCR or WVR/WCR pair to another
  27 #define E_ENABLE_LINKING        ((uint32_t)(1u << 20))
  28
  29 // Byte Address Select
  30 #define BAS_IMVA_PLUS_0         ((uint32_t)(1u << 5))
  31 #define BAS_IMVA_PLUS_1         ((uint32_t)(1u << 6))
  32 #define BAS_IMVA_PLUS_2         ((uint32_t)(1u << 7))
  33 #define BAS_IMVA_PLUS_3         ((uint32_t)(1u << 8))
  34 #define BAS_IMVA_0_1            ((uint32_t)(3u << 5))
  35 #define BAS_IMVA_2_3            ((uint32_t)(3u << 7))
  36 #define BAS_IMVA_ALL            ((uint32_t)(0xfu << 5))
  37
  38 // Break only in privileged or user mode
  39 #define S_RSVD                  ((uint32_t)(0u << 1))
  40 #define S_PRIV                  ((uint32_t)(1u << 1))
  41 #define S_USER                  ((uint32_t)(2u << 1))
  42 #define S_PRIV_USER             ((S_PRIV) | (S_USER))
  43
  44 #define BCR_ENABLE              ((uint32_t)(1u))
  45 #define WCR_ENABLE              ((uint32_t)(1u))
  46
  47 // Watchpoint load/store
  48 #define WCR_LOAD                ((uint32_t)(1u << 3))
  49 #define WCR_STORE               ((uint32_t)(1u << 4))
  50
  51 class RegisterContextDarwin_arm : public lldb_private::RegisterContext
  52 {
  53 public:
  54     RegisterContextDarwin_arm(lldb_private::Thread &thread, uint32_t concrete_frame_idx);
  55
  56     ~RegisterContextDarwin_arm() override;
  57
  58     void
  59     InvalidateAllRegisters() override;
  60
  61     size_t
  62     GetRegisterCount() override;
  63
  64     const lldb_private::RegisterInfo *
  65     GetRegisterInfoAtIndex(size_t reg) override;
  66
  67     size_t
  68     GetRegisterSetCount() override;
  69
  70     const lldb_private::RegisterSet *
  71     GetRegisterSet(size_t set) override;
  72
  73     bool
  74     ReadRegister(const lldb_private::RegisterInfo *reg_info,
  75                  lldb_private::RegisterValue &reg_value) override;
  76
  77     bool
  78     WriteRegister(const lldb_private::RegisterInfo *reg_info,
  79                   const lldb_private::RegisterValue &reg_value) override;
  80
  81     bool
  82     ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
  83
  84     bool
  85     WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
  86
  87     uint32_t
  88     ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num) override;
  89
  90     uint32_t
  91     NumSupportedHardwareBreakpoints() override;
  92
  93     uint32_t
  94     SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
  95
  96     bool
  97     ClearHardwareBreakpoint(uint32_t hw_idx) override;
  98
  99     uint32_t
 100     NumSupportedHardwareWatchpoints() override;
 101
 102     uint32_t
 103     SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write) override;
 104
 105     bool
 106     ClearHardwareWatchpoint(uint32_t hw_index) override;
 107
 108     struct GPR
 109     {
 110         uint32_t    r[16];  // R0-R15
 111         uint32_t    cpsr;   // CPSR
 112     };
 113
 114     struct QReg
 115     {
 116         uint8_t bytes[16];
 117     };
 118
 119     struct FPU
 120     {
 121         union {
 122             uint32_t s[32];
 123             uint64_t d[32];
 124             QReg     q[16];  // the 128-bit NEON registers
 125         } floats;
 126         uint32_t fpscr;
 127     };
 128
 129 //  struct NeonReg
 130 //  {
 131 //      uint8_t bytes[16];
 132 //  };
 133 //
 134 //  struct VFPv3
 135 //  {
 136 //      union {
 137 //          uint32_t s[32];
 138 //          uint64_t d[32];
 139 //          NeonReg  q[16];
 140 //      } v3;
 141 //      uint32_t fpscr;
 142 //  };
 143
 144     struct EXC
 145     {
 146         uint32_t    exception;
 147         uint32_t    fsr; /* Fault status */
 148         uint32_t    far; /* Virtual Fault Address */
 149     };
 150
 151     struct DBG
 152     {
 153         uint32_t bvr[16];
 154         uint32_t bcr[16];
 155         uint32_t wvr[16];
 156         uint32_t wcr[16];
 157     };
 158
 159     static void
 160     LogDBGRegisters (lldb_private::Log *log, const DBG& dbg);
 161
 162 protected:
 163     enum
 164     {
 165         GPRRegSet = 1, // ARM_THREAD_STATE
 166         FPURegSet = 2, // ARM_VFP_STATE
 167         EXCRegSet = 3, // ARM_EXCEPTION_STATE
 168         DBGRegSet = 4  // ARM_DEBUG_STATE
 169     };
 170
 171     enum
 172     {
 173         GPRWordCount = sizeof(GPR)/sizeof(uint32_t),
 174         FPUWordCount = sizeof(FPU)/sizeof(uint32_t),
 175         EXCWordCount = sizeof(EXC)/sizeof(uint32_t),
 176         DBGWordCount = sizeof(DBG)/sizeof(uint32_t)
 177     };
 178
 179     enum
 180     {
 181         Read = 0,
 182         Write = 1,
 183         kNumErrors = 2
 184     };
 185
 186     GPR gpr;
 187     FPU fpu;
 188     EXC exc;
 189     DBG dbg;
 190     int gpr_errs[2]; // Read/Write errors
 191     int fpu_errs[2]; // Read/Write errors
 192     int exc_errs[2]; // Read/Write errors
 193     int dbg_errs[2]; // Read/Write errors
 194
 195     void
 196     InvalidateAllRegisterStates()
 197     {
 198         SetError (GPRRegSet, Read, -1);
 199         SetError (FPURegSet, Read, -1);
 200         SetError (EXCRegSet, Read, -1);
 201     }
 202
 203     int
 204     GetError (int flavor, uint32_t err_idx) const
 205     {
 206         if (err_idx < kNumErrors)
 207         {
 208             switch (flavor)
 209             {
 210             // When getting all errors, just OR all values together to see if
 211             // we got any kind of error.
 212             case GPRRegSet:    return gpr_errs[err_idx];
 213             case FPURegSet:    return fpu_errs[err_idx];
 214             case EXCRegSet:    return exc_errs[err_idx];
 215             case DBGRegSet:    return dbg_errs[err_idx];
 216             default: break;
 217             }
 218         }
 219         return -1;
 220     }
 221
 222     bool
 223     SetError (int flavor, uint32_t err_idx, int err)
 224     {
 225         if (err_idx < kNumErrors)
 226         {
 227             switch (flavor)
 228             {
 229             case GPRRegSet:
 230                 gpr_errs[err_idx] = err;
 231                 return true;
 232
 233             case FPURegSet:
 234                 fpu_errs[err_idx] = err;
 235                 return true;
 236
 237             case EXCRegSet:
 238                 exc_errs[err_idx] = err;
 239                 return true;
 240
 241             case DBGRegSet:
 242                 exc_errs[err_idx] = err;
 243                 return true;
 244
 245             default: break;
 246             }
 247         }
 248         return false;
 249     }
 250
 251     bool
 252     RegisterSetIsCached (int set) const
 253     {
 254         return GetError(set, Read) == 0;
 255     }
 256
 257     int
 258     ReadGPR (bool force);
 259
 260     int
 261     ReadFPU (bool force);
 262
 263     int
 264     ReadEXC (bool force);
 265
 266     int
 267     ReadDBG (bool force);
 268
 269     int
 270     WriteGPR ();
 271
 272     int
 273     WriteFPU ();
 274
 275     int
 276     WriteEXC ();
 277
 278     int
 279     WriteDBG ();
 280
 281
 282     // Subclasses override these to do the actual reading.
 283     virtual int
 284     DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
 285     {
 286         return -1;
 287     }
 288
 289     virtual int
 290     DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu) = 0;
 291
 292     virtual int
 293     DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc) = 0;
 294
 295     virtual int
 296     DoReadDBG (lldb::tid_t tid, int flavor, DBG &dbg) = 0;
 297
 298     virtual int
 299     DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr) = 0;
 300
 301     virtual int
 302     DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu) = 0;
 303
 304     virtual int
 305     DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc) = 0;
 306
 307     virtual int
 308     DoWriteDBG (lldb::tid_t tid, int flavor, const DBG &dbg) = 0;
 309
 310     int
 311     ReadRegisterSet (uint32_t set, bool force);
 312
 313     int
 314     WriteRegisterSet (uint32_t set);
 315
 316     static uint32_t
 317     GetRegisterNumber (uint32_t reg_kind, uint32_t reg_num);
 318
 319     static int
 320     GetSetForNativeRegNum (int reg_num);
 321
 322     static size_t
 323     GetRegisterInfosCount ();
 324
 325     static const lldb_private::RegisterInfo *
 326     GetRegisterInfos ();
 327 };
 328
 329 #endif // liblldb_RegisterContextDarwin_arm_h_