Copyright (C) Intel Corporation. All Rights Reserved.
# Notices and Disclaimers
Intel technologies may require enabled hardware, software or service activation.
No product or component can be absolutely secure.
Your costs and results may vary.
All product plans and roadmaps are subject to change without notice.
The products described may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request.
Intel disclaims all express and implied warranties, including without limitation, the implied warranties of merchantability, fitness for a particular purpose, and non-infringement, as well as any warranty arising from course of performance, course of dealing, or usage in trade.
Code names are used by Intel to identify products, technologies, or services that are in development and not publicly available. These are not “commercial” names and not intended to function as trademarks.
No license (express or implied, by estoppel or otherwise) to any intellectual property rights is granted by this document, with the sole exception that a) you may publish an unmodified copy and b) code, identified as Sample Code in this document is licensed subject to the Zero-Clause BSD open source license (0BSD), [https://opensource.org/licenses/0BSD](https://opensource.org/licenses/0BSD). You may create software implementations based on this document and in compliance with the foregoing that are intended to execute on the Intel product(s) referenced in this document. No rights are granted to create modifications or derivatives of this document.
You may not use or facilitate the use of this document in connection with any infringement or other legal analysis concerning Intel products described herein. You agree to grant Intel a non-exclusive, royalty-free license to any patent claim thereafter drafted which includes subject matter disclosed herein.
If you give Intel any comments or suggestions related to this document or the information contained in it, Intel can use them in any way and disclose them to anyone, without payment or other obligations to you. You represent and warrant that you own, or have sufficient rights from the owner of, any such comments or suggestions, and the intellectual property rights in them, to grant the above permission.
© Intel Corporation. Intel, the Intel logo, and other Intel marks are trademarks of Intel Corporation or its subsidiaries. Other names and brands may be claimed as the property of others.
The code in this file is not 'Sample Code'.
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
if Condition_Holds(cond) then
let new_rip := Relative_Branch_Wrap(context.operand_size, Next_IP + Sign_Extend(src, 64));
Check_New_RIP?(CS, new_rip);
Branch_Near(new_rip);
endif;
Std::Bits::Add
Std::Bits::Sign_Extend
Branch_Near
Check_New_RIP
Condition_Holds
Relative_Branch_Wrap
CS
Next_IP
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 8;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_Jcc?(operand_size, context, cond, src);
rel8
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let operand_size := 64;
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, 32), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 4;
Instr_Jcc?(operand_size, context, cond, src);
rel32
src
cond
Std::Integer::Le
Std::Integer::Min
Std::Integer::Positive_Divide
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_Jcc
Next_IP
let cond := opcode[3:0];
let src := Sign_Extend(Mem_Fetch?(ip, Min(operand_size, 32)), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + (Min(operand_size, 32) / 8);
Instr_Jcc?(operand_size, context, cond, src);
relz
src
cond
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_JCXZ
Next_IP
let operand_size := 8;
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Next_IP := ip + 1;
Instr_JCXZ?(operand_size, context, src);
rel8
src
Std::Bits::Add_int
Std::Bits::Sign_Extend
In_64Bit_Mode
Mem_Fetch
Report_Invalid_Opcode
Instr_JCXZ
Next_IP
let operand_size := 8;
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
LockPrefix
#UD
Mode64
#UD
Next_IP := ip + 1;
Instr_JCXZ?(operand_size, context, src);
rel8
src
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_JCXZ
Next_IP
let operand_size := 64;
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_JCXZ?(operand_size, context, src);
rel8
src
Std::Boolean::Not
Std::Bits::Add_int
Std::Bits::Sign_Extend
Mem_Fetch
Report_Invalid_Opcode
Instr_JCXZ
Next_IP
let operand_size := 64;
let src := Sign_Extend(Mem_Fetch?(ip, 8), operand_size);
if not (not context.rex2_prefix_present) then Report_Invalid_Opcode!(); endif;
LockPrefix
#UD
Next_IP := ip + 1;
Instr_JCXZ?(operand_size, context, src);
rel8
INTEL64
src
if Is_Zero(RCX[operand_size-1 : 0]) then
let new_rip := Relative_Branch_Wrap(context.operand_size, Next_IP + Sign_Extend(src, 64));
Check_New_RIP?(CS, new_rip);
Branch_Near(new_rip);
endif;
Std::Integer::Add
Std::Integer::Le
Std::Integer::Lt
Std::Integer::Subtract
Std::Bits::Add
Std::Bits::Is_Zero
Std::Bits::Sign_Extend
Branch_Near
Check_New_RIP
Relative_Branch_Wrap
RCX
CS
Next_IP
branch
Operand is sign-extended to operand_size bits.