VirtualBox

Changeset 103334 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Feb 13, 2024 1:45:51 PM (12 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
161641
Message:

VMM/IEM: Drop the IEMLIVENESS_OLD_LAYOUT code, as clang output smaller code for the new layout on arm. bugref:10372

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

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/IEMAllN8veLiveness.cpp

    r103318 r103334  
    5151 * BEGIN & END as well as internal workers.
    5252 */
    53 #ifdef IEMLIVENESS_OLD_LAYOUT
    54 # define IEM_MC_BEGIN(a_cArgs, a_cLocals, a_fMcFlags, a_fCImplFlags) \
    55     { \
    56         /* Define local variables that we use to accumulate the liveness state changes in. */ \
    57         IEMLIVENESSPART1 LiveStatePart1  = { 0 }; \
    58         IEMLIVENESSPART2 LiveStatePart2  = { 0 }; \
    59         IEMLIVENESSPART1 LiveMaskPart1   = { 0 }; \
    60         IEMLIVENESSPART2 LiveMaskPart2   = { 0 }; \
    61         bool             fDoneXpctOrCall = false
    62 #else
    63 # define IEM_MC_BEGIN(a_cArgs, a_cLocals, a_fMcFlags, a_fCImplFlags) \
     53#define IEM_MC_BEGIN(a_cArgs, a_cLocals, a_fMcFlags, a_fCImplFlags) \
    6454    { \
    6555        /* Define local variables that we use to accumulate the liveness state changes in. */ \
    … …  
    6858        IEMLIVENESSBIT  LiveMask        = { 0 }; \
    6959        bool            fDoneXpctOrCall = false
    70 #endif
    7160
    7261AssertCompile(IEMLIVENESS_STATE_INPUT == IEMLIVENESS_STATE_MASK);
    73 #ifdef IEMLIVENESS_OLD_LAYOUT
    74 # define IEM_LIVENESS_MARK_XCPT_OR_CALL() do { \
    75             if (!fDoneXpctOrCall) \
    76             { \
    77                 uint64_t uTmp0 = pIncoming->s1.bm64 & ~LiveMaskPart1.bm64; \
    78                 uTmp0 = uTmp0 & (uTmp0 >> 1); \
    79                 LiveStatePart1.bm64 |= uTmp0 | IEMLIVENESSPART1_XCPT_OR_CALL; \
    80                 \
    81                 uint64_t uTmp1 = pIncoming->s2.bm64 & ~LiveMaskPart2.bm64; \
    82                 uTmp1 = uTmp1 & (uTmp1 >> 1); \
    83                 LiveStatePart2.bm64 |= uTmp1 | IEMLIVENESSPART2_XCPT_OR_CALL; \
    84                 \
    85                 LiveMaskPart1.bm64  |= IEMLIVENESSPART1_MASK; /* could also use UINT64_MAX here, but makes no difference */ \
    86                 LiveMaskPart2.bm64  |= IEMLIVENESSPART2_MASK; /* when compiling with gcc and cl.exe on x86 - may on arm, though. */ \
    87                 fDoneXpctOrCall      = true; \
    88             } \
    89         } while (0)
    90 #else
    9162AssertCompile(IEMLIVENESSBIT0_XCPT_OR_CALL == 0 && IEMLIVENESSBIT1_XCPT_OR_CALL != 0);
    92 # define IEM_LIVENESS_MARK_XCPT_OR_CALL() do { \
     63#define IEM_LIVENESS_MARK_XCPT_OR_CALL() do { \
    9364            if (!fDoneXpctOrCall) \
    9465            { \
    … …  
    10071            } \
    10172        } while (0)
    102 #endif
    10373
    10474
    10575AssertCompile(IEMLIVENESS_STATE_CLOBBERED == 0);
    106 #ifdef IEMLIVENESS_OLD_LAYOUT
    107 # define IEM_LIVENESS_ALL_EFLAGS_CLOBBERED() do { \
    108             LiveMaskPart2.bm64  |= IEMLIVENESSPART2_ALL_EFL_MASK; \
    109         } while (0)
    110 AssertCompile(IEMLIVENESSPART1_ALL_EFL_MASK == 0);
    111 # define IEM_LIVENESS_ALL_EFLAGS_INPUT() do { \
    112             LiveMaskPart2.bm64  |= IEMLIVENESSPART2_ALL_EFL_MASK; \
    113             LiveStatePart2.bm64 |= IEMLIVENESSPART2_ALL_EFL_INPUT; \
    114         } while (0)
    115 #else
    116 # define IEM_LIVENESS_ALL_EFLAGS_CLOBBERED() do { \
     76#define IEM_LIVENESS_ALL_EFLAGS_CLOBBERED() do { \
    11777            LiveMask.bm64       |= IEMLIVENESSBIT_ALL_EFL_MASK; \
    11878        } while (0)
    11979AssertCompile(IEMLIVENESS_STATE_INPUT == IEMLIVENESS_STATE_MASK);
    120 # define IEM_LIVENESS_ALL_EFLAGS_INPUT() do { \
     80#define IEM_LIVENESS_ALL_EFLAGS_INPUT() do { \
    12181            LiveStateBit0.bm64  |= IEMLIVENESSBIT_ALL_EFL_MASK; \
    12282            LiveStateBit1.bm64  |= IEMLIVENESSBIT_ALL_EFL_MASK; \
    12383            LiveMask.bm64       |= IEMLIVENESSBIT_ALL_EFL_MASK; \
    12484        } while (0)
    125 #endif
    126 
    127 
    128 #ifdef IEMLIVENESS_OLD_LAYOUT
    129 # define IEM_LIVENESS_ONE_EFLAG_CLOBBERED(a_Name) do { \
    130             LiveMaskPart2.a_Name  |= IEMLIVENESS_STATE_MASK; \
    131         } while (0)
    132 # define IEM_LIVENESS_ONE_EFLAG_INPUT(a_Name) do { \
    133             LiveMaskPart2.a_Name  |= IEMLIVENESS_STATE_MASK; \
    134             LiveStatePart2.a_Name |= IEMLIVENESS_STATE_INPUT; \
    135         } while (0)
    136 #else
    137 # define IEM_LIVENESS_ONE_EFLAG_CLOBBERED(a_Name) do { \
     85
     86
     87#define IEM_LIVENESS_ONE_EFLAG_CLOBBERED(a_Name) do { \
    13888            LiveMask.a_Name       |= 1; \
    13989        } while (0)
    140 # define IEM_LIVENESS_ONE_EFLAG_INPUT(a_Name) do { \
     90#define IEM_LIVENESS_ONE_EFLAG_INPUT(a_Name) do { \
    14191            LiveStateBit0.a_Name  |= 1; \
    14292            LiveStateBit1.a_Name  |= 1; \
    14393            LiveMask.a_Name       |= 1; \
    14494        } while (0)
    145 #endif
    14695
    14796
    14897/* Generic bitmap (bmGpr, bmSegBase, ++) setters. */
    149 #ifdef IEMLIVENESS_OLD_LAYOUT
    150 # define IEM_LIVENESS_BITMAP_MEMBER_CLOBBERED(a_Part, a_bmMember, a_iElement) do { \
    151             LiveMaskPart##a_Part.a_bmMember  |= (uint32_t)IEMLIVENESS_STATE_MASK  << ((a_iElement) * IEMLIVENESS_STATE_BIT_COUNT); \
    152         } while (0)
    153 # define IEM_LIVENESS_BITMAP_MEMBER_INPUT(a_Part, a_bmMember, a_iElement) do { \
    154             LiveMaskPart##a_Part.a_bmMember  |= (uint32_t)IEMLIVENESS_STATE_MASK  << ((a_iElement) * IEMLIVENESS_STATE_BIT_COUNT); \
    155             LiveStatePart##a_Part.a_bmMember |= (uint32_t)IEMLIVENESS_STATE_INPUT << ((a_iElement) * IEMLIVENESS_STATE_BIT_COUNT); \
    156         } while (0)
    157 #else
    158 # define IEM_LIVENESS_BITMAP_MEMBER_CLOBBERED(a_Part, a_bmMember, a_iElement) do { \
     98#define IEM_LIVENESS_BITMAP_MEMBER_CLOBBERED(a_Part, a_bmMember, a_iElement) do { \
    15999            LiveMask.a_bmMember  |= RT_BIT_64(a_iElement); \
    160100        } while (0)
    161 # define IEM_LIVENESS_BITMAP_MEMBER_INPUT(a_Part, a_bmMember, a_iElement) do { \
     101#define IEM_LIVENESS_BITMAP_MEMBER_INPUT(a_Part, a_bmMember, a_iElement) do { \
    162102            LiveStateBit0.a_bmMember  |= RT_BIT_64(a_iElement); \
    163103            LiveStateBit1.a_bmMember  |= RT_BIT_64(a_iElement); \
    164104            LiveMask.a_bmMember       |= RT_BIT_64(a_iElement); \
    165105        } while (0)
    166 #endif
    167106
    168107
    … …  
    216155#define IEM_LIVENESS_PC64_JMP_WITH_FLAGS()  IEM_LIVENESS_MARK_XCPT_OR_CALL(); IEM_LIVENESS_ONE_EFLAG_INPUT(fEflOther)
    217156
    218 #ifdef IEMLIVENESS_OLD_LAYOUT
    219 # define IEM_MC_END() \
    220         /* Combine the incoming state with what we've accumulated in this block. */ \
    221         /* We can help the compiler by skipping OR'ing when having applied XPCT_OR_CALL, */ \
    222         /* since that already imports all the incoming state. Saves a lot with cl.exe. */ \
    223         if (!fDoneXpctOrCall) \
    224         { \
    225             pOutgoing->s1.bm64 = LiveStatePart1.bm64 | (~LiveMaskPart1.bm64 & pIncoming->s1.bm64); \
    226             pOutgoing->s2.bm64 = LiveStatePart2.bm64 | (~LiveMaskPart2.bm64 & pIncoming->s2.bm64); \
    227         } \
    228         else \
    229         { \
    230             pOutgoing->s1.bm64 = LiveStatePart1.bm64; \
    231             pOutgoing->s2.bm64 = LiveStatePart2.bm64; \
    232         } \
    233     }
    234 #else
    235 # define IEM_MC_END() \
     157#define IEM_MC_END() \
    236158        /* Combine the incoming state with what we've accumulated in this block. */ \
    237159        /* We can help the compiler by skipping OR'ing when having applied XPCT_OR_CALL, */ \
    … …  
    248170        } \
    249171    }
    250 #endif
    251172
    252173/*

  • trunk/src/VBox/VMM/VMMAll/IEMAllN8veRecompiler.cpp

    r103318 r103334  
    36223622
    36233623            /* Construct a mask of the guest registers in the UNUSED and XCPT_OR_CALL state. */
    3624 # ifdef IEMLIVENESS_OLD_LAYOUT
    36253624            AssertCompile(IEMLIVENESS_STATE_UNUSED == 1 && IEMLIVENESS_STATE_XCPT_OR_CALL == 2);
    3626             uint64_t fToFreeMask = 0;
    3627             uint64_t fTmp = pLivenessEntry->s1.bm64;
    3628             fTmp ^= fTmp >> 1;
    3629             for (unsigned iReg = 0; i < 32; i++)
    3630                 fToFreeMask = ((fTmp >> (iReg * IEMLIVENESS_STATE_BIT_COUNT)) & 1) << iReg;
    3631 
    3632             IEMLIVENESSPART2 Part2 = pLivenessEntry->s2;
    3633             Part2.fEflOther &= Part2.fEflCf;      /** @todo optimize this */
    3634             Part2.fEflOther &= Part2.fEflPf;
    3635             Part2.fEflOther &= Part2.fEflAf;
    3636             Part2.fEflOther &= Part2.fEflZf;
    3637             Part2.fEflOther &= Part2.fEflSf;
    3638             Part2.fEflOther &= Part2.fEflOf;
    3639             fTmp = pLivenessEntry->s2.bm64;
    3640             fTmp ^= fTmp >> 1;
    3641             for (unsigned iReg = 0; i < IEMLIVENESSPART2_REG_COUNT - 6; i++)
    3642                 fToFreeMask = ((fTmp >> (iReg * IEMLIVENESS_STATE_BIT_COUNT)) & 1) << (iReg + 32);
    3643 # else
    3644             AssertCompile(IEMLIVENESS_STATE_UNUSED == 1 && IEMLIVENESS_STATE_XCPT_OR_CALL == 2);
    3645 #  if 0
     3625# if 0
    36463626            IEMLIVENESSBIT Tmp = { pLivenessEntry->Bit0.bm64 ^ pLivenessEntry->Bit1.bm64 }; /* mask of regs in either UNUSED */
    36473627            Tmp.fEflOther &= Tmp.fEflCf; /** @todo optimize this (pair of 3 (status), pair of 4 (in other), pair of 2, pair of 1). */
    … …  
    36583638            Tmp.fEflOf     = 0;
    36593639            uint64_t fToFreeMask = Tmp.bm64;
    3660 #  else
     3640# else
    36613641            uint64_t fToFreeMask = pLivenessEntry->Bit0.bm64 ^ pLivenessEntry->Bit1.bm64; /* mask of regs in either UNUSED */
    36623642            uint64_t fTmp = fToFreeMask & (fToFreeMask >> 3);   /* AF2,PF2,CF2,Other2 = AF,PF,CF,Other & OF,SF,ZF,AF */
    … …  
    36653645            fToFreeMask &= RT_BIT_64(kIemNativeGstReg_EFlags) - 1;
    36663646            fToFreeMask |= fTmp & RT_BIT_64(kIemNativeGstReg_EFlags);
    3667 #  endif
    36683647# endif
    36693648
    … …  
    40374016iemNativeLivenessGetStateByGstRegEx(PCIEMLIVENESSENTRY pLivenessEntry, unsigned enmGstRegEx)
    40384017{
    4039 #ifdef IEMLIVENESS_OLD_LAYOUT
    4040     if ((unsigned)enmGstRegEx < 32)
    4041         return (pLivenessEntry->s1.bm64 >> (enmGstRegEx * IEMLIVENESS_STATE_BIT_COUNT)) & IEMLIVENESS_STATE_MASK;
    4042     return (pLivenessEntry->s2.bm64 >> ((enmGstRegEx - 32) * IEMLIVENESS_STATE_BIT_COUNT)) & IEMLIVENESS_STATE_MASK;
    4043 #else
    40444018    return ((pLivenessEntry->Bit0.bm64 >> enmGstRegEx) & 1)
    40454019         | (((pLivenessEntry->Bit1.bm64 >> enmGstRegEx) << 1) & 2);
    4046 #endif
    40474020}
    40484021
    … …  
    40514024iemNativeLivenessGetStateByGstReg(PCIEMLIVENESSENTRY pLivenessEntry, IEMNATIVEGSTREG enmGstReg)
    40524025{
    4053 #ifdef IEMLIVENESS_OLD_LAYOUT
    4054     uint32_t uRet;
    4055     if ((unsigned)enmGstReg < 32)
    4056         uRet = (pLivenessEntry->s1.bm64 >> ((unsigned)enmGstReg * IEMLIVENESS_STATE_BIT_COUNT)) & IEMLIVENESS_STATE_MASK;
    4057     else
    4058     {
    4059         uRet = (pLivenessEntry->s2.bm64 >> (((unsigned)enmGstReg - 32) * IEMLIVENESS_STATE_BIT_COUNT)) & IEMLIVENESS_STATE_MASK;
    4060         if (enmGstReg == kIemNativeGstReg_EFlags)
    4061         {
    4062             /* Merge the eflags states to one. */
    4063             uRet  = RT_BIT_32(uRet);
    4064             uRet |= RT_BIT_32(pLivenessEntry->s2.fEflCf);
    4065             uRet |= RT_BIT_32(pLivenessEntry->s2.fEflPf);
    4066             uRet |= RT_BIT_32(pLivenessEntry->s2.fEflAf);
    4067             uRet |= RT_BIT_32(pLivenessEntry->s2.fEflZf);
    4068             uRet |= RT_BIT_32(pLivenessEntry->s2.fEflSf);
    4069             uRet |= RT_BIT_32(pLivenessEntry->s2.fEflOf);
    4070             uRet  = iemNativeLivenessMergeExpandedEFlagsState(uRet);
    4071         }
    4072     }
    4073 #else
    40744026    uint32_t uRet = ((pLivenessEntry->Bit0.bm64 >> (unsigned)enmGstReg) & 1)
    40754027                  | (((pLivenessEntry->Bit1.bm64 >> (unsigned)enmGstReg) << 1) & 2);
    … …  
    40864038        uRet  = iemNativeLivenessMergeExpandedEFlagsState(uRet);
    40874039    }
    4088 #endif
    40894040    return uRet;
    40904041}
    … …  
    98309781    {
    98319782        PVMCPUCC const pVCpu = pReNative->pVCpu;
    9832 # ifdef IEMLIVENESS_OLD_LAYOUT
    9833         IEMLIVENESSPART2 const LivenessInfo2 = pReNative->paLivenessEntries[pReNative->idxCurCall].s2;
    9834 #  define CHECK_FLAG_AND_UPDATE_STATS(a_fEfl, a_fLivenessMember, a_CoreStatName) \
    9835             if (fEflOutput & (a_fEfl)) \
    9836             { \
    9837                 if (LivenessInfo2.a_fLivenessMember != IEMLIVENESS_STATE_CLOBBERED) \
    9838                     STAM_COUNTER_INC(&pVCpu->iem.s. a_CoreStatName ## Required); \
    9839                 else \
    9840                     STAM_COUNTER_INC(&pVCpu->iem.s. a_CoreStatName ## Skippable); \
    9841             } else do { } while (0)
    9842 # else
    98439783        IEMLIVENESSBIT const LivenessBit0 = pReNative->paLivenessEntries[pReNative->idxCurCall].Bit0;
    98449784        IEMLIVENESSBIT const LivenessBit1 = pReNative->paLivenessEntries[pReNative->idxCurCall].Bit1;
    98459785        AssertCompile(IEMLIVENESS_STATE_CLOBBERED == 0);
    9846 #  define CHECK_FLAG_AND_UPDATE_STATS(a_fEfl, a_fLivenessMember, a_CoreStatName) \
     9786# define CHECK_FLAG_AND_UPDATE_STATS(a_fEfl, a_fLivenessMember, a_CoreStatName) \
    98479787            if (fEflOutput & (a_fEfl)) \
    98489788            { \
    … …  
    98529792                    STAM_COUNTER_INC(&pVCpu->iem.s. a_CoreStatName ## Skippable); \
    98539793            } else do { } while (0)
    9854 # endif
    98559794        CHECK_FLAG_AND_UPDATE_STATS(X86_EFL_CF, fEflCf, StatNativeLivenessEflCf);
    98569795        CHECK_FLAG_AND_UPDATE_STATS(X86_EFL_PF, fEflPf, StatNativeLivenessEflPf);
    … …  
    1372013659        /* The initial (final) entry. */
    1372113660        idxCall--;
    13722 # ifdef IEMLIVENESS_OLD_LAYOUT
    13723         paLivenessEntries[idxCall].s1.bm64 = IEMLIVENESSPART1_ALL_UNUSED;
    13724         paLivenessEntries[idxCall].s2.bm64 = IEMLIVENESSPART2_ALL_UNUSED;
    13725 # else
    1372613661        paLivenessEntries[idxCall].Bit0.bm64 = IEMLIVENESSBIT0_ALL_UNUSED;
    1372713662        paLivenessEntries[idxCall].Bit1.bm64 = IEMLIVENESSBIT1_ALL_UNUSED;
    13728 # endif
    1372913663
    1373013664        /* Loop backwards thru the calls and fill in the other entries. */

  • trunk/src/VBox/VMM/include/IEMN8veRecompiler.h

    r103318 r103334  
    381381typedef IEMNATIVEFIXUP *PIEMNATIVEFIXUP;
    382382
    383 //#define IEMLIVENESS_OLD_LAYOUT
    384 #ifdef IEMLIVENESS_OLD_LAYOUT
    385 
    386 typedef union IEMLIVENESSPART1
    387 {
    388     uint64_t        bm64;
    389     RT_GCC_EXTENSION struct
    390     {                                     /*   bit no */
    391         uint64_t    bmGprs      : 32;   /**< 0x00 /  0: The 16 general purpose registers. */
    392         uint64_t    fUnusedPc   : 2;    /**< 0x20 / 32: (PC in ) */
    393         uint64_t    u6Padding   : 6;    /**< 0x22 / 34: */
    394         uint64_t    bmSegBase   : 12;   /**< 0x28 / 40: */
    395         uint64_t    bmSegAttrib : 12;   /**< 0x34 / 52: */
    396     };
    397 } IEMLIVENESSPART1;
    398 AssertCompileSize(IEMLIVENESSPART1, 8);
    399 
    400 typedef union IEMLIVENESSPART2
    401 {
    402     uint64_t        bm64;
    403     RT_GCC_EXTENSION struct
    404     {                                     /*   bit no */
    405         uint64_t    bmSegLimit  : 12;   /**< 0x40 / 64: */
    406         uint64_t    bmSegSel    : 12;   /**< 0x4c / 76: */
    407         uint64_t    fEflOther   : 2;    /**< 0x58 / 88: Other EFLAGS bits   (~X86_EFL_STATUS_BITS & X86_EFL_LIVE_MASK). First! */
    408         uint64_t    fEflCf      : 2;    /**< 0x5a / 90: Carry flag          (X86_EFL_CF / 0). */
    409         uint64_t    fEflPf      : 2;    /**< 0x5c / 92: Parity flag         (X86_EFL_PF / 2). */
    410         uint64_t    fEflAf      : 2;    /**< 0x5e / 94: Auxilary carry flag (X86_EFL_AF / 4). */
    411         uint64_t    fEflZf      : 2;    /**< 0x60 / 96: Zero flag           (X86_EFL_ZF / 6). */
    412         uint64_t    fEflSf      : 2;    /**< 0x62 / 98: Signed flag         (X86_EFL_SF / 7). */
    413         uint64_t    fEflOf      : 2;    /**< 0x64 /100: Overflow flag       (X86_EFL_OF / 12). */
    414         uint64_t    u24Unused   : 26;     /* 0x66 /102 -> 0x80/128 */
    415     };
    416 } IEMLIVENESSPART2;
    417 AssertCompileSize(IEMLIVENESSPART2, 8);
    418 # define IEMLIVENESSPART2_REG_COUNT 19
    419 
    420 #else
    421383
    422384/**
    … …  
    451413AssertCompileSize(IEMLIVENESSBIT, 8);
    452414
    453 #endif
    454415
    455416/**
    … …  
    468429    RT_GCC_EXTENSION struct
    469430    {
    470 #ifdef IEMLIVENESS_OLD_LAYOUT
    471         IEMLIVENESSPART1 s1;
    472         IEMLIVENESSPART2 s2;
    473 #else
    474431        /** Bit \#0 of the register states. */
    475432        IEMLIVENESSBIT Bit0;
    476433        /** Bit \#1 of the register states. */
    477434        IEMLIVENESSBIT Bit1;
    478 #endif
    479435    };
    480436} IEMLIVENESSENTRY;
    … …  
    487443/** @name 64-bit value masks for IEMLIVENESSENTRY.
    488444 * @{ */                                      /*         0xzzzzyyyyxxxxwwww */
    489 #ifdef IEMLIVENESS_OLD_LAYOUT
    490 # define IEMLIVENESSPART1_MASK                  UINT64_C(0xffffff00ffffffff)
    491 # define IEMLIVENESSPART2_MASK                  UINT64_C(0x0000003fffffffff)
    492 #else
    493 # define IEMLIVENESSBIT_MASK                    UINT64_C(0x0007fffffff0ffff)
    494 #endif
    495 
    496 #ifdef IEMLIVENESS_OLD_LAYOUT
    497 # define IEMLIVENESSPART1_XCPT_OR_CALL          UINT64_C(0xaaaaaa00aaaaaaaa)
    498 # define IEMLIVENESSPART2_XCPT_OR_CALL          UINT64_C(0x0000002aaaaaaaaa)
    499 #else
    500 # define IEMLIVENESSBIT0_XCPT_OR_CALL           UINT64_C(0x0000000000000000)
    501 # define IEMLIVENESSBIT1_XCPT_OR_CALL           IEMLIVENESSBIT_MASK
    502 #endif
    503 
    504 #ifdef IEMLIVENESS_OLD_LAYOUT
    505 # define IEMLIVENESSPART1_ALL_UNUSED            UINT64_C(0x5555550055555555)
    506 # define IEMLIVENESSPART2_ALL_UNUSED            UINT64_C(0x0000001555555555)
    507 #else
    508 # define IEMLIVENESSBIT0_ALL_UNUSED             IEMLIVENESSBIT_MASK
    509 # define IEMLIVENESSBIT1_ALL_UNUSED             UINT64_C(0x0000000000000000)
    510 #endif
    511 
    512 #ifdef IEMLIVENESS_OLD_LAYOUT
    513 # define IEMLIVENESSPART1_ALL_EFL_MASK          UINT64_C(0x0000000000000000)
    514 # define IEMLIVENESSPART2_ALL_EFL_MASK          UINT64_C(0x0000003fff000000)
    515 #else
    516 # define IEMLIVENESSBIT_ALL_EFL_MASK            UINT64_C(0x0007f00000000000)
    517 #endif
    518 
    519 #ifdef IEMLIVENESS_OLD_LAYOUT
    520 # define IEMLIVENESSPART1_ALL_EFL_INPUT         IEMLIVENESSPART1_ALL_EFL_MASK
    521 # define IEMLIVENESSPART2_ALL_EFL_INPUT         IEMLIVENESSPART2_ALL_EFL_MASK
    522 #else
    523 # define IEMLIVENESSBIT0_ALL_EFL_INPUT          IEMLIVENESSBIT_ALL_EFL_MASK
    524 # define IEMLIVENESSBIT1_ALL_EFL_INPUT          IEMLIVENESSBIT_ALL_EFL_MASK
    525 #endif
     445#define IEMLIVENESSBIT_MASK                     UINT64_C(0x0007fffffff0ffff)
     446
     447#define IEMLIVENESSBIT0_XCPT_OR_CALL            UINT64_C(0x0000000000000000)
     448#define IEMLIVENESSBIT1_XCPT_OR_CALL            IEMLIVENESSBIT_MASK
     449
     450#define IEMLIVENESSBIT0_ALL_UNUSED              IEMLIVENESSBIT_MASK
     451#define IEMLIVENESSBIT1_ALL_UNUSED              UINT64_C(0x0000000000000000)
     452
     453#define IEMLIVENESSBIT_ALL_EFL_MASK             UINT64_C(0x0007f00000000000)
     454
     455#define IEMLIVENESSBIT0_ALL_EFL_INPUT           IEMLIVENESSBIT_ALL_EFL_MASK
     456#define IEMLIVENESSBIT1_ALL_EFL_INPUT           IEMLIVENESSBIT_ALL_EFL_MASK
    526457/** @} */
    527458
    … …  
    604535/** Initializing the outgoing state with a potential xcpt or call state.
    605536 * This only works when all later changes will be IEMLIVENESS_STATE_INPUT. */
    606 #ifdef IEMLIVENESS_OLD_LAYOUT
    607 # define IEM_LIVENESS_RAW_INIT_WITH_XCPT_OR_CALL(a_pOutgoing, a_pIncoming) \
    608     do { \
    609         uint64_t uTmp1 = (a_pIncoming)->s1.bm64; \
    610         uTmp1 = uTmp1 & (uTmp1 >> 1); \
    611         (a_pOutgoing)->s1.bm64 = uTmp1 | IEMLIVENESSPART1_XCPT_OR_CALL; \
    612         \
    613         uint64_t uTmp2 = (a_pIncoming)->s2.bm64; \
    614         uTmp2 = uTmp2 & (uTmp1 >> 1); \
    615         (a_pOutgoing)->s2.bm64 = uTmp2 | IEMLIVENESSPART2_XCPT_OR_CALL; \
    616     } while (0)
    617 #else
    618 # define IEM_LIVENESS_RAW_INIT_WITH_XCPT_OR_CALL(a_pOutgoing, a_pIncoming) \
     537#define IEM_LIVENESS_RAW_INIT_WITH_XCPT_OR_CALL(a_pOutgoing, a_pIncoming) \
    619538    do { \
    620539        (a_pOutgoing)->Bit0.bm64 = (a_pIncoming)->Bit0.bm64 & (a_pIncoming)->Bit1.bm64; \
    621540        (a_pOutgoing)->Bit1.bm64 = IEMLIVENESSBIT1_XCPT_OR_CALL; \
    622541    } while (0)
    623 #endif
    624542
    625543/** Adds a segment base register as input to the outgoing state. */
    626 #ifdef IEMLIVENESS_OLD_LAYOUT
    627 # define IEM_LIVENESS_RAW_SEG_BASE_INPUT(a_pOutgoing, a_iSReg) \
    628     (a_pOutgoing)->s1.bmSegBase   |= (uint32_t)IEMLIVENESS_STATE_INPUT << ((a_iSReg) * IEMLIVENESS_STATE_BIT_COUNT)
    629 #else
    630 # define IEM_LIVENESS_RAW_SEG_BASE_INPUT(a_pOutgoing, a_iSReg) do { \
     544#define IEM_LIVENESS_RAW_SEG_BASE_INPUT(a_pOutgoing, a_iSReg) do { \
    631545        (a_pOutgoing)->Bit0.bmSegBase   |= RT_BIT_64(a_iSReg); \
    632546        (a_pOutgoing)->Bit1.bmSegBase   |= RT_BIT_64(a_iSReg); \
    633547    } while (0)
    634 #endif
    635548
    636549/** Adds a segment attribute register as input to the outgoing state. */
    637 #ifdef IEMLIVENESS_OLD_LAYOUT
    638 # define IEM_LIVENESS_RAW_SEG_ATTRIB_INPUT(a_pOutgoing, a_iSReg) \
    639     (a_pOutgoing)->s1.bmSegAttrib |= (uint32_t)IEMLIVENESS_STATE_INPUT << ((a_iSReg) * IEMLIVENESS_STATE_BIT_COUNT)
    640 #else
    641 # define IEM_LIVENESS_RAW_SEG_ATTRIB_INPUT(a_pOutgoing, a_iSReg) do { \
     550#define IEM_LIVENESS_RAW_SEG_ATTRIB_INPUT(a_pOutgoing, a_iSReg) do { \
    642551        (a_pOutgoing)->Bit0.bmSegAttrib |= RT_BIT_64(a_iSReg); \
    643552        (a_pOutgoing)->Bit1.bmSegAttrib |= RT_BIT_64(a_iSReg); \
    644553    } while (0)
    645 #endif
    646554
    647555
    648556/** Adds a segment limit register as input to the outgoing state. */
    649 #ifdef IEMLIVENESS_OLD_LAYOUT
    650 # define IEM_LIVENESS_RAW_SEG_LIMIT_INPUT(a_pOutgoing, a_iSReg) \
    651     (a_pOutgoing)->s2.bmSegLimit  |= (uint32_t)IEMLIVENESS_STATE_INPUT << ((a_iSReg) * IEMLIVENESS_STATE_BIT_COUNT)
    652 #else
    653 # define IEM_LIVENESS_RAW_SEG_LIMIT_INPUT(a_pOutgoing, a_iSReg) do { \
     557#define IEM_LIVENESS_RAW_SEG_LIMIT_INPUT(a_pOutgoing, a_iSReg) do { \
    654558        (a_pOutgoing)->Bit0.bmSegLimit  |= RT_BIT_64(a_iSReg); \
    655559        (a_pOutgoing)->Bit1.bmSegLimit  |= RT_BIT_64(a_iSReg); \
    656560    } while (0)
    657 #endif
    658561
    659562/** Adds a segment limit register as input to the outgoing state. */
    660 #ifdef IEMLIVENESS_OLD_LAYOUT
    661 # define IEM_LIVENESS_RAW_EFLAGS_ONE_INPUT(a_pOutgoing, a_fEflMember) \
    662     (a_pOutgoing)->s2.a_fEflMember |= IEMLIVENESS_STATE_INPUT
    663 #else
    664 # define IEM_LIVENESS_RAW_EFLAGS_ONE_INPUT(a_pOutgoing, a_fEflMember) do { \
     563#define IEM_LIVENESS_RAW_EFLAGS_ONE_INPUT(a_pOutgoing, a_fEflMember) do { \
    665564        (a_pOutgoing)->Bit0.a_fEflMember  |= 1; \
    666565        (a_pOutgoing)->Bit1.a_fEflMember  |= 1; \
    667566    } while (0)
    668 #endif
    669567/** @} */
    670568
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