VirtualBox

Changeset 102876 in vbox for trunk/src/VBox/VMM/include


Ignore:
Timestamp:
Jan 15, 2024 2:26:27 PM (16 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
161096
Message:

VMM/IEM: Call different threaded functions for each branch in a conditional jump (jcc, loop, loopcc) so we can quit immediately when taking a different branch from what we did during compilation. bugref:10371

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

Legend:

Unmodified
Added
Removed

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

    r102586 r102876  
    20612061 *              Stacks}
    20622062 */
    2063 static VBOXSTRICTRC iemFinishInstructionWithFlagsSet(PVMCPUCC pVCpu) RT_NOEXCEPT
     2063static VBOXSTRICTRC iemFinishInstructionWithFlagsSet(PVMCPUCC pVCpu, int rcNormal) RT_NOEXCEPT
    20642064{
    20652065    /*
    … …  
    21022102        }
    21032103        pVCpu->cpum.GstCtx.eflags.uBoth &= ~CPUMCTX_DBG_DBGF_MASK;
     2104        Assert(rcStrict != VINF_SUCCESS);
    21042105        return rcStrict;
    21052106    }
    2106     return VINF_SUCCESS;
     2107    return rcNormal;
    21072108}
    21082109
    … …  
    21122113 *
    21132114 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    2114  */
    2115 DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegFinishClearingRF(PVMCPUCC pVCpu) RT_NOEXCEPT
     2115 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2116 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2117 *                              taking the wrong conditional branhc.
     2118 */
     2119DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegFinishClearingRF(PVMCPUCC pVCpu, int rcNormal) RT_NOEXCEPT
    21162120{
    21172121    /*
    … …  
    21212125    if (RT_LIKELY(!(  pVCpu->cpum.GstCtx.eflags.uBoth
    21222126                    & (X86_EFL_TF | X86_EFL_RF | CPUMCTX_INHIBIT_SHADOW | CPUMCTX_DBG_HIT_DRX_MASK | CPUMCTX_DBG_DBGF_MASK)) ))
    2123         return VINF_SUCCESS;
    2124     return iemFinishInstructionWithFlagsSet(pVCpu);
     2127        return rcNormal;
     2128    return iemFinishInstructionWithFlagsSet(pVCpu, rcNormal);
    21252129}
    21262130
    … …  
    21362140{
    21372141    iemRegAddToRip(pVCpu, cbInstr);
    2138     return iemRegFinishClearingRF(pVCpu);
     2142    return iemRegFinishClearingRF(pVCpu, VINF_SUCCESS);
    21392143}
    21402144
    … …  
    21482152 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    21492153 * @param   cbInstr             The number of bytes to add.
    2150  */
    2151 DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToRip64AndFinishingClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr) RT_NOEXCEPT
     2154 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2155 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2156 *                              taking the wrong conditional branhc.
     2157 */
     2158DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToRip64AndFinishingClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr, int rcNormal) RT_NOEXCEPT
    21522159{
    21532160    pVCpu->cpum.GstCtx.rip = pVCpu->cpum.GstCtx.rip + cbInstr;
    2154     return iemRegFinishClearingRF(pVCpu);
     2161    return iemRegFinishClearingRF(pVCpu, rcNormal);
    21552162}
    21562163
    … …  
    21642171 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    21652172 * @param   cbInstr             The number of bytes to add.
    2166  */
    2167 DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToEip32AndFinishingClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr) RT_NOEXCEPT
     2173 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2174 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2175 *                              taking the wrong conditional branhc.
     2176 */
     2177DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToEip32AndFinishingClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr, int rcNormal) RT_NOEXCEPT
    21682178{
    21692179    pVCpu->cpum.GstCtx.rip = (uint32_t)(pVCpu->cpum.GstCtx.eip + cbInstr);
    2170     return iemRegFinishClearingRF(pVCpu);
     2180    return iemRegFinishClearingRF(pVCpu, rcNormal);
    21712181}
    21722182
    … …  
    21802190 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    21812191 * @param   cbInstr             The number of bytes to add.
    2182  */
    2183 DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToIp16AndFinishingClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr) RT_NOEXCEPT
     2192 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2193 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2194 *                              taking the wrong conditional branhc.
     2195 */
     2196DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToIp16AndFinishingClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr, int rcNormal) RT_NOEXCEPT
    21842197{
    21852198    pVCpu->cpum.GstCtx.rip = (uint16_t)(pVCpu->cpum.GstCtx.ip + cbInstr);
    2186     return iemRegFinishClearingRF(pVCpu);
     2199    return iemRegFinishClearingRF(pVCpu, rcNormal);
    21872200}
    21882201
    … …  
    21922205 *
    21932206 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    2194  */
    2195 DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegFinishNoFlags(PVMCPUCC pVCpu) RT_NOEXCEPT
     2207 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2208 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2209 *                              taking the wrong conditional branhc.
     2210 */
     2211DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegFinishNoFlags(PVMCPUCC pVCpu, int rcNormal) RT_NOEXCEPT
    21962212{
    21972213    AssertCompile(CPUMCTX_INHIBIT_SHADOW < UINT32_MAX);
    … …  
    21992215             & (X86_EFL_TF | X86_EFL_RF | CPUMCTX_INHIBIT_SHADOW | CPUMCTX_DBG_HIT_DRX_MASK | CPUMCTX_DBG_DBGF_MASK)) );
    22002216    RT_NOREF(pVCpu);
    2201     return VINF_SUCCESS;
     2217    return rcNormal;
    22022218}
    22032219
    … …  
    22112227 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    22122228 * @param   cbInstr             The number of bytes to add.
    2213  */
    2214 DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToRip64AndFinishingNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr) RT_NOEXCEPT
     2229 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2230 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2231 *                              taking the wrong conditional branhc.
     2232 */
     2233DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToRip64AndFinishingNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr, int rcNormal) RT_NOEXCEPT
    22152234{
    22162235    pVCpu->cpum.GstCtx.rip = pVCpu->cpum.GstCtx.rip + cbInstr;
    2217     return iemRegFinishNoFlags(pVCpu);
     2236    return iemRegFinishNoFlags(pVCpu, rcNormal);
    22182237}
    22192238
    … …  
    22272246 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    22282247 * @param   cbInstr             The number of bytes to add.
    2229  */
    2230 DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToEip32AndFinishingNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr) RT_NOEXCEPT
     2248 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2249 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2250 *                              taking the wrong conditional branhc.
     2251 */
     2252DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToEip32AndFinishingNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr, int rcNormal) RT_NOEXCEPT
    22312253{
    22322254    pVCpu->cpum.GstCtx.rip = (uint32_t)(pVCpu->cpum.GstCtx.eip + cbInstr);
    2233     return iemRegFinishNoFlags(pVCpu);
     2255    return iemRegFinishNoFlags(pVCpu, rcNormal);
    22342256}
    22352257
    … …  
    22432265 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    22442266 * @param   cbInstr             The number of bytes to add.
    2245  */
    2246 DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToIp16AndFinishingNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr) RT_NOEXCEPT
     2267 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2268 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2269 *                              taking the wrong conditional branhc.
     2270 *
     2271 */
     2272DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegAddToIp16AndFinishingNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr, int rcNormal) RT_NOEXCEPT
    22472273{
    22482274    pVCpu->cpum.GstCtx.rip = (uint16_t)(pVCpu->cpum.GstCtx.ip + cbInstr);
    2249     return iemRegFinishNoFlags(pVCpu);
     2275    return iemRegFinishNoFlags(pVCpu, rcNormal);
    22502276}
    22512277
    … …  
    22612287 * @param   offNextInstr        The offset of the next instruction.
    22622288 * @param   enmEffOpSize        Effective operand size.
     2289 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2290 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2291 *                              taking the wrong conditional branhc.
    22632292 */
    22642293DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegRip64RelativeJumpS8AndFinishClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr, int8_t offNextInstr,
    2265                                                                              IEMMODE enmEffOpSize) RT_NOEXCEPT
     2294                                                                             IEMMODE enmEffOpSize, int rcNormal) RT_NOEXCEPT
    22662295{
    22672296    Assert(IEM_IS_64BIT_CODE(pVCpu));
    … …  
    22842313     * Clear RF and finish the instruction (maybe raise #DB).
    22852314     */
    2286     return iemRegFinishClearingRF(pVCpu);
     2315    return iemRegFinishClearingRF(pVCpu, rcNormal);
    22872316}
    22882317
    … …  
    22992328 * @param   offNextInstr        The offset of the next instruction.
    23002329 * @param   enmEffOpSize        Effective operand size.
     2330 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2331 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2332 *                              taking the wrong conditional branhc.
    23012333 */
    23022334DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegEip32RelativeJumpS8AndFinishClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr, int8_t offNextInstr,
    2303                                                                              IEMMODE enmEffOpSize) RT_NOEXCEPT
     2335                                                                             IEMMODE enmEffOpSize, int rcNormal) RT_NOEXCEPT
    23042336{
    23052337    Assert(!IEM_IS_64BIT_CODE(pVCpu));
    … …  
    23212353     * Clear RF and finish the instruction (maybe raise #DB).
    23222354     */
    2323     return iemRegFinishClearingRF(pVCpu);
     2355    return iemRegFinishClearingRF(pVCpu, rcNormal);
    23242356}
    23252357
    … …  
    23342366 * @param   cbInstr             Instruction size.
    23352367 * @param   offNextInstr        The offset of the next instruction.
     2368 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2369 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2370 *                              taking the wrong conditional branhc.
    23362371 */
    23372372DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegIp16RelativeJumpS8AndFinishClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr,
    2338                                                                             int8_t offNextInstr) RT_NOEXCEPT
     2373                                                                            int8_t offNextInstr, int rcNormal) RT_NOEXCEPT
    23392374{
    23402375    Assert(!IEM_IS_64BIT_CODE(pVCpu));
    … …  
    23532388     * Clear RF and finish the instruction (maybe raise #DB).
    23542389     */
    2355     return iemRegFinishClearingRF(pVCpu);
     2390    return iemRegFinishClearingRF(pVCpu, rcNormal);
    23562391}
    23572392
    … …  
    23682403 * @param   offNextInstr        The offset of the next instruction.
    23692404 * @param   enmEffOpSize        Effective operand size.
     2405 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2406 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2407 *                              taking the wrong conditional branhc.
    23702408 */
    23712409DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegRip64RelativeJumpS8AndFinishNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr, int8_t offNextInstr,
    2372                                                                           IEMMODE enmEffOpSize) RT_NOEXCEPT
     2410                                                                          IEMMODE enmEffOpSize, int rcNormal) RT_NOEXCEPT
    23732411{
    23742412    Assert(IEM_IS_64BIT_CODE(pVCpu));
    … …  
    23872425    iemOpcodeFlushLight(pVCpu, cbInstr);
    23882426#endif
    2389     return iemRegFinishNoFlags(pVCpu);
     2427    return iemRegFinishNoFlags(pVCpu, rcNormal);
    23902428}
    23912429
    … …  
    24022440 * @param   offNextInstr        The offset of the next instruction.
    24032441 * @param   enmEffOpSize        Effective operand size.
     2442 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2443 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2444 *                              taking the wrong conditional branhc.
    24042445 */
    24052446DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegEip32RelativeJumpS8AndFinishNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr, int8_t offNextInstr,
    2406                                                                           IEMMODE enmEffOpSize) RT_NOEXCEPT
     2447                                                                          IEMMODE enmEffOpSize, int rcNormal) RT_NOEXCEPT
    24072448{
    24082449    Assert(!IEM_IS_64BIT_CODE(pVCpu));
    … …  
    24202461    iemOpcodeFlushLight(pVCpu, cbInstr);
    24212462#endif
    2422     return iemRegFinishNoFlags(pVCpu);
     2463    return iemRegFinishNoFlags(pVCpu, rcNormal);
    24232464}
    24242465
    … …  
    24342475 * @param   cbInstr             Instruction size.
    24352476 * @param   offNextInstr        The offset of the next instruction.
     2477 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2478 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2479 *                              taking the wrong conditional branhc.
    24362480 */
    24372481DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegIp16RelativeJumpS8AndFinishNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr,
    2438                                                                          int8_t offNextInstr) RT_NOEXCEPT
     2482                                                                         int8_t offNextInstr, int rcNormal) RT_NOEXCEPT
    24392483{
    24402484    Assert(!IEM_IS_64BIT_CODE(pVCpu));
    … …  
    24492493    iemOpcodeFlushLight(pVCpu, cbInstr);
    24502494#endif
    2451     return iemRegFinishNoFlags(pVCpu);
     2495    return iemRegFinishNoFlags(pVCpu, rcNormal);
    24522496}
    24532497
    … …  
    24602504 * @param   cbInstr             Instruction size.
    24612505 * @param   offNextInstr        The offset of the next instruction.
     2506 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2507 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2508 *                              taking the wrong conditional branhc.
    24622509 */
    24632510DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegRip64RelativeJumpS16AndFinishClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr,
    2464                                                                               int16_t offNextInstr) RT_NOEXCEPT
     2511                                                                              int16_t offNextInstr, int rcNormal) RT_NOEXCEPT
    24652512{
    24662513    Assert(IEM_IS_64BIT_CODE(pVCpu));
    … …  
    24752522     * Clear RF and finish the instruction (maybe raise #DB).
    24762523     */
    2477     return iemRegFinishClearingRF(pVCpu);
     2524    return iemRegFinishClearingRF(pVCpu, rcNormal);
    24782525}
    24792526
    … …  
    24892536 * @param   cbInstr             Instruction size.
    24902537 * @param   offNextInstr        The offset of the next instruction.
     2538 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2539 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2540 *                              taking the wrong conditional branhc.
    24912541 *
    24922542 * @note    This is also used by 16-bit code in pre-386 mode, as the code is
    … …  
    24942544 */
    24952545DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegEip32RelativeJumpS16AndFinishClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr,
    2496                                                                               int16_t offNextInstr) RT_NOEXCEPT
     2546                                                                              int16_t offNextInstr, int rcNormal) RT_NOEXCEPT
    24972547{
    24982548    Assert(!IEM_IS_64BIT_CODE(pVCpu));
    … …  
    25112561     * Clear RF and finish the instruction (maybe raise #DB).
    25122562     */
    2513     return iemRegFinishClearingRF(pVCpu);
     2563    return iemRegFinishClearingRF(pVCpu, rcNormal);
    25142564}
    25152565
    … …  
    25232573 * @param   cbInstr             Instruction size.
    25242574 * @param   offNextInstr        The offset of the next instruction.
     2575 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2576 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2577 *                              taking the wrong conditional branhc.
    25252578 */
    25262579DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegRip64RelativeJumpS16AndFinishNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr,
    2527                                                                            int16_t offNextInstr) RT_NOEXCEPT
     2580                                                                           int16_t offNextInstr, int rcNormal) RT_NOEXCEPT
    25282581{
    25292582    Assert(IEM_IS_64BIT_CODE(pVCpu));
    … …  
    25342587    iemOpcodeFlushLight(pVCpu, cbInstr);
    25352588#endif
    2536     return iemRegFinishNoFlags(pVCpu);
     2589    return iemRegFinishNoFlags(pVCpu, rcNormal);
    25372590}
    25382591
    … …  
    25492602 * @param   cbInstr             Instruction size.
    25502603 * @param   offNextInstr        The offset of the next instruction.
     2604 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2605 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2606 *                              taking the wrong conditional branhc.
    25512607 *
    25522608 * @note    This is also used by 16-bit code in pre-386 mode, as the code is
    … …  
    25542610 */
    25552611DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegEip32RelativeJumpS16AndFinishNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr,
    2556                                                                            int16_t offNextInstr) RT_NOEXCEPT
     2612                                                                           int16_t offNextInstr, int rcNormal) RT_NOEXCEPT
    25572613{
    25582614    Assert(!IEM_IS_64BIT_CODE(pVCpu));
    … …  
    25672623    iemOpcodeFlushLight(pVCpu, cbInstr);
    25682624#endif
    2569     return iemRegFinishNoFlags(pVCpu);
     2625    return iemRegFinishNoFlags(pVCpu, rcNormal);
    25702626}
    25712627
    … …  
    25852641 * @param   cbInstr             Instruction size.
    25862642 * @param   offNextInstr        The offset of the next instruction.
     2643 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2644 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2645 *                              taking the wrong conditional branhc.
    25872646 */
    25882647DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegRip64RelativeJumpS32AndFinishClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr,
    2589                                                                               int32_t offNextInstr) RT_NOEXCEPT
     2648                                                                              int32_t offNextInstr, int rcNormal) RT_NOEXCEPT
    25902649{
    25912650    Assert(IEM_IS_64BIT_CODE(pVCpu));
    … …  
    26042663     * Clear RF and finish the instruction (maybe raise #DB).
    26052664     */
    2606     return iemRegFinishClearingRF(pVCpu);
     2665    return iemRegFinishClearingRF(pVCpu, rcNormal);
    26072666}
    26082667
    … …  
    26222681 * @param   cbInstr             Instruction size.
    26232682 * @param   offNextInstr        The offset of the next instruction.
     2683 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2684 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2685 *                              taking the wrong conditional branhc.
    26242686 */
    26252687DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegEip32RelativeJumpS32AndFinishClearingRF(PVMCPUCC pVCpu, uint8_t cbInstr,
    2626                                                                               int32_t offNextInstr) RT_NOEXCEPT
     2688                                                                              int32_t offNextInstr, int rcNormal) RT_NOEXCEPT
    26272689{
    26282690    Assert(!IEM_IS_64BIT_CODE(pVCpu));
    … …  
    26422704     * Clear RF and finish the instruction (maybe raise #DB).
    26432705     */
    2644     return iemRegFinishClearingRF(pVCpu);
     2706    return iemRegFinishClearingRF(pVCpu, rcNormal);
    26452707}
    26462708
    … …  
    26612723 * @param   cbInstr             Instruction size.
    26622724 * @param   offNextInstr        The offset of the next instruction.
     2725 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2726 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2727 *                              taking the wrong conditional branhc.
    26632728 */
    26642729DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegRip64RelativeJumpS32AndFinishNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr,
    2665                                                                            int32_t offNextInstr) RT_NOEXCEPT
     2730                                                                           int32_t offNextInstr, int rcNormal) RT_NOEXCEPT
    26662731{
    26672732    Assert(IEM_IS_64BIT_CODE(pVCpu));
    … …  
    26762741    iemOpcodeFlushLight(pVCpu, cbInstr);
    26772742#endif
    2678     return iemRegFinishNoFlags(pVCpu);
     2743    return iemRegFinishNoFlags(pVCpu, rcNormal);
    26792744}
    26802745
    … …  
    26952760 * @param   cbInstr             Instruction size.
    26962761 * @param   offNextInstr        The offset of the next instruction.
     2762 * @param   rcNormal            VINF_SUCCESS to continue TB.
     2763 *                              VINF_IEM_REEXEC_BREAK to force TB exit when
     2764 *                              taking the wrong conditional branhc.
    26972765 */
    26982766DECL_FORCE_INLINE(VBOXSTRICTRC) iemRegEip32RelativeJumpS32AndFinishNoFlags(PVMCPUCC pVCpu, uint8_t cbInstr,
    2699                                                                            int32_t offNextInstr) RT_NOEXCEPT
     2767                                                                           int32_t offNextInstr, int rcNormal) RT_NOEXCEPT
    27002768{
    27012769    Assert(!IEM_IS_64BIT_CODE(pVCpu));
    … …  
    27112779    iemOpcodeFlushLight(pVCpu, cbInstr);
    27122780#endif
    2713     return iemRegFinishNoFlags(pVCpu);
     2781    return iemRegFinishNoFlags(pVCpu, rcNormal);
    27142782}
    27152783
    … …  
    27552823    iemRegAddToRip(pVCpu, cbInstr);
    27562824    if (!(fEflOld & X86_EFL_TF))
    2757         return iemRegFinishClearingRF(pVCpu);
     2825        return iemRegFinishClearingRF(pVCpu, VINF_SUCCESS);
    27582826    return iemFinishInstructionWithTfSet(pVCpu);
    27592827}
    … …  
    27912859    else
    27922860        return iemRaiseGeneralProtectionFault0(pVCpu);
    2793     return iemRegFinishNoFlags(pVCpu);
     2861    return iemRegFinishNoFlags(pVCpu, VINF_SUCCESS);
    27942862}
    27952863
    … …  
    28122880    else
    28132881        return iemRaiseGeneralProtectionFault0(pVCpu);
    2814     return iemRegFinishNoFlags(pVCpu);
     2882    return iemRegFinishNoFlags(pVCpu, VINF_SUCCESS);
    28152883}
    28162884
    … …  
    28332901    else
    28342902        return iemRaiseGeneralProtectionFault0(pVCpu);
    2835     return iemRegFinishNoFlags(pVCpu);
     2903    return iemRegFinishNoFlags(pVCpu, VINF_SUCCESS);
    28362904}
    28372905
    … …  
    28592927    RT_NOREF_PV(cbInstr);
    28602928#endif
    2861     return iemRegFinishClearingRF(pVCpu);
     2929    return iemRegFinishClearingRF(pVCpu, VINF_SUCCESS);
    28622930}
    28632931
    … …  
    28852953    RT_NOREF_PV(cbInstr);
    28862954#endif
    2887     return iemRegFinishClearingRF(pVCpu);
     2955    return iemRegFinishClearingRF(pVCpu, VINF_SUCCESS);
    28882956}
    28892957
    … …  
    29112979    RT_NOREF_PV(cbInstr);
    29122980#endif
    2913     return iemRegFinishClearingRF(pVCpu);
     2981    return iemRegFinishClearingRF(pVCpu, VINF_SUCCESS);
    29142982}
    29152983

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

    r102586 r102876  
    28412841        &&    !!(pVCpu->cpum.GstCtx.eflags.u & (a_fBit1)) \
    28422842           == !!(pVCpu->cpum.GstCtx.eflags.u & (a_fBit2)) ) {
    2843 #define IEM_MC_IF_CX_IS_NZ()                            if (pVCpu->cpum.GstCtx.cx != 0) {
     2843#define IEM_MC_IF_CX_IS_NZ()                            if (pVCpu->cpum.GstCtx.cx  != 0) {
    28442844#define IEM_MC_IF_ECX_IS_NZ()                           if (pVCpu->cpum.GstCtx.ecx != 0) {
    28452845#define IEM_MC_IF_RCX_IS_NZ()                           if (pVCpu->cpum.GstCtx.rcx != 0) {
     2846#define IEM_MC_IF_CX_IS_NOT_ONE()                       if (pVCpu->cpum.GstCtx.cx  != 1) {
     2847#define IEM_MC_IF_ECX_IS_NOT_ONE()                      if (pVCpu->cpum.GstCtx.ecx != 1) {
     2848#define IEM_MC_IF_RCX_IS_NOT_ONE()                      if (pVCpu->cpum.GstCtx.rcx != 1) {
    28462849/** @note Not for IOPL or IF testing. */
    2847 #define IEM_MC_IF_CX_IS_NZ_AND_EFL_BIT_SET(a_fBit) \
    2848         if (   pVCpu->cpum.GstCtx.cx != 0 \
     2850#define IEM_MC_IF_CX_IS_NOT_ONE_AND_EFL_BIT_SET(a_fBit) \
     2851        if (   pVCpu->cpum.GstCtx.cx != 1 \
    28492852            && (pVCpu->cpum.GstCtx.eflags.u & a_fBit)) {
    28502853/** @note Not for IOPL or IF testing. */
    2851 #define IEM_MC_IF_ECX_IS_NZ_AND_EFL_BIT_SET(a_fBit) \
    2852         if (   pVCpu->cpum.GstCtx.ecx != 0 \
     2854#define IEM_MC_IF_ECX_IS_NOT_ONE_AND_EFL_BIT_SET(a_fBit) \
     2855        if (   pVCpu->cpum.GstCtx.ecx != 1 \
    28532856            && (pVCpu->cpum.GstCtx.eflags.u & a_fBit)) {
    28542857/** @note Not for IOPL or IF testing. */
    2855 #define IEM_MC_IF_RCX_IS_NZ_AND_EFL_BIT_SET(a_fBit) \
    2856         if (   pVCpu->cpum.GstCtx.rcx != 0 \
     2858#define IEM_MC_IF_RCX_IS_NOT_ONE_AND_EFL_BIT_SET(a_fBit) \
     2859        if (   pVCpu->cpum.GstCtx.rcx != 1 \
    28572860            && (pVCpu->cpum.GstCtx.eflags.u & a_fBit)) {
    28582861/** @note Not for IOPL or IF testing. */
    2859 #define IEM_MC_IF_CX_IS_NZ_AND_EFL_BIT_NOT_SET(a_fBit) \
    2860         if (   pVCpu->cpum.GstCtx.cx != 0 \
     2862#define IEM_MC_IF_CX_IS_NOT_ONE_AND_EFL_BIT_NOT_SET(a_fBit) \
     2863        if (   pVCpu->cpum.GstCtx.cx != 1 \
    28612864            && !(pVCpu->cpum.GstCtx.eflags.u & a_fBit)) {
    28622865/** @note Not for IOPL or IF testing. */
    2863 #define IEM_MC_IF_ECX_IS_NZ_AND_EFL_BIT_NOT_SET(a_fBit) \
    2864         if (   pVCpu->cpum.GstCtx.ecx != 0 \
     2866#define IEM_MC_IF_ECX_IS_NOT_ONE_AND_EFL_BIT_NOT_SET(a_fBit) \
     2867        if (   pVCpu->cpum.GstCtx.ecx != 1 \
    28652868            && !(pVCpu->cpum.GstCtx.eflags.u & a_fBit)) {
    28662869/** @note Not for IOPL or IF testing. */
    2867 #define IEM_MC_IF_RCX_IS_NZ_AND_EFL_BIT_NOT_SET(a_fBit) \
    2868         if (   pVCpu->cpum.GstCtx.rcx != 0 \
     2870#define IEM_MC_IF_RCX_IS_NOT_ONE_AND_EFL_BIT_NOT_SET(a_fBit) \
     2871        if (   pVCpu->cpum.GstCtx.rcx != 1 \
    28692872            && !(pVCpu->cpum.GstCtx.eflags.u & a_fBit)) {
    28702873#define IEM_MC_IF_LOCAL_IS_Z(a_Local)                   if ((a_Local) == 0) {

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

    r102857 r102876  
    49634963
    49644964
     4965/**
     4966 * Emits a compare of a 32-bit GPR with a constant value, settings status
     4967 * flags/whatever for use with conditional instruction.
     4968 *
     4969 * @note ARM64: Helper register is required (@a idxTmpReg) for isolating the
     4970 *       16-bit value from @a iGrpLeft.
     4971 * @note On ARM64 the @a uImm value must be in the range 0x000..0xfff or that
     4972 *       shifted 12 bits to the left (e.g. 0x1000..0xfff0000 with the lower 12
     4973 *       bits all zero).  Will release assert or throw exception if the caller
     4974 *       violates this restriction.
     4975 */
     4976DECL_FORCE_INLINE_THROW(uint32_t)
     4977iemNativeEmitCmpGpr16WithImmEx(PIEMNATIVEINSTR pCodeBuf, uint32_t off, uint8_t iGprLeft, uint16_t uImm,
     4978                               uint8_t idxTmpReg = UINT8_MAX)
     4979{
     4980#ifdef RT_ARCH_AMD64
     4981    pCodeBuf[off++] = X86_OP_PRF_SIZE_OP;
     4982    if (iGprLeft >= 8)
     4983        pCodeBuf[off++] = X86_OP_REX_B;
     4984    if (uImm <= UINT32_C(0x7f))
     4985    {
     4986        /* cmp Ev, Ib */
     4987        pCodeBuf[off++] = 0x83;
     4988        pCodeBuf[off++] = X86_MODRM_MAKE(X86_MOD_REG, 7, iGprLeft & 7);
     4989        pCodeBuf[off++] = (uint8_t)uImm;
     4990    }
     4991    else
     4992    {
     4993        /* cmp Ev, imm */
     4994        pCodeBuf[off++] = 0x81;
     4995        pCodeBuf[off++] = X86_MODRM_MAKE(X86_MOD_REG, 7, iGprLeft & 7);
     4996        pCodeBuf[off++] = RT_BYTE1(uImm);
     4997        pCodeBuf[off++] = RT_BYTE2(uImm);
     4998    }
     4999    RT_NOREF(idxTmpReg);
     5000
     5001#elif defined(RT_ARCH_ARM64)
     5002# ifdef IEM_WITH_THROW_CATCH
     5003    AssertStmt(idxTmpReg < 32, IEMNATIVE_DO_LONGJMP(NULL, VERR_IEM_IPE_9));
     5004# else
     5005    AssertReleaseStmt(idxTmpReg < 32, off = UINT32_MAX);
     5006# endif
     5007    Assert(Armv8A64ConvertImmRImmS2Mask32(15, 0) == 0xffff);
     5008    pCodeBuf[off++] = Armv8A64MkInstrAndImm(idxTmpReg, iGprLeft, 15, 0, false /*f64Bit*/);
     5009    off = iemNativeEmitCmpGpr32WithImmEx(pCodeBuf, off, idxTmpReg, uImm);
     5010
     5011#else
     5012# error "Port me!"
     5013#endif
     5014    return off;
     5015}
     5016
     5017
     5018/**
     5019 * Emits a compare of a 16-bit GPR with a constant value, settings status
     5020 * flags/whatever for use with conditional instruction.
     5021 *
     5022 * @note ARM64: Helper register is required (idxTmpReg).
     5023 */
     5024DECL_INLINE_THROW(uint32_t)
     5025iemNativeEmitCmpGpr16WithImm(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t iGprLeft, uint16_t uImm,
     5026                             uint8_t idxTmpReg = UINT8_MAX)
     5027{
     5028#ifdef RT_ARCH_AMD64
     5029    off = iemNativeEmitCmpGpr16WithImmEx(iemNativeInstrBufEnsure(pReNative, off, 7), off, iGprLeft, uImm, idxTmpReg);
     5030#elif defined(RT_ARCH_ARM64)
     5031    off = iemNativeEmitCmpGpr16WithImmEx(iemNativeInstrBufEnsure(pReNative, off, 2), off, iGprLeft, uImm, idxTmpReg);
     5032#else
     5033# error "Port me!"
     5034#endif
     5035    IEMNATIVE_ASSERT_INSTR_BUF_ENSURE(pReNative, off);
     5036    return off;
     5037}
     5038
     5039
    49655040
    49665041/*********************************************************************************************************************************
    … …  
    59746049
    59756050
     6051/* if (Grp1 == 0) Jmp idxLabel; */
     6052
    59766053/**
    59776054 * Emits code that jumps to @a idxLabel if @a iGprSrc is zero.
    … …  
    60146091
    60156092
     6093/* if (Grp1 != 0) Jmp idxLabel; */
     6094
    60166095/**
    60176096 * Emits code that jumps to @a idxLabel if @a iGprSrc is not zero.
    … …  
    60546133
    60556134
     6135/* if (Grp1 != Gpr2) Jmp idxLabel; */
     6136
    60566137/**
    60576138 * Emits code that jumps to the given label if @a iGprLeft and @a iGprRight
    … …  
    60816162
    60826163
     6164/* if (Grp != Imm) Jmp idxLabel; */
     6165
    60836166/**
    60846167 * Emits code that jumps to the given label if @a iGprSrc differs from @a uImm.
    … …  
    61316214    uint32_t const idxLabel = iemNativeLabelCreate(pReNative, enmLabelType, UINT32_MAX /*offWhere*/, uData);
    61326215    return iemNativeEmitTestIfGpr32NotEqualImmAndJmpToLabel(pReNative, off, iGprSrc, uImm, idxLabel);
     6216}
     6217
     6218
     6219/**
     6220 * Emits code that jumps to the given label if 16-bit @a iGprSrc differs from
     6221 * @a uImm.
     6222 */
     6223DECL_INLINE_THROW(uint32_t) iemNativeEmitTestIfGpr16NotEqualImmAndJmpToLabel(PIEMRECOMPILERSTATE pReNative, uint32_t off,
     6224                                                                             uint8_t iGprSrc, uint16_t uImm, uint32_t idxLabel)
     6225{
     6226    off = iemNativeEmitCmpGpr16WithImm(pReNative, off, iGprSrc, uImm);
     6227    off = iemNativeEmitJnzToLabel(pReNative, off, idxLabel);
     6228    return off;
     6229}
     6230
     6231
     6232/**
     6233 * Emits code that jumps to a new label if 16-bit @a iGprSrc differs from
     6234 * @a uImm.
     6235 */
     6236DECL_INLINE_THROW(uint32_t)
     6237iemNativeEmitTestIfGpr16NotEqualImmAndJmpToNewLabel(PIEMRECOMPILERSTATE pReNative, uint32_t off,
     6238                                                    uint8_t iGprSrc, uint16_t uImm,
     6239                                                    IEMNATIVELABELTYPE enmLabelType, uint16_t uData = 0)
     6240{
     6241    uint32_t const idxLabel = iemNativeLabelCreate(pReNative, enmLabelType, UINT32_MAX /*offWhere*/, uData);
     6242    return iemNativeEmitTestIfGpr16NotEqualImmAndJmpToLabel(pReNative, off, iGprSrc, uImm, idxLabel);
     6243}
     6244
     6245
     6246/* if (Grp == Imm) Jmp idxLabel; */
     6247
     6248/**
     6249 * Emits code that jumps to the given label if @a iGprSrc equals @a uImm.
     6250 */
     6251DECL_INLINE_THROW(uint32_t)
     6252iemNativeEmitTestIfGprEqualsImmAndJmpToLabel(PIEMRECOMPILERSTATE pReNative, uint32_t off,
     6253                                             uint8_t iGprSrc, uint64_t uImm, uint32_t idxLabel)
     6254{
     6255    off = iemNativeEmitCmpGprWithImm(pReNative, off, iGprSrc, uImm);
     6256    off = iemNativeEmitJzToLabel(pReNative, off, idxLabel);
     6257    return off;
     6258}
     6259
     6260
     6261/**
     6262 * Emits code that jumps to a new label if @a iGprSrc equals from @a uImm.
     6263 */
     6264DECL_INLINE_THROW(uint32_t)
     6265iemNativeEmitTestIfGprEqualsImmAndJmpToNewLabel(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t iGprSrc, uint64_t uImm,
     6266                                                IEMNATIVELABELTYPE enmLabelType, uint16_t uData = 0)
     6267{
     6268    uint32_t const idxLabel = iemNativeLabelCreate(pReNative, enmLabelType, UINT32_MAX /*offWhere*/, uData);
     6269    return iemNativeEmitTestIfGprEqualsImmAndJmpToLabel(pReNative, off, iGprSrc, uImm, idxLabel);
     6270}
     6271
     6272
     6273/**
     6274 * Emits code that jumps to the given label if 32-bit @a iGprSrc equals @a uImm.
     6275 */
     6276DECL_INLINE_THROW(uint32_t) iemNativeEmitTestIfGpr32EqualsImmAndJmpToLabel(PIEMRECOMPILERSTATE pReNative, uint32_t off,
     6277                                                                           uint8_t iGprSrc, uint32_t uImm, uint32_t idxLabel)
     6278{
     6279    off = iemNativeEmitCmpGpr32WithImm(pReNative, off, iGprSrc, uImm);
     6280    off = iemNativeEmitJzToLabel(pReNative, off, idxLabel);
     6281    return off;
     6282}
     6283
     6284
     6285/**
     6286 * Emits code that jumps to a new label if 32-bit @a iGprSrc equals @a uImm.
     6287 */
     6288DECL_INLINE_THROW(uint32_t)
     6289iemNativeEmitTestIfGpr32EqualsImmAndJmpToNewLabel(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t iGprSrc, uint32_t uImm,
     6290                                                  IEMNATIVELABELTYPE enmLabelType, uint16_t uData = 0)
     6291{
     6292    uint32_t const idxLabel = iemNativeLabelCreate(pReNative, enmLabelType, UINT32_MAX /*offWhere*/, uData);
     6293    return iemNativeEmitTestIfGpr32EqualsImmAndJmpToLabel(pReNative, off, iGprSrc, uImm, idxLabel);
     6294}
     6295
     6296
     6297/**
     6298 * Emits code that jumps to the given label if 16-bit @a iGprSrc equals @a uImm.
     6299 *
     6300 * @note ARM64: Helper register is required (idxTmpReg).
     6301 */
     6302DECL_INLINE_THROW(uint32_t) iemNativeEmitTestIfGpr16EqualsImmAndJmpToLabel(PIEMRECOMPILERSTATE pReNative, uint32_t off,
     6303                                                                           uint8_t iGprSrc, uint16_t uImm, uint32_t idxLabel,
     6304                                                                           uint8_t idxTmpReg = UINT8_MAX)
     6305{
     6306    off = iemNativeEmitCmpGpr16WithImm(pReNative, off, iGprSrc, uImm, idxTmpReg);
     6307    off = iemNativeEmitJzToLabel(pReNative, off, idxLabel);
     6308    return off;
     6309}
     6310
     6311
     6312/**
     6313 * Emits code that jumps to a new label if 16-bit @a iGprSrc equals @a uImm.
     6314 *
     6315 * @note ARM64: Helper register is required (idxTmpReg).
     6316 */
     6317DECL_INLINE_THROW(uint32_t)
     6318iemNativeEmitTestIfGpr16EqualsImmAndJmpToNewLabel(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t iGprSrc, uint16_t uImm,
     6319                                                  IEMNATIVELABELTYPE enmLabelType, uint16_t uData = 0,
     6320                                                  uint8_t idxTmpReg = UINT8_MAX)
     6321{
     6322    uint32_t const idxLabel = iemNativeLabelCreate(pReNative, enmLabelType, UINT32_MAX /*offWhere*/, uData);
     6323    return iemNativeEmitTestIfGpr16EqualsImmAndJmpToLabel(pReNative, off, iGprSrc, uImm, idxLabel, idxTmpReg);
    61336324}
    61346325
Note: See TracChangeset for help on using the changeset viewer.

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