← Back to branch summary

~ubuntu-branches/ubuntu/trusty/virtualbox/trusty-proposed

« back to all changes in this revision

Viewing changes to src/VBox/Debugger/DBGCEmulateCodeView.cpp

  • Committer: Package Import Robot
  • Author(s): Felix Geyer
  • Date: 2013-03-07 16:38:36 UTC
  • mfrom: (1.1.13) (3.1.20 experimental)
  • Revision ID: package-import@ubuntu.com-20130307163836-p93jpbgx39tp3gb4
Tags: 4.2.8-dfsg-0ubuntu1
http://bugs.debian.org/691148
http://bugs.debian.org/700823
https://launchpad.net/bugs/1101867
http://bugs.debian.org/700479
http://bugs.debian.org/686994
http://bugs.debian.org/680053
* New upstream release. (Closes: #691148)
  - Fixes compatibility with kernel 3.8. (Closes: #700823; LP: #1101867)
* Switch to my @debian.org email address.
* Move package to contrib as virtualbox 4.2 needs a non-free compiler to
  build the BIOS.
* Build-depend on libdevmapper-dev.
* Refresh patches.
  - Drop 36-fix-ftbfs-xserver-112.patch, cve-2012-3221.patch,
    CVE-2013-0420.patch 37-kcompat-3.6.patch and 38-kcompat-3.7.patch.
* Drop all virtualbox-ose transitional packages.
* Drop the virtualbox-fuse package as vdfuse fails to build with
  virtualbox 4.2.
* Update install files and VBox.sh.
* Bump required kbuild version to 0.1.9998svn2577.
* Fix path to VBoxCreateUSBNode.sh in virtualbox.postinst. (Closes: #700479)
* Add an init script to virtuabox-guest-x11 which loads the vboxvideo
  kernel module. The X Server 1.13 doesn't load it anymore. (Closes: #686994)
* Update man pages. (Closes: #680053)
* Add 36-python-multiarch.patch from Rico Tzschichholz to fix detection of
  python in multiarch paths using pkg-config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Debugger/DBGCEmulateCodeView.cpp
4
4
 */
5
5
 
6
6
/*
7
 
 * Copyright (C) 2006-2011 Oracle Corporation
 
7
 * Copyright (C) 2006-2012 Oracle Corporation
8
8
 *
9
9
 * This file is part of VirtualBox Open Source Edition (OSE), as
10
10
 * available from http://www.virtualbox.org. This file is free software;
292
292
    /* pszCmd,      cArgsMin, cArgsMax, paArgDescs,         cArgDescs,                      fFlags,  pfnHandler          pszSyntax,          ....pszDescription */
293
293
    { "ba",         3,        6,        &g_aArgBrkAcc[0],   RT_ELEMENTS(g_aArgBrkAcc),      0,       dbgcCmdBrkAccess,   "<access> <size> <address> [passes [max passes]] [cmds]",
294
294
                                                                                                                                                 "Sets a data access breakpoint." },
295
 
    { "bc",         1,       ~0U,       &g_aArgBrks[0],     RT_ELEMENTS(g_aArgBrks),        0,       dbgcCmdBrkClear,    "all | <bp#> [bp# []]", "Enabled a set of breakpoints." },
 
295
    { "bc",         1,       ~0U,       &g_aArgBrks[0],     RT_ELEMENTS(g_aArgBrks),        0,       dbgcCmdBrkClear,    "all | <bp#> [bp# []]", "Deletes a set of breakpoints." },
296
296
    { "bd",         1,       ~0U,       &g_aArgBrks[0],     RT_ELEMENTS(g_aArgBrks),        0,       dbgcCmdBrkDisable,  "all | <bp#> [bp# []]", "Disables a set of breakpoints." },
297
 
    { "be",         1,       ~0U,       &g_aArgBrks[0],     RT_ELEMENTS(g_aArgBrks),        0,       dbgcCmdBrkEnable,   "all | <bp#> [bp# []]", "Enabled a set of breakpoints." },
 
297
    { "be",         1,       ~0U,       &g_aArgBrks[0],     RT_ELEMENTS(g_aArgBrks),        0,       dbgcCmdBrkEnable,   "all | <bp#> [bp# []]", "Enables a set of breakpoints." },
298
298
    { "bl",         0,        0,        NULL,               0,                              0,       dbgcCmdBrkList,     "",                     "Lists all the breakpoints." },
299
299
    { "bp",         1,        4,        &g_aArgBrkSet[0],   RT_ELEMENTS(g_aArgBrkSet),      0,       dbgcCmdBrkSet,      "<address> [passes [max passes]] [cmds]",
300
300
                                                                                                                                                 "Sets a breakpoint (int 3)." },
367
367
};
368
368
 
369
369
/** The number of commands in the CodeView/WinDbg emulation. */
370
 
const unsigned g_cCmdsCodeView = RT_ELEMENTS(g_aCmdsCodeView);
 
370
const uint32_t g_cCmdsCodeView = RT_ELEMENTS(g_aCmdsCodeView);
 
371
 
371
372
 
372
373
 
373
374
 
706
707
            break;
707
708
    }
708
709
 
709
 
    DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%4#x %c %d %c %RGv %04RX64 (%04RX64 to ",
710
 
                     pBp->iBp, pBp->fEnabled ? 'e' : 'd', cb, chType,
 
710
    DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%#4x %c %d %c %RGv %04RX64 (%04RX64 to ",
 
711
                     pBp->iBp, pBp->fEnabled ? 'e' : 'd', (int)cb, chType,
711
712
                     pBp->GCPtr, pBp->cHits, pBp->iHitTrigger);
712
713
    if (pBp->iHitDisable == ~(uint64_t)0)
713
714
        DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "~0)  ");
714
715
    else
715
 
        DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%04RX64)");
 
716
        DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%04RX64)", pBp->iHitDisable);
716
717
 
717
718
    /*
718
719
     * Try resolve the address.
956
957
            /** @todo Batch query CS, RIP & CPU mode. */
957
958
            PVMCPU pVCpu = VMMGetCpuById(pVM, pDbgc->idCpu);
958
959
            if (    pDbgc->fRegCtxGuest
959
 
                &&  CPUMIsGuestIn64BitCodeEx(CPUMQueryGuestCtxPtr(pVCpu)))
 
960
                &&  CPUMIsGuestIn64BitCode(pVCpu))
960
961
            {
961
962
                pDbgc->DisasmPos.enmType    = DBGCVAR_TYPE_GC_FLAT;
962
963
                pDbgc->SourcePos.u.GCFlat   = CPUMGetGuestRIP(pVCpu);
1426
1427
        PDBGC       pDbgc      = DBGC_CMDHLP2DBGC(pCmdHlp);
1427
1428
        bool const  f64BitMode = !strcmp(pCmd->pszCmd, "rg64")
1428
1429
                              || (   !strcmp(pCmd->pszCmd, "rg32")
1429
 
                                  && CPUMIsGuestIn64BitCodeEx(CPUMQueryGuestCtxPtr(VMMGetCpuById(pVM, pDbgc->idCpu))));
 
1430
                                  && CPUMIsGuestIn64BitCode(VMMGetCpuById(pVM, pDbgc->idCpu)));
1430
1431
        char        szDisAndRegs[8192];
1431
1432
        int         rc;
1432
1433
 
1756
1757
        const char *pszAccessed = pDesc->Gen.u4Type & RT_BIT(0) ? "A " : "NA";
1757
1758
        const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
1758
1759
        const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : "   ";
1759
 
        uint32_t u32Base = X86DESC_BASE(*pDesc);
1760
 
        uint32_t cbLimit = X86DESC_LIMIT(*pDesc);
1761
 
        if (pDesc->Gen.u1Granularity)
1762
 
            cbLimit <<= PAGE_SHIFT;
 
1760
        uint32_t u32Base = X86DESC_BASE(pDesc);
 
1761
        uint32_t cbLimit = X86DESC_LIMIT_G(pDesc);
1763
1762
 
1764
1763
        rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Bas=%08x Lim=%08x DPL=%d %s %s %s %s AVL=%d L=%d%s\n",
1765
1764
                                iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
1813
1812
                const char *pszBig         = pDesc->Gen.u1DefBig ? "BIG" : "   ";
1814
1813
                const char *pszLong        = pDesc->Gen.u1Long ? "LONG" : "   ";
1815
1814
 
1816
 
                uint64_t u32Base = X86DESC64_BASE(*pDesc);
1817
 
                uint32_t cbLimit = X86DESC_LIMIT(*pDesc);
 
1815
                uint64_t u32Base = X86DESC64_BASE(pDesc);
 
1816
                uint32_t cbLimit = X86DESC_LIMIT_G(pDesc);
1818
1817
 
1819
1818
                rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Bas=%016RX64 Lim=%08x DPL=%d %s %s %s %sAVL=%d R=%d%s\n",
1820
1819
                                        iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
3484
3483
    }
3485
3484
 
3486
3485
    /*
3487
 
     * Dump the I/O bitmap if present.
 
3486
     * Dump the I/O permission bitmap if present. The IOPM cannot start below offset 0x64
 
3487
     * (that applies to both 32-bit and 64-bit TSSs since their size is the same).
3488
3488
     */
3489
3489
    if (enmTssType != kTss16)
3490
3490
    {
3491
 
        if (offIoBitmap < cbTss)
 
3491
        if (offIoBitmap < cbTss && offIoBitmap >= 0x64)
3492
3492
        {
3493
3493
            uint32_t        cPorts      = RT_MIN((cbTss - offIoBitmap) * 8, _64K);
3494
3494
            DBGCVAR         VarAddr;
3891
3891
static int dbgcCmdWorkerSearchMem(PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR pAddress, uint64_t cMaxHits, char chType,
3892
3892
                                  PCDBGCVAR paPatArgs, unsigned cPatArgs, PDBGCVAR pResult)
3893
3893
{
3894
 
    DBGCVAR_INIT_GC_FLAT(pResult, 0);
 
3894
    if (pResult)
 
3895
        DBGCVAR_INIT_GC_FLAT(pResult, 0);
3895
3896
 
3896
3897
    /*
3897
3898
     * Convert the search pattern into bytes and DBGFR3MemScan can deal with.
4205
4206
    NOREF(pCmd);
4206
4207
    return VINF_SUCCESS;
4207
4208
}
 
4209
 
 
4210
 
 
4211
 
 
4212
/**
 
4213
 * @callback_method_impl{Reads a unsigned 8-bit value.}
 
4214
 */
 
4215
static DECLCALLBACK(int) dbgcFuncReadU8(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, uint32_t cArgs,
 
4216
                                        PDBGCVAR pResult)
 
4217
{
 
4218
    AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
 
4219
    AssertReturn(DBGCVAR_ISPOINTER(paArgs[0].enmType), VERR_DBGC_PARSE_BUG);
 
4220
    AssertReturn(paArgs[0].enmRangeType == DBGCVAR_RANGE_NONE, VERR_DBGC_PARSE_BUG);
 
4221
 
 
4222
    uint8_t b;
 
4223
    int rc = DBGCCmdHlpMemRead(pCmdHlp, pVM, &b, sizeof(b), &paArgs[0], NULL);
 
4224
    if (RT_FAILURE(rc))
 
4225
        return rc;
 
4226
    DBGCVAR_INIT_NUMBER(pResult, b);
 
4227
 
 
4228
    NOREF(pFunc);
 
4229
    return VINF_SUCCESS;
 
4230
}
 
4231
 
 
4232
 
 
4233
/**
 
4234
 * @callback_method_impl{Reads a unsigned 16-bit value.}
 
4235
 */
 
4236
static DECLCALLBACK(int) dbgcFuncReadU16(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, uint32_t cArgs,
 
4237
                                         PDBGCVAR pResult)
 
4238
{
 
4239
    AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
 
4240
    AssertReturn(DBGCVAR_ISPOINTER(paArgs[0].enmType), VERR_DBGC_PARSE_BUG);
 
4241
    AssertReturn(paArgs[0].enmRangeType == DBGCVAR_RANGE_NONE, VERR_DBGC_PARSE_BUG);
 
4242
 
 
4243
    uint16_t u16;
 
4244
    int rc = DBGCCmdHlpMemRead(pCmdHlp, pVM, &u16, sizeof(u16), &paArgs[0], NULL);
 
4245
    if (RT_FAILURE(rc))
 
4246
        return rc;
 
4247
    DBGCVAR_INIT_NUMBER(pResult, u16);
 
4248
 
 
4249
    NOREF(pFunc);
 
4250
    return VINF_SUCCESS;
 
4251
}
 
4252
 
 
4253
 
 
4254
/**
 
4255
 * @callback_method_impl{Reads a unsigned 32-bit value.}
 
4256
 */
 
4257
static DECLCALLBACK(int) dbgcFuncReadU32(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, uint32_t cArgs,
 
4258
                                         PDBGCVAR pResult)
 
4259
{
 
4260
    AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
 
4261
    AssertReturn(DBGCVAR_ISPOINTER(paArgs[0].enmType), VERR_DBGC_PARSE_BUG);
 
4262
    AssertReturn(paArgs[0].enmRangeType == DBGCVAR_RANGE_NONE, VERR_DBGC_PARSE_BUG);
 
4263
 
 
4264
    uint32_t u32;
 
4265
    int rc = DBGCCmdHlpMemRead(pCmdHlp, pVM, &u32, sizeof(u32), &paArgs[0], NULL);
 
4266
    if (RT_FAILURE(rc))
 
4267
        return rc;
 
4268
    DBGCVAR_INIT_NUMBER(pResult, u32);
 
4269
 
 
4270
    NOREF(pFunc);
 
4271
    return VINF_SUCCESS;
 
4272
}
 
4273
 
 
4274
 
 
4275
/**
 
4276
 * @callback_method_impl{Reads a unsigned 64-bit value.}
 
4277
 */
 
4278
static DECLCALLBACK(int) dbgcFuncReadU64(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, uint32_t cArgs,
 
4279
                                         PDBGCVAR pResult)
 
4280
{
 
4281
    AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
 
4282
    AssertReturn(DBGCVAR_ISPOINTER(paArgs[0].enmType), VERR_DBGC_PARSE_BUG);
 
4283
    AssertReturn(paArgs[0].enmRangeType == DBGCVAR_RANGE_NONE, VERR_DBGC_PARSE_BUG);
 
4284
 
 
4285
    uint64_t u64;
 
4286
    int rc = DBGCCmdHlpMemRead(pCmdHlp, pVM, &u64, sizeof(u64), &paArgs[0], NULL);
 
4287
    if (RT_FAILURE(rc))
 
4288
        return rc;
 
4289
    DBGCVAR_INIT_NUMBER(pResult, u64);
 
4290
 
 
4291
    NOREF(pFunc);
 
4292
    return VINF_SUCCESS;
 
4293
}
 
4294
 
 
4295
 
 
4296
/**
 
4297
 * @callback_method_impl{Reads a unsigned pointer-sized value.}
 
4298
 */
 
4299
static DECLCALLBACK(int) dbgcFuncReadPtr(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, uint32_t cArgs,
 
4300
                                         PDBGCVAR pResult)
 
4301
{
 
4302
    AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
 
4303
    AssertReturn(DBGCVAR_ISPOINTER(paArgs[0].enmType), VERR_DBGC_PARSE_BUG);
 
4304
    AssertReturn(paArgs[0].enmRangeType == DBGCVAR_RANGE_NONE, VERR_DBGC_PARSE_BUG);
 
4305
 
 
4306
    CPUMMODE enmMode = DBGCCmdHlpGetCpuMode(pCmdHlp);
 
4307
    if (enmMode == CPUMMODE_LONG)
 
4308
        return dbgcFuncReadU64(pFunc, pCmdHlp, pVM, paArgs, cArgs, pResult);
 
4309
    return dbgcFuncReadU32(pFunc, pCmdHlp, pVM, paArgs, cArgs, pResult);
 
4310
}
 
4311
 
 
4312
 
 
4313
/**
 
4314
 * @callback_method_impl{The hi(value) function implementation.}
 
4315
 */
 
4316
static DECLCALLBACK(int) dbgcFuncHi(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, uint32_t cArgs,
 
4317
                                    PDBGCVAR pResult)
 
4318
{
 
4319
    AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
 
4320
 
 
4321
    uint16_t uHi;
 
4322
    switch (paArgs[0].enmType)
 
4323
    {
 
4324
        case DBGCVAR_TYPE_GC_FLAT:  uHi = (uint16_t)(paArgs[0].u.GCFlat >> 16); break;
 
4325
        case DBGCVAR_TYPE_GC_FAR:   uHi = (uint16_t)paArgs[0].u.GCFar.sel; break;
 
4326
        case DBGCVAR_TYPE_GC_PHYS:  uHi = (uint16_t)(paArgs[0].u.GCPhys >> 16); break;
 
4327
        case DBGCVAR_TYPE_HC_FLAT:  uHi = (uint16_t)((uintptr_t)paArgs[0].u.pvHCFlat >> 16); break;
 
4328
        case DBGCVAR_TYPE_HC_PHYS:  uHi = (uint16_t)(paArgs[0].u.HCPhys >> 16); break;
 
4329
        case DBGCVAR_TYPE_NUMBER:   uHi = (uint16_t)(paArgs[0].u.u64Number >> 16); break;
 
4330
        default:
 
4331
            AssertFailedReturn(VERR_DBGC_PARSE_BUG);
 
4332
    }
 
4333
    DBGCVAR_INIT_NUMBER(pResult, uHi);
 
4334
    DBGCVAR_SET_RANGE(pResult, paArgs[0].enmRangeType, paArgs[0].u64Range);
 
4335
 
 
4336
    NOREF(pFunc); NOREF(pCmdHlp); NOREF(pVM);
 
4337
    return VINF_SUCCESS;
 
4338
}
 
4339
 
 
4340
 
 
4341
/**
 
4342
 * @callback_method_impl{The low(value) function implementation.}
 
4343
 */
 
4344
static DECLCALLBACK(int) dbgcFuncLow(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, uint32_t cArgs,
 
4345
                                     PDBGCVAR pResult)
 
4346
{
 
4347
    AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
 
4348
 
 
4349
    uint16_t uLow;
 
4350
    switch (paArgs[0].enmType)
 
4351
    {
 
4352
        case DBGCVAR_TYPE_GC_FLAT:  uLow = (uint16_t)paArgs[0].u.GCFlat; break;
 
4353
        case DBGCVAR_TYPE_GC_FAR:   uLow = (uint16_t)paArgs[0].u.GCFar.off; break;
 
4354
        case DBGCVAR_TYPE_GC_PHYS:  uLow = (uint16_t)paArgs[0].u.GCPhys; break;
 
4355
        case DBGCVAR_TYPE_HC_FLAT:  uLow = (uint16_t)(uintptr_t)paArgs[0].u.pvHCFlat; break;
 
4356
        case DBGCVAR_TYPE_HC_PHYS:  uLow = (uint16_t)paArgs[0].u.HCPhys; break;
 
4357
        case DBGCVAR_TYPE_NUMBER:   uLow = (uint16_t)paArgs[0].u.u64Number; break;
 
4358
        default:
 
4359
            AssertFailedReturn(VERR_DBGC_PARSE_BUG);
 
4360
    }
 
4361
    DBGCVAR_INIT_NUMBER(pResult, uLow);
 
4362
    DBGCVAR_SET_RANGE(pResult, paArgs[0].enmRangeType, paArgs[0].u64Range);
 
4363
 
 
4364
    NOREF(pFunc); NOREF(pCmdHlp); NOREF(pVM);
 
4365
    return VINF_SUCCESS;
 
4366
}
 
4367
 
 
4368
 
 
4369
/**
 
4370
 * @callback_method_impl{The low(value) function implementation.}
 
4371
 */
 
4372
static DECLCALLBACK(int) dbgcFuncNot(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, uint32_t cArgs,
 
4373
                                     PDBGCVAR pResult)
 
4374
{
 
4375
    AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
 
4376
    NOREF(pFunc); NOREF(pCmdHlp); NOREF(pVM);
 
4377
    return DBGCCmdHlpEval(pCmdHlp, pResult, "!(%Dv)", &paArgs[0]);
 
4378
}
 
4379
 
 
4380
 
 
4381
/** Generic pointer argument wo/ range. */
 
4382
static const DBGCVARDESC    g_aArgPointerWoRange[] =
 
4383
{
 
4384
    /* cTimesMin,   cTimesMax,  enmCategory,            fFlags,                         pszName,        pszDescription */
 
4385
    {  1,           1,    DBGCVAR_CAT_POINTER_NO_RANGE, 0,                              "value",        "Address or number." },
 
4386
};
 
4387
 
 
4388
/** Generic pointer or number argument. */
 
4389
static const DBGCVARDESC    g_aArgPointerNumber[] =
 
4390
{
 
4391
    /* cTimesMin,   cTimesMax,  enmCategory,            fFlags,                         pszName,        pszDescription */
 
4392
    {  1,           1,      DBGCVAR_CAT_POINTER_NUMBER, 0,                              "value",        "Address or number." },
 
4393
};
 
4394
 
 
4395
 
 
4396
 
 
4397
/** Function descriptors for the CodeView / WinDbg emulation.
 
4398
 * The emulation isn't attempting to be identical, only somewhat similar.
 
4399
 */
 
4400
const DBGCFUNC g_aFuncsCodeView[] =
 
4401
{
 
4402
    { "by",     1, 1,   &g_aArgPointerWoRange[0],   RT_ELEMENTS(g_aArgPointerWoRange),  0, dbgcFuncReadU8,  "address", "Reads a byte at the given address." },
 
4403
    { "dwo",    1, 1,   &g_aArgPointerWoRange[0],   RT_ELEMENTS(g_aArgPointerWoRange),  0, dbgcFuncReadU32, "address", "Reads a 32-bit value at the given address." },
 
4404
    { "hi",     1, 1,   &g_aArgPointerNumber[0],    RT_ELEMENTS(g_aArgPointerNumber),   0, dbgcFuncHi,      "value", "Returns the high 16-bit bits of a value." },
 
4405
    { "low",    1, 1,   &g_aArgPointerNumber[0],    RT_ELEMENTS(g_aArgPointerNumber),   0, dbgcFuncLow,     "value", "Returns the low 16-bit bits of a value." },
 
4406
    { "not",    1, 1,   &g_aArgPointerNumber[0],    RT_ELEMENTS(g_aArgPointerNumber),   0, dbgcFuncNot,     "address", "Boolean NOT." },
 
4407
    { "poi",    1, 1,   &g_aArgPointerWoRange[0],   RT_ELEMENTS(g_aArgPointerWoRange),  0, dbgcFuncReadPtr, "address", "Reads a pointer sized (CS) value at the given address." },
 
4408
    { "qwo",    1, 1,   &g_aArgPointerWoRange[0],   RT_ELEMENTS(g_aArgPointerWoRange),  0, dbgcFuncReadU64, "address", "Reads a 32-bit value at the given address." },
 
4409
    { "wo",     1, 1,   &g_aArgPointerWoRange[0],   RT_ELEMENTS(g_aArgPointerWoRange),  0, dbgcFuncReadU16, "address", "Reads a 16-bit value at the given address." },
 
4410
};
 
4411
 
 
4412
/** The number of functions in the CodeView/WinDbg emulation. */
 
4413
const uint32_t g_cFuncsCodeView = RT_ELEMENTS(g_aFuncsCodeView);
 
4414