VirtualBox

Changeset 93515 in vbox for trunk/src


Ignore:
Timestamp:
Jan 31, 2022 10:17:19 PM (3 years ago)
Author:
vboxsync
Message:

iprt/asm-amd64-x86.h: Split out some non-assembly functions that related more to x86.h than to asm.h, changing the function prefix from ASM to RTX86. bugref:9898

Location:
trunk/src/VBox
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostDrivers/Support/SUPDrv.cpp

    r93387 r93515  
    43014301        uint32_t uMaxLeaf, uVendorEbx, uVendorEcx, uVendorEdx;
    43024302        ASMCpuId(0, &uMaxLeaf, &uVendorEbx, &uVendorEcx, &uVendorEdx);
    4303         if (ASMIsValidStdRange(uMaxLeaf))
     4303        if (RTX86IsValidStdRange(uMaxLeaf))
    43044304        {
    43054305            /* Query the standard CPUID leaf. */
    … …  
    43084308
    43094309            /* Check if the vendor is Intel (or compatible). */
    4310             if (   ASMIsIntelCpuEx(uVendorEbx, uVendorEcx, uVendorEdx)
    4311                 || ASMIsViaCentaurCpuEx(uVendorEbx, uVendorEcx, uVendorEdx)
    4312                 || ASMIsShanghaiCpuEx(uVendorEbx, uVendorEcx, uVendorEdx))
     4310            if (   RTX86IsIntelCpu(uVendorEbx, uVendorEcx, uVendorEdx)
     4311                || RTX86IsViaCentaurCpu(uVendorEbx, uVendorEcx, uVendorEdx)
     4312                || RTX86IsShanghaiCpu(uVendorEbx, uVendorEcx, uVendorEdx))
    43134313            {
    43144314                /* Check VT-x support. In addition, VirtualBox requires MSR and FXSAVE/FXRSTOR to function. */
    … …  
    43244324
    43254325            /* Check if the vendor is AMD (or compatible). */
    4326             if (   ASMIsAmdCpuEx(uVendorEbx, uVendorEcx, uVendorEdx)
    4327                 || ASMIsHygonCpuEx(uVendorEbx, uVendorEcx, uVendorEdx))
     4326            if (   RTX86IsAmdCpu(uVendorEbx, uVendorEcx, uVendorEdx)
     4327                || RTX86IsHygonCpu(uVendorEbx, uVendorEcx, uVendorEdx))
    43284328            {
    43294329                uint32_t fExtFeatEcx, uExtMaxId;
    … …  
    43324332
    43334333                /* Check AMD-V support. In addition, VirtualBox requires MSR and FXSAVE/FXRSTOR to function. */
    4334                 if (   ASMIsValidExtRange(uExtMaxId)
     4334                if (   RTX86IsValidExtRange(uExtMaxId)
    43354335                    && uExtMaxId >= 0x8000000a
    43364336                    && (fExtFeatEcx & X86_CPUID_AMD_FEATURE_ECX_SVM)
    … …  
    44284428        uint32_t uMaxId, uVendorEBX, uVendorECX, uVendorEDX;
    44294429        ASMCpuId(0, &uMaxId, &uVendorEBX, &uVendorECX, &uVendorEDX);
    4430         Assert(ASMIsValidStdRange(uMaxId));
    4431         Assert(   ASMIsIntelCpuEx(     uVendorEBX, uVendorECX, uVendorEDX)
    4432                || ASMIsViaCentaurCpuEx(uVendorEBX, uVendorECX, uVendorEDX)
    4433                || ASMIsShanghaiCpuEx(  uVendorEBX, uVendorECX, uVendorEDX));
     4430        Assert(RTX86IsValidStdRange(uMaxId));
     4431        Assert(   RTX86IsIntelCpu(     uVendorEBX, uVendorECX, uVendorEDX)
     4432               || RTX86IsViaCentaurCpu(uVendorEBX, uVendorECX, uVendorEDX)
     4433               || RTX86IsShanghaiCpu(  uVendorEBX, uVendorECX, uVendorEDX));
    44344434#endif
    44354435        ASMCpuId(1, &uDummy, &uDummy, &fFeaturesECX, &uDummy);
    … …  
    46794679        ASMCpuId(1, &uTFMSEAX, &uDummy, &uDummy, &uDummy);
    46804680
    4681         if (ASMIsValidStdRange(uMaxId))
     4681        if (RTX86IsValidStdRange(uMaxId))
    46824682        {
    46834683            uint64_t    uRevMsr;
    4684             if (ASMIsIntelCpuEx(uVendorEBX, uVendorECX, uVendorEDX))
     4684            if (RTX86IsIntelCpu(uVendorEBX, uVendorECX, uVendorEDX))
    46854685            {
    46864686                /* Architectural MSR available on Pentium Pro and later. */
    4687                 if (ASMGetCpuFamily(uTFMSEAX) >= 6)
     4687                if (RTX86GetCpuFamily(uTFMSEAX) >= 6)
    46884688                {
    46894689                    /* Revision is in the high dword. */
    … …  
    46934693                }
    46944694            }
    4695             else if (   ASMIsAmdCpuEx(uVendorEBX, uVendorECX, uVendorEDX)
    4696                      || ASMIsHygonCpuEx(uVendorEBX, uVendorECX, uVendorEDX))
     4695            else if (   RTX86IsAmdCpu(uVendorEBX, uVendorECX, uVendorEDX)
     4696                     || RTX86IsHygonCpu(uVendorEBX, uVendorECX, uVendorEDX))
    46974697            {
    46984698                /* Not well documented, but at least all AMD64 CPUs support this. */
    4699                 if (ASMGetCpuFamily(uTFMSEAX) >= 15)
     4699                if (RTX86GetCpuFamily(uTFMSEAX) >= 15)
    47004700                {
    47014701                    /* Revision is in the low dword. */

  • trunk/src/VBox/HostDrivers/Support/SUPDrvGip.cpp

    r93115 r93515  
    199199    /* The Intel CPU topology leaf: */
    200200    uint32_t uOther = ASMCpuId_EAX(0);
    201     if (uOther >= UINT32_C(0xb) && ASMIsValidStdRange(uOther))
     201    if (uOther >= UINT32_C(0xb) && RTX86IsValidStdRange(uOther))
    202202    {
    203203        uint32_t uEax = 0;
    … …  
    220220    /* The AMD leaf: */
    221221    uOther = ASMCpuId_EAX(UINT32_C(0x80000000));
    222     if (uOther >= UINT32_C(0x8000001e) && ASMIsValidExtRange(uOther))
     222    if (uOther >= UINT32_C(0x8000001e) && RTX86IsValidExtRange(uOther))
    223223    {
    224224        uOther = ASMGetApicIdExt8000001E();
    … …  
    371371            if (ASMHasCpuId())
    372372            {
    373                 if (   ASMIsValidExtRange(ASMCpuId_EAX(UINT32_C(0x80000000)))
     373                if (   RTX86IsValidExtRange(ASMCpuId_EAX(UINT32_C(0x80000000)))
    374374                    && (ASMCpuId_EDX(UINT32_C(0x80000001)) & X86_CPUID_EXT_FEATURE_EDX_RDTSCP) )
    375375                {
    … …  
    406406    idApic = UINT32_MAX;
    407407    uEax = ASMCpuId_EAX(0);
    408     if (uEax >= UINT32_C(0xb) && ASMIsValidStdRange(uEax))
     408    if (uEax >= UINT32_C(0xb) && RTX86IsValidStdRange(uEax))
    409409    {
    410410#if defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD)
    … …  
    430430
    431431    uEax = ASMCpuId_EAX(UINT32_C(0x80000000));
    432     if (uEax >= UINT32_C(0x8000001e) && ASMIsValidExtRange(uEax))
     432    if (uEax >= UINT32_C(0x8000001e) && RTX86IsValidExtRange(uEax))
    433433    {
    434434#if defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD)
    … …  
    17681768    {
    17691769        uEAX = ASMCpuId_EAX(0x80000000);
    1770         if (ASMIsValidExtRange(uEAX) && uEAX >= 0x80000007)
     1770        if (RTX86IsValidExtRange(uEAX) && uEAX >= 0x80000007)
    17711771        {
    17721772            uEDX = ASMCpuId_EDX(0x80000007);
    … …  
    18141814    /* (2) If it's an AMD CPU with power management, we won't trust its TSC. */
    18151815    ASMCpuId(0, &uEAX, &uEBX, &uECX, &uEDX);
    1816     if (   ASMIsValidStdRange(uEAX)
    1817         && (ASMIsAmdCpuEx(uEBX, uECX, uEDX) || ASMIsHygonCpuEx(uEBX, uECX, uEDX)) )
     1816    if (   RTX86IsValidStdRange(uEAX)
     1817        && (RTX86IsAmdCpu(uEBX, uECX, uEDX) || RTX86IsHygonCpu(uEBX, uECX, uEDX)) )
    18181818    {
    18191819        /* Check for APM support. */
    18201820        uEAX = ASMCpuId_EAX(0x80000000);
    1821         if (ASMIsValidExtRange(uEAX) && uEAX >= 0x80000007)
     1821        if (RTX86IsValidExtRange(uEAX) && uEAX >= 0x80000007)
    18221822        {
    18231823            uEDX = ASMCpuId_EDX(0x80000007);
    … …  
    40334033            && pGip->cOnlineCpus > 2
    40344034            && ASMHasCpuId()
    4035             && ASMIsValidStdRange(ASMCpuId_EAX(0))
     4035            && RTX86IsValidStdRange(ASMCpuId_EAX(0))
    40364036            && (ASMCpuId_EDX(1) & X86_CPUID_FEATURE_EDX_HTT)
    40374037            && (   !ASMIsAmdCpu()
    4038                 || ASMGetCpuFamily(u32Tmp = ASMCpuId_EAX(1)) > 0x15
    4039                 || (   ASMGetCpuFamily(u32Tmp)   == 0x15           /* Piledriver+, not bulldozer (FX-4150 didn't like it). */
    4040                     && ASMGetCpuModelAMD(u32Tmp) >= 0x02) ) )
     4038                || RTX86GetCpuFamily(u32Tmp = ASMCpuId_EAX(1)) > 0x15
     4039                || (   RTX86GetCpuFamily(u32Tmp)   == 0x15           /* Piledriver+, not bulldozer (FX-4150 didn't like it). */
     4040                    && RTX86GetCpuModelAMD(u32Tmp) >= 0x02) ) )
    40414041        || !RTMpIsCpuOnline(idMaster) )
    40424042    {

  • trunk/src/VBox/HostDrivers/Support/darwin/SUPDrv-darwin.cpp

    r93115 r93515  
    20082008    uint32_t uMaxId, uEAX, uEBX, uECX, uEDX;
    20092009    ASMCpuId(0, &uMaxId, &uEBX, &uECX, &uEDX);
    2010     if (   ASMIsValidStdRange(uMaxId)
     2010    if (   RTX86IsValidStdRange(uMaxId)
    20112011        && uMaxId >= 0x00000007)
    20122012    {

  • trunk/src/VBox/HostDrivers/Support/win/SUPLib-win.cpp

    r93239 r93515  
    840840    if (!ASMHasCpuId())
    841841        return false;
    842     if (!ASMIsValidStdRange(ASMCpuId_EAX(0)))
     842    if (!RTX86IsValidStdRange(ASMCpuId_EAX(0)))
    843843        return false;
    844844    if (!(ASMCpuId_ECX(1) & X86_CPUID_FEATURE_ECX_HVP))

  • trunk/src/VBox/Main/src-server/HostImpl.cpp

    r93209 r93515  
    337337        uint32_t uMaxId, uVendorEBX, uVendorECX, uVendorEDX;
    338338        ASMCpuId(0, &uMaxId, &uVendorEBX, &uVendorECX, &uVendorEDX);
    339         if (ASMIsValidStdRange(uMaxId))
     339        if (RTX86IsValidStdRange(uMaxId))
    340340        {
    341341            /* PAE? */
    … …  
    348348            ASMCpuId(0x80000000, &uExtMaxId, &uDummy, &uDummy, &uDummy);
    349349            ASMCpuId(0x80000001, &uDummy, &uDummy, &fExtFeaturesEcx, &fExtFeaturesEdx);
    350             m->fLongModeSupported = ASMIsValidExtRange(uExtMaxId)
     350            m->fLongModeSupported = RTX86IsValidExtRange(uExtMaxId)
    351351                                 && (fExtFeaturesEdx & X86_CPUID_EXT_FEATURE_EDX_LONG_MODE);
    352352
    … …  
    359359
    360360            /* VT-x? */
    361             if (   ASMIsIntelCpuEx(uVendorEBX, uVendorECX, uVendorEDX)
    362                 || ASMIsViaCentaurCpuEx(uVendorEBX, uVendorECX, uVendorEDX)
    363                 || ASMIsShanghaiCpuEx(uVendorEBX, uVendorECX, uVendorEDX))
     361            if (   RTX86IsIntelCpu(uVendorEBX, uVendorECX, uVendorEDX)
     362                || RTX86IsViaCentaurCpu(uVendorEBX, uVendorECX, uVendorEDX)
     363                || RTX86IsShanghaiCpu(uVendorEBX, uVendorECX, uVendorEDX))
    364364            {
    365365                if (    (fFeaturesEcx & X86_CPUID_FEATURE_ECX_VMX)
    … …  
    375375            }
    376376            /* AMD-V */
    377             else if (   ASMIsAmdCpuEx(uVendorEBX, uVendorECX, uVendorEDX)
    378                      || ASMIsHygonCpuEx(uVendorEBX, uVendorECX, uVendorEDX))
     377            else if (   RTX86IsAmdCpu(uVendorEBX, uVendorECX, uVendorEDX)
     378                     || RTX86IsHygonCpu(uVendorEBX, uVendorECX, uVendorEDX))
    379379            {
    380380                if (   (fExtFeaturesEcx & X86_CPUID_AMD_FEATURE_ECX_SVM)
    381381                    && (fFeaturesEdx    & X86_CPUID_FEATURE_EDX_MSR)
    382382                    && (fFeaturesEdx    & X86_CPUID_FEATURE_EDX_FXSR)
    383                     && ASMIsValidExtRange(uExtMaxId)
     383                    && RTX86IsValidExtRange(uExtMaxId)
    384384                   )
    385385                {

  • trunk/src/VBox/Runtime/testcase/tstRTInlineAsm.cpp

    r93115 r93515  
    409409                  "Support:                         0-%u\n",
    410410                  &s.uEBX, &s.uEDX, &s.uECX, s.uEAX);
    411     bool const fIntel = ASMIsIntelCpuEx(s.uEBX, s.uECX, s.uEDX);
     411    bool const fIntel = RTX86IsIntelCpu(s.uEBX, s.uECX, s.uEDX);
    412412
    413413    /*
    … …  
    427427                      "CLFLUSH Size:                    %d\n"
    428428                      "Brand ID:                        %#04x\n",
    429                       (s.uEAX >> 8) & 0xf, (s.uEAX >> 20) & 0x7f, ASMGetCpuFamily(s.uEAX),
    430                       (s.uEAX >> 4) & 0xf, (s.uEAX >> 16) & 0x0f, ASMGetCpuModel(s.uEAX, fIntel),
    431                       ASMGetCpuStepping(s.uEAX),
     429                      (s.uEAX >> 8) & 0xf, (s.uEAX >> 20) & 0x7f, RTX86GetCpuFamily(s.uEAX),
     430                      (s.uEAX >> 4) & 0xf, (s.uEAX >> 16) & 0x0f, RTX86GetCpuModel(s.uEAX, fIntel),
     431                      RTX86GetCpuStepping(s.uEAX),
    432432                      (s.uEAX >> 12) & 0x3, s_apszTypes[(s.uEAX >> 12) & 0x3],
    433433                      (s.uEBX >> 24) & 0xff,
    … …  
    558558                      "Stepping:                        %d\n"
    559559                      "Brand ID:                        %#05x\n",
    560                       (s.uEAX >> 8) & 0xf, (s.uEAX >> 20) & 0x7f, ASMGetCpuFamily(s.uEAX),
    561                       (s.uEAX >> 4) & 0xf, (s.uEAX >> 16) & 0x0f, ASMGetCpuModel(s.uEAX, fIntel),
    562                       ASMGetCpuStepping(s.uEAX),
     560                      (s.uEAX >> 8) & 0xf, (s.uEAX >> 20) & 0x7f, RTX86GetCpuFamily(s.uEAX),
     561                      (s.uEAX >> 4) & 0xf, (s.uEAX >> 16) & 0x0f, RTX86GetCpuModel(s.uEAX, fIntel),
     562                      RTX86GetCpuStepping(s.uEAX),
    563563                      s.uEBX & 0xfff);
    564564
    … …  
    28932893    uint32_t uAux;
    28942894    if (   ASMHasCpuId()
    2895         && ASMIsValidExtRange(ASMCpuId_EAX(0x80000000))
     2895        && RTX86IsValidExtRange(ASMCpuId_EAX(0x80000000))
    28962896        && (ASMCpuId_EDX(0x80000001) & X86_CPUID_EXT_FEATURE_EDX_RDTSCP) )
    28972897    {

  • trunk/src/VBox/VMM/VMMR0/CPUMR0.cpp

    r93115 r93515  
    249249        uint32_t cExt = 0;
    250250        ASMCpuId(0x80000000, &cExt, &u32Dummy, &u32Dummy, &u32Dummy);
    251         if (ASMIsValidExtRange(cExt))
     251        if (RTX86IsValidExtRange(cExt))
    252252        {
    253253            uint32_t fExtFeaturesEDX = ASMCpuId_EDX(0x80000001);
    … …  
    279279        pVM->cpum.s.HostFeatures.fArchMdsNo              = 0;
    280280        uint32_t const cStdRange = ASMCpuId_EAX(0);
    281         if (   ASMIsValidStdRange(cStdRange)
     281        if (   RTX86IsValidStdRange(cStdRange)
    282282            && cStdRange >= 7)
    283283        {
    … …  
    728728    uint32_t uMaxLeaf, u32EBX, u32ECX, u32EDX;
    729729    ASMCpuId(0, &uMaxLeaf, &u32EBX, &u32ECX, &u32EDX);
    730     if (   (   ASMIsIntelCpuEx(u32EBX, u32ECX, u32EDX)
    731             || ASMIsAmdCpuEx(u32EBX, u32ECX, u32EDX)
    732             || ASMIsViaCentaurCpuEx(u32EBX, u32ECX, u32EDX)
    733             || ASMIsShanghaiCpuEx(u32EBX, u32ECX, u32EDX)
    734             || ASMIsHygonCpuEx(u32EBX, u32ECX, u32EDX))
    735         && ASMIsValidStdRange(uMaxLeaf))
     730    if (   (   RTX86IsIntelCpu(u32EBX, u32ECX, u32EDX)
     731            || RTX86IsAmdCpu(u32EBX, u32ECX, u32EDX)
     732            || RTX86IsViaCentaurCpu(u32EBX, u32ECX, u32EDX)
     733            || RTX86IsShanghaiCpu(u32EBX, u32ECX, u32EDX)
     734            || RTX86IsHygonCpu(u32EBX, u32ECX, u32EDX))
     735        && RTX86IsValidStdRange(uMaxLeaf))
    736736    {
    737737        uint32_t uDummy;
    … …  
    750750            ASMCpuId(0x80000000, &uMaxExtLeaf, &u32EBX, &u32ECX, &u32EDX);
    751751            if (   uMaxExtLeaf >= UINT32_C(0x80000008)
    752                 && ASMIsValidExtRange(uMaxExtLeaf))
     752                && RTX86IsValidExtRange(uMaxExtLeaf))
    753753            {
    754754                uint32_t u32PhysBits;

  • trunk/src/VBox/VMM/VMMR0/HMR0.cpp

    r93115 r93515  
    12531253    uint32_t fWorldSwitcher = 0;
    12541254    uint32_t cLastStdLeaf   = ASMCpuId_EAX(0);
    1255     if (cLastStdLeaf >= 0x00000007 && ASMIsValidStdRange(cLastStdLeaf))
     1255    if (cLastStdLeaf >= 0x00000007 && RTX86IsValidStdRange(cLastStdLeaf))
    12561256    {
    12571257        uint32_t uEdx = 0;

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

    r93337 r93515  
    127127#include <VBox/err.h>
    128128#include <VBox/log.h>
    129 #include <iprt/asm-amd64-x86.h>
     129#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
     130# include <iprt/asm-amd64-x86.h>
     131#endif
    130132#include <iprt/assert.h>
    131133#include <iprt/cpuset.h>
    … …  
    972974
    973975
     976#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
    974977/**
    975978 * Checks for partial/leaky FXSAVE/FXRSTOR handling on AMD CPUs.
    … …  
    993996    {
    994997        uint32_t cExt = ASMCpuId_EAX(0x80000000);
    995         if (ASMIsValidExtRange(cExt))
     998        if (RTX86IsValidExtRange(cExt))
    996999        {
    9971000            uint32_t fExtFeaturesEDX = ASMCpuId_EDX(0x80000001);
    … …  
    10081011    }
    10091012}
     1013#endif
    10101014
    10111015
    … …  
    20102014     * Gather info about the host CPU.
    20112015     */
     2016#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
    20122017    if (!ASMHasCpuId())
    20132018    {
    … …  
    20152020        return VERR_UNSUPPORTED_CPU;
    20162021    }
     2022#endif
    20172023
    20182024    pVM->cpum.s.fHostMxCsrMask = CPUMR3DeterminHostMxCsrMask();
    … …  
    20542060    uint64_t fXcr0Host = 0;
    20552061    uint64_t fXStateHostMask = 0;
     2062#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
    20562063    if (   pVM->cpum.s.HostFeatures.fXSaveRstor
    20572064        && pVM->cpum.s.HostFeatures.fOpSysXSaveRstor)
    … …  
    20622069                            ("%#llx\n", fXStateHostMask), fXStateHostMask = 0);
    20632070    }
     2071#endif
    20642072    pVM->cpum.s.fXStateHostMask = fXStateHostMask;
    20652073    LogRel(("CPUM: fXStateHostMask=%#llx; initial: %#llx; host XCR0=%#llx\n",
    … …  
    21172125        return rc;
    21182126
     2127#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
    21192128    /*
    21202129     * Check if we need to workaround partial/leaky FPU handling.
    21212130     */
    21222131    cpumR3CheckLeakyFpu(pVM);
     2132#endif
    21232133
    21242134    /*

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

    r93268 r93515  
    3131
    3232#include <VBox/err.h>
    33 #include <iprt/asm-amd64-x86.h>
     33#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
     34# include <iprt/asm-amd64-x86.h>
     35#endif
    3436#include <iprt/ctype.h>
    3537#include <iprt/mem.h>
    … …  
    690692VMMR3DECL(uint32_t) CPUMR3DeterminHostMxCsrMask(void)
    691693{
     694#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
    692695    if (   ASMHasCpuId()
    693         && ASMIsValidStdRange(ASMCpuId_EAX(0))
     696        && RTX86IsValidStdRange(ASMCpuId_EAX(0))
    694697        && ASMCpuId_EDX(1) & X86_CPUID_FEATURE_EDX_FXSR)
    695698    {
    … …  
    702705        return pState->MXCSR_MASK;
    703706    }
     707#endif
    704708    return 0;
    705709}
    … …  
    10871091
    10881092
     1093#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
    10891094/**
    10901095 * Checks if ECX make a difference when reading a given CPUID leaf.
    … …  
    11771182        if (uSubLeaf >= 128)
    11781183        {
    1179 #ifndef IN_VBOX_CPU_REPORT
     1184# ifndef IN_VBOX_CPU_REPORT
    11801185            /* Ok, limit it according to the documentation if possible just to
    11811186               avoid annoying users with these detection issues. */
    … …  
    11951200                return true;
    11961201            }
    1197 #endif
     1202# endif
    11981203            *pcSubLeaves = UINT32_MAX;
    11991204            return true;
    … …  
    12121217    return true;
    12131218}
     1219#endif /* RT_ARCH_X86 || RT_ARCH_AMD64 */
    12141220
    12151221
    … …  
    12871293}
    12881294
     1295#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
    12891296
    12901297/**
    … …  
    13581365                             || uEbx
    13591366                             || uEdx
    1360                              || ASMIsAmdCpuEx((*ppaLeaves)[0].uEbx, (*ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)
    1361                              || ASMIsHygonCpuEx((*ppaLeaves)[0].uEbx, (*ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)) )
     1367                             || RTX86IsAmdCpu((*ppaLeaves)[0].uEbx, (*ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)
     1368                             || RTX86IsHygonCpu((*ppaLeaves)[0].uEbx, (*ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)) )
    13621369                    fFlags |= CPUMCPUIDLEAF_F_CONTAINS_APIC_ID;
    13631370
    … …  
    13671374                else if (   uLeaf == UINT32_C(0x80000001)
    13681375                         && (   (uEdx & X86_CPUID_AMD_FEATURE_EDX_APIC)
    1369                              || ASMIsAmdCpuEx((*ppaLeaves)[0].uEbx, (*ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)
    1370                              || ASMIsHygonCpuEx((*ppaLeaves)[0].uEbx, (*ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)) )
     1376                             || RTX86IsAmdCpu((*ppaLeaves)[0].uEbx, (*ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)
     1377                             || RTX86IsHygonCpu((*ppaLeaves)[0].uEbx, (*ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)) )
    13711378                    fFlags |= CPUMCPUIDLEAF_F_CONTAINS_APIC;
    13721379
    … …  
    14801487    uint32_t uLastStd = ASMCpuId_EAX(0);
    14811488    uint32_t uLastExt = ASMCpuId_EAX(0x80000000);
    1482     if (!ASMIsValidExtRange(uLastExt))
     1489    if (!RTX86IsValidExtRange(uLastExt))
    14831490        uLastExt = 0x80000000;
    14841491
    … …  
    16241631}
    16251632
     1633#endif /* RT_ARCH_X86 || RT_ARCH_AMD64 */
    16261634
    16271635/**
    … …  
    16491657
    16501658
     1659#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
    16511660/**
    16521661 * Detect the CPU vendor give n the
    … …  
    16601669VMMR3DECL(CPUMCPUVENDOR) CPUMR3CpuIdDetectVendorEx(uint32_t uEAX, uint32_t uEBX, uint32_t uECX, uint32_t uEDX)
    16611670{
    1662     if (ASMIsValidStdRange(uEAX))
    1663     {
    1664         if (ASMIsAmdCpuEx(uEBX, uECX, uEDX))
     1671    if (RTX86IsValidStdRange(uEAX))
     1672    {
     1673        if (RTX86IsAmdCpu(uEBX, uECX, uEDX))
    16651674            return CPUMCPUVENDOR_AMD;
    16661675
    1667         if (ASMIsIntelCpuEx(uEBX, uECX, uEDX))
     1676        if (RTX86IsIntelCpu(uEBX, uECX, uEDX))
    16681677            return CPUMCPUVENDOR_INTEL;
    16691678
    1670         if (ASMIsViaCentaurCpuEx(uEBX, uECX, uEDX))
     1679        if (RTX86IsViaCentaurCpu(uEBX, uECX, uEDX))
    16711680            return CPUMCPUVENDOR_VIA;
    16721681
    1673         if (ASMIsShanghaiCpuEx(uEBX, uECX, uEDX))
     1682        if (RTX86IsShanghaiCpu(uEBX, uECX, uEDX))
    16741683            return CPUMCPUVENDOR_SHANGHAI;
    16751684
    … …  
    16791688            return CPUMCPUVENDOR_CYRIX;
    16801689
    1681         if (ASMIsHygonCpuEx(uEBX, uECX, uEDX))
     1690        if (RTX86IsHygonCpu(uEBX, uECX, uEDX))
    16821691            return CPUMCPUVENDOR_HYGON;
    16831692
    … …  
    16891698    return CPUMCPUVENDOR_UNKNOWN;
    16901699}
     1700#endif /* RT_ARCH_X86 || RT_ARCH_AMD64 */
    16911701
    16921702
    … …  
    18921902                                                            pStd0Leaf->uEcx,
    18931903                                                            pStd0Leaf->uEdx);
    1894         pFeatures->uFamily      = ASMGetCpuFamily(pStd1Leaf->uEax);
    1895         pFeatures->uModel       = ASMGetCpuModel(pStd1Leaf->uEax, pFeatures->enmCpuVendor == CPUMCPUVENDOR_INTEL);
    1896         pFeatures->uStepping    = ASMGetCpuStepping(pStd1Leaf->uEax);
     1904        pFeatures->uFamily      = RTX86GetCpuFamily(pStd1Leaf->uEax);
     1905        pFeatures->uModel       = RTX86GetCpuModel(pStd1Leaf->uEax, pFeatures->enmCpuVendor == CPUMCPUVENDOR_INTEL);
     1906        pFeatures->uStepping    = RTX86GetCpuStepping(pStd1Leaf->uEax);
    18971907        pFeatures->enmMicroarch = CPUMR3CpuIdDetermineMicroarchEx((CPUMCPUVENDOR)pFeatures->enmCpuVendor,
    18981908                                                                  pFeatures->uFamily,
    … …  
    25952605    {
    25962606        PCPUMCPUIDLEAF pStdFeatureLeaf = cpumR3CpuIdGetExactLeaf(pCpum, 1, 0);
    2597         uint32_t uCurIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(ASMGetCpuStepping(pStdFeatureLeaf->uEax),
    2598                                                                 ASMGetCpuModelIntel(pStdFeatureLeaf->uEax),
    2599                                                                 ASMGetCpuFamily(pStdFeatureLeaf->uEax),
     2607        uint32_t uCurIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(RTX86GetCpuStepping(pStdFeatureLeaf->uEax),
     2608                                                                RTX86GetCpuModelIntel(pStdFeatureLeaf->uEax),
     2609                                                                RTX86GetCpuFamily(pStdFeatureLeaf->uEax),
    26002610                                                                0);
    26012611        uint32_t uMaxIntelFamilyModelStep = pConfig->uMaxIntelFamilyModelStep;
    … …  
    53975407            PCPUMCPUIDLEAF pLeaf = cpumR3CpuIdGetLeaf(*ppaLeaves, *pcLeaves, 0, 0);
    53985408            if (   pLeaf
    5399                 && ASMIsIntelCpuEx(pLeaf->uEbx, pLeaf->uEcx, pLeaf->uEdx))
     5409                && RTX86IsIntelCpu(pLeaf->uEbx, pLeaf->uEcx, pLeaf->uEdx))
    54005410            {
    54015411                CPUMCPUIDLEAF Leaf;
    … …  
    57725782    {
    57735783        /** @todo deal with no 0x80000001 on the host. */
    5774         bool const fHostAmd  = ASMIsAmdCpuEx(aHostRawStd[0].uEbx, aHostRawStd[0].uEcx, aHostRawStd[0].uEdx)
    5775                             || ASMIsHygonCpuEx(aHostRawStd[0].uEbx, aHostRawStd[0].uEcx, aHostRawStd[0].uEdx);
    5776         bool const fGuestAmd = ASMIsAmdCpuEx(aGuestCpuIdExt[0].uEbx, aGuestCpuIdExt[0].uEcx, aGuestCpuIdExt[0].uEdx)
    5777                             || ASMIsHygonCpuEx(aGuestCpuIdExt[0].uEbx, aGuestCpuIdExt[0].uEcx, aGuestCpuIdExt[0].uEdx);
     5784        bool const fHostAmd  = RTX86IsAmdCpu(aHostRawStd[0].uEbx, aHostRawStd[0].uEcx, aHostRawStd[0].uEdx)
     5785                            || RTX86IsHygonCpu(aHostRawStd[0].uEbx, aHostRawStd[0].uEcx, aHostRawStd[0].uEdx);
     5786        bool const fGuestAmd = RTX86IsAmdCpu(aGuestCpuIdExt[0].uEbx, aGuestCpuIdExt[0].uEcx, aGuestCpuIdExt[0].uEdx)
     5787                            || RTX86IsHygonCpu(aGuestCpuIdExt[0].uEbx, aGuestCpuIdExt[0].uEcx, aGuestCpuIdExt[0].uEdx);
    57785788
    57795789        /* CPUID(0x80000001).ecx */
    … …  
    66106620                    "%36s %#04x\n"
    66116621                    ,
    6612                     "Family:",      (uEAX >> 8) & 0xf, (uEAX >> 20) & 0x7f, ASMGetCpuFamily(uEAX),
    6613                     "Model:",       (uEAX >> 4) & 0xf, (uEAX >> 16) & 0x0f, ASMGetCpuModel(uEAX, fIntel),
    6614                     "Stepping:",    ASMGetCpuStepping(uEAX),
     6622                    "Family:",      (uEAX >> 8) & 0xf, (uEAX >> 20) & 0x7f, RTX86GetCpuFamily(uEAX),
     6623                    "Model:",       (uEAX >> 4) & 0xf, (uEAX >> 16) & 0x0f, RTX86GetCpuModel(uEAX, fIntel),
     6624                    "Stepping:",    RTX86GetCpuStepping(uEAX),
    66156625                    "Type:",        (uEAX >> 12) & 3, s_apszTypes[(uEAX >> 12) & 3],
    66166626                    "APIC ID:",     (uEBX >> 24) & 0xff,
    … …  
    68436853    PCCPUMCPUIDLEAF pCurLeaf;
    68446854    PCCPUMCPUIDLEAF pNextLeaf;
    6845     bool const      fIntel = ASMIsIntelCpuEx(pVM->cpum.s.aGuestCpuIdPatmStd[0].uEbx,
    6846                                              pVM->cpum.s.aGuestCpuIdPatmStd[0].uEcx,
    6847                                              pVM->cpum.s.aGuestCpuIdPatmStd[0].uEdx);
     6855    bool const      fIntel = RTX86IsIntelCpu(pVM->cpum.s.aGuestCpuIdPatmStd[0].uEbx,
     6856                                               pVM->cpum.s.aGuestCpuIdPatmStd[0].uEcx,
     6857                                               pVM->cpum.s.aGuestCpuIdPatmStd[0].uEdx);
    68486858
    68496859    /*
    … …  
    69526962
    69536963    ASMCpuIdExSlow(UINT32_C(0x80000000), 0, 0, 0, &Host.uEax, &Host.uEbx, &Host.uEcx, &Host.uEdx);
    6954     cHstMax  = ASMIsValidExtRange(Host.uEax) ? RT_MIN(Host.uEax, UINT32_C(0x80000fff)) : 0;
     6964    cHstMax  = RTX86IsValidExtRange(Host.uEax) ? RT_MIN(Host.uEax, UINT32_C(0x80000fff)) : 0;
    69556965    cGstMax  = (uintptr_t)(pCurLeaf - paLeaves) < cLeaves && pCurLeaf->uLeaf == UINT32_C(0x80000000)
    69566966             ? RT_MIN(pCurLeaf->uEax, UINT32_C(0x80000fff)) : 0;
    … …  
    70177027                            "Stepping:                        %d\n"
    70187028                            "Brand ID:                        %#05x\n",
    7019                             (uEAX >> 8) & 0xf, (uEAX >> 20) & 0x7f, ASMGetCpuFamily(uEAX),
    7020                             (uEAX >> 4) & 0xf, (uEAX >> 16) & 0x0f, ASMGetCpuModel(uEAX, fIntel),
    7021                             ASMGetCpuStepping(uEAX),
     7029                            (uEAX >> 8) & 0xf, (uEAX >> 20) & 0x7f, RTX86GetCpuFamily(uEAX),
     7030                            (uEAX >> 4) & 0xf, (uEAX >> 16) & 0x0f, RTX86GetCpuModel(uEAX, fIntel),
     7031                            RTX86GetCpuStepping(uEAX),
    70227032                            pCurLeaf->uEbx & 0xfff);
    70237033

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

    r93115 r93515  
    897897                                                                     pInfo->paCpuIdLeavesR3[0].uEdx);
    898898        uint32_t      const uStd1Eax     = pInfo->paCpuIdLeavesR3[1].uEax;
    899         uint8_t       const uFamily      = ASMGetCpuFamily(uStd1Eax);
    900         uint8_t       const uModel       = ASMGetCpuModel(uStd1Eax, enmVendor == CPUMCPUVENDOR_INTEL);
    901         uint8_t       const uStepping    = ASMGetCpuStepping(uStd1Eax);
     899        uint8_t       const uFamily      = RTX86GetCpuFamily(uStd1Eax);
     900        uint8_t       const uModel       = RTX86GetCpuModel(uStd1Eax, enmVendor == CPUMCPUVENDOR_INTEL);
     901        uint8_t       const uStepping    = RTX86GetCpuStepping(uStd1Eax);
    902902        CPUMMICROARCH const enmMicroarch = CPUMR3CpuIdDetermineMicroarchEx(enmVendor, uFamily, uModel, uStepping);
    903903

  • trunk/src/VBox/VMM/VMMR3/NEMR3Native-win.cpp

    r93355 r93515  
    467467    if (!ASMHasCpuId())
    468468        return RTErrInfoSet(pErrInfo, VERR_NEM_NOT_AVAILABLE, "No CPUID support");
    469     if (!ASMIsValidStdRange(ASMCpuId_EAX(0)))
     469    if (!RTX86IsValidStdRange(ASMCpuId_EAX(0)))
    470470        return RTErrInfoSet(pErrInfo, VERR_NEM_NOT_AVAILABLE, "No CPUID leaf #1");
    471471    if (!(ASMCpuId_ECX(1) & X86_CPUID_FEATURE_ECX_HVP))
    … …  
    477477    uint32_t uEdx = 0;
    478478    ASMCpuIdExSlow(0x40000000, 0, 0, 0, &cMaxHyperLeaf, &uEbx, &uEcx, &uEdx);
    479     if (!ASMIsValidHypervisorRange(cMaxHyperLeaf))
     479    if (!RTX86IsValidHypervisorRange(cMaxHyperLeaf))
    480480        return RTErrInfoSetF(pErrInfo, VERR_NEM_NOT_AVAILABLE, "Invalid hypervisor CPUID range (%#x %#x %#x %#x)",
    481481                             cMaxHyperLeaf, uEbx, uEcx, uEdx);

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

    r93308 r93515  
    887887         */
    888888        ASMCpuId(0x80000000, &uEAX, &uEBX, &uECX, &uEDX);
    889         if (uEAX >= 0x80000007 && ASMIsValidExtRange(uEAX))
     889        if (uEAX >= 0x80000007 && RTX86IsValidExtRange(uEAX))
    890890        {
    891891            ASMCpuId(0x80000007, &uEAX, &uEBX, &uECX, &uEDX);
    … …  
    927927             * as the AMD test above.
    928928             */
    929             /** @todo use ASMGetCpuFamily() and ASMGetCpuModel() here. */
     929            /** @todo use RTX86GetCpuFamily() and RTX86GetCpuModel() here. */
    930930            ASMCpuId(1, &uEAX, &uEBX, &uECX, &uEDX);
    931931            unsigned uModel  = (uEAX >> 4) & 0x0f;
    … …  
    947947             * Eden X2 and QuadCore.
    948948             */
    949             /** @todo use ASMGetCpuFamily() and ASMGetCpuModel() here. */
     949            /** @todo use RTX86GetCpuFamily() and RTX86GetCpuModel() here. */
    950950            ASMCpuId(1, &uEAX, &uEBX, &uECX, &uEDX);
    951951            unsigned uStepping = (uEAX & 0x0f);
    … …  
    963963             * Shanghai - Check the model, family and stepping.
    964964             */
    965             /** @todo use ASMGetCpuFamily() and ASMGetCpuModel() here. */
     965            /** @todo use RTX86GetCpuFamily() and RTX86GetCpuModel() here. */
    966966            ASMCpuId(1, &uEAX, &uEBX, &uECX, &uEDX);
    967967            unsigned uFamily   = (uEAX >> 8) & 0x0f;

  • trunk/src/VBox/VMM/tools/VBoxCpuReport.cpp

    r93115 r93515  
    176176    {
    177177        uint32_t cMaxExt = ASMCpuId_EAX(0x80000000);
    178         if (ASMIsValidExtRange(cMaxExt)&& cMaxExt >= 0x80000008)
     178        if (RTX86IsValidExtRange(cMaxExt)&& cMaxExt >= 0x80000008)
    179179            cMaxWidth = ASMCpuId_EAX(0x80000008) & 0xff;
    180         else if (   ASMIsValidStdRange(ASMCpuId_EAX(0))
     180        else if (   RTX86IsValidStdRange(ASMCpuId_EAX(0))
    181181                 && (ASMCpuId_EDX(1) & X86_CPUID_FEATURE_EDX_PSE36))
    182182            cMaxWidth = 36;
    … …  
    191191{
    192192    return ASMHasCpuId()
    193         && ASMIsValidStdRange(ASMCpuId_EAX(0))
     193        && RTX86IsValidStdRange(ASMCpuId_EAX(0))
    194194        && (ASMCpuId_EDX(1) & X86_CPUID_FEATURE_EDX_PAE);
    195195}
    … …  
    199199{
    200200    return ASMHasCpuId()
    201         && ASMIsValidExtRange(ASMCpuId_EAX(0x80000000))
     201        && RTX86IsValidExtRange(ASMCpuId_EAX(0x80000000))
    202202        && (ASMCpuId_EDX(0x80000001) & X86_CPUID_EXT_FEATURE_EDX_LONG_MODE);
    203203}
    … …  
    207207{
    208208    return ASMHasCpuId()
    209         && ASMIsValidExtRange(ASMCpuId_EAX(0x80000000))
     209        && RTX86IsValidExtRange(ASMCpuId_EAX(0x80000000))
    210210        && (ASMCpuId_EDX(0x80000001) & X86_CPUID_EXT_FEATURE_EDX_NX);
    211211}
    … …  
    215215{
    216216    return ASMHasCpuId()
    217         && ASMIsValidStdRange(ASMCpuId_EAX(0))
     217        && RTX86IsValidStdRange(ASMCpuId_EAX(0))
    218218        && (ASMCpuId_ECX(1) & X86_CPUID_FEATURE_ECX_X2APIC);
    219219}
    … …  
    44124412     * Are MSRs supported by the CPU?
    44134413     */
    4414     if (   !ASMIsValidStdRange(ASMCpuId_EAX(0))
     4414    if (   !RTX86IsValidStdRange(ASMCpuId_EAX(0))
    44154415        || !(ASMCpuId_EDX(1) & X86_CPUID_FEATURE_EDX_MSR) )
    44164416    {
    … …  
    44584458    uint32_t uEax, uEbx, uEcx, uEdx;
    44594459    ASMCpuIdExSlow(0, 0, 0, 0, &uEax, &uEbx, &uEcx, &uEdx);
    4460     if (!ASMIsValidStdRange(uEax))
     4460    if (!RTX86IsValidStdRange(uEax))
    44614461        return RTMsgErrorRc(VERR_NOT_SUPPORTED, "Invalid std CPUID range: %#x\n", uEax);
    44624462    g_enmVendor = CPUMR3CpuIdDetectVendorEx(uEax, uEbx, uEcx, uEdx);
    … …  
    44644464    ASMCpuIdExSlow(1, 0, 0, 0, &uEax, &uEbx, &uEcx, &uEdx);
    44654465    g_enmMicroarch = CPUMR3CpuIdDetermineMicroarchEx(g_enmVendor,
    4466                                                      ASMGetCpuFamily(uEax),
    4467                                                      ASMGetCpuModel(uEax, g_enmVendor == CPUMCPUVENDOR_INTEL),
    4468                                                      ASMGetCpuStepping(uEax));
     4466                                                     RTX86GetCpuFamily(uEax),
     4467                                                     RTX86GetCpuModel(uEax, g_enmVendor == CPUMCPUVENDOR_INTEL),
     4468                                                     RTX86GetCpuStepping(uEax));
    44694469    g_fIntelNetBurst = CPUMMICROARCH_IS_INTEL_NETBURST(g_enmMicroarch);
    44704470
    … …  
    46374637    uint32_t uEax, uEbx, uEcx, uEdx;
    46384638    ASMCpuIdExSlow(0, 0, 0, 0, &uEax, &uEbx, &uEcx, &uEdx);
    4639     if (!ASMIsValidStdRange(uEax))
     4639    if (!RTX86IsValidStdRange(uEax))
    46404640        return RTMsgErrorRc(VERR_NOT_SUPPORTED, "Invalid std CPUID range: %#x\n", uEax);
    46414641
    … …  
    46504650    ASMCpuIdExSlow(1, 0, 0, 0, &uEax, &uEbx, &uEcx, &uEdx);
    46514651    CPUMMICROARCH enmMicroarch = CPUMR3CpuIdDetermineMicroarchEx(enmVendor,
    4652                                                                  ASMGetCpuFamily(uEax),
    4653                                                                  ASMGetCpuModel(uEax, enmVendor == CPUMCPUVENDOR_INTEL),
    4654                                                                  ASMGetCpuStepping(uEax));
     4652                                                                 RTX86GetCpuFamily(uEax),
     4653                                                                 RTX86GetCpuModel(uEax, enmVendor == CPUMCPUVENDOR_INTEL),
     4654                                                                 RTX86GetCpuStepping(uEax));
    46554655
    46564656    /*
    … …  
    46644664
    46654665    ASMCpuIdExSlow(0x80000000, 0, 0, 0, &uEax, &uEbx, &uEcx, &uEdx);
    4666     if (ASMIsValidExtRange(uEax) && uEax >= UINT32_C(0x80000004))
     4666    if (RTX86IsValidExtRange(uEax) && uEax >= UINT32_C(0x80000004))
    46674667    {
    46684668        /* Get the raw name and strip leading spaces. */
    … …  
    47374737    {
    47384738        ASMCpuIdExSlow(1, 0, 0, 0, &uEax, &uEbx, &uEcx, &uEdx);
    4739         RTStrPrintf(szNameC, sizeof(szNameC), "%s_%u_%u_%u", cpuVendorToString(enmVendor), ASMGetCpuFamily(uEax),
    4740                     ASMGetCpuModel(uEax, enmVendor == CPUMCPUVENDOR_INTEL), ASMGetCpuStepping(uEax));
     4739        RTStrPrintf(szNameC, sizeof(szNameC), "%s_%u_%u_%u", cpuVendorToString(enmVendor), RTX86GetCpuFamily(uEax),
     4740                    RTX86GetCpuModel(uEax, enmVendor == CPUMCPUVENDOR_INTEL), RTX86GetCpuStepping(uEax));
    47414741        pszCpuDesc = pszName = szNameC;
    47424742        vbCpuRepDebug("Name/NameC: %s\n", szNameC);
    … …  
    48434843                   pszCpuDesc,
    48444844                   CPUMR3CpuVendorName(enmVendor),
    4845                    ASMGetCpuFamily(uEax),
    4846                    ASMGetCpuModel(uEax, enmVendor == CPUMCPUVENDOR_INTEL),
    4847                    ASMGetCpuStepping(uEax),
     4845                   RTX86GetCpuFamily(uEax),
     4846                   RTX86GetCpuModel(uEax, enmVendor == CPUMCPUVENDOR_INTEL),
     4847                   RTX86GetCpuStepping(uEax),
    48484848                   CPUMR3MicroarchName(enmMicroarch),
    48494849                   vbCpuRepGuessScalableBusFrequencyName(),

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-cmn-GetCpuVendor.c

    r93115 r93515  
    3737        uint32_t uEbx, uEcx, uEdx;
    3838        ASMCpuIdExSlow(0, 0, 0, 0, NULL, &uEbx, &uEcx, &uEdx);
    39         if (ASMIsIntelCpuEx(uEbx, uEcx, uEdx))
     39        if (RTX86IsIntelCpu(uEbx, uEcx, uEdx))
    4040            return BS3CPUVENDOR_INTEL;
    41         if (ASMIsAmdCpuEx(uEbx, uEcx, uEdx))
     41        if (RTX86IsAmdCpu(uEbx, uEcx, uEdx))
    4242            return BS3CPUVENDOR_AMD;
    43         if (ASMIsViaCentaurCpuEx(uEbx, uEcx, uEdx))
     43        if (RTX86IsViaCentaurCpu(uEbx, uEcx, uEdx))
    4444            return BS3CPUVENDOR_VIA;
    45         if (ASMIsShanghaiCpuEx(uEbx, uEcx, uEdx))
     45        if (RTX86IsShanghaiCpu(uEbx, uEcx, uEdx))
    4646            return BS3CPUVENDOR_SHANGHAI;
    47         if (ASMIsHygonCpuEx(uEbx, uEcx, uEdx))
     47        if (RTX86IsHygonCpu(uEbx, uEcx, uEdx))
    4848            return BS3CPUVENDOR_HYGON;
    4949        return BS3CPUVENDOR_UNKNOWN;

  • trunk/src/VBox/ValidationKit/testboxscript/TestBoxHelper.cpp

    r93302 r93515  
    467467    /* VT-x */
    468468    ASMCpuId(0x00000000, &uEax, &uEbx, &uEcx, &uEdx);
    469     if (ASMIsValidStdRange(uEax))
     469    if (RTX86IsValidStdRange(uEax))
    470470    {
    471471        ASMCpuId(0x00000001, &uEax, &uEbx, &uEcx, &uEdx);
    … …  
    476476    /* AMD-V */
    477477    ASMCpuId(0x80000000, &uEax, &uEbx, &uEcx, &uEdx);
    478     if (ASMIsValidExtRange(uEax))
     478    if (RTX86IsValidExtRange(uEax))
    479479    {
    480480        ASMCpuId(0x80000001, &uEax, &uEbx, &uEcx, &uEdx);
    … …  
    509509        uint32_t uEax, uEbx, uEcx, uEdx;
    510510        ASMCpuId(0x80000000, &uEax, &uEbx, &uEcx, &uEdx);
    511         if (ASMIsValidExtRange(uEax) && uEax >= 0x8000000a)
     511        if (RTX86IsValidExtRange(uEax) && uEax >= 0x8000000a)
    512512        {
    513513            ASMCpuId(0x8000000a, &uEax, &uEbx, &uEcx, &uEdx);
    … …  
    617617            uint32_t uEax, uEbx, uEcx, uEdx;
    618618            ASMCpuId(0x00000000, &uEax, &uEbx, &uEcx, &uEdx);
    619             if (ASMIsValidStdRange(uEax))
     619            if (RTX86IsValidStdRange(uEax))
    620620            {
    621621                ASMCpuId(0x00000001, &uEax, &uEbx, &uEcx, &uEdx);
    … …  
    625625                       won't necessarily do so. */
    626626                    ASMCpuId(0x80000000, &uEax, &uEbx, &uEcx, &uEdx);
    627                     if (ASMIsValidExtRange(uEax))
     627                    if (RTX86IsValidExtRange(uEax))
    628628                    {
    629629                        ASMCpuId(0x80000001, &uEax, &uEbx, &uEcx, &uEdx);
    … …  
    652652    uint32_t uEax, uEbx, uEcx, uEdx;
    653653    ASMCpuId(0, &uEax, &uEbx, &uEcx, &uEdx);
    654     if (ASMIsValidStdRange(uEax) && uEax >= 1)
     654    if (RTX86IsValidStdRange(uEax) && uEax >= 1)
    655655    {
    656656        uint32_t uEax1 = ASMCpuId_EAX(1);
    657         uint32_t uVersion = (ASMGetCpuFamily(uEax1) << 24)
    658                           | (ASMGetCpuModel(uEax1, ASMIsIntelCpuEx(uEbx, uEcx, uEdx)) << 8)
    659                           | ASMGetCpuStepping(uEax1);
     657        uint32_t uVersion = (RTX86GetCpuFamily(uEax1) << 24)
     658                          | (RTX86GetCpuModel(uEax1, RTX86IsIntelCpu(uEbx, uEcx, uEdx)) << 8)
     659                          | RTX86GetCpuStepping(uEax1);
    660660        int cch = RTPrintf("%#x\n", uVersion);
    661661        return cch > 0 ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
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