VirtualBox

Changeset 35468 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
Jan 10, 2011 5:16:11 PM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
69339
Message:

CPUMDbg.cpp: Hacking in progress (to laptop).

Location:
trunk/src/VBox/VMM
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/Makefile.kmk

    r35380 r35468  
    7878        VMMR3/CFGM.cpp \
    7979        VMMR3/CPUM.cpp \
     80        VMMR3/CPUMDbg.cpp \
    8081        VMMR3/DBGF.cpp \
    8182        VMMR3/DBGFAddr.cpp \

  • trunk/src/VBox/VMM/VMMR3/CPUMDbg.cpp

    r35410 r35468  
    55
    66/*
    7  * Copyright (C) 2010 Oracle Corporation
     7 * Copyright (C) 2010-2011 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2121*******************************************************************************/
    2222#define LOG_GROUP LOG_GROUP_DBGF
     23#include <VBox/vmm/cpum.h>
    2324#include <VBox/vmm/dbgf.h>
    24 #include "DBGFInternal.h"
     25#include "CPUMInternal.h"
    2526#include <VBox/vmm/vm.h>
    2627#include <VBox/param.h>
    2728#include <VBox/err.h>
    2829#include <VBox/log.h>
    29 
    30 
    31 static DECLCALLBACK(int) dbgfR3RegSet_seg(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
    32 {
    33     return VERR_NOT_IMPLEMENTED;
    34 }
    35 
    36 static DECLCALLBACK(int) dbgfR3RegGet_crX(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
    37 {
    38     return VERR_NOT_IMPLEMENTED;
    39 }
    40 
    41 static DECLCALLBACK(int) dbgfR3RegSet_crX(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
    42 {
    43     return VERR_NOT_IMPLEMENTED;
    44 }
    45 
    46 static DECLCALLBACK(int) dbgfR3RegGet_drX(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
    47 {
    48     return VERR_NOT_IMPLEMENTED;
    49 }
    50 
    51 static DECLCALLBACK(int) dbgfR3RegSet_drX(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
    52 {
    53     return VERR_NOT_IMPLEMENTED;
    54 }
    55 
    56 static DECLCALLBACK(int) dbgfR3RegGet_msr(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
    57 {
    58     return VERR_NOT_IMPLEMENTED;
    59 }
    60 
    61 static DECLCALLBACK(int) dbgfR3RegSet_msr(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
    62 {
    63     return VERR_NOT_IMPLEMENTED;
    64 }
    65 
    66 static DECLCALLBACK(int) dbgfR3RegGet_gdtr(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
    67 {
    68     return VERR_NOT_IMPLEMENTED;
    69 }
    70 
    71 static DECLCALLBACK(int) dbgfR3RegSet_gdtr(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
    72 {
    73     return VERR_NOT_IMPLEMENTED;
    74 }
    75 
    76 static DECLCALLBACK(int) dbgfR3RegGet_idtr(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
    77 {
    78     return VERR_NOT_IMPLEMENTED;
    79 }
    80 
    81 static DECLCALLBACK(int) dbgfR3RegSet_idtr(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
    82 {
    83     return VERR_NOT_IMPLEMENTED;
    84 }
    85 
    86 static DECLCALLBACK(int) dbgfR3RegGet_ftw(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
    87 {
    88     return VERR_NOT_IMPLEMENTED;
    89 }
    90 
    91 static DECLCALLBACK(int) dbgfR3RegSet_ftw(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
    92 {
    93     return VERR_NOT_IMPLEMENTED;
    94 }
    95 
    96 static DECLCALLBACK(int) dbgfR3RegGet_stN(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
    97 {
    98     return VERR_NOT_IMPLEMENTED;
    99 }
    100 
    101 static DECLCALLBACK(int) dbgfR3RegSet_stN(PVMCPU pVCpu, struct DBGFREGDESC const *pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
    102 {
    103     return VERR_NOT_IMPLEMENTED;
    104 }
    105 
     30#include <iprt/thread.h>
     31
     32
     33#if 0
     34/**
     35 * @interface_method_impl{DBGFREGDESC, pfnGet}
     36 */
     37static DECLCALLBACK(int) cpumR3RegGet_Generic(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
     38{
     39    PVMCPU      pVCpu   = (PVMCPU)pvUser;
     40    void const *pv      = (uint8_t const *)&pVCpu->cpum.s.Guest + pDesc->offRegister;
     41
     42    VMCPU_ASSERT_EMT(pVCpu);
     43
     44    switch (pDesc->enmType)
     45    {
     46        case DBGFREGVALTYPE_U8:        pValue->u8   = *(uint8_t  const *)pv; return VINF_SUCCESS;
     47        case DBGFREGVALTYPE_U16:       pValue->u16  = *(uint16_t const *)pv; return VINF_SUCCESS;
     48        case DBGFREGVALTYPE_U32:       pValue->u32  = *(uint32_t const *)pv; return VINF_SUCCESS;
     49        case DBGFREGVALTYPE_U64:       pValue->u64  = *(uint64_t const *)pv; return VINF_SUCCESS;
     50        case DBGFREGVALTYPE_U128:      pValue->u128 = *(PCRTUINT128U    )pv; return VINF_SUCCESS;
     51        default:
     52            AssertMsgFailedReturn(("%d %s\n", pDesc->enmType, pDesc->pszName), VERR_INTERNAL_ERROR_3);
     53    }
     54}
     55
     56
     57/**
     58 * @interface_method_impl{DBGFREGDESC, pfnGet}
     59 */
     60static DECLCALLBACK(int) cpumR3RegSet_Generic(void *pvUser, PCDBGFREGDESC pDesc, PCDBGFREGVAL pValue, PCDBGFREGVAL pfMask)
     61{
     62    PVMCPU      pVCpu = (PVMCPU)pvUser;
     63    void       *pv    = (uint8_t *)&pVCpu->cpum.s.Guest + pDesc->offRegister;
     64
     65    VMCPU_ASSERT_EMT(pVCpu);
     66
     67    switch (pDesc->enmType)
     68    {
     69        case DBGFREGVALTYPE_U8:
     70            *(uint8_t *)pv &= ~pfMask->u8;
     71            *(uint8_t *)pv |= pValue->u8 & pfMask->u8;
     72            return VINF_SUCCESS;
     73
     74        case DBGFREGVALTYPE_U16:
     75            *(uint16_t *)pv &= ~pfMask->u16;
     76            *(uint16_t *)pv |= pValue->u16 & pfMask->u16;
     77            return VINF_SUCCESS;
     78
     79        case DBGFREGVALTYPE_U32:
     80            *(uint32_t *)pv &= ~pfMask->u32;
     81            *(uint32_t *)pv |= pValue->u32 & pfMask->u32;
     82            return VINF_SUCCESS;
     83
     84        case DBGFREGVALTYPE_U64:
     85            *(uint64_t *)pv &= ~pfMask->u64;
     86            *(uint64_t *)pv |= pValue->u64 & pfMask->u64;
     87            return VINF_SUCCESS;
     88
     89        case DBGFREGVALTYPE_U128:
     90            ((PRTUINT128U)pv)->s.Hi &= ~pfMask->u128.s.Hi;
     91            ((PRTUINT128U)pv)->s.Lo &= ~pfMask->u128.s.Lo;
     92            ((PRTUINT128U)pv)->s.Hi |= pValue->u128.s.Hi & pfMask->u128.s.Hi;
     93            ((PRTUINT128U)pv)->s.Lo |= pValue->u128.s.Lo & pfMask->u128.s.Lo;
     94            return VINF_SUCCESS;
     95
     96        default:
     97            AssertMsgFailedReturn(("%d %s\n", pDesc->enmType, pDesc->pszName), VERR_INTERNAL_ERROR_3);
     98    }
     99}
     100
     101
     102/**
     103 * @interface_method_impl{DBGFREGDESC, pfnGet}
     104 */
     105static DECLCALLBACK(int) cpumR3RegSet_seg(void *pvUser, PCDBGFREGDESC pDesc, PCDBGFREGVAL pValue, PCDBGFREGVAL pfMask)
     106{
     107    /** @todo perform a selector load, updating hidden selectors and stuff. */
     108    return VERR_NOT_IMPLEMENTED;
     109}
     110
     111
     112static DECLCALLBACK(int) cpumR3RegGet_crX(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
     113{
     114    return VERR_NOT_IMPLEMENTED;
     115}
     116
     117static DECLCALLBACK(int) cpumR3RegSet_crX(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
     118{
     119    return VERR_NOT_IMPLEMENTED;
     120}
     121
     122static DECLCALLBACK(int) cpumR3RegGet_drX(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
     123{
     124    return VERR_NOT_IMPLEMENTED;
     125}
     126
     127static DECLCALLBACK(int) cpumR3RegSet_drX(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
     128{
     129    return VERR_NOT_IMPLEMENTED;
     130}
     131
     132static DECLCALLBACK(int) cpumR3RegGet_msr(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
     133{
     134    return VERR_NOT_IMPLEMENTED;
     135}
     136
     137static DECLCALLBACK(int) cpumR3RegSet_msr(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
     138{
     139    return VERR_NOT_IMPLEMENTED;
     140}
     141
     142static DECLCALLBACK(int) cpumR3RegGet_gdtr(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
     143{
     144    return VERR_NOT_IMPLEMENTED;
     145}
     146
     147static DECLCALLBACK(int) cpumR3RegSet_gdtr(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
     148{
     149    return VERR_NOT_IMPLEMENTED;
     150}
     151
     152static DECLCALLBACK(int) cpumR3RegGet_idtr(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
     153{
     154    return VERR_NOT_IMPLEMENTED;
     155}
     156
     157static DECLCALLBACK(int) cpumR3RegSet_idtr(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
     158{
     159    return VERR_NOT_IMPLEMENTED;
     160}
     161
     162static DECLCALLBACK(int) cpumR3RegGet_ftw(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCCPUMCTX pCtx, PRTUINT128U puValue)
     163{
     164    return VERR_NOT_IMPLEMENTED;
     165}
     166
     167static DECLCALLBACK(int) cpumR3RegSet_ftw(PVMCPU pVCpu, PCDBGFREGDESC pDesc, PCPUMCTX pCtx, RTUINT128U uValue, RTUINT128U fMask)
     168{
     169    return VERR_NOT_IMPLEMENTED;
     170}
     171
     172/**
     173 * @interface_method_impl{DBGFREGDESC, pfnGet}
     174 */
     175static DECLCALLBACK(int) cpumR3RegGet_stN(void *pvUser, PCDBGFREGDESC pDesc, PCDBGFREGVAL pValue, PCDBGFREGVAL pfMask)
     176{
     177    return VERR_NOT_IMPLEMENTED;
     178}
     179
     180/**
     181 * @interface_method_impl{DBGFREGDESC, pfnGet}
     182 */
     183static DECLCALLBACK(int) cpumR3RegSet_stN(void *pvUser, PCDBGFREGDESC pDesc, PCDBGFREGVAL pValue, PCDBGFREGVAL pfMask)
     184{
     185    return VERR_NOT_IMPLEMENTED;
     186}
    106187
    107188
    … …  
    109190 * Set up aliases.
    110191 */
    111 #define DBGFREGALIAS_STD(Name, psz32, psz16, psz8)  \
    112     static DBGFREGALIAS const g_aDbgfRegAliases_##Name[] = \
     192#define CPUMREGALIAS_STD(Name, psz32, psz16, psz8)  \
     193    static DBGFREGALIAS const g_aCpumRegAliases_##Name[] = \
    113194    { \
    114         { psz32, DBGFREGVALTYPE_U32    }, \
    115         { psz16, DBGFREGVALTYPE_U16    }, \
    116         { psz8,  DBGFREGVALTYPE_U8     }, \
    117         { NULL, DBGFREGVALTYPE_INVALID } \
     195        { psz32, DBGFREGVALTYPE_U32     }, \
     196        { psz16, DBGFREGVALTYPE_U16     }, \
     197        { psz8,  DBGFREGVALTYPE_U8      }, \
     198        { NULL,  DBGFREGVALTYPE_INVALID } \
    118199    }
    119 DBGFREGALIAS_STD(rax,  "eax",   "ax",   "al");
    120 DBGFREGALIAS_STD(rcx,  "ecx",   "cx",   "cl");
    121 DBGFREGALIAS_STD(rdx,  "edx",   "dx",   "dl");
    122 DBGFREGALIAS_STD(rbx,  "ebx",   "bx",   "bl");
    123 DBGFREGALIAS_STD(rsp,  "esp",   "sp",   NULL);
    124 DBGFREGALIAS_STD(rbp,  "ebp",   "bp",   NULL);
    125 DBGFREGALIAS_STD(rsi,  "esi",   "si",  "sil");
    126 DBGFREGALIAS_STD(rdi,  "edi",   "di",  "dil");
    127 DBGFREGALIAS_STD(r8,   "r8d",  "r8w",  "r8b");
    128 DBGFREGALIAS_STD(r9,   "r9d",  "r9w",  "r9b");
    129 DBGFREGALIAS_STD(r10, "r10d", "r10w", "r10b");
    130 DBGFREGALIAS_STD(r11, "r11d", "r11w", "r11b");
    131 DBGFREGALIAS_STD(r12, "r12d", "r12w", "r12b");
    132 DBGFREGALIAS_STD(r13, "r13d", "r13w", "r13b");
    133 DBGFREGALIAS_STD(r14, "r14d", "r14w", "r14b");
    134 DBGFREGALIAS_STD(r15, "r15d", "r15w", "r15b");
    135 DBGFREGALIAS_STD(rip, "eip",   "ip",    NULL);
    136 DBGFREGALIAS_STD(rflags, "eflags", "flags", NULL);
    137 #undef DBGFREGALIAS_STD
    138 
    139 static DBGFREGALIAS const g_aDbgfRegAliases_fpuip[] =
     200CPUMREGALIAS_STD(rax,  "eax",   "ax",   "al");
     201CPUMREGALIAS_STD(rcx,  "ecx",   "cx",   "cl");
     202CPUMREGALIAS_STD(rdx,  "edx",   "dx",   "dl");
     203CPUMREGALIAS_STD(rbx,  "ebx",   "bx",   "bl");
     204CPUMREGALIAS_STD(rsp,  "esp",   "sp",   NULL);
     205CPUMREGALIAS_STD(rbp,  "ebp",   "bp",   NULL);
     206CPUMREGALIAS_STD(rsi,  "esi",   "si",  "sil");
     207CPUMREGALIAS_STD(rdi,  "edi",   "di",  "dil");
     208CPUMREGALIAS_STD(r8,   "r8d",  "r8w",  "r8b");
     209CPUMREGALIAS_STD(r9,   "r9d",  "r9w",  "r9b");
     210CPUMREGALIAS_STD(r10, "r10d", "r10w", "r10b");
     211CPUMREGALIAS_STD(r11, "r11d", "r11w", "r11b");
     212CPUMREGALIAS_STD(r12, "r12d", "r12w", "r12b");
     213CPUMREGALIAS_STD(r13, "r13d", "r13w", "r13b");
     214CPUMREGALIAS_STD(r14, "r14d", "r14w", "r14b");
     215CPUMREGALIAS_STD(r15, "r15d", "r15w", "r15b");
     216CPUMREGALIAS_STD(rip, "eip",   "ip",    NULL);
     217CPUMREGALIAS_STD(rflags, "eflags", "flags", NULL);
     218#undef CPUMREGALIAS_STD
     219
     220static DBGFREGALIAS const g_aCpumRegAliases_fpuip[] =
    140221{
    141222    { "fpuip", DBGFREGVALTYPE_U16  },
    … …  
    143224};
    144225
    145 static DBGFREGALIAS const g_aDbgfRegAliases_fpudp[] =
     226static DBGFREGALIAS const g_aCpumRegAliases_fpudp[] =
    146227{
    147228    { "fpudp", DBGFREGVALTYPE_U16  },
    … …  
    149230};
    150231
    151 static DBGFREGALIAS const g_aDbgfRegAliases_cr0[] =
     232static DBGFREGALIAS const g_aCpumRegAliases_cr0[] =
    152233{
    153234    { "msw", DBGFREGVALTYPE_U16  },
    … …  
    159240 */
    160241/** Sub-fields for the (hidden) segment attribute register. */
    161 static DBGFREGSUBFIELD const g_aDbgfRegFields_seg[] =
    162 {
    163     { "type",   0,   4,  0 },
    164     { "s",      4,   1,  0 },
    165     { "dpl",    5,   2,  0 },
    166     { "p",      7,   1,  0 },
    167     { "avl",   12,   1,  0 },
    168     { "l",     13,   1,  0 },
    169     { "d",     14,   1,  0 },
    170     { "g",     15,   1,  0 },
    171     { NULL,     0,   0,  0 }
     242static DBGFREGSUBFIELD const g_aCpumRegFields_seg[] =
     243{
     244    DBGFREGSUBFIELD_RW("type",   0,   4,  0),
     245    DBGFREGSUBFIELD_RW("s",      4,   1,  0),
     246    DBGFREGSUBFIELD_RW("dpl",    5,   2,  0),
     247    DBGFREGSUBFIELD_RW("p",      7,   1,  0),
     248    DBGFREGSUBFIELD_RW("avl",   12,   1,  0),
     249    DBGFREGSUBFIELD_RW("l",     13,   1,  0),
     250    DBGFREGSUBFIELD_RW("d",     14,   1,  0),
     251    DBGFREGSUBFIELD_RW("g",     15,   1,  0),
     252    DBGFREGSUBFIELD_TERMINATOR()
    172253};
    173254
    174255/** Sub-fields for the flags register. */
    175 static DBGFREGSUBFIELD const g_aDbgfRegFields_rflags[] =
    176 {
    177     { "cf",     0,   1,  0 },
    178     { "pf",     2,   1,  0 },
    179     { "af",     4,   1,  0 },
    180     { "zf",     6,   1,  0 },
    181     { "sf",     7,   1,  0 },
    182     { "tf",     8,   1,  0 },
    183     { "if",     9,   1,  0 },
    184     { "df",    10,   1,  0 },
    185     { "of",    11,   1,  0 },
    186     { "iopl",  12,   2,  0 },
    187     { "nt",    14,   1,  0 },
    188     { "rf",    16,   1,  0 },
    189     { "vm",    17,   1,  0 },
    190     { "ac",    18,   1,  0 },
    191     { "vif",   19,   1,  0 },
    192     { "vip",   20,   1,  0 },
    193     { "id",    21,   1,  0 },
    194     { NULL,     0,   0,  0 }
     256static DBGFREGSUBFIELD const g_aCpumRegFields_rflags[] =
     257{
     258    DBGFREGSUBFIELD_RW("cf",     0,   1,  0),
     259    DBGFREGSUBFIELD_RW("pf",     2,   1,  0),
     260    DBGFREGSUBFIELD_RW("af",     4,   1,  0),
     261    DBGFREGSUBFIELD_RW("zf",     6,   1,  0),
     262    DBGFREGSUBFIELD_RW("sf",     7,   1,  0),
     263    DBGFREGSUBFIELD_RW("tf",     8,   1,  0),
     264    DBGFREGSUBFIELD_RW("if",     9,   1,  0),
     265    DBGFREGSUBFIELD_RW("df",    10,   1,  0),
     266    DBGFREGSUBFIELD_RW("of",    11,   1,  0),
     267    DBGFREGSUBFIELD_RW("iopl",  12,   2,  0),
     268    DBGFREGSUBFIELD_RW("nt",    14,   1,  0),
     269    DBGFREGSUBFIELD_RW("rf",    16,   1,  0),
     270    DBGFREGSUBFIELD_RW("vm",    17,   1,  0),
     271    DBGFREGSUBFIELD_RW("ac",    18,   1,  0),
     272    DBGFREGSUBFIELD_RW("vif",   19,   1,  0),
     273    DBGFREGSUBFIELD_RW("vip",   20,   1,  0),
     274    DBGFREGSUBFIELD_RW("id",    21,   1,  0),
     275    DBGFREGSUBFIELD_TERMINATOR()
    195276};
    196277
    197278/** Sub-fields for the FPU control word register. */
    198 static DBGFREGSUBFIELD const g_aDbgfRegFields_fcw[] =
    199 {
    200     { "im",     1,   1,  0 },
    201     { "dm",     2,   1,  0 },
    202     { "zm",     3,   1,  0 },
    203     { "om",     4,   1,  0 },
    204     { "um",     5,   1,  0 },
    205     { "pm",     6,   1,  0 },
    206     { "pc",     8,   2,  0 },
    207     { "rc",    10,   2,  0 },
    208     { "x",     12,   1,  0 },
    209     { NULL,     0,   0,  0 }
     279static DBGFREGSUBFIELD const g_aCpumRegFields_fcw[] =
     280{
     281    DBGFREGSUBFIELD_RW("im",     1,   1,  0),
     282    DBGFREGSUBFIELD_RW("dm",     2,   1,  0),
     283    DBGFREGSUBFIELD_RW("zm",     3,   1,  0),
     284    DBGFREGSUBFIELD_RW("om",     4,   1,  0),
     285    DBGFREGSUBFIELD_RW("um",     5,   1,  0),
     286    DBGFREGSUBFIELD_RW("pm",     6,   1,  0),
     287    DBGFREGSUBFIELD_RW("pc",     8,   2,  0),
     288    DBGFREGSUBFIELD_RW("rc",    10,   2,  0),
     289    DBGFREGSUBFIELD_RW("x",     12,   1,  0),
     290    DBGFREGSUBFIELD_TERMINATOR()
    210291};
    211292
    212293/** Sub-fields for the FPU status word register. */
    213 static DBGFREGSUBFIELD const g_aDbgfRegFields_fsw[] =
    214 {
    215     { "ie",     0,   1,  0 },
    216     { "de",     1,   1,  0 },
    217     { "ze",     2,   1,  0 },
    218     { "oe",     3,   1,  0 },
    219     { "ue",     4,   1,  0 },
    220     { "pe",     5,   1,  0 },
    221     { "se",     6,   1,  0 },
    222     { "es",     7,   1,  0 },
    223     { "c0",     8,   1,  0 },
    224     { "c1",     9,   1,  0 },
    225     { "c2",    10,   1,  0 },
    226     { "top",   11,   3,  0 },
    227     { "c3",    14,   1,  0 },
    228     { "b",     15,   1,  0 },
    229     { NULL,     0,   0,  0 }
     294static DBGFREGSUBFIELD const g_aCpumRegFields_fsw[] =
     295{
     296    DBGFREGSUBFIELD_RW("ie",     0,   1,  0),
     297    DBGFREGSUBFIELD_RW("de",     1,   1,  0),
     298    DBGFREGSUBFIELD_RW("ze",     2,   1,  0),
     299    DBGFREGSUBFIELD_RW("oe",     3,   1,  0),
     300    DBGFREGSUBFIELD_RW("ue",     4,   1,  0),
     301    DBGFREGSUBFIELD_RW("pe",     5,   1,  0),
     302    DBGFREGSUBFIELD_RW("se",     6,   1,  0),
     303    DBGFREGSUBFIELD_RW("es",     7,   1,  0),
     304    DBGFREGSUBFIELD_RW("c0",     8,   1,  0),
     305    DBGFREGSUBFIELD_RW("c1",     9,   1,  0),
     306    DBGFREGSUBFIELD_RW("c2",    10,   1,  0),
     307    DBGFREGSUBFIELD_RW("top",   11,   3,  0),
     308    DBGFREGSUBFIELD_RW("c3",    14,   1,  0),
     309    DBGFREGSUBFIELD_RW("b",     15,   1,  0),
     310    DBGFREGSUBFIELD_TERMINATOR()
    230311};
    231312
    232313/** Sub-fields for the FPU tag word register. */
    233 static DBGFREGSUBFIELD const g_aDbgfRegFields_ftw[] =
    234 {
    235     { "tag0",   0,   2,  0 },
    236     { "tag1",   2,   2,  0 },
    237     { "tag2",   4,   2,  0 },
    238     { "tag3",   6,   2,  0 },
    239     { "tag4",   8,   2,  0 },
    240     { "tag5",  10,   2,  0 },
    241     { "tag6",  12,   2,  0 },
    242     { "tag7",  14,   2,  0 },
    243     { NULL,     0,   0,  0 }
     314static DBGFREGSUBFIELD const g_aCpumRegFields_ftw[] =
     315{
     316    DBGFREGSUBFIELD_RW("tag0",   0,   2,  0),
     317    DBGFREGSUBFIELD_RW("tag1",   2,   2,  0),
     318    DBGFREGSUBFIELD_RW("tag2",   4,   2,  0),
     319    DBGFREGSUBFIELD_RW("tag3",   6,   2,  0),
     320    DBGFREGSUBFIELD_RW("tag4",   8,   2,  0),
     321    DBGFREGSUBFIELD_RW("tag5",  10,   2,  0),
     322    DBGFREGSUBFIELD_RW("tag6",  12,   2,  0),
     323    DBGFREGSUBFIELD_RW("tag7",  14,   2,  0),
     324    DBGFREGSUBFIELD_TERMINATOR()
    244325};
    245326
    246327/** Sub-fields for the Multimedia Extensions Control and Status Register. */
    247 static DBGFREGSUBFIELD const g_aDbgfRegFields_mxcsr[] =
    248 {
    249     { "ie",     0,   1,  0 },
    250     { "de",     1,   1,  0 },
    251     { "ze",     2,   1,  0 },
    252     { "oe",     3,   1,  0 },
    253     { "ue",     4,   1,  0 },
    254     { "pe",     5,   1,  0 },
    255     { "daz",    6,   1,  0 },
    256     { "im",     7,   1,  0 },
    257     { "dm",     8,   1,  0 },
    258     { "zm",     9,   1,  0 },
    259     { "om",    10,   1,  0 },
    260     { "um",    11,   1,  0 },
    261     { "pm",    12,   1,  0 },
    262     { "rc",    13,   2,  0 },
    263     { "fz",    14,   1,  0 },
    264     { NULL,     0,   0,  0 }
     328static DBGFREGSUBFIELD const g_aCpumRegFields_mxcsr[] =
     329{
     330    DBGFREGSUBFIELD_RW("ie",     0,   1,  0),
     331    DBGFREGSUBFIELD_RW("de",     1,   1,  0),
     332    DBGFREGSUBFIELD_RW("ze",     2,   1,  0),
     333    DBGFREGSUBFIELD_RW("oe",     3,   1,  0),
     334    DBGFREGSUBFIELD_RW("ue",     4,   1,  0),
     335    DBGFREGSUBFIELD_RW("pe",     5,   1,  0),
     336    DBGFREGSUBFIELD_RW("daz",    6,   1,  0),
     337    DBGFREGSUBFIELD_RW("im",     7,   1,  0),
     338    DBGFREGSUBFIELD_RW("dm",     8,   1,  0),
     339    DBGFREGSUBFIELD_RW("zm",     9,   1,  0),
     340    DBGFREGSUBFIELD_RW("om",    10,   1,  0),
     341    DBGFREGSUBFIELD_RW("um",    11,   1,  0),
     342    DBGFREGSUBFIELD_RW("pm",    12,   1,  0),
     343    DBGFREGSUBFIELD_RW("rc",    13,   2,  0),
     344    DBGFREGSUBFIELD_RW("fz",    14,   1,  0),
     345    DBGFREGSUBFIELD_TERMINATOR()
    265346};
    266347
    267348/** Sub-fields for the FPU tag word register. */
    268 static DBGFREGSUBFIELD const g_aDbgfRegFields_stN[] =
    269 {
    270     { "man",    0,  64,  0 },
    271     { "exp",   64,  15,  0 },
    272     { "sig",   79,   1,  0 },
    273     { NULL,     0,   0,  0 }
     349static DBGFREGSUBFIELD const g_aCpumRegFields_stN[] =
     350{
     351    DBGFREGSUBFIELD_RW("man",    0,  64,  0),
     352    DBGFREGSUBFIELD_RW("exp",   64,  15,  0),
     353    DBGFREGSUBFIELD_RW("sig",   79,   1,  0),
     354    DBGFREGSUBFIELD_TERMINATOR()
    274355};
    275356
    276357/** Sub-fields for the MMX registers. */
    277 static DBGFREGSUBFIELD const g_aDbgfRegFields_mmN[] =
    278 {
    279     { "dw0",    0,  32,  0 },
    280     { "dw1",   32,  32,  0 },
    281     { "w0",     0,  16,  0 },
    282     { "w1",    16,  16,  0 },
    283     { "w2",    32,  16,  0 },
    284     { "w3",    48,  16,  0 },
    285     { "b0",     0,   8,  0 },
    286     { "b1",     8,   8,  0 },
    287     { "b2",    16,   8,  0 },
    288     { "b3",    24,   8,  0 },
    289     { "b4",    32,   8,  0 },
    290     { "b5",    40,   8,  0 },
    291     { "b6",    48,   8,  0 },
    292     { "b7",    56,   8,  0 },
    293     { NULL,     0,   0,  0 }
     358static DBGFREGSUBFIELD const g_aCpumRegFields_mmN[] =
     359{
     360    DBGFREGSUBFIELD_RW("dw0",    0,  32,  0),
     361    DBGFREGSUBFIELD_RW("dw1",   32,  32,  0),
     362    DBGFREGSUBFIELD_RW("w0",     0,  16,  0),
     363    DBGFREGSUBFIELD_RW("w1",    16,  16,  0),
     364    DBGFREGSUBFIELD_RW("w2",    32,  16,  0),
     365    DBGFREGSUBFIELD_RW("w3",    48,  16,  0),
     366    DBGFREGSUBFIELD_RW("b0",     0,   8,  0),
     367    DBGFREGSUBFIELD_RW("b1",     8,   8,  0),
     368    DBGFREGSUBFIELD_RW("b2",    16,   8,  0),
     369    DBGFREGSUBFIELD_RW("b3",    24,   8,  0),
     370    DBGFREGSUBFIELD_RW("b4",    32,   8,  0),
     371    DBGFREGSUBFIELD_RW("b5",    40,   8,  0),
     372    DBGFREGSUBFIELD_RW("b6",    48,   8,  0),
     373    DBGFREGSUBFIELD_RW("b7",    56,   8,  0),
     374    DBGFREGSUBFIELD_TERMINATOR()
    294375};
    295376
    296377/** Sub-fields for the XMM registers. */
    297 static DBGFREGSUBFIELD const g_aDbgfRegFields_xmmN[] =
    298 {
    299     { "r0",      0,     32,  0 },
    300     { "r0.man",  0+ 0,  23,  0 },
    301     { "r0.exp",  0+23,   8,  0 },
    302     { "r0.sig",  0+31,   1,  0 },
    303     { "r1",     32,     32,  0 },
    304     { "r1.man", 32+ 0,  23,  0 },
    305     { "r1.exp", 32+23,   8,  0 },
    306     { "r1.sig", 32+31,   1,  0 },
    307     { "r2",     64,     32,  0 },
    308     { "r2.man", 64+ 0,  23,  0 },
    309     { "r2.exp", 64+23,   8,  0 },
    310     { "r2.sig", 64+31,   1,  0 },
    311     { "r3",     96,     32,  0 },
    312     { "r3.man", 96+ 0,  23,  0 },
    313     { "r3.exp", 96+23,   8,  0 },
    314     { "r3.sig", 96+31,   1,  0 },
    315     { NULL,      0,      0,  0 }
     378static DBGFREGSUBFIELD const g_aCpumRegFields_xmmN[] =
     379{
     380    DBGFREGSUBFIELD_RW("r0",      0,     32,  0),
     381    DBGFREGSUBFIELD_RW("r0.man",  0+ 0,  23,  0),
     382    DBGFREGSUBFIELD_RW("r0.exp",  0+23,   8,  0),
     383    DBGFREGSUBFIELD_RW("r0.sig",  0+31,   1,  0),
     384    DBGFREGSUBFIELD_RW("r1",     32,     32,  0),
     385    DBGFREGSUBFIELD_RW("r1.man", 32+ 0,  23,  0),
     386    DBGFREGSUBFIELD_RW("r1.exp", 32+23,   8,  0),
     387    DBGFREGSUBFIELD_RW("r1.sig", 32+31,   1,  0),
     388    DBGFREGSUBFIELD_RW("r2",     64,     32,  0),
     389    DBGFREGSUBFIELD_RW("r2.man", 64+ 0,  23,  0),
     390    DBGFREGSUBFIELD_RW("r2.exp", 64+23,   8,  0),
     391    DBGFREGSUBFIELD_RW("r2.sig", 64+31,   1,  0),
     392    DBGFREGSUBFIELD_RW("r3",     96,     32,  0),
     393    DBGFREGSUBFIELD_RW("r3.man", 96+ 0,  23,  0),
     394    DBGFREGSUBFIELD_RW("r3.exp", 96+23,   8,  0),
     395    DBGFREGSUBFIELD_RW("r3.sig", 96+31,   1,  0),
     396    DBGFREGSUBFIELD_TERMINATOR()
    316397};
    317398
    318399/** Sub-fields for the CR0 register. */
    319 static DBGFREGSUBFIELD const g_aDbgfRegFields_cr0[] =
    320 {
    321     /** @todo  */
    322     { NULL,      0,      0,  0 }
     400static DBGFREGSUBFIELD const g_aCpumRegFields_cr0[] =
     401{
     402    /** @todo  */
     403    DBGFREGSUBFIELD_TERMINATOR()
    323404};
    324405
    325406/** Sub-fields for the CR3 register. */
    326 static DBGFREGSUBFIELD const g_aDbgfRegFields_cr3[] =
    327 {
    328     /** @todo  */
    329     { NULL,      0,      0,  0 }
     407static DBGFREGSUBFIELD const g_aCpumRegFields_cr3[] =
     408{
     409    /** @todo  */
     410    DBGFREGSUBFIELD_TERMINATOR()
    330411};
    331412
    332413/** Sub-fields for the CR4 register. */
    333 static DBGFREGSUBFIELD const g_aDbgfRegFields_cr4[] =
    334 {
    335     /** @todo  */
    336     { NULL,      0,      0,  0 }
     414static DBGFREGSUBFIELD const g_aCpumRegFields_cr4[] =
     415{
     416    /** @todo  */
     417    DBGFREGSUBFIELD_TERMINATOR()
    337418};
    338419
    339420/** Sub-fields for the DR6 register. */
    340 static DBGFREGSUBFIELD const g_aDbgfRegFields_dr6[] =
    341 {
    342     /** @todo  */
    343     { NULL,      0,      0,  0 }
     421static DBGFREGSUBFIELD const g_aCpumRegFields_dr6[] =
     422{
     423    /** @todo  */
     424    DBGFREGSUBFIELD_TERMINATOR()
    344425};
    345426
    346427/** Sub-fields for the DR7 register. */
    347 static DBGFREGSUBFIELD const g_aDbgfRegFields_dr7[] =
    348 {
    349     /** @todo  */
    350     { NULL,      0,      0,  0 }
     428static DBGFREGSUBFIELD const g_aCpumRegFields_dr7[] =
     429{
     430    /** @todo  */
     431    DBGFREGSUBFIELD_TERMINATOR()
    351432};
    352433
    353434/** Sub-fields for the CR_PAT MSR. */
    354 static DBGFREGSUBFIELD const g_aDbgfRegFields_apic_base[] =
    355 {
    356     { "bsp",     8,      1,  0 },
    357     { "ge",      9,      1,  0 },
    358     { "base",    12,    20, 12 },
    359     { NULL,      0,      0,  0 }
     435static DBGFREGSUBFIELD const g_aCpumRegFields_apic_base[] =
     436{
     437    DBGFREGSUBFIELD_RW("bsp",     8,      1,  0),
     438    DBGFREGSUBFIELD_RW("ge",      9,      1,  0),
     439    DBGFREGSUBFIELD_RW("base",    12,    20, 12),
     440    DBGFREGSUBFIELD_TERMINATOR()
    360441};
    361442
    362443/** Sub-fields for the CR_PAT MSR. */
    363 static DBGFREGSUBFIELD const g_aDbgfRegFields_cr_pat[] =
    364 {
    365     /** @todo  */
    366     { NULL,      0,      0,  0 }
     444static DBGFREGSUBFIELD const g_aCpumRegFields_cr_pat[] =
     445{
     446    /** @todo  */
     447    DBGFREGSUBFIELD_TERMINATOR()
    367448};
    368449
    369450/** Sub-fields for the PERF_STATUS MSR. */
    370 static DBGFREGSUBFIELD const g_aDbgfRegFields_perf_status[] =
    371 {
    372     /** @todo  */
    373     { NULL,      0,      0,  0 }
     451static DBGFREGSUBFIELD const g_aCpumRegFields_perf_status[] =
     452{
     453    /** @todo  */
     454    DBGFREGSUBFIELD_TERMINATOR()
    374455};
    375456
    376457/** Sub-fields for the EFER MSR. */
    377 static DBGFREGSUBFIELD const g_aDbgfRegFields_efer[] =
    378 {
    379     /** @todo  */
    380     { NULL,      0,      0,  0 }
     458static DBGFREGSUBFIELD const g_aCpumRegFields_efer[] =
     459{
     460    /** @todo  */
     461    DBGFREGSUBFIELD_TERMINATOR()
    381462};
    382463
    383464/** Sub-fields for the STAR MSR. */
    384 static DBGFREGSUBFIELD const g_aDbgfRegFields_star[] =
    385 {
    386     /** @todo  */
    387     { NULL,      0,      0,  0 }
     465static DBGFREGSUBFIELD const g_aCpumRegFields_star[] =
     466{
     467    /** @todo  */
     468    DBGFREGSUBFIELD_TERMINATOR()
    388469};
    389470
    390471/** Sub-fields for the CSTAR MSR. */
    391 static DBGFREGSUBFIELD const g_aDbgfRegFields_cstar[] =
    392 {
    393     /** @todo  */
    394     { NULL,      0,      0,  0 }
     472static DBGFREGSUBFIELD const g_aCpumRegFields_cstar[] =
     473{
     474    /** @todo  */
     475    DBGFREGSUBFIELD_TERMINATOR()
    395476};
    396477
    397478/** Sub-fields for the LSTAR MSR. */
    398 static DBGFREGSUBFIELD const g_aDbgfRegFields_lstar[] =
    399 {
    400     /** @todo  */
    401     { NULL,      0,      0,  0 }
     479static DBGFREGSUBFIELD const g_aCpumRegFields_lstar[] =
     480{
     481    /** @todo  */
     482    DBGFREGSUBFIELD_TERMINATOR()
    402483};
    403484
    404485/** Sub-fields for the SF_MASK MSR. */
    405 static DBGFREGSUBFIELD const g_aDbgfRegFields_sf_mask[] =
    406 {
    407     /** @todo  */
    408     { NULL,      0,      0,  0 }
     486static DBGFREGSUBFIELD const g_aCpumRegFields_sf_mask[] =
     487{
     488    /** @todo  */
     489    DBGFREGSUBFIELD_TERMINATOR()
    409490};
    410491
    … …  
    414495 * The register descriptors.
    415496 */
    416 static DBGFREGDESC const g_aDbgfRegDescs[] =
    417 {
    418 #define DBGFREGDESC_REG(UName, LName) \
    419     { #LName, DBGFREG_##UName, DBGFREGVALTYPE_U64, RT_OFFSETOF(CPUMCTX, LName), NULL, NULL, g_aDbgfRegAliases_##LName, NULL }
    420     DBGFREGDESC_REG(RAX, rax),
    421     DBGFREGDESC_REG(RCX, rcx),
    422     DBGFREGDESC_REG(RDX, rdx),
    423     DBGFREGDESC_REG(RSP, rsp),
    424     DBGFREGDESC_REG(RBP, rbp),
    425     DBGFREGDESC_REG(RSI, rsi),
    426     DBGFREGDESC_REG(RDI, rdi),
    427     DBGFREGDESC_REG(R8,   r8),
    428     DBGFREGDESC_REG(R9,   r9),
    429     DBGFREGDESC_REG(R10, r10),
    430     DBGFREGDESC_REG(R11, r11),
    431     DBGFREGDESC_REG(R12, r12),
    432     DBGFREGDESC_REG(R13, r13),
    433     DBGFREGDESC_REG(R14, r14),
    434     DBGFREGDESC_REG(R15, r15),
    435 #define DBGFREGDESC_SEG(UName, LName) \
    436     { #LName,         DBGFREG_##UName,        DBGFREGVALTYPE_U16, RT_OFFSETOF(CPUMCTX, LName),               NULL, dbgfR3RegSet_seg, NULL, NULL },  \
    437     { #LName "_attr", DBGFREG_##UName##_ATTR, DBGFREGVALTYPE_U32, RT_OFFSETOF(CPUMCTX, LName##Hid.Attr.u),   NULL, NULL, NULL, g_aDbgfRegFields_seg }, \
    438     { #LName "_base", DBGFREG_##UName##_ATTR, DBGFREGVALTYPE_U64, RT_OFFSETOF(CPUMCTX, LName##Hid.u64Base),  NULL, NULL, NULL, NULL }, \
    439     { #LName "_lim",  DBGFREG_##UName##_ATTR, DBGFREGVALTYPE_U32, RT_OFFSETOF(CPUMCTX, LName##Hid.u32Limit), NULL, NULL, NULL, NULL }
    440     DBGFREGDESC_SEG(CS, cs),
    441     DBGFREGDESC_SEG(DS, ds),
    442     DBGFREGDESC_SEG(ES, es),
    443     DBGFREGDESC_SEG(FS, fs),
    444     DBGFREGDESC_SEG(GS, gs),
    445     DBGFREGDESC_SEG(SS, ss),
    446     DBGFREGDESC_REG(RIP, rip),
    447     { "rflags",     DBGFREG_RFLAGS,     DBGFREGVALTYPE_U64, RT_OFFSETOF(CPUMCTX, rflags),           NULL, NULL, g_aDbgfRegAliases_rflags, g_aDbgfRegFields_rflags },
    448     { "fcw",        DBGFREG_FCW,        DBGFREGVALTYPE_U16, RT_OFFSETOF(CPUMCTX, fpu.FCW),          NULL, NULL, NULL, g_aDbgfRegFields_fcw },
    449     { "fsw",        DBGFREG_FSW,        DBGFREGVALTYPE_U16, RT_OFFSETOF(CPUMCTX, fpu.FSW),          NULL, NULL, NULL, g_aDbgfRegFields_fsw },
    450     { "ftw",        DBGFREG_FTW,        DBGFREGVALTYPE_U16, RT_OFFSETOF(CPUMCTX, fpu.FTW), dbgfR3RegGet_ftw, dbgfR3RegSet_ftw, NULL, g_aDbgfRegFields_ftw },
    451     { "fop",        DBGFREG_FOP,        DBGFREGVALTYPE_U16, RT_OFFSETOF(CPUMCTX, fpu.FOP),          NULL, NULL, NULL, NULL },
    452     { "fpuip",      DBGFREG_FPUIP,      DBGFREGVALTYPE_U32, RT_OFFSETOF(CPUMCTX, fpu.FPUIP),        NULL, NULL, g_aDbgfRegAliases_fpuip, NULL },
    453     { "fpucs",      DBGFREG_FPUCS,      DBGFREGVALTYPE_U16, RT_OFFSETOF(CPUMCTX, fpu.CS),           NULL, NULL, NULL, NULL },
    454     { "fpudp",      DBGFREG_FPUDP,      DBGFREGVALTYPE_U32, RT_OFFSETOF(CPUMCTX, fpu.FPUDP),        NULL, NULL, g_aDbgfRegAliases_fpudp, NULL },
    455     { "fpuds",      DBGFREG_FPUDS,      DBGFREGVALTYPE_U16, RT_OFFSETOF(CPUMCTX, fpu.DS),           NULL, NULL, NULL, NULL },
    456     { "mxcsr",      DBGFREG_MXCSR,      DBGFREGVALTYPE_U32, RT_OFFSETOF(CPUMCTX, fpu.MXCSR),        NULL, NULL, NULL, g_aDbgfRegFields_mxcsr },
    457     { "mxcsr_mask", DBGFREG_MXCSR_MASK, DBGFREGVALTYPE_U32, RT_OFFSETOF(CPUMCTX, fpu.MXCSR_MASK),   NULL, NULL, NULL, g_aDbgfRegFields_mxcsr },
    458 #define DBGFREGDESC_ST(n) \
    459     { "st" #n,      DBGFREG_ST##n,      DBGFREGVALTYPE_80, ~(size_t)0, dbgfR3RegGet_stN, dbgfR3RegSet_stN, NULL, g_aDbgfRegFields_stN }
    460     DBGFREGDESC_ST(0),
    461     DBGFREGDESC_ST(1),
    462     DBGFREGDESC_ST(2),
    463     DBGFREGDESC_ST(3),
    464     DBGFREGDESC_ST(4),
    465     DBGFREGDESC_ST(5),
    466     DBGFREGDESC_ST(6),
    467     DBGFREGDESC_ST(7),
    468 #define DBGFREGDESC_MM(n) \
    469     { "mm" #n,      DBGFREG_MM##n,      DBGFREGVALTYPE_U64, RT_OFFSETOF(CPUMCTX, fpu.aRegs[n].mmx), NULL, NULL, NULL, g_aDbgfRegFields_mmN }
    470     DBGFREGDESC_MM(0),
    471     DBGFREGDESC_MM(1),
    472     DBGFREGDESC_MM(2),
    473     DBGFREGDESC_MM(3),
    474     DBGFREGDESC_MM(4),
    475     DBGFREGDESC_MM(5),
    476     DBGFREGDESC_MM(6),
    477     DBGFREGDESC_MM(7),
    478 #define DBGFREGDESC_XMM(n) \
    479     { "xmm" #n,     DBGFREG_XMM##n,     DBGFREGVALTYPE_U128, RT_OFFSETOF(CPUMCTX, fpu.aXMM[n].xmm), NULL, NULL, NULL, g_aDbgfRegFields_xmmN }
    480     DBGFREGDESC_XMM(0),
    481     DBGFREGDESC_XMM(1),
    482     DBGFREGDESC_XMM(2),
    483     DBGFREGDESC_XMM(3),
    484     DBGFREGDESC_XMM(4),
    485     DBGFREGDESC_XMM(5),
    486     DBGFREGDESC_XMM(6),
    487     DBGFREGDESC_XMM(7),
    488     DBGFREGDESC_XMM(8),
    489     DBGFREGDESC_XMM(9),
    490     DBGFREGDESC_XMM(10),
    491     DBGFREGDESC_XMM(11),
    492     DBGFREGDESC_XMM(12),
    493     DBGFREGDESC_XMM(13),
    494     DBGFREGDESC_XMM(14),
    495     DBGFREGDESC_XMM(15),
    496     { "gdtr_base",  DBGFREG_GDTR_BASE,      DBGFREGVALTYPE_U64, RT_OFFSETOF(CPUMCTX, gdtr.pGdt),           NULL, NULL, NULL, NULL },
    497     { "gdtr_limit", DBGFREG_GDTR_LIMIT,     DBGFREGVALTYPE_U16, RT_OFFSETOF(CPUMCTX, gdtr.cbGdt),          NULL, NULL, NULL, NULL },
    498     { "idtr_base",  DBGFREG_IDTR_BASE,      DBGFREGVALTYPE_U64, RT_OFFSETOF(CPUMCTX, idtr.pIdt),           NULL, NULL, NULL, NULL },
    499     { "idtr_limit", DBGFREG_IDTR_LIMIT,     DBGFREGVALTYPE_U16, RT_OFFSETOF(CPUMCTX, idtr.cbIdt),          NULL, NULL, NULL, NULL },
    500     DBGFREGDESC_SEG(LDTR, ldtr),
    501     DBGFREGDESC_SEG(TR, tr),
    502     { "cr0",        DBGFREG_CR0,       DBGFREGVALTYPE_U32, 0, dbgfR3RegGet_crX, dbgfR3RegSet_crX, g_aDbgfRegAliases_cr0, g_aDbgfRegFields_cr0 },
    503     { "cr2",        DBGFREG_CR2,       DBGFREGVALTYPE_U64, 2, dbgfR3RegGet_crX, dbgfR3RegSet_crX, NULL, NULL },
    504     { "cr3",        DBGFREG_CR3,       DBGFREGVALTYPE_U64, 3, dbgfR3RegGet_crX, dbgfR3RegSet_crX, NULL, g_aDbgfRegFields_cr3 },
    505     { "cr4",        DBGFREG_CR4,       DBGFREGVALTYPE_U32, 4, dbgfR3RegGet_crX, dbgfR3RegSet_crX, NULL, g_aDbgfRegFields_cr4 },
    506     { "cr8",        DBGFREG_CR8,       DBGFREGVALTYPE_U32, 8, dbgfR3RegGet_crX, dbgfR3RegSet_crX, NULL, NULL },
    507     { "dr0",        DBGFREG_DR0,       DBGFREGVALTYPE_U64, 0, dbgfR3RegGet_drX, dbgfR3RegSet_drX, NULL, NULL },
    508     { "dr1",        DBGFREG_DR1,       DBGFREGVALTYPE_U64, 1, dbgfR3RegGet_drX, dbgfR3RegSet_drX, NULL, NULL },
    509     { "dr2",        DBGFREG_DR2,       DBGFREGVALTYPE_U64, 2, dbgfR3RegGet_drX, dbgfR3RegSet_drX, NULL, NULL },
    510     { "dr3",        DBGFREG_DR3,       DBGFREGVALTYPE_U64, 3, dbgfR3RegGet_drX, dbgfR3RegSet_drX, NULL, NULL },
    511     { "dr6",        DBGFREG_DR6,       DBGFREGVALTYPE_U32, 6, dbgfR3RegGet_drX, dbgfR3RegSet_drX, NULL, g_aDbgfRegFields_dr6 },
    512     { "dr7",        DBGFREG_DR7,       DBGFREGVALTYPE_U32, 7, dbgfR3RegGet_drX, dbgfR3RegSet_drX, NULL, g_aDbgfRegFields_dr7 },
    513     { "apic_base",    DBGFREG_MSR_IA32_APICBASE,      DBGFREGVALTYPE_U32, MSR_IA32_APICBASE,      dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, g_aDbgfRegFields_apic_base },
    514     { "pat",          DBGFREG_MSR_IA32_CR_PAT,        DBGFREGVALTYPE_U64, MSR_IA32_CR_PAT,        dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, g_aDbgfRegFields_cr_pat },
    515     { "perf_status",  DBGFREG_MSR_IA32_PERF_STATUS,   DBGFREGVALTYPE_U64, MSR_IA32_PERF_STATUS,   dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, g_aDbgfRegFields_perf_status },
    516     { "sysenter_cs",  DBGFREG_MSR_IA32_SYSENTER_CS,   DBGFREGVALTYPE_U16, MSR_IA32_SYSENTER_CS,   dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, NULL },
    517     { "sysenter_eip", DBGFREG_MSR_IA32_SYSENTER_EIP,  DBGFREGVALTYPE_U32, MSR_IA32_SYSENTER_EIP,  dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, NULL },
    518     { "sysenter_esp", DBGFREG_MSR_IA32_SYSENTER_ESP,  DBGFREGVALTYPE_U32, MSR_IA32_SYSENTER_ESP,  dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, NULL },
    519     { "tsc",          DBGFREG_MSR_IA32_TSC,           DBGFREGVALTYPE_U32, MSR_IA32_TSC,           dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, NULL },
    520     { "efer",         DBGFREG_MSR_K6_EFER,            DBGFREGVALTYPE_U32, MSR_K6_EFER,            dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, g_aDbgfRegFields_efer },
    521     { "star",         DBGFREG_MSR_K6_STAR,            DBGFREGVALTYPE_U64, MSR_K6_STAR,            dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, g_aDbgfRegFields_star },
    522     { "cstar",        DBGFREG_MSR_K8_CSTAR,           DBGFREGVALTYPE_U64, MSR_K8_CSTAR,           dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, g_aDbgfRegFields_cstar },
    523     { "msr_fs_base",  DBGFREG_MSR_K8_FS_BASE,         DBGFREGVALTYPE_U64, MSR_K8_FS_BASE,         dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, NULL },
    524     { "msr_gs_base",  DBGFREG_MSR_K8_GS_BASE,         DBGFREGVALTYPE_U64, MSR_K8_GS_BASE,         dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, NULL },
    525     { "krnl_gs_base", DBGFREG_MSR_K8_KERNEL_GS_BASE,  DBGFREGVALTYPE_U64, MSR_K8_KERNEL_GS_BASE,  dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, NULL },
    526     { "lstar",        DBGFREG_MSR_K8_LSTAR,           DBGFREGVALTYPE_U64, MSR_K8_LSTAR,           dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, g_aDbgfRegFields_lstar },
    527     { "tsc_aux",      DBGFREG_MSR_K8_TSC_AUX,         DBGFREGVALTYPE_U64, MSR_K8_TSC_AUX,         dbgfR3RegGet_msr, dbgfR3RegSet_msr, NULL, NULL },
    528     { "ah",           DBGFREG_AH,       DBGFREGVALTYPE_U8,  RT_OFFSETOF(CPUMCTX, rax) + 1,  NULL, NULL, NULL, NULL },
    529     { "ch",           DBGFREG_CH,       DBGFREGVALTYPE_U8,  RT_OFFSETOF(CPUMCTX, rcx) + 1,  NULL, NULL, NULL, NULL },
    530     { "dh",           DBGFREG_DH,       DBGFREGVALTYPE_U8,  RT_OFFSETOF(CPUMCTX, rdx) + 1,  NULL, NULL, NULL, NULL },
    531     { "bh",           DBGFREG_BH,       DBGFREGVALTYPE_U8,  RT_OFFSETOF(CPUMCTX, rbx) + 1,  NULL, NULL, NULL, NULL },
    532     { "gdtr",         DBGFREG_GDTR,     DBGFREGVALTYPE_DTR, ~(size_t)0, dbgfR3RegGet_gdtr, dbgfR3RegSet_gdtr, NULL, NULL },
    533     { "idtr",         DBGFREG_IDTR,     DBGFREGVALTYPE_DTR, ~(size_t)0, dbgfR3RegGet_idtr, dbgfR3RegSet_idtr, NULL, NULL },
    534 #undef DBGFREGDESC_REG
    535 #undef DBGFREGDESC_SEG
    536 #undef DBGFREGDESC_ST
    537 #undef DBGFREGDESC_MM
    538 #undef DBGFREGDESC_XMM
    539 };
    540 
     497static DBGFREGDESC const g_aCpumRegDescs[] =
     498{
     499#define CPUMREGDESC_REG(UName, LName) \
     500    { #LName, DBGFREG_##UName, DBGFREGVALTYPE_U64, 0, RT_OFFSETOF(CPUMCTX, LName), cpumR3RegGet_Generic, cpumR3RegSet_Generic, g_aCpumRegAliases_##LName, NULL }
     501    CPUMREGDESC_REG(RAX, rax),
     502    CPUMREGDESC_REG(RCX, rcx),
     503    CPUMREGDESC_REG(RDX, rdx),
     504    CPUMREGDESC_REG(RSP, rsp),
     505    CPUMREGDESC_REG(RBP, rbp),
     506    CPUMREGDESC_REG(RSI, rsi),
     507    CPUMREGDESC_REG(RDI, rdi),
     508    CPUMREGDESC_REG(R8,   r8),
     509    CPUMREGDESC_REG(R9,   r9),
     510    CPUMREGDESC_REG(R10, r10),
     511    CPUMREGDESC_REG(R11, r11),
     512    CPUMREGDESC_REG(R12, r12),
     513    CPUMREGDESC_REG(R13, r13),
     514    CPUMREGDESC_REG(R14, r14),
     515    CPUMREGDESC_REG(R15, r15),
     516#define CPUMREGDESC_SEG(UName, LName) \
     517    { #LName,         DBGFREG_##UName,        DBGFREGVALTYPE_U16, 0, RT_OFFSETOF(CPUMCTX, LName),               cpumR3RegGet_Generic, cpumR3RegSet_seg,     NULL, NULL },  \
     518    { #LName "_attr", DBGFREG_##UName##_ATTR, DBGFREGVALTYPE_U32, 0, RT_OFFSETOF(CPUMCTX, LName##Hid.Attr.u),   cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, g_aCpumRegFields_seg }, \
     519    { #LName "_base", DBGFREG_##UName##_ATTR, DBGFREGVALTYPE_U64, 0, RT_OFFSETOF(CPUMCTX, LName##Hid.u64Base),  cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, NULL }, \
     520    { #LName "_lim",  DBGFREG_##UName##_ATTR, DBGFREGVALTYPE_U32, 0, RT_OFFSETOF(CPUMCTX, LName##Hid.u32Limit), cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, NULL }
     521    CPUMREGDESC_SEG(CS, cs),
     522    CPUMREGDESC_SEG(DS, ds),
     523    CPUMREGDESC_SEG(ES, es),
     524    CPUMREGDESC_SEG(FS, fs),
     525    CPUMREGDESC_SEG(GS, gs),
     526    CPUMREGDESC_SEG(SS, ss),
     527    CPUMREGDESC_REG(RIP, rip),
     528    { "rflags",     DBGFREG_RFLAGS,     DBGFREGVALTYPE_U64, 0, RT_OFFSETOF(CPUMCTX, rflags),         cpumR3RegGet_Generic, cpumR3RegSet_Generic, g_aCpumRegAliases_rflags, g_aCpumRegFields_rflags },
     529    { "fcw",        DBGFREG_FCW,        DBGFREGVALTYPE_U16, 0, RT_OFFSETOF(CPUMCTX, fpu.FCW),        cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, g_aCpumRegFields_fcw },
     530    { "fsw",        DBGFREG_FSW,        DBGFREGVALTYPE_U16, 0, RT_OFFSETOF(CPUMCTX, fpu.FSW),        cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, g_aCpumRegFields_fsw },
     531    { "ftw",        DBGFREG_FTW,        DBGFREGVALTYPE_U16, 0, RT_OFFSETOF(CPUMCTX, fpu.FTW),        cpumR3RegGet_ftw,     cpumR3RegSet_ftw,     NULL, g_aCpumRegFields_ftw },
     532    { "fop",        DBGFREG_FOP,        DBGFREGVALTYPE_U16, 0, RT_OFFSETOF(CPUMCTX, fpu.FOP),        cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, NULL },
     533    { "fpuip",      DBGFREG_FPUIP,      DBGFREGVALTYPE_U32, 0, RT_OFFSETOF(CPUMCTX, fpu.FPUIP),      cpumR3RegGet_Generic, cpumR3RegSet_Generic, g_aCpumRegAliases_fpuip, NULL },
     534    { "fpucs",      DBGFREG_FPUCS,      DBGFREGVALTYPE_U16, 0, RT_OFFSETOF(CPUMCTX, fpu.CS),         cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, NULL },
     535    { "fpudp",      DBGFREG_FPUDP,      DBGFREGVALTYPE_U32, 0, RT_OFFSETOF(CPUMCTX, fpu.FPUDP),      cpumR3RegGet_Generic, cpumR3RegSet_Generic, g_aCpumRegAliases_fpudp, NULL },
     536    { "fpuds",      DBGFREG_FPUDS,      DBGFREGVALTYPE_U16, 0, RT_OFFSETOF(CPUMCTX, fpu.DS),         cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, NULL },
     537    { "mxcsr",      DBGFREG_MXCSR,      DBGFREGVALTYPE_U32, 0, RT_OFFSETOF(CPUMCTX, fpu.MXCSR),      cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, g_aCpumRegFields_mxcsr },
     538    { "mxcsr_mask", DBGFREG_MXCSR_MASK, DBGFREGVALTYPE_U32, 0, RT_OFFSETOF(CPUMCTX, fpu.MXCSR_MASK), cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, g_aCpumRegFields_mxcsr },
     539#define CPUMREGDESC_ST(n) \
     540    { "st" #n,      DBGFREG_ST##n,      DBGFREGVALTYPE_LRD, 0, ~(size_t)0, cpumR3RegGet_stN, cpumR3RegSet_stN, NULL, g_aCpumRegFields_stN }
     541    CPUMREGDESC_ST(0),
     542    CPUMREGDESC_ST(1),
     543    CPUMREGDESC_ST(2),
     544    CPUMREGDESC_ST(3),
     545    CPUMREGDESC_ST(4),
     546    CPUMREGDESC_ST(5),
     547    CPUMREGDESC_ST(6),
     548    CPUMREGDESC_ST(7),
     549#define CPUMREGDESC_MM(n) \
     550    { "mm" #n,      DBGFREG_MM##n,      DBGFREGVALTYPE_U64, 0, RT_OFFSETOF(CPUMCTX, fpu.aRegs[n].mmx), cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, g_aCpumRegFields_mmN }
     551    CPUMREGDESC_MM(0),
     552    CPUMREGDESC_MM(1),
     553    CPUMREGDESC_MM(2),
     554    CPUMREGDESC_MM(3),
     555    CPUMREGDESC_MM(4),
     556    CPUMREGDESC_MM(5),
     557    CPUMREGDESC_MM(6),
     558    CPUMREGDESC_MM(7),
     559#define CPUMREGDESC_XMM(n) \
     560    { "xmm" #n,     DBGFREG_XMM##n,     DBGFREGVALTYPE_U128, 0, RT_OFFSETOF(CPUMCTX, fpu.aXMM[n].xmm), cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, g_aCpumRegFields_xmmN }
     561    CPUMREGDESC_XMM(0),
     562    CPUMREGDESC_XMM(1),
     563    CPUMREGDESC_XMM(2),
     564    CPUMREGDESC_XMM(3),
     565    CPUMREGDESC_XMM(4),
     566    CPUMREGDESC_XMM(5),
     567    CPUMREGDESC_XMM(6),
     568    CPUMREGDESC_XMM(7),
     569    CPUMREGDESC_XMM(8),
     570    CPUMREGDESC_XMM(9),
     571    CPUMREGDESC_XMM(10),
     572    CPUMREGDESC_XMM(11),
     573    CPUMREGDESC_XMM(12),
     574    CPUMREGDESC_XMM(13),
     575    CPUMREGDESC_XMM(14),
     576    CPUMREGDESC_XMM(15),
     577    { "gdtr_base",  DBGFREG_GDTR_BASE,      DBGFREGVALTYPE_U64, 0, RT_OFFSETOF(CPUMCTX, gdtr.pGdt),  cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, NULL },
     578    { "gdtr_limit", DBGFREG_GDTR_LIMIT,     DBGFREGVALTYPE_U16, 0, RT_OFFSETOF(CPUMCTX, gdtr.cbGdt), cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, NULL },
     579    { "idtr_base",  DBGFREG_IDTR_BASE,      DBGFREGVALTYPE_U64, 0, RT_OFFSETOF(CPUMCTX, idtr.pIdt),  cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, NULL },
     580    { "idtr_limit", DBGFREG_IDTR_LIMIT,     DBGFREGVALTYPE_U16, 0, RT_OFFSETOF(CPUMCTX, idtr.cbIdt), cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL, NULL },
     581    CPUMREGDESC_SEG(LDTR, ldtr),
     582    CPUMREGDESC_SEG(TR, tr),
     583    { "cr0",        DBGFREG_CR0,       DBGFREGVALTYPE_U32, 0, 0, cpumR3RegGet_crX, cpumR3RegSet_crX, g_aCpumRegAliases_cr0, g_aCpumRegFields_cr0 },
     584    { "cr2",        DBGFREG_CR2,       DBGFREGVALTYPE_U64, 0, 2, cpumR3RegGet_crX, cpumR3RegSet_crX, NULL, NULL },
     585    { "cr3",        DBGFREG_CR3,       DBGFREGVALTYPE_U64, 0, 3, cpumR3RegGet_crX, cpumR3RegSet_crX, NULL, g_aCpumRegFields_cr3 },
     586    { "cr4",        DBGFREG_CR4,       DBGFREGVALTYPE_U32, 0, 4, cpumR3RegGet_crX, cpumR3RegSet_crX, NULL, g_aCpumRegFields_cr4 },
     587    { "cr8",        DBGFREG_CR8,       DBGFREGVALTYPE_U32, 0, 8, cpumR3RegGet_crX, cpumR3RegSet_crX, NULL, NULL },
     588    { "dr0",        DBGFREG_DR0,       DBGFREGVALTYPE_U64, 0, 0, cpumR3RegGet_drX, cpumR3RegSet_drX, NULL, NULL },
     589    { "dr1",        DBGFREG_DR1,       DBGFREGVALTYPE_U64, 0, 1, cpumR3RegGet_drX, cpumR3RegSet_drX, NULL, NULL },
     590    { "dr2",        DBGFREG_DR2,       DBGFREGVALTYPE_U64, 0, 2, cpumR3RegGet_drX, cpumR3RegSet_drX, NULL, NULL },
     591    { "dr3",        DBGFREG_DR3,       DBGFREGVALTYPE_U64, 0, 3, cpumR3RegGet_drX, cpumR3RegSet_drX, NULL, NULL },
     592    { "dr6",        DBGFREG_DR6,       DBGFREGVALTYPE_U32, 0, 6, cpumR3RegGet_drX, cpumR3RegSet_drX, NULL, g_aCpumRegFields_dr6 },
     593    { "dr7",        DBGFREG_DR7,       DBGFREGVALTYPE_U32, 0, 7, cpumR3RegGet_drX, cpumR3RegSet_drX, NULL, g_aCpumRegFields_dr7 },
     594    { "apic_base",    DBGFREG_MSR_IA32_APICBASE,      DBGFREGVALTYPE_U32, 0, MSR_IA32_APICBASE,      cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, g_aCpumRegFields_apic_base },
     595    { "pat",          DBGFREG_MSR_IA32_CR_PAT,        DBGFREGVALTYPE_U64, 0, MSR_IA32_CR_PAT,        cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, g_aCpumRegFields_cr_pat },
     596    { "perf_status",  DBGFREG_MSR_IA32_PERF_STATUS,   DBGFREGVALTYPE_U64, 0, MSR_IA32_PERF_STATUS,   cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, g_aCpumRegFields_perf_status },
     597    { "sysenter_cs",  DBGFREG_MSR_IA32_SYSENTER_CS,   DBGFREGVALTYPE_U16, 0, MSR_IA32_SYSENTER_CS,   cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, NULL },
     598    { "sysenter_eip", DBGFREG_MSR_IA32_SYSENTER_EIP,  DBGFREGVALTYPE_U32, 0, MSR_IA32_SYSENTER_EIP,  cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, NULL },
     599    { "sysenter_esp", DBGFREG_MSR_IA32_SYSENTER_ESP,  DBGFREGVALTYPE_U32, 0, MSR_IA32_SYSENTER_ESP,  cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, NULL },
     600    { "tsc",          DBGFREG_MSR_IA32_TSC,           DBGFREGVALTYPE_U32, 0, MSR_IA32_TSC,           cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, NULL },
     601    { "efer",         DBGFREG_MSR_K6_EFER,            DBGFREGVALTYPE_U32, 0, MSR_K6_EFER,            cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, g_aCpumRegFields_efer },
     602    { "star",         DBGFREG_MSR_K6_STAR,            DBGFREGVALTYPE_U64, 0, MSR_K6_STAR,            cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, g_aCpumRegFields_star },
     603    { "cstar",        DBGFREG_MSR_K8_CSTAR,           DBGFREGVALTYPE_U64, 0, MSR_K8_CSTAR,           cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, g_aCpumRegFields_cstar },
     604    { "msr_fs_base",  DBGFREG_MSR_K8_FS_BASE,         DBGFREGVALTYPE_U64, 0, MSR_K8_FS_BASE,         cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, NULL },
     605    { "msr_gs_base",  DBGFREG_MSR_K8_GS_BASE,         DBGFREGVALTYPE_U64, 0, MSR_K8_GS_BASE,         cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, NULL },
     606    { "krnl_gs_base", DBGFREG_MSR_K8_KERNEL_GS_BASE,  DBGFREGVALTYPE_U64, 0, MSR_K8_KERNEL_GS_BASE,  cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, NULL },
     607    { "lstar",        DBGFREG_MSR_K8_LSTAR,           DBGFREGVALTYPE_U64, 0, MSR_K8_LSTAR,           cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, g_aCpumRegFields_lstar },
     608    { "tsc_aux",      DBGFREG_MSR_K8_TSC_AUX,         DBGFREGVALTYPE_U64, 0, MSR_K8_TSC_AUX,         cpumR3RegGet_msr, cpumR3RegSet_msr, NULL, NULL },
     609    { "ah",           DBGFREG_AH,       DBGFREGVALTYPE_U8,  0, RT_OFFSETOF(CPUMCTX, rax) + 1,  NULL, NULL, NULL, NULL },
     610    { "ch",           DBGFREG_CH,       DBGFREGVALTYPE_U8,  0, RT_OFFSETOF(CPUMCTX, rcx) + 1,  NULL, NULL, NULL, NULL },
     611    { "dh",           DBGFREG_DH,       DBGFREGVALTYPE_U8,  0, RT_OFFSETOF(CPUMCTX, rdx) + 1,  NULL, NULL, NULL, NULL },
     612    { "bh",           DBGFREG_BH,       DBGFREGVALTYPE_U8,  0, RT_OFFSETOF(CPUMCTX, rbx) + 1,  NULL, NULL, NULL, NULL },
     613    { "gdtr",         DBGFREG_GDTR,     DBGFREGVALTYPE_DTR, 0, ~(size_t)0, cpumR3RegGet_gdtr, cpumR3RegSet_gdtr, NULL, NULL },
     614    { "idtr",         DBGFREG_IDTR,     DBGFREGVALTYPE_DTR, 0, ~(size_t)0, cpumR3RegGet_idtr, cpumR3RegSet_idtr, NULL, NULL },
     615#undef CPUMREGDESC_REG
     616#undef CPUMREGDESC_SEG
     617#undef CPUMREGDESC_ST
     618#undef CPUMREGDESC_MM
     619#undef CPUMREGDESC_XMM
     620};
     621
     622#endif

  • trunk/src/VBox/VMM/VMMR3/DBGFReg.cpp

    r35466 r35468  
    55
    66/*
    7  * Copyright (C) 2010 Oracle Corporation
     7 * Copyright (C) 2010-2011 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette