VirtualBox

Changeset 100340 in vbox for trunk/src


Ignore:
Timestamp:
Jul 2, 2023 10:50:12 PM (18 months ago)
Author:
vboxsync
Message:

VMM/IEMAllAImpl.asm: IBT endbr64/32 and notrack related changes. bugref:10406 ticketref:21435

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/IEMAllAImpl.asm

    r99790 r100340  
    8888 %endif
    8989NAME_FASTCALL(%1,%2,@):
     90        IBT_ENDBRxx
    9091%endmacro
    9192
    … …  
    461462 %endif
    462463        mov     [%1], T0_32             ; Save the result.
     464%endmacro
     465
     466
     467;;
     468; Checks that the size expression %1 matches %2 adjusted according to
     469; RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK and for 256 entries.
     470; @param 1  The jump array size assembly expression.
     471; @param 2  The size without accounting for the IBT_ENDBRxx_WITHOUT_NOTRACK instruction.
     472;
     473%macro IEMCHECK_256_JUMP_ARRAY_SIZE 2
     474 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     475        dw      (0xffff - %2 - 256*4) + %1  ; will cause warning if entries are too big.
     476        dw      (0xffff + %2 + 256*4) - %1  ; will cause warning if entries are too small.
     477 %else
     478        dw      (0xffff - %2)         + %1  ; will cause warning if entries are too big.
     479        dw      (0xffff + %2)         - %1  ; will cause warning if entries are too small.
     480 %endif
    463481%endmacro
    464482
    … …  
    39053923        movq    mm1, [A1]
    39063924        movq    mm0, mm0                ; paranoia!
     3925        lea     T1, [.imm0 xWrtRIP]
     3926 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     3927        lea     T0, [A2 + A2*8]         ; sizeof(pshufw+ret) == 9
     3928 %else
    39073929        lea     T0, [A2 + A2*4]         ; sizeof(pshufw+ret) == 5
    3908         lea     T1, [.imm0 xWrtRIP]
     3930 %endif
    39093931        lea     T1, [T1 + T0]
     3932        IBT_NOTRACK
    39103933        call    T1
    39113934        movq    [A0], mm0
    … …  
    39163939%rep 256
    39173940.imm %+ bImm:
    3918        pshufw    mm0, mm1, bImm
    3919        ret
     3941        IBT_ENDBRxx_WITHOUT_NOTRACK
     3942        pshufw  mm0, mm1, bImm
     3943        ret
    39203944 %assign bImm bImm + 1
    39213945%endrep
    3922 .immEnd:                                ; 256*5 == 0x500
    3923 dw 0xfaff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    3924 dw 0x104ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     3946.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x500
    39253947ENDPROC iemAImpl_pshufw_u64
    39263948
    … …  
    39343956        movdqu  xmm0, xmm1              ; paranoia!
    39353957        lea     T1, [.imm0 xWrtRIP]
    3936         lea     T0, [A2 + A2*2]         ; sizeof(pshufXX+ret) == 6: (A3 * 3) *2
     3958 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     3959        lea     T0, [A2 + A2*4]         ; sizeof(pshufXX+ret) == 10: A2 * 10 = (A2 * 5) * 2
     3960 %else
     3961        lea     T0, [A2 + A2*2]         ; sizeof(pshufXX+ret) ==  6: A2 *  6 = (A2 * 3) * 2
     3962 %endif
    39373963        lea     T1, [T1 + T0*2]
     3964        IBT_NOTRACK
    39383965        call    T1
    39393966        movdqu  [A0], xmm0
    … …  
    39413968        IEMIMPL_SSE_EPILOGUE
    39423969        EPILOGUE_3_ARGS
     3970
    39433971 %assign bImm 0
    39443972 %rep 256
    39453973.imm %+ bImm:
    3946        %1       xmm0, xmm1, bImm
    3947        ret
     3974        IBT_ENDBRxx_WITHOUT_NOTRACK
     3975        %1      xmm0, xmm1, bImm
     3976        ret
    39483977  %assign bImm bImm + 1
    39493978 %endrep
    3950 .immEnd:                                ; 256*6 == 0x600
    3951 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    3952 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     3979.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    39533980ENDPROC iemAImpl_ %+ %1 %+ _u128
    39543981%endmacro
    … …  
    39673994        vmovdqu  ymm0, ymm1             ; paranoia!
    39683995        lea     T1, [.imm0 xWrtRIP]
    3969         lea     T0, [A2 + A2*2]         ; sizeof(pshufXX+ret) == 6: (A3 * 3) *2
     3996 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     3997        lea     T0, [A2 + A2*4]         ; sizeof(pshufXX+ret) == 10: A2 * 10 = (A2 * 5) * 2
     3998 %else
     3999        lea     T0, [A2 + A2*2]         ; sizeof(pshufXX+ret) ==  6: A2 *  6 = (A2 * 3) * 2
     4000 %endif
    39704001        lea     T1, [T1 + T0*2]
     4002        IBT_NOTRACK
    39714003        call    T1
    39724004        vmovdqu  [A0], ymm0
    … …  
    39774009 %rep 256
    39784010.imm %+ bImm:
    3979        %1       ymm0, ymm1, bImm
    3980        ret
     4011        IBT_ENDBRxx_WITHOUT_NOTRACK
     4012        %1      ymm0, ymm1, bImm
     4013        ret
    39814014  %assign bImm bImm + 1
    39824015 %endrep
    3983 .immEnd:                                ; 256*6 == 0x600
    3984 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    3985 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     4016.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    39864017ENDPROC iemAImpl_ %+ %1 %+ _u256
    39874018%endmacro
    … …  
    40024033
    40034034        movq    mm0, [A0]
     4035        lea     T1, [.imm0 xWrtRIP]
     4036 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     4037        lea     T0, [A1 + A1*8]         ; sizeof(psXX+ret) == 9
     4038 %else
    40044039        lea     T0, [A1 + A1*4]         ; sizeof(psXX+ret) == 5
    4005         lea     T1, [.imm0 xWrtRIP]
     4040 %endif
    40064041        lea     T1, [T1 + T0]
     4042        IBT_NOTRACK
    40074043        call    T1
    40084044        movq    [A0], mm0
    … …  
    40134049%rep 256
    40144050.imm %+ bImm:
    4015        %1       mm0, bImm
    4016        ret
     4051        IBT_ENDBRxx_WITHOUT_NOTRACK
     4052        %1      mm0, bImm
     4053        ret
    40174054 %assign bImm bImm + 1
    40184055%endrep
    4019 .immEnd:                                ; 256*5 == 0x500
    4020 dw 0xfaff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    4021 dw 0x104ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     4056.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x500
    40224057ENDPROC iemAImpl_ %+ %1 %+ _imm_u64
    40234058%endmacro
    … …  
    40404075        movdqu  xmm0, [A0]
    40414076        lea     T1, [.imm0 xWrtRIP]
    4042         lea     T0, [A1 + A1*2]         ; sizeof(psXX+ret) == 6: (A3 * 3) *2
     4077 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     4078        lea     T0, [A1 + A1*4]         ; sizeof(psXX+ret) == 10: A1 * 10 = (A1 * 5) * 2
     4079 %else
     4080        lea     T0, [A1 + A1*2]         ; sizeof(psXX+ret) ==  6: A1 *  6 = (A1 * 3) * 2
     4081 %endif
    40434082        lea     T1, [T1 + T0*2]
     4083        IBT_NOTRACK
    40444084        call    T1
    40454085        movdqu  [A0], xmm0
    … …  
    40504090 %rep 256
    40514091.imm %+ bImm:
    4052        %1       xmm0, bImm
    4053        ret
     4092        IBT_ENDBRxx_WITHOUT_NOTRACK
     4093        %1      xmm0, bImm
     4094        ret
    40544095  %assign bImm bImm + 1
    40554096 %endrep
    4056 .immEnd:                                ; 256*6 == 0x600
    4057 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    4058 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     4097.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    40594098ENDPROC iemAImpl_ %+ %1 %+ _imm_u128
    40604099%endmacro
    … …  
    48814920        movdqu  xmm1, [A1]
    48824921        lea     T1, [.imm0 xWrtRIP]
    4883         lea     T0, [A2 + A2*2]         ; sizeof(shufpX+ret+int3) == 6: (A2 * 3) *2
     4922 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     4923        lea     T0, [A2 + A2*4]         ; sizeof(shufpX+ret+int3) == 10: A2 * 10 = (A2 * 5) * 2
     4924 %else
     4925        lea     T0, [A2 + A2*2]         ; sizeof(shufpX+ret+int3) ==  6: A2 *  6 = (A2 * 3) * 2
     4926 %endif
    48844927        lea     T1, [T1 + T0*2]
     4928        IBT_NOTRACK
    48854929        call    T1
    48864930        movdqu  [A0], xmm0
    … …  
    48914935 %rep 256
    48924936.imm %+ bImm:
    4893        shufps   xmm0, xmm1, bImm
    4894        ret
    4895        int3
     4937        IBT_ENDBRxx_WITHOUT_NOTRACK
     4938        shufps  xmm0, xmm1, bImm
     4939        ret
     4940        int3
    48964941  %assign bImm bImm + 1
    48974942 %endrep
    4898 .immEnd:                                ; 256*6 == 0x600
    4899 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    4900 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     4943.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    49014944ENDPROC iemAImpl_shufps_u128
    49024945
    … …  
    49164959        movdqu  xmm1, [A1]
    49174960        lea     T1, [.imm0 xWrtRIP]
    4918         lea     T0, [A2 + A2*2]         ; sizeof(shufpX+ret) == 6: (A2 * 3) *2
     4961 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     4962        lea     T0, [A2 + A2*4]         ; sizeof(shufpX+ret) == 10: A2 * 10 = (A2 * 5) * 2
     4963 %else
     4964        lea     T0, [A2 + A2*2]         ; sizeof(shufpX+ret) ==  6: A2 *  6 = (A2 * 3) * 2
     4965 %endif
    49194966        lea     T1, [T1 + T0*2]
     4967        IBT_NOTRACK
    49204968        call    T1
    49214969        movdqu  [A0], xmm0
    … …  
    49264974 %rep 256
    49274975.imm %+ bImm:
    4928        shufpd   xmm0, xmm1, bImm
    4929        ret
     4976        IBT_ENDBRxx_WITHOUT_NOTRACK
     4977        shufpd  xmm0, xmm1, bImm
     4978        ret
    49304979  %assign bImm bImm + 1
    49314980 %endrep
    4932 .immEnd:                                ; 256*6 == 0x600
    4933 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    4934 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     4981.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    49354982ENDPROC iemAImpl_shufpd_u128
    49364983
    … …  
    49545001        movdqu  xmm1, [A2]
    49555002        lea     T1, [.imm0 xWrtRIP]
    4956         lea     T0, [A3 + A3*2]         ; sizeof(vshufpX+ret) == 6: (A3 * 3) *2
     5003 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5004        lea     T0, [A3 + A3*4]         ; sizeof(vshufpX+ret) == 10: A3 * 10 = (A3 * 5) * 2
     5005 %else
     5006        lea     T0, [A3 + A3*2]         ; sizeof(vshufpX+ret) ==  6: A3 *  6 = (A3 * 3) * 2
     5007 %endif
    49575008        lea     T1, [T1 + T0*2]
     5009        IBT_NOTRACK
    49585010        call    T1
    49595011        movdqu  [A0], xmm0
    … …  
    49645016 %rep 256
    49655017.imm %+ bImm:
    4966        %1       xmm0, xmm0, xmm1, bImm
    4967        ret
     5018        IBT_ENDBRxx_WITHOUT_NOTRACK
     5019        %1      xmm0, xmm0, xmm1, bImm
     5020        ret
    49685021  %assign bImm bImm + 1
    49695022 %endrep
    4970 .immEnd:                                ; 256*6 == 0x600
    4971 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    4972 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5023.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    49735024ENDPROC iemAImpl_ %+ %1 %+ _u128
    49745025
    … …  
    49805031        vmovdqu ymm1, [A2]
    49815032        lea     T1, [.imm0 xWrtRIP]
    4982         lea     T0, [A3 + A3*2]         ; sizeof(vshufpX+ret) == 6: (A3 * 3) *2
     5033 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5034        lea     T0, [A3 + A3*4]         ; sizeof(vshufpX+ret) == 10: A3 * 10 = (A3 * 5) * 2
     5035 %else
     5036        lea     T0, [A3 + A3*2]         ; sizeof(vshufpX+ret) ==  6: A3 *  6 = (A3 * 3) * 2
     5037 %endif
    49835038        lea     T1, [T1 + T0*2]
     5039        IBT_NOTRACK
    49845040        call    T1
    49855041        vmovdqu [A0], ymm0
    … …  
    49905046 %rep 256
    49915047.imm %+ bImm:
    4992        %1       ymm0, ymm0, ymm1, bImm
    4993        ret
     5048        IBT_ENDBRxx_WITHOUT_NOTRACK
     5049        %1      ymm0, ymm0, ymm1, bImm
     5050        ret
    49945051  %assign bImm bImm + 1
    49955052 %endrep
    4996 .immEnd:                                ; 256*6 == 0x600
    4997 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    4998 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5053.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    49995054ENDPROC iemAImpl_ %+ %1 %+ _u256
    50005055%endmacro
    … …  
    50915146        movq    mm1, A1
    50925147        lea     T1, [.imm0 xWrtRIP]
    5093         lea     T0, [A2 + A2*2]         ; sizeof(palignr+ret) == 6: (A2 * 3) *2
     5148 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5149        lea     T0, [A2 + A2*4]         ; sizeof(endbrxx+palignr+ret) == 10: A2 * 10 = (A2 * 5) * 2
     5150 %else
     5151        lea     T0, [A2 + A2*2]         ; sizeof(palignr+ret)         ==  6: A2 *  6 = (A2 * 3) * 2
     5152 %endif
    50945153        lea     T1, [T1 + T0*2]
     5154        IBT_NOTRACK
    50955155        call    T1
    50965156        movq    [A0], mm0
    … …  
    51015161 %rep 256
    51025162.imm %+ bImm:
    5103        palignr  mm0, mm1, bImm
    5104        ret
     5163        IBT_ENDBRxx_WITHOUT_NOTRACK
     5164        palignr mm0, mm1, bImm
     5165        ret
    51055166  %assign bImm bImm + 1
    51065167 %endrep
    5107 .immEnd:                                ; 256*6 == 0x600
    5108 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5109 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5168.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    51105169ENDPROC iemAImpl_palignr_u64
    51115170
    … …  
    51305189        movdqu  xmm1, [A1]
    51315190        lea     T1, [.imm0 xWrtRIP]
    5132         lea     T0, [A2 + A2*3]         ; sizeof(insnX+ret) == 8: (A2 * 4) * 2
    5133         lea     T1, [T1 + T0*2]
     5191 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5192        lea     T0, [A2 + A2*2]         ; sizeof(endbrxx+insnX+ret+int3) == 12: A2 * 12 = (A2 * 3) * 4
     5193        lea     T1, [T1 + T0*4]
     5194 %else
     5195        lea     T1, [T1 + A2*8]         ; sizeof(insnX+ret+int3)         ==  8: A2 * 8
     5196 %endif
     5197        IBT_NOTRACK
    51345198        call    T1
    51355199        movdqu  [A0], xmm0
    … …  
    51405204 %rep 256
    51415205.imm %+ bImm:
    5142        %1       xmm0, xmm1, bImm
    5143        ret
    5144        int3
     5206        IBT_ENDBRxx_WITHOUT_NOTRACK
     5207        %1      xmm0, xmm1, bImm
     5208        ret
     5209        int3
    51455210  %assign bImm bImm + 1
    51465211 %endrep
    5147 .immEnd:                                ; 256*8 == 0x800
    5148 dw 0xf7ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5149 dw 0x107ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5212.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x800
    51505213ENDPROC iemAImpl_ %+ %1 %+ _u128
    51515214%endmacro
    … …  
    51815244        movdqu  xmm1, [A2]
    51825245        lea     T1, [.imm0 xWrtRIP]
    5183         lea     T0, [A3 + A3*3]         ; sizeof(insnX+ret) == 8: (A3 * 4) * 2
    5184         lea     T1, [T1 + T0*2]
     5246 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5247        lea     T0, [A3 + A3*2]         ; sizeof(endbrxx+insnX+ret+int3) == 12: A3 * 12 = (A3 * 3) * 4
     5248        lea     T1, [T1 + T0*4]
     5249 %else
     5250        lea     T1, [T1 + A3*8]         ; sizeof(insnX+ret+int3)         ==  8: A3 * 8
     5251 %endif
     5252        IBT_NOTRACK
    51855253        call    T1
    51865254        movdqu  [A0], xmm0
    … …  
    51915259 %rep 256
    51925260.imm %+ bImm:
    5193        %1       xmm0, xmm0, xmm1, bImm
    5194        ret
    5195        int3
     5261        IBT_ENDBRxx_WITHOUT_NOTRACK
     5262        %1      xmm0, xmm0, xmm1, bImm
     5263        ret
     5264        int3
    51965265  %assign bImm bImm + 1
    51975266 %endrep
    5198 .immEnd:                                ; 256*8 == 0x800
    5199 dw 0xf7ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5200 dw 0x107ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5267.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x800
    52015268ENDPROC iemAImpl_ %+ %1 %+ _u128
    52025269
    … …  
    52095276        vmovdqu ymm1, [A2]
    52105277        lea     T1, [.imm0 xWrtRIP]
    5211         lea     T0, [A3 + A3*3]         ; sizeof(insnX+ret) == 8: (A3 * 4) * 2
    5212         lea     T1, [T1 + T0*2]
     5278 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5279        lea     T0, [A3 + A3*2]         ; sizeof(endbrxx+insnX+ret+int3) == 12: A3 * 12 = (A3 * 3) * 4
     5280        lea     T1, [T1 + T0*4]
     5281 %else
     5282        lea     T1, [T1 + A3*8]         ; sizeof(insnX+ret+int3)         ==  8: A3 *  8
     5283 %endif
     5284        IBT_NOTRACK
    52135285        call    T1
    52145286        vmovdqu [A0], ymm0
    … …  
    52195291 %rep 256
    52205292.imm %+ bImm:
    5221        %1       ymm0, ymm0, ymm1, bImm
    5222        ret
    5223        int3
     5293        IBT_ENDBRxx_WITHOUT_NOTRACK
     5294        %1      ymm0, ymm0, ymm1, bImm
     5295        ret
     5296        int3
    52245297  %assign bImm bImm + 1
    52255298 %endrep
    5226 .immEnd:                                ; 256*8 == 0x800
    5227 dw 0xf7ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5228 dw 0x107ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5299.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x800
    52295300ENDPROC iemAImpl_ %+ %1 %+ _u256
    52305301 %endif
    … …  
    52695340        mov     T2, A0                  ; A0 can be ecx/rcx in some calling conventions which gets overwritten later (T2 only available on AMD64)
    52705341        lea     T1, [.imm0 xWrtRIP]
    5271         lea     T0, [A3 + A3*3]         ; sizeof(insnX+ret) == 8: (A3 * 4) * 2
    5272         lea     T1, [T1 + T0*2]
     5342 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5343        lea     T0, [A3 + A3*2]         ; sizeof(endbrxx+insnX+ret) == 12: A3 * 12 = (A3 * 3) * 4
     5344        lea     T1, [T1 + T0*4]
     5345 %else
     5346        lea     T1, [T1 + A3*8]         ; sizeof(insnX+ret)         ==  8: A3 * 8
     5347 %endif
     5348        IBT_NOTRACK
    52735349        call    T1
    52745350
    … …  
    52815357 %rep 256
    52825358.imm %+ bImm:
    5283        pcmpistri xmm0, xmm1, bImm
    5284        ret
    5285        int3
     5359        IBT_ENDBRxx_WITHOUT_NOTRACK
     5360        pcmpistri xmm0, xmm1, bImm
     5361        ret
     5362        int3
    52865363  %assign bImm bImm + 1
    52875364 %endrep
    5288 .immEnd:                                ; 256*8 == 0x800
    5289 dw 0xf7ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5290 dw 0x107ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5365.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x800
    52915366ENDPROC iemAImpl_pcmpistri_u128
    52925367
    … …  
    53075382        mov     T2, A0                  ; A0 can be ecx/rcx in some calling conventions which gets overwritten later (T2 only available on AMD64)
    53085383        lea     T1, [.imm0 xWrtRIP]
    5309         lea     T0, [A3 + A3*3]         ; sizeof(insnX+ret) == 8: (A3 * 4) * 2
    5310         lea     T1, [T1 + T0*2]
    5311         push    xDX                                     ; xDX can be A1 or A2 depending on the calling convention
    5312         mov     xAX,  [A2 + IEMPCMPESTRXSRC.u64Rax]     ; T0 is rax, so only overwrite it after we're done using it
    5313         mov     xDX,  [A2 + IEMPCMPESTRXSRC.u64Rdx]
     5384 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5385        lea     T0, [A3 + A3*2]         ; sizeof(endbrxx+insnX+ret) == 12: A3 * 12 = (A3 * 3) * 4
     5386        lea     T1, [T1 + T0*4]
     5387 %else
     5388        lea     T1, [T1 + A3*8]         ; sizeof(insnX+ret)         == 8: A3 * 8
     5389 %endif
     5390        push    xDX                                 ; xDX can be A1 or A2 depending on the calling convention
     5391        mov     xAX, [A2 + IEMPCMPESTRXSRC.u64Rax]  ; T0 is rax, so only overwrite it after we're done using it
     5392        mov     xDX, [A2 + IEMPCMPESTRXSRC.u64Rdx]
     5393        IBT_NOTRACK
    53145394        call    T1
    53155395
    … …  
    53235403 %rep 256
    53245404.imm %+ bImm:
    5325        db 0x48                          ; Use the REX.W prefix to make pcmpestr{i,m} use full RAX/RDX (would use EAX/EDX only otherwise.)
    5326        pcmpestri xmm0, xmm1, bImm
    5327        ret
     5405        IBT_ENDBRxx_WITHOUT_NOTRACK
     5406        db      0x48                    ; Use the REX.W prefix to make pcmpestr{i,m} use full RAX/RDX (would use EAX/EDX only otherwise.)
     5407        pcmpestri xmm0, xmm1, bImm
     5408        ret
    53285409  %assign bImm bImm + 1
    53295410 %endrep
    5330 .immEnd:                                ; 256*8 == 0x800
    5331 dw 0xf7ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5332 dw 0x107ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5411.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x800
    53335412ENDPROC iemAImpl_pcmpestri_u128
    53345413
    … …  
    53485427        movdqu  xmm2, [A2 + IEMPCMPISTRXSRC.uSrc2]
    53495428        lea     T1, [.imm0 xWrtRIP]
    5350         lea     T0, [A3 + A3*3]         ; sizeof(insnX+ret) == 8: (A3 * 4) * 2
    5351         lea     T1, [T1 + T0*2]
     5429 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5430        lea     T0, [A3 + A3*2]         ; sizeof(endbrxx+pcmpistrm+ret) == 12: A3 * 12 = (A3 * 3) * 4
     5431        lea     T1, [T1 + T0*4]
     5432 %else
     5433        lea     T0, [T1 + A3*8]         ; sizeof(pcmpistrm+ret)         ==  8: A3 * 8
     5434 %endif
     5435        IBT_NOTRACK
    53525436        call    T1
    53535437
    … …  
    53605444 %rep 256
    53615445.imm %+ bImm:
    5362        pcmpistrm xmm1, xmm2, bImm
    5363        ret
    5364        int3
     5446        IBT_ENDBRxx_WITHOUT_NOTRACK
     5447        pcmpistrm xmm1, xmm2, bImm
     5448        ret
     5449        int3
    53655450  %assign bImm bImm + 1
    53665451 %endrep
    5367 .immEnd:                                ; 256*8 == 0x800
    5368 dw 0xf7ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5369 dw 0x107ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5452.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x800
    53705453ENDPROC iemAImpl_pcmpistrm_u128
    53715454
    … …  
    53855468        movdqu  xmm2, [A2 + IEMPCMPESTRXSRC.uSrc2]
    53865469        lea     T1, [.imm0 xWrtRIP]
    5387         lea     T0, [A3 + A3*3]         ; sizeof(insnX+ret) == 8: (A3 * 4) * 2
    5388         lea     T1, [T1 + T0*2]
    5389         push    xDX                                     ; xDX can be A1 or A2 depending on the calling convention
    5390         mov     xAX,  [A2 + IEMPCMPESTRXSRC.u64Rax]     ; T0 is rax, so only overwrite it after we're done using it
    5391         mov     xDX,  [A2 + IEMPCMPESTRXSRC.u64Rdx]
     5470 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5471        lea     T0, [A3 + A3*2]         ; sizeof(endbrxx+insnX+ret) == 12: A3 * 12 = (A3 * 3) * 4
     5472        lea     T1, [T1 + T0*4]
     5473 %else
     5474        lea     T1, [T1 + A3*8]         ; sizeof(insnX+ret)         ==  8: A3 * 8
     5475 %endif
     5476        push    xDX                                 ; xDX can be A1 or A2 depending on the calling convention
     5477        mov     xAX, [A2 + IEMPCMPESTRXSRC.u64Rax]  ; T0 is rax, so only overwrite it after we're done using it
     5478        mov     xDX, [A2 + IEMPCMPESTRXSRC.u64Rdx]
     5479        IBT_NOTRACK
    53925480        call    T1
    53935481
    5394         pop    xDX
     5482        pop     xDX
    53955483        IEM_SAVE_FLAGS A1, X86_EFL_STATUS_BITS, 0
    53965484        movdqu  [A0], xmm0
    … …  
    54015489 %rep 256
    54025490.imm %+ bImm:
    5403        db 0x48                          ; Use the REX.W prefix to make pcmpestr{i,m} use full RAX/RDX (would use EAX/EDX only otherwise.)
    5404        pcmpestrm xmm1, xmm2, bImm
    5405        ret
     5491        IBT_ENDBRxx_WITHOUT_NOTRACK
     5492        db      0x48                    ; Use the REX.W prefix to make pcmpestr{i,m} use full RAX/RDX (would use EAX/EDX only otherwise.)
     5493        pcmpestrm xmm1, xmm2, bImm
     5494        ret
    54065495  %assign bImm bImm + 1
    54075496 %endrep
    5408 .immEnd:                                ; 256*8 == 0x800
    5409 dw 0xf7ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5410 dw 0x107ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5497.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x800
    54115498ENDPROC iemAImpl_pcmpestrm_u128
    54125499
    … …  
    54245511
    54255512        movq    mm0,  [A0]
    5426         lea     T0, [A2 + A2*4]         ; sizeof(pinsrw+ret) == 5
    54275513        lea     T1, [.imm0 xWrtRIP]
     5514 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5515        lea     T0, [A2 + A2*8]         ; sizeof(endbrxx+pinsrw+ret) == 9: A2 * 9
     5516 %else
     5517        lea     T0, [A2 + A2*4]         ; sizeof(pinsrw+ret)         == 5: A2 * 5
     5518 %endif
    54285519        lea     T1, [T1 + T0]
     5520        IBT_NOTRACK
    54295521        call    T1
    54305522        movq    [A0], mm0
    … …  
    54355527 %rep 256
    54365528.imm %+ bImm:
    5437        pinsrw   mm0, A1_32, bImm
    5438        ret
     5529        IBT_ENDBRxx_WITHOUT_NOTRACK
     5530        pinsrw  mm0, A1_32, bImm
     5531        ret
    54395532  %assign bImm bImm + 1
    54405533 %endrep
    5441 .immEnd:                                ; 256*5 == 0x500
    5442 dw 0xfaff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5443 dw 0x104ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5534.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x500
    54445535ENDPROC iemAImpl_pinsrw_u64
    54455536
    … …  
    54505541        movdqu  xmm0, [A0]
    54515542        lea     T1, [.imm0 xWrtRIP]
    5452         lea     T0, [A2 + A2*2]         ; sizeof(pinsrw+ret) == 6: (A2 * 3) *2
     5543 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5544        lea     T0, [A2 + A2*4]         ; sizeof(endbrxx+pinsrw+ret) == 10: A2 * 10 = (A2 * 5) * 2
     5545 %else
     5546        lea     T0, [A2 + A2*2]         ; sizeof(pinsrw+ret)         ==  6: A2 *  6 = (A2 * 3) * 2
     5547 %endif
    54535548        lea     T1, [T1 + T0*2]
     5549        IBT_NOTRACK
    54545550        call    T1
    54555551        movdqu  [A0], xmm0
    … …  
    54605556 %rep 256
    54615557.imm %+ bImm:
    5462        pinsrw   xmm0, A1_32, bImm
    5463        ret
     5558        IBT_ENDBRxx_WITHOUT_NOTRACK
     5559        pinsrw  xmm0, A1_32, bImm
     5560        ret
    54645561  %assign bImm bImm + 1
    54655562 %endrep
    5466 .immEnd:                                ; 256*6 == 0x600
    5467 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5468 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5563.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    54695564ENDPROC iemAImpl_pinsrw_u128
    54705565
    … …  
    54835578        movdqu  xmm0, [A1]
    54845579        lea     T1, [.imm0 xWrtRIP]
    5485         lea     T0, [A3 + A3*2]         ; sizeof(vpinsrw+ret) == 6: (A3 * 3) *2
     5580 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5581        lea     T0, [A3 + A3*4]         ; sizeof(endbrxx+vpinsrw+ret) == 10: A3 * 10 = (A3 * 5) * 2
     5582 %else
     5583        lea     T0, [A3 + A3*2]         ; sizeof(vpinsrw+ret)         ==  6: A3 *  6 = (A3 * 3) * 2
     5584 %endif
    54865585        lea     T1, [T1 + T0*2]
    54875586        mov     A1, A2                  ; A2 requires longer encoding on Windows
     5587        IBT_NOTRACK
    54885588        call    T1
    54895589        movdqu  [A0], xmm0
    … …  
    54945594 %rep 256
    54955595.imm %+ bImm:
    5496        vpinsrw   xmm0, xmm0, A1_32, bImm
    5497        ret
     5596        IBT_ENDBRxx_WITHOUT_NOTRACK
     5597        vpinsrw xmm0, xmm0, A1_32, bImm
     5598        ret
    54985599  %assign bImm bImm + 1
    54995600 %endrep
    5500 .immEnd:                                ; 256*6 == 0x600
    5501 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5502 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5601.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    55035602ENDPROC iemAImpl_vpinsrw_u128
    55045603
    … …  
    55165615
    55175616        movq    mm0,  A1
    5518         lea     T0, [A2 + A2*4]         ; sizeof(pextrw+ret) == 5
    55195617        lea     T1, [.imm0 xWrtRIP]
     5618 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5619        lea     T0, [A2 + A2*8]         ; sizeof(endbrxx+pextrw+ret) == 9: A2 * 9
     5620 %else
     5621        lea     T0, [A2 + A2*4]         ; sizeof(pextrw+ret)         == 5: A2 * 5
     5622 %endif
    55205623        lea     T1, [T1 + T0]
     5624        IBT_NOTRACK
    55215625        call    T1
    55225626        mov     word [A0], T0_16
    … …  
    55275631 %rep 256
    55285632.imm %+ bImm:
    5529        pextrw   T0_32, mm0, bImm
    5530        ret
     5633        IBT_ENDBRxx_WITHOUT_NOTRACK
     5634        pextrw  T0_32, mm0, bImm
     5635        ret
    55315636  %assign bImm bImm + 1
    55325637 %endrep
    5533 .immEnd:                                ; 256*5 == 0x500
    5534 dw 0xfaff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5535 dw 0x104ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5638.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x500
    55365639ENDPROC iemAImpl_pextrw_u64
    55375640
    … …  
    55425645        movdqu  xmm0, [A1]
    55435646        lea     T1, [.imm0 xWrtRIP]
    5544         lea     T0, [A2 + A2*2]         ; sizeof(pextrw+ret) == 6: (A2 * 3) *2
     5647 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5648        lea     T0, [A2 + A2*4]         ; sizeof(endbrxx+pextrw+ret) == 10: A2 * 10 = (A2 * 5) * 2
     5649 %else
     5650        lea     T0, [A2 + A2*2]         ; sizeof(pextrw+ret)         ==  6: A2 *  6 = (A2 * 3) * 2
     5651 %endif
    55455652        lea     T1, [T1 + T0*2]
     5653        IBT_NOTRACK
    55465654        call    T1
    55475655        mov     word [A0], T0_16
    … …  
    55525660 %rep 256
    55535661.imm %+ bImm:
    5554        pextrw   T0_32, xmm0, bImm
    5555        ret
     5662        IBT_ENDBRxx_WITHOUT_NOTRACK
     5663        pextrw  T0_32, xmm0, bImm
     5664        ret
    55565665  %assign bImm bImm + 1
    55575666 %endrep
    5558 .immEnd:                                ; 256*6 == 0x600
    5559 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5560 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5667.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    55615668ENDPROC iemAImpl_pextrw_u128
    55625669
    … …  
    55745681        movdqu  xmm0, [A1]
    55755682        lea     T1, [.imm0 xWrtRIP]
    5576         lea     T0, [A2 + A2*2]         ; sizeof(vpextrw+ret) == 6: (A2 * 3) *2
     5683 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     5684        lea     T0, [A2 + A2*4]         ; sizeof(endbrxx+vpextrw+ret) == 10: A2 * 10 = (A2 * 5) * 2
     5685 %else
     5686        lea     T0, [A2 + A2*2]         ; sizeof(vpextrw+ret)         ==  6: A2 *  6 = (A2 * 3) * 2
     5687 %endif
    55775688        lea     T1, [T1 + T0*2]
     5689        IBT_NOTRACK
    55785690        call    T1
    55795691        mov     word [A0], T0_16
    … …  
    55845696 %rep 256
    55855697.imm %+ bImm:
    5586        vpextrw   T0_32, xmm0, bImm
    5587        ret
     5698        IBT_ENDBRxx_WITHOUT_NOTRACK
     5699        vpextrw T0_32, xmm0, bImm
     5700        ret
    55885701  %assign bImm bImm + 1
    55895702 %endrep
    5590 .immEnd:                                ; 256*6 == 0x600
    5591 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    5592 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     5703.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    55935704ENDPROC iemAImpl_vpextrw_u128
    55945705
    … …  
    61526263        movdqu  xmm0, [A2 + IEMMEDIAF2XMMSRC.uSrc1]
    61536264        movdqu  xmm1, [A2 + IEMMEDIAF2XMMSRC.uSrc2]
    6154         lea     T0, [A3 + A3*4]         ; sizeof(cmpps+ret) == 5
    61556265        lea     T1, [.imm0 xWrtRIP]
     6266 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     6267        lea     T0, [A3 + A3*8]         ; sizeof(endbrxx+cmpps+ret) == 9: A3 * 9
     6268 %else
     6269        lea     T0, [A3 + A3*4]         ; sizeof(cmpps+ret)         == 5: A3 * 5
     6270 %endif
    61566271        lea     T1, [T1 + T0]
     6272        IBT_NOTRACK
    61576273        call    T1
    61586274        movdqu  [A1], xmm0
    … …  
    61646280 %rep 256
    61656281.imm %+ bImm:
    6166        cmpps xmm0, xmm1, bImm
    6167        ret
     6282        IBT_ENDBRxx_WITHOUT_NOTRACK
     6283        cmpps   xmm0, xmm1, bImm
     6284        ret
    61686285  %assign bImm bImm + 1
    61696286 %endrep
    6170 .immEnd:                                ; 256*5 == 0x500
    6171 dw 0xfaff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    6172 dw 0x104ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     6287.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x500
    61736288ENDPROC iemAImpl_cmpps_u128
    61746289
    … …  
    61956310        movdqu  xmm1, [A2 + IEMMEDIAF2XMMSRC.uSrc2]
    61966311        lea     T1, [.imm0 xWrtRIP]
    6197         lea     T0, [A3 + A3*2]         ; sizeof(pshufXX+ret) == 6: (A3 * 3) *2
     6312 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     6313        lea     T0, [A3 + A3*4]         ; sizeof(endbrxx+cmpXX+ret) == 10: A3 * 10 = (A3 * 5) * 2
     6314 %else
     6315        lea     T0, [A3 + A3*2]         ; sizeof(cmpXX+ret)         ==  6: A3 *  6 = (A3 * 3) * 2
     6316 %endif
    61986317        lea     T1, [T1 + T0*2]
     6318        IBT_NOTRACK
    61996319        call    T1
    62006320        movdqu  [A1], xmm0
    … …  
    62066326 %rep 256
    62076327.imm %+ bImm:
    6208        %1       xmm0, xmm1, bImm
    6209        ret
     6328        IBT_ENDBRxx_WITHOUT_NOTRACK
     6329        %1      xmm0, xmm1, bImm
     6330        ret
    62106331  %assign bImm bImm + 1
    62116332 %endrep
    6212 .immEnd:                                ; 256*6 == 0x600
    6213 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    6214 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     6333.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    62156334ENDPROC iemAImpl_ %+ %1 %+ _u128
    62166335%endmacro
    … …  
    62426361        movdqu  xmm1, [A2 + IEMMEDIAF2XMMSRC.uSrc2]
    62436362        lea     T1, [.imm0 xWrtRIP]
    6244         lea     T0, [A3*2 + A3]        ; sizeof(insn+ret) == 7: 2 * (A3 * 3) + A3
    6245         lea     T0, [T0*2]
    6246         lea     T0, [T0 + A3]
    6247         lea     T1, [T1 + T0]
     6363 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     6364        lea     T0, [A3 + A3*2]         ; sizeof(endbrxx+insn+ret+int3) == 12: A3 * 12 = (A3 * 3) * 4
     6365        lea     T1, [T1 + T0*4]
     6366 %else
     6367        lea     T1, [T1 + A3*8]         ; sizeof(insn+ret+int3)         ==  8: A3 * 8
     6368 %endif
     6369        IBT_NOTRACK
    62486370        call    T1
    62496371        movdqu  [A1], xmm0
    … …  
    62556377 %rep 256
    62566378.imm %+ bImm:
    6257        %1       xmm0, xmm1, bImm
    6258        ret
     6379        IBT_ENDBRxx_WITHOUT_NOTRACK
     6380        %1      xmm0, xmm1, bImm
     6381        ret
     6382        int3
    62596383  %assign bImm bImm + 1
    62606384 %endrep
    6261 .immEnd:                                ; 256*(6+1) == 0x700
    6262 dw 0xf8ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    6263 dw 0x106ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     6385.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x800
    62646386ENDPROC iemAImpl_ %+ %1 %+ _u128
    62656387%endmacro
    … …  
    64066528        movdqu  xmm1, [A1]
    64076529        lea     T1, [.imm0 xWrtRIP]
    6408         lea     T0, [A2 + A2*2]         ; sizeof(insnX+ret) == 6: (A2 * 3) * 2
     6530 %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
     6531        lea     T0, [A2 + A2*4]         ; sizeof(endbrxx+sha1rnds4+ret) == 10: A2 * 10 = (A2 * 5) * 2
     6532 %else
     6533        lea     T0, [A2 + A2*2]         ; sizeof(sha1rnds4+ret)         ==  6: A2 *  6 = (A2 * 3) * 2
     6534 %endif
    64096535        lea     T1, [T1 + T0*2]
     6536        IBT_NOTRACK
    64106537        call    T1
    64116538        movdqu  [A0], xmm0
    … …  
    64166543 %rep 256
    64176544.imm %+ bImm:
    6418        sha1rnds4       xmm0, xmm1, bImm
    6419        ret
     6545        IBT_ENDBRxx_WITHOUT_NOTRACK
     6546        sha1rnds4 xmm0, xmm1, bImm
     6547        ret
    64206548  %assign bImm bImm + 1
    64216549 %endrep
    6422 .immEnd:                                ; 256*6 == 0x600
    6423 dw 0xf9ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
    6424 dw 0x105ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     6550.immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    64256551ENDPROC iemAImpl_sha1rnds4_u128
    64266552
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