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

   1 //===-- RegisterInfos_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 #include "llvm/Support/Compiler.h"
  11 #include <cstddef>
  12 #include <cstdint>
  13
  14
  15 #ifdef DECLARE_REGISTER_INFOS_I386_STRUCT
  16
  17 // Computes the offset of the given GPR in the user data area.
  18 #define GPR_OFFSET(regname) (LLVM_EXTENSION offsetof(GPR, regname))
  19
  20 // Computes the offset of the given FPR in the extended data area.
  21 #define FPR_OFFSET(regname)                                                    \
  22   (LLVM_EXTENSION offsetof(UserArea, i387) +                                   \
  23    LLVM_EXTENSION offsetof(FPR_i386, regname))
  24
  25 // Computes the offset of the YMM register assembled from register halves.
  26 // Based on DNBArchImplI386.cpp from debugserver
  27 #define YMM_OFFSET(reg_index)                                                  \
  28   (LLVM_EXTENSION offsetof(UserArea, i387) +                                   \
  29    LLVM_EXTENSION offsetof(FPR, fxsave) +                                      \
  30    LLVM_EXTENSION offsetof(FXSAVE, xmm[7]) + sizeof(XMMReg) +                  \
  31    (32 * reg_index))
  32
  33 #define BNDR_OFFSET(reg_index)                                                 \
  34   (LLVM_EXTENSION offsetof(UserArea, i387) +                                   \
  35    LLVM_EXTENSION offsetof(FPR, xsave) +                                       \
  36    LLVM_EXTENSION offsetof(XSAVE, mpxr[reg_index]))
  37
  38 #define BNDC_OFFSET(reg_index)                                                 \
  39   (LLVM_EXTENSION offsetof(UserArea, i387) +                                   \
  40    LLVM_EXTENSION offsetof(FPR, xsave) +                                       \
  41    LLVM_EXTENSION offsetof(XSAVE, mpxc[reg_index]))
  42
  43 // Number of bytes needed to represent a FPR.
  44 #if !defined(FPR_SIZE)
  45 #define FPR_SIZE(reg) sizeof(((FXSAVE *)nullptr)->reg)
  46 #endif
  47
  48 // Number of bytes needed to represent the i'th FP register.
  49 #define FP_SIZE sizeof(((MMSReg *)nullptr)->bytes)
  50
  51 // Number of bytes needed to represent an XMM register.
  52 #define XMM_SIZE sizeof(XMMReg)
  53
  54 // Number of bytes needed to represent a YMM register.
  55 #define YMM_SIZE sizeof(YMMReg)
  56
  57 // Number of bytes needed to represent MPX registers.
  58 #define BNDR_SIZE sizeof(MPXReg)
  59 #define BNDC_SIZE sizeof(MPXCsr)
  60
  61 // Note that the size and offset will be updated by platform-specific classes.
  62 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)                       \
  63   {                                                                            \
  64     #reg, alt, sizeof(((GPR *)nullptr)->reg),                                  \
  65                       GPR_OFFSET(reg), eEncodingUint, eFormatHex,              \
  66                                  {kind1, kind2, kind3, kind4,                  \
  67                                   lldb_##reg##_i386 },                         \
  68                                   nullptr, nullptr, nullptr, 0                 \
  69   }
  70
  71 #define DEFINE_FPR(name, reg, kind1, kind2, kind3, kind4)                      \
  72   {                                                                            \
  73     #name, nullptr, FPR_SIZE(reg), FPR_OFFSET(reg), eEncodingUint, eFormatHex, \
  74                                            {kind1, kind2, kind3, kind4,        \
  75                                             lldb_##name##_i386 },              \
  76                                             nullptr, nullptr, nullptr, 0       \
  77   }
  78
  79 // RegisterKind: EHFrame, DWARF, Generic, Process Plugin, LLDB
  80
  81 #define DEFINE_FP_ST(reg, i)                                                   \
  82   {                                                                            \
  83     #reg #i, nullptr, FP_SIZE,                                                 \
  84         LLVM_EXTENSION FPR_OFFSET(                                             \
  85             stmm[i]), eEncodingVector, eFormatVectorOfUInt8,                   \
  86             {ehframe_st##i##_i386, dwarf_st##i##_i386, LLDB_INVALID_REGNUM,    \
  87              LLDB_INVALID_REGNUM, lldb_st##i##_i386 },                         \
  88              nullptr, nullptr, nullptr, 0                                      \
  89   }
  90
  91 #define DEFINE_FP_MM(reg, i)                                                   \
  92   {                                                                            \
  93     #reg #i, nullptr, sizeof(uint64_t),                                        \
  94                           LLVM_EXTENSION FPR_OFFSET(                           \
  95                               stmm[i]), eEncodingUint, eFormatHex,             \
  96                               {ehframe_mm##i##_i386, dwarf_mm##i##_i386,       \
  97                                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,       \
  98                                lldb_mm##i##_i386 },                            \
  99                                nullptr, nullptr, nullptr, 0                    \
 100   }
 101
 102 #define DEFINE_XMM(reg, i)                                                     \
 103   {                                                                            \
 104     #reg #i, nullptr, XMM_SIZE,                                                \
 105         LLVM_EXTENSION FPR_OFFSET(                                             \
 106             reg[i]), eEncodingVector, eFormatVectorOfUInt8,                    \
 107             {ehframe_##reg##i##_i386, dwarf_##reg##i##_i386,                   \
 108              LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_##reg##i##_i386 }, \
 109              nullptr, nullptr, nullptr, 0                                      \
 110   }
 111
 112 // I believe the YMM registers use dwarf_xmm_%_i386 register numbers and then
 113 // differentiate based on register size.
 114 #define DEFINE_YMM(reg, i)                                                     \
 115   {                                                                            \
 116     #reg #i, nullptr, YMM_SIZE,                                                \
 117         LLVM_EXTENSION YMM_OFFSET(i), eEncodingVector, eFormatVectorOfUInt8,   \
 118                                   {LLDB_INVALID_REGNUM, dwarf_xmm##i##_i386,   \
 119                                    LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,   \
 120                                    lldb_##reg##i##_i386 },                     \
 121                                    nullptr, nullptr, nullptr, 0                \
 122   }
 123
 124 #define DEFINE_BNDR(reg, i)                                                    \
 125   {                                                                            \
 126     #reg #i, nullptr, BNDR_SIZE,                                               \
 127         LLVM_EXTENSION BNDR_OFFSET(i), eEncodingVector, eFormatVectorOfUInt64, \
 128         {dwarf_##reg##i##_i386, dwarf_##reg##i##_i386, LLDB_INVALID_REGNUM,    \
 129          LLDB_INVALID_REGNUM, lldb_##reg##i##_i386 },                          \
 130          nullptr, nullptr, nullptr, 0                                          \
 131   }
 132
 133 #define DEFINE_BNDC(name, i)                                                   \
 134   {                                                                            \
 135     #name, nullptr, BNDC_SIZE,                                                 \
 136            LLVM_EXTENSION BNDC_OFFSET(i), eEncodingVector,                     \
 137            eFormatVectorOfUInt8,                                               \
 138            {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,     \
 139             LLDB_INVALID_REGNUM, lldb_##name##_i386 },                         \
 140             nullptr, nullptr, nullptr, 0                                       \
 141   }
 142
 143 #define DEFINE_DR(reg, i)                                                      \
 144   {                                                                            \
 145     #reg #i, nullptr, DR_SIZE,                                                 \
 146         DR_OFFSET(i), eEncodingUint, eFormatHex,                               \
 147                   {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                   \
 148                    LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                   \
 149                    LLDB_INVALID_REGNUM },                                      \
 150                    nullptr, nullptr, nullptr, 0                                \
 151   }
 152
 153 #define DEFINE_GPR_PSEUDO_16(reg16, reg32)                                     \
 154   {                                                                            \
 155     #reg16, nullptr, 2,                                                        \
 156         GPR_OFFSET(reg32), eEncodingUint, eFormatHex,                          \
 157                    {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
 158                     LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
 159                     lldb_##reg16##_i386 },                                     \
 160                     RegisterContextPOSIX_x86::g_contained_##reg32,             \
 161                     RegisterContextPOSIX_x86::g_invalidate_##reg32, nullptr, 0 \
 162   }
 163
 164 #define DEFINE_GPR_PSEUDO_8H(reg8, reg32)                                      \
 165   {                                                                            \
 166     #reg8, nullptr, 1,                                                         \
 167         GPR_OFFSET(reg32) + 1, eEncodingUint, eFormatHex,                      \
 168                    {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
 169                     LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
 170                     lldb_##reg8##_i386 },                                      \
 171                     RegisterContextPOSIX_x86::g_contained_##reg32,             \
 172                     RegisterContextPOSIX_x86::g_invalidate_##reg32, nullptr, 0 \
 173   }
 174
 175 #define DEFINE_GPR_PSEUDO_8L(reg8, reg32)                                      \
 176   {                                                                            \
 177     #reg8, nullptr, 1,                                                         \
 178         GPR_OFFSET(reg32), eEncodingUint, eFormatHex,                          \
 179                    {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
 180                     LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
 181                     lldb_##reg8##_i386 },                                      \
 182                     RegisterContextPOSIX_x86::g_contained_##reg32,             \
 183                     RegisterContextPOSIX_x86::g_invalidate_##reg32, nullptr, 0 \
 184   }
 185
 186 static RegisterInfo g_register_infos_i386[] = {
 187     // General purpose registers.
 188     DEFINE_GPR(eax, nullptr, ehframe_eax_i386, dwarf_eax_i386,
 189                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 190     DEFINE_GPR(ebx, nullptr, ehframe_ebx_i386, dwarf_ebx_i386,
 191                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 192     DEFINE_GPR(ecx, nullptr, ehframe_ecx_i386, dwarf_ecx_i386,
 193                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 194     DEFINE_GPR(edx, nullptr, ehframe_edx_i386, dwarf_edx_i386,
 195                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 196     DEFINE_GPR(edi, nullptr, ehframe_edi_i386, dwarf_edi_i386,
 197                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 198     DEFINE_GPR(esi, nullptr, ehframe_esi_i386, dwarf_esi_i386,
 199                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 200     DEFINE_GPR(ebp, "fp", ehframe_ebp_i386, dwarf_ebp_i386,
 201                LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM),
 202     DEFINE_GPR(esp, "sp", ehframe_esp_i386, dwarf_esp_i386,
 203                LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM),
 204     DEFINE_GPR(eip, "pc", ehframe_eip_i386, dwarf_eip_i386,
 205                LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM),
 206     DEFINE_GPR(eflags, "flags", ehframe_eflags_i386, dwarf_eflags_i386,
 207                LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM),
 208     DEFINE_GPR(cs, nullptr, LLDB_INVALID_REGNUM, dwarf_cs_i386,
 209                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 210     DEFINE_GPR(fs, nullptr, LLDB_INVALID_REGNUM, dwarf_fs_i386,
 211                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 212     DEFINE_GPR(gs, nullptr, LLDB_INVALID_REGNUM, dwarf_gs_i386,
 213                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 214     DEFINE_GPR(ss, nullptr, LLDB_INVALID_REGNUM, dwarf_ss_i386,
 215                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 216     DEFINE_GPR(ds, nullptr, LLDB_INVALID_REGNUM, dwarf_ds_i386,
 217                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 218     DEFINE_GPR(es, nullptr, LLDB_INVALID_REGNUM, dwarf_es_i386,
 219                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 220
 221     DEFINE_GPR_PSEUDO_16(ax, eax), DEFINE_GPR_PSEUDO_16(bx, ebx),
 222     DEFINE_GPR_PSEUDO_16(cx, ecx), DEFINE_GPR_PSEUDO_16(dx, edx),
 223     DEFINE_GPR_PSEUDO_16(di, edi), DEFINE_GPR_PSEUDO_16(si, esi),
 224     DEFINE_GPR_PSEUDO_16(bp, ebp), DEFINE_GPR_PSEUDO_16(sp, esp),
 225     DEFINE_GPR_PSEUDO_8H(ah, eax), DEFINE_GPR_PSEUDO_8H(bh, ebx),
 226     DEFINE_GPR_PSEUDO_8H(ch, ecx), DEFINE_GPR_PSEUDO_8H(dh, edx),
 227     DEFINE_GPR_PSEUDO_8L(al, eax), DEFINE_GPR_PSEUDO_8L(bl, ebx),
 228     DEFINE_GPR_PSEUDO_8L(cl, ecx), DEFINE_GPR_PSEUDO_8L(dl, edx),
 229
 230     // i387 Floating point registers.
 231     DEFINE_FPR(fctrl, fctrl, LLDB_INVALID_REGNUM, dwarf_fctrl_i386,
 232                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 233     DEFINE_FPR(fstat, fstat, LLDB_INVALID_REGNUM, dwarf_fstat_i386,
 234                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 235     DEFINE_FPR(ftag, ftag, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 236                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 237     DEFINE_FPR(fop, fop, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 238                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 239     DEFINE_FPR(fiseg, ptr.i386_.fiseg, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 240                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 241     DEFINE_FPR(fioff, ptr.i386_.fioff, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 242                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 243     DEFINE_FPR(foseg, ptr.i386_.foseg, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 244                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 245     DEFINE_FPR(fooff, ptr.i386_.fooff, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 246                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 247     DEFINE_FPR(mxcsr, mxcsr, LLDB_INVALID_REGNUM, dwarf_mxcsr_i386,
 248                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 249     DEFINE_FPR(mxcsrmask, mxcsrmask, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 250                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
 251
 252     // FP registers.
 253     DEFINE_FP_ST(st, 0), DEFINE_FP_ST(st, 1), DEFINE_FP_ST(st, 2),
 254     DEFINE_FP_ST(st, 3), DEFINE_FP_ST(st, 4), DEFINE_FP_ST(st, 5),
 255     DEFINE_FP_ST(st, 6), DEFINE_FP_ST(st, 7), DEFINE_FP_MM(mm, 0),
 256     DEFINE_FP_MM(mm, 1), DEFINE_FP_MM(mm, 2), DEFINE_FP_MM(mm, 3),
 257     DEFINE_FP_MM(mm, 4), DEFINE_FP_MM(mm, 5), DEFINE_FP_MM(mm, 6),
 258     DEFINE_FP_MM(mm, 7),
 259
 260     // XMM registers
 261     DEFINE_XMM(xmm, 0), DEFINE_XMM(xmm, 1), DEFINE_XMM(xmm, 2),
 262     DEFINE_XMM(xmm, 3), DEFINE_XMM(xmm, 4), DEFINE_XMM(xmm, 5),
 263     DEFINE_XMM(xmm, 6), DEFINE_XMM(xmm, 7),
 264
 265     // Copy of YMM registers assembled from xmm and ymmh
 266     DEFINE_YMM(ymm, 0), DEFINE_YMM(ymm, 1), DEFINE_YMM(ymm, 2),
 267     DEFINE_YMM(ymm, 3), DEFINE_YMM(ymm, 4), DEFINE_YMM(ymm, 5),
 268     DEFINE_YMM(ymm, 6), DEFINE_YMM(ymm, 7),
 269
 270     // MPX registers
 271     DEFINE_BNDR(bnd, 0),
 272     DEFINE_BNDR(bnd, 1),
 273     DEFINE_BNDR(bnd, 2),
 274     DEFINE_BNDR(bnd, 3),
 275
 276     DEFINE_BNDC(bndcfgu, 0),
 277     DEFINE_BNDC(bndstatus, 1),
 278
 279     // Debug registers for lldb internal use
 280     DEFINE_DR(dr, 0), DEFINE_DR(dr, 1), DEFINE_DR(dr, 2), DEFINE_DR(dr, 3),
 281     DEFINE_DR(dr, 4), DEFINE_DR(dr, 5), DEFINE_DR(dr, 6), DEFINE_DR(dr, 7)};
 282
 283 static_assert((sizeof(g_register_infos_i386) /
 284                sizeof(g_register_infos_i386[0])) == k_num_registers_i386,
 285               "g_register_infos_x86_64 has wrong number of register infos");
 286
 287 #undef GPR_OFFSET
 288 #undef FPR_OFFSET
 289 #undef YMM_OFFSET
 290 #undef FPR_SIZE
 291 #undef FP_SIZE
 292 #undef XMM_SIZE
 293 #undef YMM_SIZE
 294 #undef DEFINE_GPR
 295 #undef DEFINE_FPR
 296 #undef DEFINE_FP
 297 #undef DEFINE_XMM
 298 #undef DEFINE_YMM
 299 #undef DEFINE_BNDR
 300 #undef DEFINE_BNDC
 301 #undef DEFINE_DR
 302 #undef DEFINE_GPR_PSEUDO_16
 303 #undef DEFINE_GPR_PSEUDO_8H
 304 #undef DEFINE_GPR_PSEUDO_8L
 305
 306 #endif // DECLARE_REGISTER_INFOS_I386_STRUCT