diff --git a/README.md b/README.md index 413519f8b..988c4e1f1 100644 --- a/README.md +++ b/README.md @@ -23,6 +23,7 @@ iced is a blazing fast and correct x86 (16/32/64-bit) instruction decoder, disas - Python: [README](https://github.com/icedland/iced/blob/master/src/rust/iced-x86-py/README.md) - JavaScript + WebAssembly: [README](https://github.com/icedland/iced/blob/master/src/rust/iced-x86-js/README.md) - Lua: [README](https://github.com/icedland/iced/blob/master/src/rust/iced-x86-lua/README.md) +- Delphi: [README](https://github.com/icedland/iced/blob/master/src/Delphi/README.md) # License diff --git a/src/Delphi/README.md b/src/Delphi/README.md new file mode 100644 index 000000000..0abfbe1c5 --- /dev/null +++ b/src/Delphi/README.md @@ -0,0 +1,1397 @@ +iced-x86-delphi +[![Latest version](https://img.shields.io/crates/v/iced-x86.svg)](https://crates.io/crates/iced-x86) +[![Documentation](https://docs.rs/iced-x86/badge.svg)](https://docs.rs/iced-x86) +![License](https://img.shields.io/crates/l/iced-x86.svg) + +iced-x86 is a blazing fast and correct x86 (16/32/64-bit) instruction decoder, disassembler and assembler written in Rust. + +- 👍 Supports all Intel and AMD instructions +- 👍 Correct: All instructions are tested and iced has been tested against other disassemblers/assemblers (xed, gas, objdump, masm, dumpbin, nasm, ndisasm) and fuzzed +- 👍 The formatter supports masm, nasm, gas (AT&T), Intel (XED) and there are many options to customize the output +- 👍 Blazing fast: Decodes >240 MB/s, 125MB/s with Formatting +- 👍 Small decoded instructions, only 40 bytes and the decoder doesn't allocate any memory +- 👍 The encoder can be used to re-encode decoded instructions at any address +- 👍 API to get instruction info, eg. read/written registers, memory and rflags bits; CPUID feature flag, control flow info, etc +- 👍 License: MIT + +## Minimum supported version +iced-x86 supports `Delphi 7` or later. + +## Usage + +Add this to your Project: + +```pascal + uIced.Types, + uIced.Imports, + uIced, +``` + +## How-tos (See Samples-Folder) +## Samples are designed to work with older compilers and can be simplyfied on recent versions. +- [Disassemble (decode and format instructions)](#disassemble-decode-and-format-instructions) +- [Disassemble with a symbol resolver](#disassemble-with-a-symbol-resolver) +- [Disassemble with colorized text](#disassemble-with-colorized-text) +- [Move code in memory (eg. hook a function)](#move-code-in-memory-eg-hook-a-function) +- [Get instruction info, eg. read/written regs/mem, control flow info, etc](#get-instruction-info-eg-readwritten-regsmem-control-flow-info-etc) +- [Get the virtual address of a memory operand](#get-the-virtual-address-of-a-memory-operand) +- [Disassemble old/deprecated CPU instructions](#disassemble-olddeprecated-cpu-instructions) +- [Disassemble as fast as possible](#disassemble-as-fast-as-possible) +- [Create and encode instructions](#create-and-encode-instructions) + + +## Disassemble (decode and format instructions) + +This example uses a [`Decoder`] and one of the [`Formatter`]s to decode and format the code, +eg. [`GasFormatter`], [`IntelFormatter`], [`MasmFormatter`], [`NasmFormatter`], [`SpecializedFormatter`] (or [`FastFormatter`]). + +[`Decoder`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.Decoder.html +[`Formatter`]: https://docs.rs/iced-x86/1.21.0/iced_x86/trait.Formatter.html +[`GasFormatter`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.GasFormatter.html +[`IntelFormatter`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.IntelFormatter.html +[`MasmFormatter`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.MasmFormatter.html +[`NasmFormatter`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.NasmFormatter.html +[`SpecializedFormatter`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.SpecializedFormatter.html +[`FastFormatter`]: https://docs.rs/iced-x86/1.21.0/iced_x86/type.FastFormatter.html + +```pascal +{ +This example produces the following output: +00007FFAC46ACDA4 48895C2410 mov [rsp+10h],rbx +00007FFAC46ACDA9 4889742418 mov [rsp+18h],rsi +00007FFAC46ACDAE 55 push rbp +00007FFAC46ACDAF 57 push rdi +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h +00007FFAC46ACDC1 488B0518570A00 mov rax,[rel 7FFA`C475`24E0h] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[rel 7FFA`C474`F208h] +00007FFAC46ACDD9 488D05787C0400 lea rax,[rel 7FFA`C46F`4A58h] +00007FFAC46ACDE0 33FF xor edi,edi +} + +const + HEXBYTES_COLUMN_BYTE_LENGTH = 10; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); +var + Instruction : TInstruction; + sOutput : String; + start_index : Integer; + i : Integer; + pInstruction: PAnsiChar; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNONE ); + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + Iced.Formatter.FormatterType := ftNasm; + + // Change some options, there are many more + Iced.Formatter.DigitSeparator := '`'; + Iced.Formatter.FirstOperandCharIndex := 10; + + while Iced.Decoder.CanDecode do + begin + Iced.DecodeFormat( Instruction, pInstruction ); + + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h]" + + // Hex + start_index := instruction.RIP-EXAMPLE_CODE_RIP; + sOutput := ''; + for i := start_index to start_index+Instruction.len-1 do + sOutput := sOutput + IntToHex( EXAMPLE_CODE[ i ], 2 ); + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + + sOutput := Format( '%.16x ', [ instruction.RIP ] ) + sOutput + string( pInstruction ); + + WriteLn( sOutput ); + end; + + WriteLn( 'Press enter to exit.' ); + ReadLn; +``` + +## Disassemble with a symbol resolver + +Creates a custom [`SymbolResolver`] that is called by a [`Formatter`]. + +[`SymbolResolver`]: https://docs.rs/iced-x86/1.21.0/iced_x86/trait.SymbolResolver.html +[`Formatter`]: https://docs.rs/iced-x86/1.21.0/iced_x86/trait.Formatter.html + +```pascal +{ +This example produces the following output: +mov rcx, [rdx+my_data (0x5AA55AA5)] +} + +type + TSymbolItem = packed record + Offset : UInt64; + Name : AnsiString; + end; + TSymbolList = Array of TSymbolItem; + +const + Symbols : Array [ 0..0 ] of TSymbolItem = ( + ( Offset: UInt64( $5AA55AA5 ); Name: 'my_data' ) + ); + +function SymbolResolverCallback( const Instruction: TInstruction; Operand: Cardinal; InstructionOperand : Cardinal; Address: UInt64; Size: Cardinal; UserData : Pointer ) : PAnsiChar; cdecl; +var + i : Integer; +begin + result := ''; + for i := Low( Symbols ) to High( Symbols ) do + begin + if ( Symbols[ i ].Offset = Address ) then + result := PAnsiChar( Symbols[ i ].Name ); + end; +end; + +const + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = 0; + EXAMPLE_CODE : Array [ 0..6 ] of Byte = ( $48, $8B, $8A, $A5, $5A, $A5, $5A ); + EXAMPLE_OFFSET = $0000001FB55A1234; +var + Instruction : TInstruction; + Offset : UInt64; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNone ); + + Iced.Formatter.FormatterType := ftNasm; + Iced.Formatter.SymbolResolver := SymbolResolverCallback; + Iced.Formatter.ShowSymbols := True; + + Iced.DecodeFormat( Instruction, pInstruction ); + WriteLn( string( pInstruction ) ); + + WriteLn( 'Press enter to exit.' ); + ReadLn; +``` + +## Disassemble with colorized text + +Creates a custom [`FormatterOutput`] that is called by a [`Formatter`]. + +This example will fail to compile unless you install the `colored` crate, see below. + +[`FormatterOutput`]: https://docs.rs/iced-x86/1.21.0/iced_x86/trait.FormatterOutput.html +[`Formatter`]: https://docs.rs/iced-x86/1.21.0/iced_x86/trait.Formatter.html + +```pascal +{ +This example produces the following output: +00007FFAC46ACDA4 48895C2410 mov [rsp+10h],rbx +00007FFAC46ACDA9 4889742418 mov [rsp+18h],rsi +00007FFAC46ACDAE 55 push rbp +00007FFAC46ACDAF 57 push rdi +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h +00007FFAC46ACDC1 488B0518570A00 mov rax,[7FFAC47524E0h] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[7FFAC474F208h] +00007FFAC46ACDD9 488D05787C0400 lea rax,[7FFAC46F4A58h] +00007FFAC46ACDE0 33FF xor edi,edi +} + +interface + +uses + Classes, Controls, Forms, StdCtrls, ComCtrls; + +type + TFrmFormatterOutput = class(TForm) + rEdtOutput: TRichEdit; + procedure FormShow(Sender: TObject); + private + { Private-Deklarationen } + procedure DisassembleWithFormatterCallback; + public + { Public-Deklarationen } + end; + +var + FrmFormatterOutput: TFrmFormatterOutput; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +implementation + +{$R *.dfm} + +uses + Graphics, SysUtils, + uIced.Types, + uIced.Imports, + uIced; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +procedure TFrmFormatterOutput.FormShow(Sender: TObject); +begin + DisassembleWithFormatterCallback; +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +procedure FormatterOutputCallback( Text : PAnsiChar; Kind : TFormatterTextKind; UserData : Pointer ); cdecl; +begin + // Determine Color + case Kind.FormatterTextKind of + ftkDirective, + ftkKeyword : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clYellow; + + ftkPrefix, + ftkMnemonic : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clRed; + + ftkRegister : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clMaroon; + ftkNumber : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clGray; + else + FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clWindowText; + end; + + // Append Text + FrmFormatterOutput.rEdtOutput.SelText := Text; +end; + +procedure TFrmFormatterOutput.DisassembleWithFormatterCallback; +const + HEXBYTES_COLUMN_BYTE_LENGTH = 10; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); +var + Instruction : TInstruction; + sOutput : String; + start_index : Integer; + i : Integer; +begin + rEdtOutput.Lines.Clear; + if NOT IsInitDLL then + begin + rEdtOutput.Lines.Add( 'Library not loaded.' ); + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNONE ); + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // NOT for Fast and Specialized + Iced.Formatter.FormatterType := ftIntel; + Iced.Formatter.FirstOperandCharIndex := 8; + Iced.Formatter.Callback := FormatterOutputCallback; + + while Iced.Decoder.CanDecode do + begin + Iced.Decoder.Decode( Instruction ); + + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF " + + // Hex + start_index := instruction.RIP-EXAMPLE_CODE_RIP; + sOutput := ''; + for i := start_index to start_index+Instruction.len-1 do + sOutput := sOutput + IntToHex( EXAMPLE_CODE[ i ], 2 ); + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + + // Set Color for offset and Hex + FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clWindowText; + rEdtOutput.SelText := Format( '%.16x ', [ instruction.RIP ] ) + sOutput; + + // Formatter callback gets called with each TextKind + // Eg. "lea rbp,[rsp-100h]" + Iced.Formatter.Format( Instruction ); + + // Start new line + rEdtOutput.SelText := #13#10; + end; +end; +``` + +## Move code in memory (eg. hook a function) + +Uses instruction info API and the encoder to patch a function to jump to the programmer's function. + +```pascal +{ +This example produces the following output: +Original code: +00007FFAC46ACDA4 48895C2410 mov [rsp+10h],rbx +00007FFAC46ACDA9 4889742418 mov [rsp+18h],rsi +00007FFAC46ACDAE 55 push rbp +00007FFAC46ACDAF 57 push rdi +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h +00007FFAC46ACDC1 488B0518570A00 mov rax,[rel 7FFAC47524E0h] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[rel 7FFAC474F208h] +00007FFAC46ACDD9 488D05787C0400 lea rax,[rel 7FFAC46F4A58h] +00007FFAC46ACDE0 33FF xor edi,edi + +Original + patched code: +00007FFAC46ACDA4 48B8F0DEBC9A78563412 mov rax,123456789ABCDEF0h +00007FFAC46ACDAE FFE0 jmp rax +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h +00007FFAC46ACDC1 488B0518570A00 mov rax,[rel 7FFAC47524E0h] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[rel 7FFAC474F208h] +00007FFAC46ACDD9 488D05787C0400 lea rax,[rel 7FFAC46F4A58h] +00007FFAC46ACDE0 33FF xor edi,edi + +Moved code: +00007FFAC48ACDA4 48895C2410 mov [rsp+10h],rbx +00007FFAC48ACDA9 4889742418 mov [rsp+18h],rsi +00007FFAC48ACDAE 55 push rbp +00007FFAC48ACDAF 57 push rdi +00007FFAC48ACDB0 E9FBFFDFFF jmp 00007FFAC46ACDB0h +} + +const + EXAMPLE_CODE_BITNESS = bt64; + HEXBYTES_COLUMN_BYTE_LENGTH = 12; + +procedure Disassemble( Data : PByte; Size : Cardinal; RIP : UInt64 ); +var + Instruction : TInstruction; + sOutput : String; + start_index : Integer; + i : Integer; + pInstruction: PAnsiChar; +begin + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + Iced.Decoder.SetData( Data, Size, RIP, doNONE ); + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + Iced.Formatter.FormatterType := ftNasm; + + // Change some options, there are many more +// Iced.Formatter.DigitSeparator := '`'; + Iced.Formatter.FirstOperandCharIndex := 10; + + while Iced.Decoder.CanDecode do + begin + Iced.DecodeFormat( Instruction, pInstruction ); + + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h]" + + // Hex + start_index := instruction.RIP-RIP; + sOutput := ''; + for i := start_index to start_index+Instruction.len-1 do + begin + sOutput := sOutput + IntToHex( Data^, 2 ); + Inc( Data ); + end; + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + + sOutput := Format( '%.16x ', [ instruction.RIP ] ) + sOutput + string( pInstruction ); + + WriteLn( sOutput ); + end; + + WriteLn( '' ); +end; + +const + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; +var + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); +const + // In 64-bit mode, we need 12 bytes to jump to any address: + // mov rax,imm64 // 10 + // jmp rax // 2 + // We overwrite rax because it's probably not used by the called function. + // In 32-bit mode, a normal JMP is just 5 bytes + required_bytes = 10+2; +var + YOUR_FUNC : UInt64 = UInt64( $123456789ABCDEF0 ); // Address of your code +var + Instruction : TInstruction; + Instructions : TInstructionList; + sOutput : String; + start_index : Integer; + i : Integer; + total_bytes : Cardinal; + relocated_base_address : UInt64; + Results : TBlockEncoderResult; + _target : UInt64; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + WriteLn( 'Original code:' ); + Disassemble( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP ); + + Instructions := TInstructionList.Create; + + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNONE ); + + total_bytes := 0; + while Iced.Decoder.CanDecode do + begin + Iced.Decoder.Decode( Instruction ); + if NOT Instruction.IsValid then + begin + WriteLn( 'Error: Decoding failed.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Instructions.Free; + Exit; + end; + + Instructions.Add( Instruction ); + Inc( total_bytes, Instruction.len ); + + if ( total_bytes >= required_bytes ) then + break; + + case Instruction.FlowControl.FlowControl of + fcNext : ; + + fcUnconditionalBranch : begin + // You could check if it's just jumping forward a few bytes and follow it + // but this is a simple example so we'll fail. + if ( Instruction.op_kinds[ 0 ].OpKind = okNearBranch64 ) then + _target := Instruction.NearBranchTarget; + + WriteLn( 'Not supported by this simple example.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Instructions.Free; + Exit; + end; + + fcIndirectBranch, + fcConditionalBranch, + fcReturn, + fcCall, + fcIndirectCall, + fcInterrupt, + fcXbeginXabortXend, + fcException : begin + WriteLn( 'Not supported by this simple example.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Instructions.Free; + Exit; + end; + end; + end; + + if ( total_bytes < required_bytes ) OR ( Instructions.Count < 1 ) then + begin + WriteLn( 'Not enough bytes!' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + // Create a JMP instruction that branches to the original code, except those instructions + // that we'll re-encode. We don't need to do it if it already ends in 'ret' + Instruction := Instructions[ Instructions.Count-1 ]; + if ( Instruction.FlowControl.FlowControl <> fcReturn ) then + Instructions.Add( Instruction.with_branch( Jmp_rel32_64, Instruction.next_rip ) ); + + // Relocate the code to some new location. It can fix short/near branches and + // convert them to short/near/long forms if needed. This also works even if it's a + // jrcxz/loop/loopcc instruction which only have short forms. + // + // It can currently only fix RIP relative operands if the new location is within 2GB + // of the target data location. + // + // Note that a block is not the same thing as a basic block. A block can contain any + // number of instructions, including any number of branch instructions. One block + // should be enough unless you must relocate different blocks to different locations. + relocated_base_address := EXAMPLE_CODE_RIP + $200000; + + Iced.BlockEncoder.Encode( relocated_base_address, Instructions, Results ); + Instructions.free; + + // Patch the original code. Pretend that we use some OS API to write to memory... + // We could use the BlockEncoder/Encoder for this but it's easy to do yourself too. + // This is 'mov rax,imm64; jmp rax' + EXAMPLE_CODE[ 0 ] := $48; // \ 'MOV RAX,imm64' + EXAMPLE_CODE[ 1 ] := $B8; + Move( YOUR_FUNC, EXAMPLE_CODE[ 2 ], SizeOf( YOUR_FUNC ) ); + EXAMPLE_CODE[ 10 ] := $FF; // \ JMP RAX + EXAMPLE_CODE[ 11 ] := $E0; + + // Disassemble it + WriteLn( 'Original + patched code:' ); + Disassemble( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP ); + + // Disassemble the moved code + WriteLn( 'Moved code:' ); + Disassemble( PByte( Results.code_buffer ), Results.code_buffer_len, relocated_base_address ); + + WriteLn( 'Press enter to exit.' ); + ReadLn; +``` + +## Get instruction info, eg. read/written regs/mem, control flow info, etc + +Shows how to get used registers/memory and other info. It uses [`Instruction`] methods +and an [`InstructionInfoFactory`] to get this info. + +[`Instruction`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.Instruction.html +[`InstructionInfoFactory`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.InstructionInfoFactory.html + +```pascal +{ +This example produces the following output: +00007FFAC46ACDA4 48895C2410 mov [rsp+10h],rbx + OpCode: o64 89 /r + Instruction: MOV r/m64, r64 + Encoding: Legacy + Mnemonic: Mov + Code: Mov_rm64_r64 + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 4, size = 1 + Memory Size: 8 + Op0Access: Write + Op1Access: Read + Op0: r64_or_mem + Op1: r64_reg + Used reg: RSP:Read + Used reg: RBX:Read + Used mem: SS:RSP+0x10:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDA9 4889742418 mov [rsp+18h],rsi + OpCode: o64 89 /r + Instruction: MOV r/m64, r64 + Encoding: Legacy + Mnemonic: Mov + Code: Mov_rm64_r64 + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 4, size = 1 + Memory Size: 8 + Op0Access: Write + Op1Access: Read + Op0: r64_or_mem + Op1: r64_reg + Used reg: RSP:Read + Used reg: RSI:Read + Used mem: SS:RSP+0x18:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDAE 55 push rbp + OpCode: o64 50+ro + Instruction: PUSH r64 + Encoding: Legacy + Mnemonic: Push + Code: Push_r64 + CpuidFeature: X64 + FlowControl: Next + SP Increment: -8 + Op0Access: Read + Op0: r64_opcode + Used reg: RBP:Read + Used reg: RSP:ReadWrite + Used mem: SS:RSP+0xFFFFFFFFFFFFFFF8:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDAF 57 push rdi + OpCode: o64 50+ro + Instruction: PUSH r64 + Encoding: Legacy + Mnemonic: Push + Code: Push_r64 + CpuidFeature: X64 + FlowControl: Next + SP Increment: -8 + Op0Access: Read + Op0: r64_opcode + Used reg: RDI:Read + Used reg: RSP:ReadWrite + Used mem: SS:RSP+0xFFFFFFFFFFFFFFF8:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDB0 4156 push r14 + OpCode: o64 50+ro + Instruction: PUSH r64 + Encoding: Legacy + Mnemonic: Push + Code: Push_r64 + CpuidFeature: X64 + FlowControl: Next + SP Increment: -8 + Op0Access: Read + Op0: r64_opcode + Used reg: R14:Read + Used reg: RSP:ReadWrite + Used mem: SS:RSP+0xFFFFFFFFFFFFFFF8:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] + OpCode: o64 8D /r + Instruction: LEA r64, m + Encoding: Legacy + Mnemonic: Lea + Code: Lea_r64_m + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 4, size = 4 + Op0Access: Write + Op1Access: NoMemAccess + Op0: r64_reg + Op1: mem + Used reg: RBP:Write + Used reg: RSP:Read +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h + OpCode: o64 81 /5 id + Instruction: SUB r/m64, imm32 + Encoding: Legacy + Mnemonic: Sub + Code: Sub_rm64_imm32 + CpuidFeature: X64 + FlowControl: Next + Immediate offset = 3, size = 4 + RFLAGS Written: OF, SF, ZF, AF, CF, PF + RFLAGS Modified: OF, SF, ZF, AF, CF, PF + Op0Access: ReadWrite + Op1Access: Read + Op0: r64_or_mem + Op1: imm32sex64 + Used reg: RSP:ReadWrite +00007FFAC46ACDC1 488B0518570A00 mov rax,[7FFAC47524E0h] + OpCode: o64 8B /r + Instruction: MOV r64, r/m64 + Encoding: Legacy + Mnemonic: Mov + Code: Mov_r64_rm64 + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 3, size = 4 + Memory Size: 8 + Op0Access: Write + Op1Access: Read + Op0: r64_reg + Op1: r64_or_mem + Used reg: RAX:Write + Used mem: DS:None+0x7FFAC47524E0:None:1:UInt64:Read:Code64:0 +00007FFAC46ACDC8 4833C4 xor rax,rsp + OpCode: o64 33 /r + Instruction: XOR r64, r/m64 + Encoding: Legacy + Mnemonic: Xor + Code: Xor_r64_rm64 + CpuidFeature: X64 + FlowControl: Next + RFLAGS Written: SF, ZF, PF + RFLAGS Cleared: OF, CF + RFLAGS Undefined: AF + RFLAGS Modified: OF, SF, ZF, AF, CF, PF + Op0Access: ReadWrite + Op1Access: Read + Op0: r64_reg + Op1: r64_or_mem + Used reg: RAX:ReadWrite + Used reg: RSP:Read +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax + OpCode: o64 89 /r + Instruction: MOV r/m64, r64 + Encoding: Legacy + Mnemonic: Mov + Code: Mov_rm64_r64 + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 3, size = 4 + Memory Size: 8 + Op0Access: Write + Op1Access: Read + Op0: r64_or_mem + Op1: r64_reg + Used reg: RBP:Read + Used reg: RAX:Read + Used mem: SS:RBP+0xF0:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[7FFAC474F208h] + OpCode: o64 8B /r + Instruction: MOV r64, r/m64 + Encoding: Legacy + Mnemonic: Mov + Code: Mov_r64_rm64 + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 3, size = 4 + Memory Size: 8 + Op0Access: Write + Op1Access: Read + Op0: r64_reg + Op1: r64_or_mem + Used reg: R8:Write + Used mem: DS:None+0x7FFAC474F208:None:1:UInt64:Read:Code64:0 +00007FFAC46ACDD9 488D05787C0400 lea rax,[7FFAC46F4A58h] + OpCode: o64 8D /r + Instruction: LEA r64, m + Encoding: Legacy + Mnemonic: Lea + Code: Lea_r64_m + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 3, size = 4 + Op0Access: Write + Op1Access: NoMemAccess + Op0: r64_reg + Op1: mem + Used reg: RAX:Write +00007FFAC46ACDE0 33FF xor edi,edi + OpCode: o32 33 /r + Instruction: XOR r32, r/m32 + Encoding: Legacy + Mnemonic: Xor + Code: Xor_r32_rm32 + CpuidFeature: INTEL386 + FlowControl: Next + RFLAGS Cleared: OF, SF, CF + RFLAGS Set: ZF, PF + RFLAGS Undefined: AF + RFLAGS Modified: OF, SF, ZF, AF, CF, PF + Op0Access: Write + Op1Access: None + Op0: r32_reg + Op1: r32_or_mem + Used reg: RDI:Write +} + +const +// HEXBYTES_COLUMN_BYTE_LENGTH = 16; // 30; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); +var + Instruction : TInstruction; + Offsets : TConstantOffsets; + FPU_Info : TFpuStackIncrementInfo; + CPUIDFeatures : TCPUIDFeaturesArray; + OPKinds : TOPKindsArray; + Encoding : TEncodingKind; + Mnemonic : TMnemonic; + FlowControl : TFlowControl; + OPKind : TOpCodeOperandKind; + MemorySize : TMemorySize; +// OPKinds_ : TOPCodeOperandKindArray; + Info : TInstructionInfo; + CC : TConditionCode; + RFlags : TRFlags; + tOutput : PAnsiChar; + + S : String; + C : UInt64; + i : Integer; + Data : PByte; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + Data := @EXAMPLE_CODE[ 0 ]; + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNONE ); + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + Iced.Formatter.FormatterType := ftMasm; + + while Iced.Decoder.CanDecode do + begin + Iced.DecodeFormat( Instruction, tOutput ); + + // Assembly + C := Instruction.next_rip-Instruction.len; + S := Format( '%.16x ', [ C ] ); + + for i := 0 to Instruction.len-1 do + begin + S := S + Format( '%.2x', [ Data^ ] ); + Inc( Data ); + end; + + S := S + ' '; + + WriteLn( S + String( tOutput ) ); + + // Gets offsets in the instruction of the displacement and immediates and their sizes. + // This can be useful if there are relocations in the binary. The encoder has a similar + // method. This method must be called after decode() and you must pass in the last + // instruction decode() returned. + Iced.Decoder.GetConstantOffsets( Instruction, Offsets ); + + WriteLn( ' OpCode: ' + Instruction.OpCodeString ); + WriteLn( ' Instruction: ' + Instruction.InstructionString ); + Encoding := Instruction.Encoding; + WriteLn( ' Encoding: ' + Encoding.AsString ); + Mnemonic := Instruction.Mnemonic; + WriteLn( ' Mnemonic: ' + Mnemonic.AsString ); + WriteLn( ' Code: ' + Instruction.code.AsString ); + + CPUIDFeatures := Instruction.CPUIDFeatures; + S := ''; + for i := 0 to CPUIDFeatures.Count-1 do + begin + if ( i > 0 ) then + S := S + 'AND ' + CPUIDFeatures.Entries[ i ].AsString + else + S := CPUIDFeatures.Entries[ i ].AsString; + end; + WriteLn( ' CpuidFeature: ' + S ); + + FlowControl := Instruction.FlowControl; + WriteLn( ' FlowControl: ' + FlowControl.AsString ); + + FPU_Info := Instruction.FPU_StackIncrementInfo; + if FPU_Info.writes_top then + begin + if ( FPU_Info.increment = 0 ) then + WriteLn( ' FPU TOP: the instruction overwrites TOP' ) + else + WriteLn( Format( ' FPU TOP inc: %d', [ FPU_Info.increment ] ) ); + + if FPU_Info.conditional then + WriteLn( ' FPU TOP cond write: true' ) + else + WriteLn( ' FPU TOP cond write: false' ); + end; + + if ( Offsets.displacement_size <> 0 ) then + WriteLn( Format( ' Displacement offset = %d, size = %d', [ Offsets.displacement_offset, Offsets.displacement_size ] ) ); + if ( Offsets.immediate_size <> 0 ) then + WriteLn( Format( ' Immediate offset = %d, size = %d', [ Offsets.immediate_offset, Offsets.immediate_size ] ) ); + if ( Offsets.immediate_size2 <> 0 ) then + WriteLn( Format( ' Immediate #2 offset = %d, size = %d', [ Offsets.immediate_offset2, Offsets.immediate_size2 ] ) ); + + if Instruction.IsStackInstruction then + WriteLn( Format( ' SP Increment: %d', [ Instruction.StackPointerIncrement ] ) ); + + CC := Instruction.ConditionCode; + RFlags := Instruction.RFlags; + if ( CC.ConditionCode <> cc_None ) then + WriteLn( Format( ' Condition code: %s', [ CC.AsString ] ) ); + + if ( NOT RFlags.Read.IsNone ) OR ( NOT RFlags.Written.IsNone ) OR ( NOT RFlags.Cleared.IsNone ) OR ( NOT RFlags.Set_.IsNone ) OR ( NOT RFlags.Undefined.IsNone ) OR ( NOT RFlags.Modified.IsNone ) then + begin + if ( NOT RFlags.Read.IsNone ) then + WriteLn( ' RFLAGS Read: ' + RFlags.Read.AsString ); + if ( NOT RFlags.Written.IsNone ) then + WriteLn( ' RFLAGS Written: ' + RFlags.Written.AsString ); + if ( NOT RFlags.Cleared.IsNone ) then + WriteLn( ' RFLAGS Cleared: ' + RFlags.Cleared.AsString ); + if ( NOT RFlags.Set_.IsNone ) then + WriteLn( ' RFLAGS Set: ' + RFlags.Set_.AsString ); + if ( NOT RFlags.Undefined.IsNone ) then + WriteLn( ' RFLAGS Undefined: ' + RFlags.Undefined.AsString ); + if ( NOT RFlags.Modified.IsNone ) then + WriteLn( ' RFLAGS Modified: ' + RFlags.Modified.AsString ); + end; + + FillChar( OPKinds, SizeOf( OPKinds ), 0 ); + Instruction.OPKinds( OPKinds ); + for i := 0 to OPKinds.Count-1 do + begin + if ( OPKinds.Entries[ i ].OpKind = okMemory ) then + begin + MemorySize := Instruction.MemorySize; + if ( MemorySize.Size <> 0 ) then + WriteLn( ' Memory Size: ' + IntToStr( MemorySize.Size ) ); + break; + end; + end; + + Iced.InfoFactory.Info( Instruction, Info ); + for i := 0 to Instruction.OPCount-1 do + WriteLn( Format( ' Op%dAccess: %s', [ i, Info.op_accesses[ i ].AsString ] ) ); + + for i := 0 to Instruction.OpCodeInfo_OPCount-1 do + begin + OPKind := Instruction.OpCodeInfo.op_kinds[ i ]; + WriteLn( Format( ' Op%d: %s', [ i, OPKind.AsString ] ) ); + end; + + for i := 0 to Info.used_registers.Count-1 do + WriteLn( Format( ' Used reg: %s:%s', [ Info.used_registers.Entries[ i ].register_.AsString, Info.used_registers.Entries[ i ].access.AsString ] ) ); + + for i := 0 to Info.used_memory_locations.Count-1 do + WriteLn( Format( ' Used mem: %s:%s+0x%.2x:%s:%d:%s:%s:%s:%d', [ + Info.used_memory_locations.Entries[ i ].segment.AsString, + Info.used_memory_locations.Entries[ i ].base.AsString, + Info.used_memory_locations.Entries[ i ].displacement, + Info.used_memory_locations.Entries[ i ].index.AsString, + Info.used_memory_locations.Entries[ i ].scale, + Info.used_memory_locations.Entries[ i ].memory_size.AsString, + Info.used_memory_locations.Entries[ i ].access.AsString, + Info.used_memory_locations.Entries[ i ].address_size.AsString, + Info.used_memory_locations.Entries[ i ].vsib_size + ] ) ); + end; + + WriteLn( 'Press enter to exit.' ); + ReadLn; +``` + +## Get the virtual address of a memory operand + +```pascal +function VirtualAddressResolverCallback( Register: TRegister; Index : NativeUInt; Size : NativeUInt; var Address : UInt64; UserData : Pointer ) : boolean; cdecl; +begin + result := True; + case Register.Register of + // The base address of ES, CS, SS and DS is always 0 in 64-bit mode + ES, CS, SS, DS: Address := 0; + + RDI : Address := $10000000; + R12 : Address := $000400000000; + else + result := False; + end; +end; + +const + HEXBYTES_COLUMN_BYTE_LENGTH = 5; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = 0; + EXAMPLE_CODE : Array [ 0..7 ] of Byte = ( $42, $01, $B4, $E7, $34, $12, $5A, $A5 ); + EXAMPLE_OFFSET = $0000001FB55A1234; +var + Instruction : TInstruction; + Offset : UInt64; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNone ); + + Iced.Decoder.Decode( Instruction ); + Offset := Instruction.VirtualAddress( VirtualAddressResolverCallback ); + if ( Offset = EXAMPLE_OFFSET ) then + WriteLn( 'OK: ' + Format( '%.16x', [ Offset ] ) ) + else + WriteLn( 'Failed.' ); + + WriteLn( 'Press enter to exit.' ); + ReadLn; +``` + +## Disassemble old/deprecated CPU instructions + +```pascal +{ +This example produces the following output: +00000000731E0A03 660F1A08 bndmov bnd1,[eax] +00000000731E0A07 0F26DE mov tr3,esi +00000000731E0A0A 0F3600 rdshr [eax] +00000000731E0A0D 0F39 dmint +00000000731E0A0F 0F7808 svdc [eax],cs +00000000731E0A12 0F3D cpu_read +00000000731E0A14 0F5808 pmvzb mm1,[eax] +00000000731E0A17 DFFC frinear +00000000731E0A19 0F3F altinst +} + +const + HEXBYTES_COLUMN_BYTE_LENGTH = 5; + EXAMPLE_CODE_BITNESS = bt32; + EXAMPLE_CODE_RIP = $731E0A03; + EXAMPLE_CODE : Array [ 0..23 ] of Byte = ( + // bndmov bnd1,[eax] + $66, $0F, $1A, $08, + // mov tr3,esi + $0F, $26, $DE, + // rdshr [eax] + $0F, $36, $00, + // dmint + $0F, $39, + // svdc [eax],cs + $0F, $78, $08, + // cpu_read + $0F, $3D, + // pmvzb mm1,[eax] + $0F, $58, $08, + // frinear + $DF, $FC, + // altinst + $0F, $3F + ); +var + Instruction : TInstruction; + sOutput : String; + start_index : Integer; + i : Integer; + pInstruction: PAnsiChar; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doMPX OR doMOV_TR OR doCYRIX OR doCYRIX_DMI OR doALTINST ); + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + Iced.Formatter.FormatterType := ftNasm; + + while Iced.Decoder.CanDecode do + begin + Iced.DecodeFormat( Instruction, pInstruction ); + + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h]" + + // Hex + start_index := instruction.RIP-EXAMPLE_CODE_RIP; + sOutput := ''; + for i := start_index to start_index+Instruction.len-1 do + sOutput := sOutput + IntToHex( EXAMPLE_CODE[ i ], 2 ); + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + + sOutput := Format( '%.16x ', [ instruction.RIP ] ) + sOutput + string( pInstruction ); + + WriteLn( sOutput ); + end; + + WriteLn( 'Press enter to exit.' ); + ReadLn; +``` + +## Disassemble as fast as possible + +For fastest possible disassembly you should set [`ENABLE_DB_DW_DD_DQ`] to `false` +and you should also override the unsafe [`verify_output_has_enough_bytes_left()`] and return `false`. + +[`ENABLE_DB_DW_DD_DQ`]: https://docs.rs/iced-x86/trait.SpecializedFormatterTraitOptions.html#associatedconstant.ENABLE_DB_DW_DD_DQ +[`verify_output_has_enough_bytes_left()`]: https://docs.rs/iced-x86/trait.SpecializedFormatterTraitOptions.html#method.verify_output_has_enough_bytes_left + +```pascal +{ +This example produces the following output: +00007FFAC46ACDA4 48895C2410 mov [rsp+0x10],rbx +00007FFAC46ACDA9 4889742418 mov [rsp+0x18],rsi +00007FFAC46ACDAE 55 push rbp +00007FFAC46ACDAF 57 push rdi +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-0x100] +00007FFAC46ACDBA 4881EC00020000 sub rsp,0x200 +00007FFAC46ACDC1 488B0518570A00 mov rax,[0x7FFAC47524E0] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0xF0],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[0x7FFAC474F208] +00007FFAC46ACDD9 488D05787C0400 lea rax,[0x7FFAC46F4A58] +00007FFAC46ACDE0 33FF xor edi,edi +} + +const + HEXBYTES_COLUMN_BYTE_LENGTH = 10; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); + +procedure DecodeFormatCallback( const Instruction: TInstruction; Formatted : PAnsiChar; Size : NativeUInt; var Stop : Boolean; UserData : Pointer ); cdecl; +type + PPByte = ^PByte; +var + sOutput : String; + i : Integer; +begin + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h]" + + // Hex + sOutput := ''; + for i := 0 to Instruction.len-1 do + begin + sOutput := sOutput + IntToHex( PPByte( UserData )^^, 2 ); + Inc( PPByte( UserData )^ ); + end; + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + + WriteLn( Format( '%.16x ', [ instruction.RIP ] ) + sOutput + Formatted ); +end; + +var + pData : PByte; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNONE ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + + // If you never create a db/dw/dd/dq 'instruction', we don't need this feature (default). + Iced.Formatter.Enable_DB_DW_DD_DQ := False; + + // For a few percent faster code, you can also disable this... (default). + Iced.Formatter.VerifyOutputHasEnoughBytesLeft := False; + + Iced.Formatter.FormatterType := ftSpecialized; + + // Change some options, there are many more + Iced.Formatter.UseHexPrefix := True; + + pData := @EXAMPLE_CODE[ 0 ]; + Iced.DecodeFormatToEnd( DecodeFormatCallback, @pData ); + + WriteLn( 'Press enter to exit.' ); + ReadLn; +``` + +## Create and encode instructions + +NOTE: It's much easier to just use [`CodeAssembler`], see the example above. +This example shows how to create instructions without using it. + +This example uses a [`BlockEncoder`] to encode created [`Instruction`]s. + +[`BlockEncoder`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.BlockEncoder.html +[`CodeAssembler`]: https://docs.rs/iced-x86/1.21.0/iced_x86/code_asm/struct.CodeAssembler.html +[`Instruction`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.Instruction.html + +```pascal +{ +This example produces the following output: +00001248FC840000 55 push %rbp +00001248FC840001 57 push %rdi +00001248FC840002 56 push %rsi +00001248FC840003 4881EC50000000 sub $0x50,%rsp +00001248FC84000A C5F877 vzeroupper +00001248FC84000D 488D6C2460 lea 0x60(%rsp),%rbp +00001248FC840012 488BF1 mov %rcx,%rsi +00001248FC840015 488D7DC8 lea -0x38(%rbp),%rdi +00001248FC840019 B90A000000 mov $0xA,%ecx +00001248FC84001E 33C0 xor %eax,%eax +00001248FC840020 F3AB rep stos %eax,(%rdi) +00001248FC840022 4881FE78563412 cmp $0x12345678,%rsi +00001248FC840029 7501 jne 0x00001248FC84002C +00001248FC84002B 90 nop +00001248FC84002C 4533FF xor %r15d,%r15d +00001248FC84002F 4C8D3501000000 lea 0x1248FC840037,%r14 +00001248FC840036 90 nop +00001248FC840037 12345678 .byte 0x12,0x34,0x56,0x78 +} +const + HEXBYTES_COLUMN_BYTE_LENGTH = 16; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00001248FC840000; + raw_data : Array [ 0..3 ] of Byte = ( $12, $34, $56, $78 ); +var + Instruction : TInstruction; + MemoryOperand : TMemoryOperand; + Instructions : TInstructionList; + Results : TBlockEncoderResult; + Data : PByte; + S : String; + i : Integer; + label1 : UInt64; + data1 : UInt64; + pInstruction : PAnsiChar; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Instructions := TInstructionList.Create; + // All created instructions get an IP of 0. The label id is just an IP. + // The branch instruction's *target* IP should be equal to the IP of the + // target instruction. + label1 := Instructions.CreateLabel; + + Instructions.Add( Instruction.with1( Push_r64, RBP ) ); + Instructions.Add( Instruction.with1( Push_r64, RDI ) ); + Instructions.Add( Instruction.with1( Push_r64, RSI ) ); + Instructions.Add( Instruction.with2( Sub_rm64_imm32, RSP, Cardinal( $50 ) ) ); + Instructions.Add( Instruction.with_( VEX_Vzeroupper ) ); + Instructions.Add( Instruction.with2( + Lea_r64_m, + RBP, + MemoryOperand.with_base_displ( RSP, $60 ) + ) ); + Instructions.Add( Instruction.with2( Mov_r64_rm64, RSI, RCX ) ); + Instructions.Add( Instruction.with2( + Lea_r64_m, + RDI, + MemoryOperand.with_base_displ( RBP, -$38 ) + ) ); + Instructions.Add( Instruction.with2( Mov_r32_imm32, ECX, Cardinal( $0A ) ) ); + Instructions.Add( Instruction.with2( Xor_r32_rm32, EAX, EAX ) ); + Instructions.Add( Instruction.with_rep_stosd( Cardinal( EXAMPLE_CODE_BITNESS ) ) ); + Instructions.Add( Instruction.with2( Cmp_rm64_imm32, RSI, Cardinal( $12345678 ) ) ); + // Create a branch instruction that references label1 + Instructions.Add( Instruction.with_branch( Jne_rel32_64, label1 ) ); + Instructions.Add( Instruction.with_( Nopd ) ); + // Add the instruction that is the target of the branch + Instructions.Add( Instruction.with2( Xor_r32_rm32, R15D, R15D ), label1 ); + + // Create an instruction that accesses some data using an RIP relative memory operand + data1 := Instructions.CreateLabel; + Instructions.Add( Instruction.with2( + Lea_r64_m, + R14, + MemoryOperand.with_base_displ( RIP, Int64( data1 ) ) + ) ); + Instructions.Add( Instruction.with_( Nopd ) ); + Instructions.Add( Instruction.with_declare_byte( @raw_data[ 0 ], Length( raw_data ) ), data1 ); + + // Use BlockEncoder to encode a block of instructions. This block can contain any + // number of branches and any number of instructions. It does support encoding more + // than one block but it's rarely needed. + // It uses Encoder to encode all instructions. + // If the target of a branch is too far away, it can fix it to use a longer branch. + // This can be disabled by enabling some BlockEncoderOptions flags. + + Iced.BlockEncoder.Bitness := EXAMPLE_CODE_BITNESS; + Iced.BlockEncoder.Encode( EXAMPLE_CODE_RIP, Instructions, Results ); + Instructions.Free; + + // Now disassemble the encoded instructions. Note that the 'jmp near' + // instruction was turned into a 'jmp short' instruction because we + // didn't disable branch optimizations. + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + Data := PByte( Results.code_buffer ); + Iced.Decoder.SetData( PByte( Results.code_buffer ), Results.code_buffer_len-Length( raw_data ), EXAMPLE_CODE_RIP{Results.RIP}, doNONE ); + + Iced.Formatter.FormatterType := ftGas; + Iced.Formatter.FirstOperandCharIndex := 8; + + while Iced.Decoder.CanDecode do + begin + Iced.DecodeFormat( Instruction, pInstruction ); + + // Assembly + S := Format( '%.16x ', [ Instruction.RIP ] ); + + for i := 0 to Instruction.len-1 do + begin + S := S + Format( '%.2x', [ Data^ ] ); + Inc( Data ); + end; + + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len*2+1 do + S := S + ' '; + + WriteLn( S + string( pInstruction ) ); + end; + + Instruction.from_declare_byte( Data, Length( raw_data ) ); + Instruction.len := Length( raw_data ); + S := Format( '%.16x ', [ Iced.Decoder.IP ] ); + for i := 0 to Instruction.len-1 do + begin + S := S + Format( '%.2x', [ Data^ ] ); + Inc( Data ); + end; + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len*2+1 do + S := S + ' '; + WriteLn( S + Iced.Formatter.FormatToString( Instruction ) ); + + WriteLn( 'Press enter to exit.' ); + ReadLn; +``` diff --git a/src/Delphi/Samples/CreateAndEncode/CreateAndEncode.dpr b/src/Delphi/Samples/CreateAndEncode/CreateAndEncode.dpr new file mode 100644 index 000000000..8022c7489 --- /dev/null +++ b/src/Delphi/Samples/CreateAndEncode/CreateAndEncode.dpr @@ -0,0 +1,176 @@ +program DisassembleGlobal; + +{$APPTYPE CONSOLE} + +uses + madExcept, + madLinkDisAsm, + madListHardware, + madListProcesses, + madListModules, + SysUtils, + + uIced.Types in '..\..\uIced.Types.pas', + uIced.Imports in '..\..\uIced.Imports.pas', + uIced in '..\..\uIced.pas'; + +{ +This example produces the following output: +00001248FC840000 55 push %rbp +00001248FC840001 57 push %rdi +00001248FC840002 56 push %rsi +00001248FC840003 4881EC50000000 sub $0x50,%rsp +00001248FC84000A C5F877 vzeroupper +00001248FC84000D 488D6C2460 lea 0x60(%rsp),%rbp +00001248FC840012 488BF1 mov %rcx,%rsi +00001248FC840015 488D7DC8 lea -0x38(%rbp),%rdi +00001248FC840019 B90A000000 mov $0xA,%ecx +00001248FC84001E 33C0 xor %eax,%eax +00001248FC840020 F3AB rep stos %eax,(%rdi) +00001248FC840022 4881FE78563412 cmp $0x12345678,%rsi +00001248FC840029 7501 jne 0x00001248FC84002C +00001248FC84002B 90 nop +00001248FC84002C 4533FF xor %r15d,%r15d +00001248FC84002F 4C8D3501000000 lea 0x1248FC840037,%r14 +00001248FC840036 90 nop +00001248FC840037 12345678 .byte 0x12,0x34,0x56,0x78 +} +const + HEXBYTES_COLUMN_BYTE_LENGTH = 16; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00001248FC840000; + raw_data : Array [ 0..3 ] of Byte = ( $12, $34, $56, $78 ); +var + Instruction : TInstruction; + MemoryOperand : TMemoryOperand; + Instructions : TInstructionList; + Results : TBlockEncoderResult; + Data : PByte; + S : String; + i : Integer; + label1 : UInt64; + data1 : UInt64; + pInstruction : PAnsiChar; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Instructions := TInstructionList.Create; + // All created instructions get an IP of 0. The label id is just an IP. + // The branch instruction's *target* IP should be equal to the IP of the + // target instruction. + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + label1 := Instructions.CreateLabel; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + Instructions.Add( Instruction.with1( Push_r64, RBP ) ); + Instructions.Add( Instruction.with1( Push_r64, RDI ) ); + Instructions.Add( Instruction.with1( Push_r64, RSI ) ); + Instructions.Add( Instruction.with2( Sub_rm64_imm32, RSP, Cardinal( $50 ) ) ); + Instructions.Add( Instruction.with_( VEX_Vzeroupper ) ); + Instructions.Add( Instruction.with2( + Lea_r64_m, + RBP, + MemoryOperand.with_base_displ( RSP, $60 ) + ) ); + Instructions.Add( Instruction.with2( Mov_r64_rm64, RSI, RCX ) ); + Instructions.Add( Instruction.with2( + Lea_r64_m, + RDI, + MemoryOperand.with_base_displ( RBP, -$38 ) + ) ); + Instructions.Add( Instruction.with2( Mov_r32_imm32, ECX, Cardinal( $0A ) ) ); + Instructions.Add( Instruction.with2( Xor_r32_rm32, EAX, EAX ) ); + Instructions.Add( Instruction.with_rep_stosd( Cardinal( EXAMPLE_CODE_BITNESS ) ) ); + Instructions.Add( Instruction.with2( Cmp_rm64_imm32, RSI, Cardinal( $12345678 ) ) ); + // Create a branch instruction that references label1 + Instructions.Add( Instruction.with_branch( Jne_rel32_64, label1 ) ); + Instructions.Add( Instruction.with_( Nopd ) ); + // Add the instruction that is the target of the branch + Instructions.Add( Instruction.with2( Xor_r32_rm32, R15D, R15D ), label1 ); + + // Create an instruction that accesses some data using an RIP relative memory operand + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + data1 := Instructions.CreateLabel; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Instructions.Add( Instruction.with2( + Lea_r64_m, + R14, + MemoryOperand.with_base_displ( RIP, Int64( data1 ) ) + ) ); + Instructions.Add( Instruction.with_( Nopd ) ); + Instructions.Add( Instruction.with_declare_byte( @raw_data[ 0 ], Length( raw_data ) ), data1 ); + + // Use BlockEncoder to encode a block of instructions. This block can contain any + // number of branches and any number of instructions. It does support encoding more + // than one block but it's rarely needed. + // It uses Encoder to encode all instructions. + // If the target of a branch is too far away, it can fix it to use a longer branch. + // This can be disabled by enabling some BlockEncoderOptions flags. + + Iced.BlockEncoder.Bitness := EXAMPLE_CODE_BITNESS; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.BlockEncoder.Encode( EXAMPLE_CODE_RIP, Instructions, Results ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Instructions.Free; + + // Now disassemble the encoded instructions. Note that the 'jmp near' + // instruction was turned into a 'jmp short' instruction because we + // didn't disable branch optimizations. + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + Data := PByte( Results.code_buffer ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( PByte( Results.code_buffer ), Results.code_buffer_len-Length( raw_data ), EXAMPLE_CODE_RIP{Results.RIP}, doNONE ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + Iced.Formatter.FormatterType := ftGas; + Iced.Formatter.FirstOperandCharIndex := 8; + + while Iced.Decoder.CanDecode do + begin +// Iced.Decoder.Decode( Instruction ); + Iced.DecodeFormat( Instruction, pInstruction ); + + // Assembly + S := Format( '%.16x ', [ Instruction.RIP ] ); + + for i := 0 to Instruction.len-1 do + begin + S := S + Format( '%.2x', [ Data^ ] ); + Inc( Data ); + end; + + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len*2+1 do + S := S + ' '; + +// WriteLn( S + Iced.Formatter.FormatToString( Instruction ) ); + WriteLn( S + string( pInstruction ) ); + end; + +// Data := PByte( Results.code_buffer ); // @raw_data[ 0 ]; +// Inc( Data, Results.code_buffer_len-Length( raw_data ) ); + Instruction.from_declare_byte( Data, Length( raw_data ) ); + Instruction.len := Length( raw_data ); + S := Format( '%.16x ', [ Iced.Decoder.IP ] ); + for i := 0 to Instruction.len-1 do + begin + S := S + Format( '%.2x', [ Data^ ] ); + Inc( Data ); + end; + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len*2+1 do + S := S + ' '; + WriteLn( S + Iced.Formatter.FormatToString( Instruction ) ); + +// Iced.Decoder.SetIP( Decoder, EXAMPLE_RIP ); +// Iced.Decoder.SetPosition( Decoder, 0 ); + + WriteLn( 'Press enter to exit.' ); + ReadLn; + +end. diff --git a/src/Delphi/Samples/DisassembleFast/DisassembleFast.dpr b/src/Delphi/Samples/DisassembleFast/DisassembleFast.dpr new file mode 100644 index 000000000..5caf56f4c --- /dev/null +++ b/src/Delphi/Samples/DisassembleFast/DisassembleFast.dpr @@ -0,0 +1,140 @@ +program DisassembleFast; + +{$APPTYPE CONSOLE} + +uses + madExcept, + madLinkDisAsm, + madListHardware, + madListProcesses, + madListModules, + SysUtils, + + uIced.Types in '..\..\uIced.Types.pas', + uIced.Imports in '..\..\uIced.Imports.pas', + uIced in '..\..\uIced.pas'; + +{ +This example produces the following output: +00007FFAC46ACDA4 48895C2410 mov [rsp+0x10],rbx +00007FFAC46ACDA9 4889742418 mov [rsp+0x18],rsi +00007FFAC46ACDAE 55 push rbp +00007FFAC46ACDAF 57 push rdi +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-0x100] +00007FFAC46ACDBA 4881EC00020000 sub rsp,0x200 +00007FFAC46ACDC1 488B0518570A00 mov rax,[0x7FFAC47524E0] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0xF0],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[0x7FFAC474F208] +00007FFAC46ACDD9 488D05787C0400 lea rax,[0x7FFAC46F4A58] +00007FFAC46ACDE0 33FF xor edi,edi +} + +const + HEXBYTES_COLUMN_BYTE_LENGTH = 10; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); + +procedure DecodeFormatCallback( const Instruction: TInstruction; Formatted : PAnsiChar; Size : NativeUInt; var Stop : Boolean; UserData : Pointer ); cdecl; +type + PPByte = ^PByte; +var + sOutput : String; + i : Integer; +begin + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h]" + + // Hex + sOutput := ''; + for i := 0 to Instruction.len-1 do + begin + sOutput := sOutput + IntToHex( PPByte( UserData )^^, 2 ); + Inc( PPByte( UserData )^ ); + end; + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + + WriteLn( Format( '%.16x ', [ instruction.RIP ] ) + sOutput + Formatted ); +end; + +var + pData : PByte; +// Instruction : TInstruction; +// pInstruction: PAnsiChar; +// sOutput : String; +// i : Integer; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNONE ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + + // If you never create a db/dw/dd/dq 'instruction', we don't need this feature (default). + Iced.Formatter.Enable_DB_DW_DD_DQ := False; + + // For a few percent faster code, you can also disable this... (default). + Iced.Formatter.VerifyOutputHasEnoughBytesLeft := False; + + Iced.Formatter.FormatterType := ftSpecialized; + + // Change some options, there are many more + Iced.Formatter.UseHexPrefix := True; + + pData := @EXAMPLE_CODE[ 0 ]; + Iced.DecodeFormatToEnd( DecodeFormatCallback, @pData ); +{ + while Iced.Decoder.CanDecode do + begin +// Iced.Decoder.Decode( Instruction ); + Iced.DecodeFormat( Instruction, pInstruction ); + + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h]" + + // Hex + sOutput := ''; + for i := 0 to Instruction.len-1 do + begin + sOutput := sOutput + IntToHex( pData^, 2 ); + Inc( pData ); + end; + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + +// sOutput := Format( '%.16x ', [ Instruction.RIP ] ) + sOutput + Iced.Formatter.FormatToString( Instruction ); + sOutput := Format( '%.16x ', [ Instruction.RIP ] ) + sOutput + string( pInstruction ); + + WriteLn( sOutput ); + end; +} + + WriteLn( 'Press enter to exit.' ); + ReadLn; + +end. diff --git a/src/Delphi/Samples/DisassembleGlobal/DisassembleGlobal.dpr b/src/Delphi/Samples/DisassembleGlobal/DisassembleGlobal.dpr new file mode 100644 index 000000000..07fc1be41 --- /dev/null +++ b/src/Delphi/Samples/DisassembleGlobal/DisassembleGlobal.dpr @@ -0,0 +1,98 @@ +program DisassembleGlobal; + +{$APPTYPE CONSOLE} + +uses + SysUtils, + + uIced.Types in '..\..\uIced.Types.pas', + uIced.Imports in '..\..\uIced.Imports.pas', + uIced in '..\..\uIced.pas'; + +{ +This example produces the following output: +00007FFAC46ACDA4 48895C2410 mov [rsp+10h],rbx +00007FFAC46ACDA9 4889742418 mov [rsp+18h],rsi +00007FFAC46ACDAE 55 push rbp +00007FFAC46ACDAF 57 push rdi +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h +00007FFAC46ACDC1 488B0518570A00 mov rax,[rel 7FFA`C475`24E0h] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[rel 7FFA`C474`F208h] +00007FFAC46ACDD9 488D05787C0400 lea rax,[rel 7FFA`C46F`4A58h] +00007FFAC46ACDE0 33FF xor edi,edi +} + +const + HEXBYTES_COLUMN_BYTE_LENGTH = 10; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); +var + Instruction : TInstruction; + sOutput : String; + start_index : Integer; + i : Integer; + pInstruction: PAnsiChar; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNONE ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + Iced.Formatter.FormatterType := ftNasm; + + // Change some options, there are many more + Iced.Formatter.DigitSeparator := '`'; + Iced.Formatter.FirstOperandCharIndex := 10; + + while Iced.Decoder.CanDecode do + begin +// Iced.Decoder.Decode( Instruction ); + Iced.DecodeFormat( Instruction, pInstruction ); + + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h]" + + // Hex + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + start_index := instruction.RIP-EXAMPLE_CODE_RIP; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + sOutput := ''; + for i := start_index to start_index+Instruction.len-1 do + sOutput := sOutput + IntToHex( EXAMPLE_CODE[ i ], 2 ); + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + +// sOutput := Format( '%.16x ', [ instruction.RIP ] ) + sOutput + Iced.Formatter.FormatToString( Instruction ); + sOutput := Format( '%.16x ', [ instruction.RIP ] ) + sOutput + string( pInstruction ); + + WriteLn( sOutput ); + end; + + WriteLn( 'Press enter to exit.' ); + ReadLn; + +end. diff --git a/src/Delphi/Samples/DisassembleLocal/DisassembleLocal.dpr b/src/Delphi/Samples/DisassembleLocal/DisassembleLocal.dpr new file mode 100644 index 000000000..927ea7ace --- /dev/null +++ b/src/Delphi/Samples/DisassembleLocal/DisassembleLocal.dpr @@ -0,0 +1,99 @@ +program DisassembleLocal; + +{$APPTYPE CONSOLE} + +uses + SysUtils, + + uIced.Types in '..\..\uIced.Types.pas', + uIced.Imports in '..\..\uIced.Imports.pas', + uIced in '..\..\uIced.pas'; + +{ +This example produces the following output: +00007FFAC46ACDA4 48895C2410 mov [rsp+10h],rbx +00007FFAC46ACDA9 4889742418 mov [rsp+18h],rsi +00007FFAC46ACDAE 55 push rbp +00007FFAC46ACDAF 57 push rdi +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h +00007FFAC46ACDC1 488B0518570A00 mov rax,[rel 7FFA`C475`24E0h] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[rel 7FFA`C474`F208h] +00007FFAC46ACDD9 488D05787C0400 lea rax,[rel 7FFA`C46F`4A58h] +00007FFAC46ACDE0 33FF xor edi,edi +} + +const + HEXBYTES_COLUMN_BYTE_LENGTH = 10; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); +var + Decoder : TIcedDecoder; + Formatter : TIcedFormatter; + Instruction : TInstruction; + sOutput : String; + start_index : Integer; + i : Integer; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Decoder := TIcedDecoder.Create( EXAMPLE_CODE_BITNESS ); + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNONE ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + Formatter := TIcedFormatter.Create( ftNasm ); + + // Change some options, there are many more + Formatter.DigitSeparator := '`'; + Formatter.FirstOperandCharIndex := 10; + + while Decoder.CanDecode do + begin + Decoder.Decode( Instruction ); + + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h]" + + // Hex + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + start_index := instruction.RIP-EXAMPLE_CODE_RIP; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + sOutput := ''; + for i := start_index to start_index+Instruction.len-1 do + sOutput := sOutput + IntToHex( EXAMPLE_CODE[ i ], 2 ); + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + + sOutput := Format( '%.16x ', [ instruction.RIP ] ) + sOutput + Formatter.FormatToString( Instruction ); + + WriteLn( sOutput ); + end; + Decoder.free; + Formatter.free; + + WriteLn( 'Press enter to exit.' ); + ReadLn; + +end. diff --git a/src/Delphi/Samples/DisassembleOldInstructions/DisassembleOldInstructions.dpr b/src/Delphi/Samples/DisassembleOldInstructions/DisassembleOldInstructions.dpr new file mode 100644 index 000000000..91e3a2863 --- /dev/null +++ b/src/Delphi/Samples/DisassembleOldInstructions/DisassembleOldInstructions.dpr @@ -0,0 +1,105 @@ +program DisassembleOldInstructions; + +{$APPTYPE CONSOLE} + +uses + SysUtils, + + uIced.Types in '..\..\uIced.Types.pas', + uIced.Imports in '..\..\uIced.Imports.pas', + uIced in '..\..\uIced.pas'; + +{ +This example produces the following output: +00000000731E0A03 660F1A08 bndmov bnd1,[eax] +00000000731E0A07 0F26DE mov tr3,esi +00000000731E0A0A 0F3600 rdshr [eax] +00000000731E0A0D 0F39 dmint +00000000731E0A0F 0F7808 svdc [eax],cs +00000000731E0A12 0F3D cpu_read +00000000731E0A14 0F5808 pmvzb mm1,[eax] +00000000731E0A17 DFFC frinear +00000000731E0A19 0F3F altinst +} + +const + HEXBYTES_COLUMN_BYTE_LENGTH = 5; + EXAMPLE_CODE_BITNESS = bt32; + EXAMPLE_CODE_RIP = $731E0A03; + EXAMPLE_CODE : Array [ 0..23 ] of Byte = ( + // bndmov bnd1,[eax] + $66, $0F, $1A, $08, + // mov tr3,esi + $0F, $26, $DE, + // rdshr [eax] + $0F, $36, $00, + // dmint + $0F, $39, + // svdc [eax],cs + $0F, $78, $08, + // cpu_read + $0F, $3D, + // pmvzb mm1,[eax] + $0F, $58, $08, + // frinear + $DF, $FC, + // altinst + $0F, $3F + ); +var + Instruction : TInstruction; + sOutput : String; + start_index : Integer; + i : Integer; + pInstruction: PAnsiChar; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doMPX OR doMOV_TR OR doCYRIX OR doCYRIX_DMI OR doALTINST ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + Iced.Formatter.FormatterType := ftNasm; + + while Iced.Decoder.CanDecode do + begin +// Iced.Decoder.Decode( Instruction ); + Iced.DecodeFormat( Instruction, pInstruction ); + + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h]" + + // Hex + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + start_index := instruction.RIP-EXAMPLE_CODE_RIP; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + sOutput := ''; + for i := start_index to start_index+Instruction.len-1 do + sOutput := sOutput + IntToHex( EXAMPLE_CODE[ i ], 2 ); + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + +// sOutput := Format( '%.16x ', [ instruction.RIP ] ) + sOutput + Iced.Formatter.FormatToString( Instruction ); + sOutput := Format( '%.16x ', [ instruction.RIP ] ) + sOutput + string( pInstruction ); + + WriteLn( sOutput ); + end; + + WriteLn( 'Press enter to exit.' ); + ReadLn; + +end. \ No newline at end of file diff --git a/src/Delphi/Samples/DisassembleStringLists/DisassembleStringLists.dpr b/src/Delphi/Samples/DisassembleStringLists/DisassembleStringLists.dpr new file mode 100644 index 000000000..2510f30e4 --- /dev/null +++ b/src/Delphi/Samples/DisassembleStringLists/DisassembleStringLists.dpr @@ -0,0 +1,102 @@ +program DisassembleStringLists; + +{$APPTYPE CONSOLE} + +uses + SysUtils, + Classes, + + uIced.Types in '..\..\uIced.Types.pas', + uIced.Imports in '..\..\uIced.Imports.pas', + uIced in '..\..\uIced.pas'; + +{ +This example produces the following output: +00007FFAC46ACDA4 48895C2410 mov [rsp+10h],rbx +00007FFAC46ACDA9 4889742418 mov [rsp+18h],rsi +00007FFAC46ACDAE 55 push rbp +00007FFAC46ACDAF 57 push rdi +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h +00007FFAC46ACDC1 488B0518570A00 mov rax,[rel 7FFA`C475`24E0h] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[rel 7FFA`C474`F208h] +00007FFAC46ACDD9 488D05787C0400 lea rax,[rel 7FFA`C46F`4A58h] +00007FFAC46ACDE0 33FF xor edi,edi +} + +const + HEXBYTES_COLUMN_BYTE_LENGTH = 10; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); +var + Assembly : TStringList; + Hex : TStringList; + Len : Byte; + Offset : UInt64; + i, j : Integer; + sOutput : String; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + Iced.Formatter.FormatterType := ftNasm; + + // Change some options, there are many more + Iced.Formatter.DigitSeparator := '`'; + Iced.Formatter.FirstOperandCharIndex := 10; + + Assembly := TStringList.Create; + Hex := TStringList.Create; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( Iced.Decode( PByte( @EXAMPLE_CODE[ 0 ] ), Cardinal( Length( EXAMPLE_CODE ) ), Assembly, EXAMPLE_CODE_RIP, Hex, doNONE ) = 0 ) then + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + begin + WriteLn( 'Decoding failed.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Offset := EXAMPLE_CODE_RIP; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + for i := 0 to Hex.Count-1 do + begin + sOutput := Hex[ i ]; + Len := Length( sOutput ) div 2; + if ( Len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for j := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Len-1 do + sOutput := sOutput + ' ' + end; + + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h]" + sOutput := Format( '%.16x ', [ Offset ] ) + sOutput + Assembly[ i ]; + Inc( Offset, Len ); + + WriteLn( sOutput ); + end; + Assembly.Free; + Hex.Free; + + WriteLn( 'Press enter to exit.' ); + ReadLn; + +end. diff --git a/src/Delphi/Samples/FormatterOutput/FormatterOutput.dpr b/src/Delphi/Samples/FormatterOutput/FormatterOutput.dpr new file mode 100644 index 000000000..eafb13942 --- /dev/null +++ b/src/Delphi/Samples/FormatterOutput/FormatterOutput.dpr @@ -0,0 +1,18 @@ +program FormatterOutput; + +uses + Forms, + + uIced.Types in '..\..\uIced.Types.pas', + uIced.Imports in '..\..\uIced.Imports.pas', + uIced in '..\..\uIced.pas', + + Main in 'Main.pas' {FrmFormatterOutput}; + +{$R *.res} + +begin + Application.Initialize; + Application.CreateForm(TFrmFormatterOutput, FrmFormatterOutput); + Application.Run; +end. diff --git a/src/Delphi/Samples/FormatterOutput/Main.dfm b/src/Delphi/Samples/FormatterOutput/Main.dfm new file mode 100644 index 000000000..b75dd7188 --- /dev/null +++ b/src/Delphi/Samples/FormatterOutput/Main.dfm @@ -0,0 +1,36 @@ +object FrmFormatterOutput: TFrmFormatterOutput + Left = 484 + Top = 226 + AutoScroll = False + Caption = 'FormatterOutput' + ClientHeight = 246 + ClientWidth = 535 + Color = clBtnFace + Font.Charset = DEFAULT_CHARSET + Font.Color = clWindowText + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [] + OldCreateOrder = False + Position = poScreenCenter + PrintScale = poNone + Scaled = False + OnShow = FormShow + PixelsPerInch = 96 + TextHeight = 13 + object rEdtOutput: TRichEdit + Left = 0 + Top = 0 + Width = 535 + Height = 246 + Align = alClient + Font.Charset = DEFAULT_CHARSET + Font.Color = clWindowText + Font.Height = -11 + Font.Name = 'Consolas' + Font.Style = [] + ParentFont = False + ReadOnly = True + TabOrder = 0 + end +end diff --git a/src/Delphi/Samples/FormatterOutput/Main.pas b/src/Delphi/Samples/FormatterOutput/Main.pas new file mode 100644 index 000000000..ca5c06fa6 --- /dev/null +++ b/src/Delphi/Samples/FormatterOutput/Main.pas @@ -0,0 +1,157 @@ +unit Main; + +{ +This example produces the following output: +00007FFAC46ACDA4 48895C2410 mov [rsp+10h],rbx +00007FFAC46ACDA9 4889742418 mov [rsp+18h],rsi +00007FFAC46ACDAE 55 push rbp +00007FFAC46ACDAF 57 push rdi +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h +00007FFAC46ACDC1 488B0518570A00 mov rax,[7FFAC47524E0h] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[7FFAC474F208h] +00007FFAC46ACDD9 488D05787C0400 lea rax,[7FFAC46F4A58h] +00007FFAC46ACDE0 33FF xor edi,edi +} + +interface + +uses + Classes, Controls, Forms, StdCtrls, ComCtrls; + +type + TFrmFormatterOutput = class(TForm) + rEdtOutput: TRichEdit; + procedure FormShow(Sender: TObject); + private + { Private-Deklarationen } + procedure DisassembleWithFormatterCallback; + public + { Public-Deklarationen } + end; + +var + FrmFormatterOutput: TFrmFormatterOutput; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +implementation + +{$R *.dfm} + +uses + Graphics, SysUtils, + uIced.Types, + uIced.Imports, + uIced; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +procedure TFrmFormatterOutput.FormShow(Sender: TObject); +begin + DisassembleWithFormatterCallback; +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +procedure FormatterOutputCallback( Text : PAnsiChar; Kind : TFormatterTextKind; UserData : Pointer ); cdecl; +begin + // Determine Color + case Kind.FormatterTextKind of + ftkDirective, + ftkKeyword : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clYellow; + + ftkPrefix, + ftkMnemonic : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clRed; + + ftkRegister : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clMaroon; + ftkNumber : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clGray; + +// ftkText : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := ; +// ftkOperator : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := ; +// ftkPunctuation : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := ; +// +// ftkDecorator : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := ; +// ftkSelectorValue : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := ; +// ftkLabelAddress : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := ; +// ftkFunctionAddress : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := ; +// ftkData : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := ; +// ftkLabel : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := ; +// ftkFunction : FrmFormatterOutput.rEdtOutput.SelAttributes.Color := ; + else + FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clWindowText; + end; + + // Append Text + FrmFormatterOutput.rEdtOutput.SelText := Text; +end; + +procedure TFrmFormatterOutput.DisassembleWithFormatterCallback; +const + HEXBYTES_COLUMN_BYTE_LENGTH = 10; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); +var + Instruction : TInstruction; + sOutput : String; + start_index : Integer; + i : Integer; +begin + rEdtOutput.Lines.Clear; + if NOT IsInitDLL then + begin + rEdtOutput.Lines.Add( 'Library not loaded.' ); + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNONE ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // NOT for Fast and Specialized + Iced.Formatter.FormatterType := ftIntel; + Iced.Formatter.FirstOperandCharIndex := 8; + Iced.Formatter.Callback := FormatterOutputCallback; + + while Iced.Decoder.CanDecode do + begin + Iced.Decoder.Decode( Instruction ); + + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF " + + // Hex + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + start_index := instruction.RIP-EXAMPLE_CODE_RIP; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + sOutput := ''; + for i := start_index to start_index+Instruction.len-1 do + sOutput := sOutput + IntToHex( EXAMPLE_CODE[ i ], 2 ); + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + + // Set Color for offset and Hex + FrmFormatterOutput.rEdtOutput.SelAttributes.Color := clWindowText; + rEdtOutput.SelText := Format( '%.16x ', [ instruction.RIP ] ) + sOutput; + + // Formatter callback gets called with each TextKind + // Eg. "lea rbp,[rsp-100h]" + Iced.Formatter.Format( Instruction ); + + // Start new line + rEdtOutput.SelText := #13#10; + end; +end; + +end. diff --git a/src/Delphi/Samples/GetInstructionInfo/GetInstructionInfo.dpr b/src/Delphi/Samples/GetInstructionInfo/GetInstructionInfo.dpr new file mode 100644 index 000000000..1d654c24f --- /dev/null +++ b/src/Delphi/Samples/GetInstructionInfo/GetInstructionInfo.dpr @@ -0,0 +1,420 @@ +program GetInstructionInfo; + +{$APPTYPE CONSOLE} + +uses + SysUtils, + + uIced.Types in '..\..\uIced.Types.pas', + uIced.Imports in '..\..\uIced.Imports.pas', + uIced in '..\..\uIced.pas'; + +{ +This example produces the following output: +00007FFAC46ACDA4 48895C2410 mov [rsp+10h],rbx + OpCode: o64 89 /r + Instruction: MOV r/m64, r64 + Encoding: Legacy + Mnemonic: Mov + Code: Mov_rm64_r64 + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 4, size = 1 + Memory Size: 8 + Op0Access: Write + Op1Access: Read + Op0: r64_or_mem + Op1: r64_reg + Used reg: RSP:Read + Used reg: RBX:Read + Used mem: SS:RSP+0x10:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDA9 4889742418 mov [rsp+18h],rsi + OpCode: o64 89 /r + Instruction: MOV r/m64, r64 + Encoding: Legacy + Mnemonic: Mov + Code: Mov_rm64_r64 + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 4, size = 1 + Memory Size: 8 + Op0Access: Write + Op1Access: Read + Op0: r64_or_mem + Op1: r64_reg + Used reg: RSP:Read + Used reg: RSI:Read + Used mem: SS:RSP+0x18:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDAE 55 push rbp + OpCode: o64 50+ro + Instruction: PUSH r64 + Encoding: Legacy + Mnemonic: Push + Code: Push_r64 + CpuidFeature: X64 + FlowControl: Next + SP Increment: -8 + Op0Access: Read + Op0: r64_opcode + Used reg: RBP:Read + Used reg: RSP:ReadWrite + Used mem: SS:RSP+0xFFFFFFFFFFFFFFF8:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDAF 57 push rdi + OpCode: o64 50+ro + Instruction: PUSH r64 + Encoding: Legacy + Mnemonic: Push + Code: Push_r64 + CpuidFeature: X64 + FlowControl: Next + SP Increment: -8 + Op0Access: Read + Op0: r64_opcode + Used reg: RDI:Read + Used reg: RSP:ReadWrite + Used mem: SS:RSP+0xFFFFFFFFFFFFFFF8:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDB0 4156 push r14 + OpCode: o64 50+ro + Instruction: PUSH r64 + Encoding: Legacy + Mnemonic: Push + Code: Push_r64 + CpuidFeature: X64 + FlowControl: Next + SP Increment: -8 + Op0Access: Read + Op0: r64_opcode + Used reg: R14:Read + Used reg: RSP:ReadWrite + Used mem: SS:RSP+0xFFFFFFFFFFFFFFF8:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] + OpCode: o64 8D /r + Instruction: LEA r64, m + Encoding: Legacy + Mnemonic: Lea + Code: Lea_r64_m + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 4, size = 4 + Op0Access: Write + Op1Access: NoMemAccess + Op0: r64_reg + Op1: mem + Used reg: RBP:Write + Used reg: RSP:Read +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h + OpCode: o64 81 /5 id + Instruction: SUB r/m64, imm32 + Encoding: Legacy + Mnemonic: Sub + Code: Sub_rm64_imm32 + CpuidFeature: X64 + FlowControl: Next + Immediate offset = 3, size = 4 + RFLAGS Written: OF, SF, ZF, AF, CF, PF + RFLAGS Modified: OF, SF, ZF, AF, CF, PF + Op0Access: ReadWrite + Op1Access: Read + Op0: r64_or_mem + Op1: imm32sex64 + Used reg: RSP:ReadWrite +00007FFAC46ACDC1 488B0518570A00 mov rax,[7FFAC47524E0h] + OpCode: o64 8B /r + Instruction: MOV r64, r/m64 + Encoding: Legacy + Mnemonic: Mov + Code: Mov_r64_rm64 + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 3, size = 4 + Memory Size: 8 + Op0Access: Write + Op1Access: Read + Op0: r64_reg + Op1: r64_or_mem + Used reg: RAX:Write + Used mem: DS:None+0x7FFAC47524E0:None:1:UInt64:Read:Code64:0 +00007FFAC46ACDC8 4833C4 xor rax,rsp + OpCode: o64 33 /r + Instruction: XOR r64, r/m64 + Encoding: Legacy + Mnemonic: Xor + Code: Xor_r64_rm64 + CpuidFeature: X64 + FlowControl: Next + RFLAGS Written: SF, ZF, PF + RFLAGS Cleared: OF, CF + RFLAGS Undefined: AF + RFLAGS Modified: OF, SF, ZF, AF, CF, PF + Op0Access: ReadWrite + Op1Access: Read + Op0: r64_reg + Op1: r64_or_mem + Used reg: RAX:ReadWrite + Used reg: RSP:Read +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax + OpCode: o64 89 /r + Instruction: MOV r/m64, r64 + Encoding: Legacy + Mnemonic: Mov + Code: Mov_rm64_r64 + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 3, size = 4 + Memory Size: 8 + Op0Access: Write + Op1Access: Read + Op0: r64_or_mem + Op1: r64_reg + Used reg: RBP:Read + Used reg: RAX:Read + Used mem: SS:RBP+0xF0:None:1:UInt64:Write:Code64:0 +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[7FFAC474F208h] + OpCode: o64 8B /r + Instruction: MOV r64, r/m64 + Encoding: Legacy + Mnemonic: Mov + Code: Mov_r64_rm64 + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 3, size = 4 + Memory Size: 8 + Op0Access: Write + Op1Access: Read + Op0: r64_reg + Op1: r64_or_mem + Used reg: R8:Write + Used mem: DS:None+0x7FFAC474F208:None:1:UInt64:Read:Code64:0 +00007FFAC46ACDD9 488D05787C0400 lea rax,[7FFAC46F4A58h] + OpCode: o64 8D /r + Instruction: LEA r64, m + Encoding: Legacy + Mnemonic: Lea + Code: Lea_r64_m + CpuidFeature: X64 + FlowControl: Next + Displacement offset = 3, size = 4 + Op0Access: Write + Op1Access: NoMemAccess + Op0: r64_reg + Op1: mem + Used reg: RAX:Write +00007FFAC46ACDE0 33FF xor edi,edi + OpCode: o32 33 /r + Instruction: XOR r32, r/m32 + Encoding: Legacy + Mnemonic: Xor + Code: Xor_r32_rm32 + CpuidFeature: INTEL386 + FlowControl: Next + RFLAGS Cleared: OF, SF, CF + RFLAGS Set: ZF, PF + RFLAGS Undefined: AF + RFLAGS Modified: OF, SF, ZF, AF, CF, PF + Op0Access: Write + Op1Access: None + Op0: r32_reg + Op1: r32_or_mem + Used reg: RDI:Write +} + +const +// HEXBYTES_COLUMN_BYTE_LENGTH = 16; // 30; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); +var + Instruction : TInstruction; + Offsets : TConstantOffsets; + FPU_Info : TFpuStackIncrementInfo; + CPUIDFeatures : TCPUIDFeaturesArray; + OPKinds : TOPKindsArray; + Encoding : TEncodingKind; + Mnemonic : TMnemonic; + FlowControl : TFlowControl; + OPKind : TOpCodeOperandKind; + MemorySize : TMemorySize; +// OPKinds_ : TOPCodeOperandKindArray; + Info : TInstructionInfo; + CC : TConditionCode; + RFlags : TRFlags; + tOutput : PAnsiChar; + + S : String; + C : UInt64; + i : Integer; + Data : PByte; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + Data := @EXAMPLE_CODE[ 0 ]; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNONE ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + Iced.Formatter.FormatterType := ftMasm; + + while Iced.Decoder.CanDecode do + begin + Iced.DecodeFormat( Instruction, tOutput ); + + // Assembly + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + C := Instruction.next_rip-Instruction.len; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + S := Format( '%.16x ', [ C ] ); + + for i := 0 to Instruction.len-1 do + begin + S := S + Format( '%.2x', [ Data^ ] ); + Inc( Data ); + end; + +// for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len*2+1 do + S := S + ' '; + + // For quick hacks, it's fine to use the Display trait to format an instruction, + // but for real code, use a formatter, eg. MasmFormatter. See other examples. +// WriteLn( S + Instruction.Format ); + +// Iced.Formatter.Format( Instruction, tOutput ); + WriteLn( S + tOutput ); + + // Gets offsets in the instruction of the displacement and immediates and their sizes. + // This can be useful if there are relocations in the binary. The encoder has a similar + // method. This method must be called after decode() and you must pass in the last + // instruction decode() returned. + Iced.Decoder.GetConstantOffsets( Instruction, Offsets ); + +// FillChar( OPKinds_, SizeOf( OPKinds_ ), 0 ); +// Instruction.OpCodeInfo_OPKinds( OPKinds_ ); + + WriteLn( ' OpCode: ' + Instruction.OpCodeString ); + WriteLn( ' Instruction: ' + Instruction.InstructionString ); + Encoding := Instruction.Encoding; + WriteLn( ' Encoding: ' + Encoding.AsString ); + Mnemonic := Instruction.Mnemonic; + WriteLn( ' Mnemonic: ' + Mnemonic.AsString ); + WriteLn( ' Code: ' + Instruction.code.AsString ); + + CPUIDFeatures := Instruction.CPUIDFeatures; + S := ''; + for i := 0 to CPUIDFeatures.Count-1 do + begin + if ( i > 0 ) then + S := S + 'AND ' + CPUIDFeatures.Entries[ i ].AsString + else + S := CPUIDFeatures.Entries[ i ].AsString; + end; + WriteLn( ' CpuidFeature: ' + S ); + + FlowControl := Instruction.FlowControl; + WriteLn( ' FlowControl: ' + FlowControl.AsString ); + + FPU_Info := Instruction.FPU_StackIncrementInfo; + if FPU_Info.writes_top then + begin + if ( FPU_Info.increment = 0 ) then + WriteLn( ' FPU TOP: the instruction overwrites TOP' ) + else + WriteLn( Format( ' FPU TOP inc: %d', [ FPU_Info.increment ] ) ); + + if FPU_Info.conditional then + WriteLn( ' FPU TOP cond write: true' ) + else + WriteLn( ' FPU TOP cond write: false' ); + end; + + if ( Offsets.displacement_size <> 0 ) then + WriteLn( Format( ' Displacement offset = %d, size = %d', [ Offsets.displacement_offset, Offsets.displacement_size ] ) ); + if ( Offsets.immediate_size <> 0 ) then + WriteLn( Format( ' Immediate offset = %d, size = %d', [ Offsets.immediate_offset, Offsets.immediate_size ] ) ); + if ( Offsets.immediate_size2 <> 0 ) then + WriteLn( Format( ' Immediate #2 offset = %d, size = %d', [ Offsets.immediate_offset2, Offsets.immediate_size2 ] ) ); + + if Instruction.IsStackInstruction then + WriteLn( Format( ' SP Increment: %d', [ Instruction.StackPointerIncrement ] ) ); + + CC := Instruction.ConditionCode; + RFlags := Instruction.RFlags; + if ( CC.ConditionCode <> cc_None ) then + WriteLn( Format( ' Condition code: %s', [ CC.AsString ] ) ); + + if ( NOT RFlags.Read.IsNone ) OR ( NOT RFlags.Written.IsNone ) OR ( NOT RFlags.Cleared.IsNone ) OR ( NOT RFlags.Set_.IsNone ) OR ( NOT RFlags.Undefined.IsNone ) OR ( NOT RFlags.Modified.IsNone ) then + begin + if ( NOT RFlags.Read.IsNone ) then + WriteLn( ' RFLAGS Read: ' + RFlags.Read.AsString ); + if ( NOT RFlags.Written.IsNone ) then + WriteLn( ' RFLAGS Written: ' + RFlags.Written.AsString ); + if ( NOT RFlags.Cleared.IsNone ) then + WriteLn( ' RFLAGS Cleared: ' + RFlags.Cleared.AsString ); + if ( NOT RFlags.Set_.IsNone ) then + WriteLn( ' RFLAGS Set: ' + RFlags.Set_.AsString ); + if ( NOT RFlags.Undefined.IsNone ) then + WriteLn( ' RFLAGS Undefined: ' + RFlags.Undefined.AsString ); + if ( NOT RFlags.Modified.IsNone ) then + WriteLn( ' RFLAGS Modified: ' + RFlags.Modified.AsString ); + end; + + FillChar( OPKinds, SizeOf( OPKinds ), 0 ); + Instruction.OPKinds( OPKinds ); + for i := 0 to OPKinds.Count-1 do + begin + if ( OPKinds.Entries[ i ].OpKind = okMemory ) then + begin + MemorySize := Instruction.MemorySize; + if ( MemorySize.Size <> 0 ) then + WriteLn( ' Memory Size: ' + IntToStr( MemorySize.Size ) ); + break; + end; + end; + + Iced.InfoFactory.Info( Instruction, Info ); + for i := 0 to Instruction.OPCount-1 do + WriteLn( Format( ' Op%dAccess: %s', [ i, Info.op_accesses[ i ].AsString ] ) ); + + for i := 0 to Instruction.OpCodeInfo_OPCount-1 do + begin + OPKind := Instruction.OpCodeInfo.op_kinds[ i ]; + WriteLn( Format( ' Op%d: %s', [ i, OPKind.AsString ] ) ); + end; + + for i := 0 to Info.used_registers.Count-1 do + WriteLn( Format( ' Used reg: %s:%s', [ Info.used_registers.Entries[ i ].register_.AsString, Info.used_registers.Entries[ i ].access.AsString ] ) ); + + for i := 0 to Info.used_memory_locations.Count-1 do +// WriteLn( ' Used mem: ' + Info.used_memory_locations.Entries[ i ].AsString ); + WriteLn( Format( ' Used mem: %s:%s+0x%.2x:%s:%d:%s:%s:%s:%d', [ + Info.used_memory_locations.Entries[ i ].segment.AsString, + Info.used_memory_locations.Entries[ i ].base.AsString, + Info.used_memory_locations.Entries[ i ].displacement, + Info.used_memory_locations.Entries[ i ].index.AsString, + Info.used_memory_locations.Entries[ i ].scale, + Info.used_memory_locations.Entries[ i ].memory_size.AsString, + Info.used_memory_locations.Entries[ i ].access.AsString, + Info.used_memory_locations.Entries[ i ].address_size.AsString, + Info.used_memory_locations.Entries[ i ].vsib_size + ] ) ); + end; +// Iced.Decoder.SetIP( Decoder, EXAMPLE_RIP ); +// Iced.Decoder.SetPosition( Decoder, 0 ); + + WriteLn( 'Press enter to exit.' ); + ReadLn; + +end. diff --git a/src/Delphi/Samples/HookCode/HookCode.dpr b/src/Delphi/Samples/HookCode/HookCode.dpr new file mode 100644 index 000000000..994b6e372 --- /dev/null +++ b/src/Delphi/Samples/HookCode/HookCode.dpr @@ -0,0 +1,266 @@ +program HookCode; + +{$APPTYPE CONSOLE} + +uses + SysUtils, + + uIced.Types in '..\..\uIced.Types.pas', + uIced.Imports in '..\..\uIced.Imports.pas', + uIced in '..\..\uIced.pas'; + +{ +This example produces the following output: +Original code: +00007FFAC46ACDA4 48895C2410 mov [rsp+10h],rbx +00007FFAC46ACDA9 4889742418 mov [rsp+18h],rsi +00007FFAC46ACDAE 55 push rbp +00007FFAC46ACDAF 57 push rdi +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h +00007FFAC46ACDC1 488B0518570A00 mov rax,[rel 7FFAC47524E0h] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[rel 7FFAC474F208h] +00007FFAC46ACDD9 488D05787C0400 lea rax,[rel 7FFAC46F4A58h] +00007FFAC46ACDE0 33FF xor edi,edi + +Original + patched code: +00007FFAC46ACDA4 48B8F0DEBC9A78563412 mov rax,123456789ABCDEF0h +00007FFAC46ACDAE FFE0 jmp rax +00007FFAC46ACDB0 4156 push r14 +00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h] +00007FFAC46ACDBA 4881EC00020000 sub rsp,200h +00007FFAC46ACDC1 488B0518570A00 mov rax,[rel 7FFAC47524E0h] +00007FFAC46ACDC8 4833C4 xor rax,rsp +00007FFAC46ACDCB 488985F0000000 mov [rbp+0F0h],rax +00007FFAC46ACDD2 4C8B052F240A00 mov r8,[rel 7FFAC474F208h] +00007FFAC46ACDD9 488D05787C0400 lea rax,[rel 7FFAC46F4A58h] +00007FFAC46ACDE0 33FF xor edi,edi + +Moved code: +00007FFAC48ACDA4 48895C2410 mov [rsp+10h],rbx +00007FFAC48ACDA9 4889742418 mov [rsp+18h],rsi +00007FFAC48ACDAE 55 push rbp +00007FFAC48ACDAF 57 push rdi +00007FFAC48ACDB0 E9FBFFDFFF jmp 00007FFAC46ACDB0h +} + +const + EXAMPLE_CODE_BITNESS = bt64; + HEXBYTES_COLUMN_BYTE_LENGTH = 12; + +procedure Disassemble( Data : PByte; Size : Cardinal; RIP : UInt64 ); +var + Instruction : TInstruction; + sOutput : String; + start_index : Integer; + i : Integer; + pInstruction: PAnsiChar; +begin + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( Data, Size, RIP, doNONE ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + // Formatters: Masm*, Nasm*, Gas* (AT&T) and Intel* (XED). + // For fastest code, see `SpecializedFormatter` which is ~3.3x faster. Use it if formatting + // speed is more important than being able to re-assemble formatted instructions. + Iced.Formatter.FormatterType := ftNasm; + + // Change some options, there are many more +// Iced.Formatter.DigitSeparator := '`'; + Iced.Formatter.FirstOperandCharIndex := 10; + + while Iced.Decoder.CanDecode do + begin +// Iced.Decoder.Decode( Instruction ); + Iced.DecodeFormat( Instruction, pInstruction ); + + // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF lea rbp,[rsp-100h]" + + // Hex + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + start_index := instruction.RIP-RIP; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + sOutput := ''; + for i := start_index to start_index+Instruction.len-1 do + begin + sOutput := sOutput + IntToHex( Data^, 2 ); + Inc( Data ); + end; + + if ( Instruction.len < HEXBYTES_COLUMN_BYTE_LENGTH ) then + begin + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len-1 do + sOutput := sOutput + ' ' + end; + +// sOutput := Format( '%.16x ', [ instruction.RIP ] ) + sOutput + Iced.Formatter.FormatToString( Instruction ); + sOutput := Format( '%.16x ', [ instruction.RIP ] ) + sOutput + string( pInstruction ); + + WriteLn( sOutput ); + end; + + WriteLn( '' ); +end; + +const + EXAMPLE_CODE_RIP = $00007FFAC46ACDA4; +var + EXAMPLE_CODE : Array [ 0..61 ] of Byte = ( $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); +const + // In 64-bit mode, we need 12 bytes to jump to any address: + // mov rax,imm64 // 10 + // jmp rax // 2 + // We overwrite rax because it's probably not used by the called function. + // In 32-bit mode, a normal JMP is just 5 bytes + required_bytes = 10+2; +var + YOUR_FUNC : UInt64 = UInt64( $123456789ABCDEF0 ); // Address of your code +var + Instruction : TInstruction; + Instructions : TInstructionList; + sOutput : String; + start_index : Integer; + i : Integer; + total_bytes : Cardinal; + relocated_base_address : UInt64; + Results : TBlockEncoderResult; + _target : UInt64; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + WriteLn( 'Original code:' ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Disassemble( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + Instructions := TInstructionList.Create; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNONE ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + total_bytes := 0; + while Iced.Decoder.CanDecode do + begin + Iced.Decoder.Decode( Instruction ); + if NOT Instruction.IsValid then + begin + WriteLn( 'Error: Decoding failed.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Instructions.Free; + Exit; + end; + + Instructions.Add( Instruction ); + Inc( total_bytes, Instruction.len ); + + if ( total_bytes >= required_bytes ) then + break; + + case Instruction.FlowControl.FlowControl of + fcNext : ; + + fcUnconditionalBranch : begin + // You could check if it's just jumping forward a few bytes and follow it + // but this is a simple example so we'll fail. + if ( Instruction.op_kinds[ 0 ].OpKind = okNearBranch64 ) then + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + _target := Instruction.NearBranchTarget; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + WriteLn( 'Not supported by this simple example.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Instructions.Free; + Exit; + end; + + fcIndirectBranch, + fcConditionalBranch, + fcReturn, + fcCall, + fcIndirectCall, + fcInterrupt, + fcXbeginXabortXend, + fcException : begin + WriteLn( 'Not supported by this simple example.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Instructions.Free; + Exit; + end; + end; + end; + + if ( total_bytes < required_bytes ) OR ( Instructions.Count < 1 ) then + begin + WriteLn( 'Not enough bytes!' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + // Create a JMP instruction that branches to the original code, except those instructions + // that we'll re-encode. We don't need to do it if it already ends in 'ret' + Instruction := Instructions[ Instructions.Count-1 ]; + if ( Instruction.FlowControl.FlowControl <> fcReturn ) then + Instructions.Add( Instruction.with_branch( Jmp_rel32_64, Instruction.next_rip ) ); + + // Relocate the code to some new location. It can fix short/near branches and + // convert them to short/near/long forms if needed. This also works even if it's a + // jrcxz/loop/loopcc instruction which only have short forms. + // + // It can currently only fix RIP relative operands if the new location is within 2GB + // of the target data location. + // + // Note that a block is not the same thing as a basic block. A block can contain any + // number of instructions, including any number of branch instructions. One block + // should be enough unless you must relocate different blocks to different locations. + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + relocated_base_address := EXAMPLE_CODE_RIP + $200000; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + Iced.BlockEncoder.Encode( relocated_base_address, Instructions, Results ); + Instructions.free; + + // Patch the original code. Pretend that we use some OS API to write to memory... + // We could use the BlockEncoder/Encoder for this but it's easy to do yourself too. + // This is 'mov rax,imm64; jmp rax' + EXAMPLE_CODE[ 0 ] := $48; // \ 'MOV RAX,imm64' + EXAMPLE_CODE[ 1 ] := $B8; + Move( YOUR_FUNC, EXAMPLE_CODE[ 2 ], SizeOf( YOUR_FUNC ) ); + EXAMPLE_CODE[ 10 ] := $FF; // \ JMP RAX + EXAMPLE_CODE[ 11 ] := $E0; + + // Disassemble it + WriteLn( 'Original + patched code:' ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Disassemble( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + // Disassemble the moved code + WriteLn( 'Moved code:' ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Disassemble( PByte( Results.code_buffer ), Results.code_buffer_len, relocated_base_address ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + WriteLn( 'Press enter to exit.' ); + ReadLn; + +end. diff --git a/src/Delphi/Samples/SymbolResolver/SymbolResolver.dpr b/src/Delphi/Samples/SymbolResolver/SymbolResolver.dpr new file mode 100644 index 000000000..d234c63fd --- /dev/null +++ b/src/Delphi/Samples/SymbolResolver/SymbolResolver.dpr @@ -0,0 +1,93 @@ +program SymbolResolver; + +{$APPTYPE CONSOLE} + +uses + madExcept, + madLinkDisAsm, + madListHardware, + madListProcesses, + madListModules, + SysUtils, + Classes, + + uIced.Types in '..\..\uIced.Types.pas', + uIced.Imports in '..\..\uIced.Imports.pas', + uIced in '..\..\uIced.pas'; + +{ +This example produces the following output: +mov rcx, [rdx+my_data (0x5AA55AA5)] +} + +type + TSymbolItem = packed record + Offset : UInt64; + Name : AnsiString; + end; + TSymbolList = Array of TSymbolItem; + +const + Symbols : Array [ 0..0 ] of TSymbolItem = ( + ( Offset: UInt64( $5AA55AA5 ); Name: 'my_data' ) + ); + +function SymbolResolverCallback( const Instruction: TInstruction; Operand: Cardinal; InstructionOperand : Cardinal; Address: UInt64; Size: Cardinal; UserData : Pointer ) : PAnsiChar; cdecl; +var + i : Integer; +begin + result := ''; + for i := Low( Symbols ) to High( Symbols ) do + begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( Symbols[ i ].Offset = Address ) then + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := PAnsiChar( Symbols[ i ].Name ); + end; +end; + +const + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = 0; + EXAMPLE_CODE : Array [ 0..6 ] of Byte = ( $48, $8B, $8A, $A5, $5A, $A5, $5A ); + EXAMPLE_OFFSET = $0000001FB55A1234; +var + Instruction : TInstruction; + Offset : UInt64; + pInstruction: PAnsiChar; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNone ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + Iced.Formatter.FormatterType := ftNasm; + Iced.Formatter.SymbolResolver := SymbolResolverCallback; + Iced.Formatter.ShowSymbols := True; + + // True : mov rcx,[rdx+my_data (5AA55AA5h)] + // False (Default): mov rcx,[rdx+my_data] + Iced.Formatter.ShowSymbolAddress := True; + + // True (Default): mov rcx, [rdx+my_data (0x5AA55AA5)] + // False : mov rcx, my_data (0x5AA55AA5)[rdx] +// Iced.Formatter.SymbolDisplacementInBrackets := True; + +// Iced.Decoder.Decode( Instruction ); +// WriteLn( Iced.Formatter.FormatToString( Instruction ) ); + + Iced.DecodeFormat( Instruction, pInstruction ); + WriteLn( string( pInstruction ) ); + + WriteLn( 'Press enter to exit.' ); + ReadLn; + +end. diff --git a/src/Delphi/Samples/VirtualAddress/VirtualAddress.dpr b/src/Delphi/Samples/VirtualAddress/VirtualAddress.dpr new file mode 100644 index 000000000..61121f91a --- /dev/null +++ b/src/Delphi/Samples/VirtualAddress/VirtualAddress.dpr @@ -0,0 +1,309 @@ +program VirtualAddress; + +{$APPTYPE CONSOLE} + +uses + SysUtils, + + uIced.Types in '..\..\uIced.Types.pas', + uIced.Imports in '..\..\uIced.Imports.pas', + uIced in '..\..\uIced.pas'; + +function VirtualAddressResolverCallback( Register: TRegister; Index : NativeUInt; Size : NativeUInt; var Address : UInt64; UserData : Pointer ) : boolean; cdecl; +begin + result := True; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + case Register.Register of + // The base address of ES, CS, SS and DS is always 0 in 64-bit mode + ES, CS, SS, DS: Address := 0; + + RDI : Address := $10000000; + R12 : Address := $000400000000; + +// AL : Address := ; +// CL : Address := ; +// DL : Address := ; +// BL : Address := ; +// AH : Address := ; +// CH : Address := ; +// DH : Address := ; +// BH : Address := ; +// SPL : Address := ; +// BPL : Address := ; +// SIL : Address := ; +// DIL : Address := ; +// R8L : Address := ; +// R9L : Address := ; +// R10L : Address := ; +// R11L : Address := ; +// R12L : Address := ; +// R13L : Address := ; +// R14L : Address := ; +// R15L : Address := ; +// AX : Address := ; +// CX : Address := ; +// DX : Address := ; +// BX : Address := ; +// SP : Address := ; +// BP : Address := ; +// SI : Address := ; +// DI : Address := ; +// R8W : Address := ; +// R9W : Address := ; +// R10W : Address := ; +// R11W : Address := ; +// R12W : Address := ; +// R13W : Address := ; +// R14W : Address := ; +// R15W : Address := ; +// EAX : Address := ; +// ECX : Address := ; +// EDX : Address := ; +// EBX : Address := ; +// ESP : Address := ; +// EBP : Address := ; +// ESI : Address := ; +// EDI : Address := ; +// R8D : Address := ; +// R9D : Address := ; +// R10D : Address := ; +// R11D : Address := ; +// R12D : Address := ; +// R13D : Address := ; +// R14D : Address := ; +// R15D : Address := ; +// RAX : Address := ; +// RCX : Address := ; +// RDX : Address := ; +// RBX : Address := ; +// RSP : Address := ; +// RBP : Address := ; +// RSI : Address := ; +// RDI : Address := ; +// R8 : Address := ; +// R9 : Address := ; +// R10 : Address := ; +// R11 : Address := ; +// R12 : Address := ; +// R13 : Address := ; +// R14 : Address := ; +// R15 : Address := ; +// EIP : Address := ; +// RIP : Address := ; +// FS : Address := ; +// GS : Address := ; +// XMM0 : Address := ; +// XMM1 : Address := ; +// XMM2 : Address := ; +// XMM3 : Address := ; +// XMM4 : Address := ; +// XMM5 : Address := ; +// XMM6 : Address := ; +// XMM7 : Address := ; +// XMM8 : Address := ; +// XMM9 : Address := ; +// XMM10 : Address := ; +// XMM11 : Address := ; +// XMM12 : Address := ; +// XMM13 : Address := ; +// XMM14 : Address := ; +// XMM15 : Address := ; +// XMM16 : Address := ; +// XMM17 : Address := ; +// XMM18 : Address := ; +// XMM19 : Address := ; +// XMM20 : Address := ; +// XMM21 : Address := ; +// XMM22 : Address := ; +// XMM23 : Address := ; +// XMM24 : Address := ; +// XMM25 : Address := ; +// XMM26 : Address := ; +// XMM27 : Address := ; +// XMM28 : Address := ; +// XMM29 : Address := ; +// XMM30 : Address := ; +// XMM31 : Address := ; +// YMM0 : Address := ; +// YMM1 : Address := ; +// YMM2 : Address := ; +// YMM3 : Address := ; +// YMM4 : Address := ; +// YMM5 : Address := ; +// YMM6 : Address := ; +// YMM7 : Address := ; +// YMM8 : Address := ; +// YMM9 : Address := ; +// YMM10 : Address := ; +// YMM11 : Address := ; +// YMM12 : Address := ; +// YMM13 : Address := ; +// YMM14 : Address := ; +// YMM15 : Address := ; +// YMM16 : Address := ; +// YMM17 : Address := ; +// YMM18 : Address := ; +// YMM19 : Address := ; +// YMM20 : Address := ; +// YMM21 : Address := ; +// YMM22 : Address := ; +// YMM23 : Address := ; +// YMM24 : Address := ; +// YMM25 : Address := ; +// YMM26 : Address := ; +// YMM27 : Address := ; +// YMM28 : Address := ; +// YMM29 : Address := ; +// YMM30 : Address := ; +// YMM31 : Address := ; +// ZMM0 : Address := ; +// ZMM1 : Address := ; +// ZMM2 : Address := ; +// ZMM3 : Address := ; +// ZMM4 : Address := ; +// ZMM5 : Address := ; +// ZMM6 : Address := ; +// ZMM7 : Address := ; +// ZMM8 : Address := ; +// ZMM9 : Address := ; +// ZMM10 : Address := ; +// ZMM11 : Address := ; +// ZMM12 : Address := ; +// ZMM13 : Address := ; +// ZMM14 : Address := ; +// ZMM15 : Address := ; +// ZMM16 : Address := ; +// ZMM17 : Address := ; +// ZMM18 : Address := ; +// ZMM19 : Address := ; +// ZMM20 : Address := ; +// ZMM21 : Address := ; +// ZMM22 : Address := ; +// ZMM23 : Address := ; +// ZMM24 : Address := ; +// ZMM25 : Address := ; +// ZMM26 : Address := ; +// ZMM27 : Address := ; +// ZMM28 : Address := ; +// ZMM29 : Address := ; +// ZMM30 : Address := ; +// ZMM31 : Address := ; +// K0 : Address := ; +// K1 : Address := ; +// K2 : Address := ; +// K3 : Address := ; +// K4 : Address := ; +// K5 : Address := ; +// K6 : Address := ; +// K7 : Address := ; +// BND0 : Address := ; +// BND1 : Address := ; +// BND2 : Address := ; +// BND3 : Address := ; +// CR0 : Address := ; +// CR1 : Address := ; +// CR2 : Address := ; +// CR3 : Address := ; +// CR4 : Address := ; +// CR5 : Address := ; +// CR6 : Address := ; +// CR7 : Address := ; +// CR8 : Address := ; +// CR9 : Address := ; +// CR10 : Address := ; +// CR11 : Address := ; +// CR12 : Address := ; +// CR13 : Address := ; +// CR14 : Address := ; +// CR15 : Address := ; +// DR0 : Address := ; +// DR1 : Address := ; +// DR2 : Address := ; +// DR3 : Address := ; +// DR4 : Address := ; +// DR5 : Address := ; +// DR6 : Address := ; +// DR7 : Address := ; +// DR8 : Address := ; +// DR9 : Address := ; +// DR10 : Address := ; +// DR11 : Address := ; +// DR12 : Address := ; +// DR13 : Address := ; +// DR14 : Address := ; +// DR15 : Address := ; +// ST0 : Address := ; +// ST1 : Address := ; +// ST2 : Address := ; +// ST3 : Address := ; +// ST4 : Address := ; +// ST5 : Address := ; +// ST6 : Address := ; +// ST7 : Address := ; +// MM0 : Address := ; +// MM1 : Address := ; +// MM2 : Address := ; +// MM3 : Address := ; +// MM4 : Address := ; +// MM5 : Address := ; +// MM6 : Address := ; +// MM7 : Address := ; +// TR0 : Address := ; +// TR1 : Address := ; +// TR2 : Address := ; +// TR3 : Address := ; +// TR4 : Address := ; +// TR5 : Address := ; +// TR6 : Address := ; +// TR7 : Address := ; +// TMM0 : Address := ; +// TMM1 : Address := ; +// TMM2 : Address := ; +// TMM3 : Address := ; +// TMM4 : Address := ; +// TMM5 : Address := ; +// TMM6 : Address := ; +// TMM7 : Address := ; + else + result := False; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +const + HEXBYTES_COLUMN_BYTE_LENGTH = 5; + EXAMPLE_CODE_BITNESS = bt64; + EXAMPLE_CODE_RIP = 0; + EXAMPLE_CODE : Array [ 0..7 ] of Byte = ( $42, $01, $B4, $E7, $34, $12, $5A, $A5 ); + EXAMPLE_OFFSET = $0000001FB55A1234; +var + Instruction : TInstruction; + Offset : UInt64; +begin + if NOT IsInitDLL then + begin + WriteLn( 'Library not loaded.' ); + WriteLn( 'Press enter to exit.' ); + ReadLn; + Exit; + end; + + Iced.Decoder.Bitness := EXAMPLE_CODE_BITNESS; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( @EXAMPLE_CODE[ 0 ], Length( EXAMPLE_CODE ), EXAMPLE_CODE_RIP, doNone ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + Iced.Decoder.Decode( Instruction ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Offset := Instruction.VirtualAddress( VirtualAddressResolverCallback ); + if ( Offset = EXAMPLE_OFFSET ) then + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + WriteLn( 'OK: ' + Format( '%.16x', [ Offset ] ) ) + else + WriteLn( 'Failed.' ); + + WriteLn( 'Press enter to exit.' ); + ReadLn; + +end. diff --git a/src/Delphi/uIced.Imports.pas b/src/Delphi/uIced.Imports.pas new file mode 100644 index 000000000..a38636643 --- /dev/null +++ b/src/Delphi/uIced.Imports.pas @@ -0,0 +1,2641 @@ +unit uIced.Imports; + +{ + Iced (Dis)Assembler + + TetzkatLipHoka 2022-2024 +} + +interface + +{$WARN UNSAFE_TYPE OFF} + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +uses + uIced.Types; + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~DLL Declarations~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +var + // Free Memory + IcedFreeMemory : function( Pointer : Pointer ) : Boolean; cdecl = nil; + + // Creates a decoder + // + // # Errors + // Fails if `bitness` is not one of 16, 32, 64. + // + // # Arguments + // * `bitness`: 16, 32 or 64 + // * `data`: Data to decode + // * `data`: ByteSize of `Data` + // * `options`: Decoder options, `0` or eg. `DecoderOptions::NO_INVALID_CHECK | DecoderOptions::AMD` + Decoder_Create : function( Bitness : Cardinal; Data : PByte; DataSize : NativeUInt; IP : UInt64; Options : Cardinal = doNONE ) : Pointer; cdecl = nil; + + // Returns `true` if there's at least one more byte to decode. It doesn't verify that the + // next instruction is valid, it only checks if there's at least one more byte to read. + // See also [`position()`] and [`max_position()`] + // + // It's not required to call this method. If this method returns `false`, then [`decode_out()`] + // and [`decode()`] will return an instruction whose [`code()`] == [`Code::INVALID`]. + Decoder_CanDecode : function( Decoder : Pointer ) : Boolean; cdecl = nil; + + // Gets the current `IP`/`EIP`/`RIP` value, see also [`position()`] + Decoder_GetIP : function( Decoder : Pointer ) : UInt64; cdecl = nil; + + // Sets the current `IP`/`EIP`/`RIP` value, see also [`try_set_position()`] + // This method only updates the IP value, it does not change the data position, use [`try_set_position()`] to change the position. + Decoder_SetIP : function ( Decoder : Pointer; Value : UInt64 ) : boolean; cdecl = nil; + + // Gets the bitness (16, 32 or 64) + Decoder_GetBitness : function( Decoder : Pointer ) : Cardinal; cdecl = nil; + + // Gets the max value that can be passed to [`try_set_position()`]. This is the size of the data that gets + // decoded to instructions and it's the length of the slice that was passed to the constructor. + Decoder_GetMaxPosition : function( Decoder : Pointer ) : NativeUInt; cdecl = nil; + + // Gets the current data position. This value is always <= [`max_position()`]. + // When [`position()`] == [`max_position()`], it's not possible to decode more + // instructions and [`can_decode()`] returns `false`. + Decoder_GetPosition : function( Decoder : Pointer ) : NativeUInt; cdecl = nil; + + // Sets the current data position, which is the index into the data passed to the constructor. + // This value is always <= [`max_position()`] + Decoder_SetPosition : function ( Decoder : Pointer; Value : NativeUInt ) : boolean; cdecl = nil; + + // Gets the last decoder error. Unless you need to know the reason it failed, + // it's better to check [`instruction.is_invalid()`]. + Decoder_GetLastError : function( Decoder : Pointer ) : TDecoderError; cdecl = nil; + DecoderError_AsString : procedure( const DecoderError : TDecoderErrorType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + + // Decodes and returns the next instruction, see also [`decode_out(&mut Instruction)`] + // which avoids copying the decoded instruction to the caller's return variable. + // See also [`last_error()`]. + Decoder_Decode : procedure( Decoder : Pointer; const Instruction : TInstruction ); cdecl = nil; + Decoder_DecodeToEnd : procedure( Decoder : Pointer; Callback : TDecoderCallback; UserData : Pointer = nil ); cdecl = nil; + + // Gets the offsets of the constants (memory displacement and immediate) in the decoded instruction. + // The caller can check if there are any relocations at those addresses. + // + // # Arguments + // * `instruction`: The latest instruction that was decoded by this decoder + Decoder_GetConstantOffsets : function( Decoder : Pointer; const Instruction : TInstruction; var ConstantOffsets : TConstantOffsets ) : Boolean; cdecl = nil; + + // Creates a formatter Output Callback + FormatterOutput_Create : function( Callback : TFormatterOutputCallback; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Creates a masm formatter + // + // # Arguments + // - `symbol_resolver`: Symbol resolver or `None` + // - `options_provider`: Operand options provider or `None` + MasmFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; OptionsProvider : TFormatterOptionsProviderCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + MasmFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + MasmFormatter_DecodeFormatCallback : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + MasmFormatter_Format : procedure( Formatter : Pointer; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + MasmFormatter_FormatCallback : procedure( Formatter : Pointer; const Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + MasmFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + + // Creates a Nasm formatter + // + // # Arguments + // - `symbol_resolver`: Symbol resolver or `None` + // - `options_provider`: Operand options provider or `None` + NasmFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; OptionsProvider : TFormatterOptionsProviderCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + NasmFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + NasmFormatter_DecodeFormatCallback : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + NasmFormatter_Format : procedure( Formatter : Pointer; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + NasmFormatter_FormatCallback : procedure( Formatter : Pointer; const Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + NasmFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + + // Creates a Gas formatter + // + // # Arguments + // - `symbol_resolver`: Symbol resolver or `None` + // - `options_provider`: Operand options provider or `None` + GasFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; OptionsProvider : TFormatterOptionsProviderCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + GasFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + GasFormatter_DecodeFormatCallback : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + GasFormatter_Format : procedure( Formatter : Pointer; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + GasFormatter_FormatCallback : procedure( Formatter : Pointer; const Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + GasFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + + // Creates a Intel formatter + // + // # Arguments + // - `symbol_resolver`: Symbol resolver or `None` + // - `options_provider`: Operand options provider or `None` + IntelFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; OptionsProvider : TFormatterOptionsProviderCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + IntelFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + IntelFormatter_DecodeFormatCallback : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + IntelFormatter_Format : procedure( Formatter : Pointer; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + IntelFormatter_FormatCallback : procedure( Formatter : Pointer; const Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + IntelFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + + // Creates a Fast formatter (Specialized) + // NOTE: Fast Formatter only supports Specialized-Options + FastFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + FastFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + FastFormatter_Format : procedure( Formatter : Pointer; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + FastFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + + // Creates a Specialized formatter + SpecializedFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + SpecializedFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; Options : Byte; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + SpecializedFormatter_Format : procedure( Formatter : Pointer; Options : Byte; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + SpecializedFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Options : Byte; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + +// Options + // NOTE: Specialized Formatter only supports the following Options + + // Always show the size of memory operands + // + // Default | Value | Example | Example + // --------|-------|---------|-------- + // _ | `true` | `mov eax,dword ptr [ebx]` | `add byte ptr [eax],0x12` + // X | `false` | `mov eax,[ebx]` | `add byte ptr [eax],0x12` + SpecializedFormatter_GetAlwaysShowMemorySize : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // Always show the size of memory operands + // + // Default | Value | Example | Example + // --------|-------|---------|-------- + // _ | `true` | `mov eax,dword ptr [ebx]` | `add byte ptr [eax],0x12` + // X | `false` | `mov eax,[ebx]` | `add byte ptr [eax],0x12` + // + // # Arguments + // * `value`: New value + SpecializedFormatter_SetAlwaysShowMemorySize : function( Formatter: Pointer; Value : Boolean ) : boolean; cdecl = nil; + + // Use a hex prefix ( `0x` ) or a hex suffix ( `h` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `0x5A` + // X | `false` | `5Ah` + SpecializedFormatter_GetUseHexPrefix : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // Use a hex prefix ( `0x` ) or a hex suffix ( `h` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `0x5A` + // X | `false` | `5Ah` + // + // # Arguments + // * `value`: New value + SpecializedFormatter_SetUseHexPrefix : function( Formatter: Pointer; Value : Boolean ) : boolean; cdecl = nil; + + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Formatter Options + // Format Instruction + Formatter_Format : procedure( Formatter : Pointer; FormatterType : TIcedFormatterType; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + Formatter_FormatCallback : procedure( Formatter : Pointer; FormatterType : TIcedFormatterType; const Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + + // Prefixes are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `REP stosd` + // X | `false` | `rep stosd` + Formatter_GetUpperCasePrefixes : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Prefixes are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `REP stosd` + // X | `false` | `rep stosd` + // + // # Arguments + // + // * `value`: New value + Formatter_SetUpperCasePrefixes : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Mnemonics are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `MOV rcx,rax` + // X | `false` | `mov rcx,rax` + Formatter_GetUpperCaseMnemonics : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Mnemonics are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `MOV rcx,rax` + // X | `false` | `mov rcx,rax` + // + // # Arguments + // * `value`: New value + Formatter_SetUpperCaseMnemonics : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Registers are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov RCX,[RAX+RDX*8]` + // X | `false` | `mov rcx,[rax+rdx*8]` + Formatter_GetUpperCaseRegisters : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Registers are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov RCX,[RAX+RDX*8]` + // X | `false` | `mov rcx,[rax+rdx*8]` + // + // # Arguments + // * `value`: New value + Formatter_SetUpperCaseRegisters : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Keywords are uppercased ( eg. `BYTE PTR`, `SHORT` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov BYTE PTR [rcx],12h` + // X | `false` | `mov byte ptr [rcx],12h` + Formatter_GetUpperCaseKeyWords : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Keywords are uppercased ( eg. `BYTE PTR`, `SHORT` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov BYTE PTR [rcx],12h` + // X | `false` | `mov byte ptr [rcx],12h` + // + // # Arguments + // * `value`: New value + Formatter_SetUpperCaseKeyWords : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Uppercase decorators, eg. `{z ); `, `{sae ); `, `{rd-sae ); ` ( but not opmask registers: `{k1 ); ` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `vunpcklps xmm2{k5 ); {Z ); ,xmm6,dword bcst [rax+4]` + // X | `false` | `vunpcklps xmm2{k5 ); {z ); ,xmm6,dword bcst [rax+4]` + Formatter_GetUpperCaseDecorators : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Uppercase decorators, eg. `{z ); `, `{sae ); `, `{rd-sae ); ` ( but not opmask registers: `{k1 ); ` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `vunpcklps xmm2{k5 ); {Z ); ,xmm6,dword bcst [rax+4]` + // X | `false` | `vunpcklps xmm2{k5 ); {z ); ,xmm6,dword bcst [rax+4]` + // + // # Arguments + // * `value`: New value + Formatter_SetUpperCaseDecorators : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Everything is uppercased, except numbers and their prefixes/suffixes + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `MOV EAX,GS:[RCX*4+0ffh]` + // X | `false` | `mov eax,gs:[rcx*4+0ffh]` + Formatter_GetUpperCaseEverything : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Everything is uppercased, except numbers and their prefixes/suffixes + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `MOV EAX,GS:[RCX*4+0ffh]` + // X | `false` | `mov eax,gs:[rcx*4+0ffh]` + // + // # Arguments + // + // * `value`: New value + Formatter_SetUpperCaseEverything : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Character index ( 0-based ) where the first operand is formatted. Can be set to 0 to format it immediately after the mnemonic. + // At least one space or tab is always added between the mnemonic and the first operand. + // + // Default | Value | Example + // --------|-------|-------- + // X | `0` | `movrcx,rbp` + // _ | `8` | `movrcx,rbp` + Formatter_GetFirstOperandCharIndex : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Character index ( 0-based ) where the first operand is formatted. Can be set to 0 to format it immediately after the mnemonic. + // At least one space or tab is always added between the mnemonic and the first operand. + // + // Default | Value | Example + // --------|-------|-------- + // X | `0` | `movrcx,rbp` + // _ | `8` | `movrcx,rbp` + // + // # Arguments + // * `value`: New value + Formatter_SetFirstOperandCharIndex : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Size of a tab character or 0 to use spaces + // + // - Default: `0` + Formatter_GetTabSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Size of a tab character or 0 to use spaces + // + // - Default: `0` + // + // # Arguments + // + // * `value`: New value + Formatter_SetTabSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Add a space after the operand separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov rax, rcx` + // X | `false` | `mov rax,rcx` + Formatter_GetSpaceAfterOperandSeparator : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add a space after the operand separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov rax, rcx` + // X | `false` | `mov rax,rcx` + // + // # Arguments + // * `value`: New value + Formatter_SetSpaceAfterOperandSeparator : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Add a space between the memory expression and the brackets + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[ rcx+rdx ]` + // X | `false` | `mov eax,[rcx+rdx]` + Formatter_GetSpaceAfterMemoryBracket : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add a space between the memory expression and the brackets + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[ rcx+rdx ]` + // X | `false` | `mov eax,[rcx+rdx]` + // + // # Arguments + // * `value`: New value + Formatter_SetSpaceAfterMemoryBracket : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Add spaces between memory operand `+` and `-` operators + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx + rdx*8 - 80h]` + // X | `false` | `mov eax,[rcx+rdx*8-80h]` + Formatter_GetSpaceBetweenMemoryAddOperators : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add spaces between memory operand `+` and `-` operators + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx + rdx*8 - 80h]` + // X | `false` | `mov eax,[rcx+rdx*8-80h]` + // + // # Arguments + // * `value`: New value + Formatter_SetSpaceBetweenMemoryAddOperators : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Add spaces between memory operand `*` operator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx+rdx * 8-80h]` + // X | `false` | `mov eax,[rcx+rdx*8-80h]` + Formatter_GetSpaceBetweenMemoryMulOperators : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add spaces between memory operand `*` operator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx+rdx * 8-80h]` + // X | `false` | `mov eax,[rcx+rdx*8-80h]` + // + // # Arguments + // * `value`: New value + Formatter_SetSpaceBetweenMemoryMulOperators : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show memory operand scale value before the index register + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[8*rdx]` + // X | `false` | `mov eax,[rdx*8]` + Formatter_GetScaleBeforeIndex : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show memory operand scale value before the index register + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[8*rdx]` + // X | `false` | `mov eax,[rdx*8]` + // + // # Arguments + // * `value`: New value + Formatter_SetScaleBeforeIndex : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Always show the scale value even if it's `*1` + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rbx+rcx*1]` + // X | `false` | `mov eax,[rbx+rcx]` + Formatter_GetAlwaysShowScale : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Always show the scale value even if it's `*1` + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rbx+rcx*1]` + // X | `false` | `mov eax,[rbx+rcx]` + // + // # Arguments + // * `value`: New value + Formatter_SetAlwaysShowScale : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Always show the effective segment register. If the option is `false`, only show the segment register if + // there's a segment override prefix. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,ds:[ecx]` + // X | `false` | `mov eax,[ecx]` + Formatter_GetAlwaysShowSegmentRegister : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Always show the effective segment register. If the option is `false`, only show the segment register if + // there's a segment override prefix. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,ds:[ecx]` + // X | `false` | `mov eax,[ecx]` + // + // # Arguments + // * `value`: New value + Formatter_SetAlwaysShowSegmentRegister : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show zero displacements + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx*2+0]` + // X | `false` | `mov eax,[rcx*2]` + Formatter_GetShowZeroDisplacements : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show zero displacements + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx*2+0]` + // X | `false` | `mov eax,[rcx*2]` + // + // # Arguments + // * `value`: New value + Formatter_SetShowZeroDisplacements : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Hex number prefix or an empty string, eg. `"0x"` + // + // - Default: `""` ( masm/nasm/intel ), `"0x"` ( gas ) + Formatter_GetHexPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Hex number prefix or an empty string, eg. `"0x"` + // + // - Default: `""` ( masm/nasm/intel ), `"0x"` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetHexPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Hex number suffix or an empty string, eg. `"h"` + // + // - Default: `"h"` ( masm/nasm/intel ), `""` ( gas ) + Formatter_GetHexSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Hex number suffix or an empty string, eg. `"h"` + // + // - Default: `"h"` ( masm/nasm/intel ), `""` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetHexSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `0x12345678` + // X | `4` | `0x1234_5678` + Formatter_GetHexDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `0x12345678` + // X | `4` | `0x1234_5678` + // + // # Arguments + // * `value`: New value + Formatter_SetHexDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Decimal number prefix or an empty string + // + // - Default: `""` + Formatter_GetDecimalPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Decimal number prefix or an empty string + // + // - Default: `""` + // + // # Arguments + // * `value`: New value + Formatter_SetDecimalPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Decimal number suffix or an empty string + // + // - Default: `""` + Formatter_GetDecimalSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Decimal number suffix or an empty string + // + // - Default: `""` + // + // # Arguments + // * `value`: New value + Formatter_SetDecimalSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `12345678` + // X | `3` | `12_345_678` + Formatter_GetDecimalDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `12345678` + // X | `3` | `12_345_678` + // + // # Arguments + // * `value`: New value + Formatter_SetDecimalDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Octal number prefix or an empty string + // + // - Default: `""` ( masm/nasm/intel ), `"0"` ( gas ) + Formatter_GetOctalPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Octal number prefix or an empty string + // + // - Default: `""` ( masm/nasm/intel ), `"0"` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetOctalPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Octal number suffix or an empty string + // + // - Default: `"o"` ( masm/nasm/intel ), `""` ( gas ) + Formatter_GetOctalSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Octal number suffix or an empty string + // + // - Default: `"o"` ( masm/nasm/intel ), `""` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetOctalSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `12345670` + // X | `4` | `1234_5670` + Formatter_GetOctalDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `12345670` + // X | `4` | `1234_5670` + // + // # Arguments + // * `value`: New value + Formatter_SetOctalDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Binary number prefix or an empty string + // + // - Default: `""` ( masm/nasm/intel ), `"0b"` ( gas ) + Formatter_GetBinaryPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Binary number prefix or an empty string + // + // - Default: `""` ( masm/nasm/intel ), `"0b"` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetBinaryPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Binary number suffix or an empty string + // + // - Default: `"b"` ( masm/nasm/intel ), `""` ( gas ) + Formatter_GetBinarySuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Binary number suffix or an empty string + // + // - Default: `"b"` ( masm/nasm/intel ), `""` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetBinarySuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `11010111` + // X | `4` | `1101_0111` + Formatter_GetBinaryDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `11010111` + // X | `4` | `1101_0111` + // + // # Arguments + // * `value`: New value + Formatter_SetBinaryDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Digit separator or an empty string. See also eg. [`hex_digit_group_size( )`] + // + // [`hex_digit_group_size( )`]: #method.hex_digit_group_size + // + // Default | Value | Example + // --------|-------|-------- + // X | `""` | `0x12345678` + // _ | `"_"` | `0x1234_5678` + Formatter_GetDigitSeparator : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Digit separator or an empty string. See also eg. [`hex_digit_group_size( )`] + // + // [`hex_digit_group_size( )`]: #method.hex_digit_group_size + // + // Default | Value | Example + // --------|-------|-------- + // X | `""` | `0x12345678` + // _ | `"_"` | `0x1234_5678` + // + // # Arguments + // * `value`: New value + Formatter_SetDigitSeparator : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Add leading zeros to hexadecimal/octal/binary numbers. + // This option has no effect on branch targets and displacements, use [`branch_leading_zeros`] + // and [`displacement_leading_zeros`]. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `0x0000000A`/`0000000Ah` + // X | `false` | `0xA`/`0Ah` + Formatter_GetLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add leading zeros to hexadecimal/octal/binary numbers. + // This option has no effect on branch targets and displacements, use [`branch_leading_zeros`] + // and [`displacement_leading_zeros`]. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `0x0000000A`/`0000000Ah` + // X | `false` | `0xA`/`0Ah` + // + // # Arguments + // * `value`: New value + Formatter_SetLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Use uppercase hex digits + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `0xFF` + // _ | `false` | `0xff` + Formatter_GetUppercaseHex : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Use uppercase hex digits + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `0xFF` + // _ | `false` | `0xff` + // + // # Arguments + // * `value`: New value + Formatter_SetUppercaseHex : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Small hex numbers ( -9 .. 9 ) are shown in decimal + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `9` + // _ | `false` | `0x9` + Formatter_GetSmallHexNumbersInDecimal : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Small hex numbers ( -9 .. 9 ) are shown in decimal + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `9` + // _ | `false` | `0x9` + // + // # Arguments + // * `value`: New value + Formatter_SetSmallHexNumbersInDecimal : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Add a leading zero to hex numbers if there's no prefix and the number starts with hex digits `A-F` + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `0FFh` + // _ | `false` | `FFh` + Formatter_GetAddLeadingZeroToHexNumbers : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add a leading zero to hex numbers if there's no prefix and the number starts with hex digits `A-F` + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `0FFh` + // _ | `false` | `FFh` + // + // # Arguments + // * `value`: New value + Formatter_SetAddLeadingZeroToHexNumbers : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Number base + // + // - Default: [`Hexadecimal`] + // + // [`Hexadecimal`]: enum.NumberBase.html#variant.Hexadecimal + Formatter_GetNumberBase : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TNumberBase; cdecl = nil; + + // Number base + // + // - Default: [`Hexadecimal`] + // + // [`Hexadecimal`]: enum.NumberBase.html#variant.Hexadecimal + // + // # Arguments + // * `value`: New value + Formatter_SetNumberBase : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TNumberBase ) : boolean; cdecl = nil; + + // Add leading zeros to branch offsets. Used by `CALL NEAR`, `CALL FAR`, `JMP NEAR`, `JMP FAR`, `Jcc`, `LOOP`, `LOOPcc`, `XBEGIN` + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `je 00000123h` + // _ | `false` | `je 123h` + Formatter_GetBranchLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add leading zeros to branch offsets. Used by `CALL NEAR`, `CALL FAR`, `JMP NEAR`, `JMP FAR`, `Jcc`, `LOOP`, `LOOPcc`, `XBEGIN` + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `je 00000123h` + // _ | `false` | `je 123h` + // + // # Arguments + // * `value`: New value + Formatter_SetBranchLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show immediate operands as signed numbers + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,-1` + // X | `false` | `mov eax,FFFFFFFF` + Formatter_GetSignedImmediateOperands : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show immediate operands as signed numbers + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,-1` + // X | `false` | `mov eax,FFFFFFFF` + // + // # Arguments + // * `value`: New value + Formatter_SetSignedImmediateOperands : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Displacements are signed numbers + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `mov al,[eax-2000h]` + // _ | `false` | `mov al,[eax+0FFFFE000h]` + Formatter_GetSignedMemoryDisplacements : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Displacements are signed numbers + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `mov al,[eax-2000h]` + // _ | `false` | `mov al,[eax+0FFFFE000h]` + // + // # Arguments + // + // * `value`: New value + Formatter_SetSignedMemoryDisplacements : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Add leading zeros to displacements + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov al,[eax+00000012h]` + // X | `false` | `mov al,[eax+12h]` + Formatter_GetDisplacementLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add leading zeros to displacements + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov al,[eax+00000012h]` + // X | `false` | `mov al,[eax+12h]` + // + // # Arguments + // * `value`: New value + Formatter_SetDisplacementLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Options that control if the memory size ( eg. `DWORD PTR` ) is shown or not. + // This is ignored by the gas ( AT&T ) formatter. + // + // - Default: [`Default`] + // + // [`Default`]: enum.MemorySizeOptions.html#variant.Default + Formatter_GetMemorySizeOptions : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TMemorySizeOptions; cdecl = nil; + + // Options that control if the memory size ( eg. `DWORD PTR` ) is shown or not. + // This is ignored by the gas ( AT&T ) formatter. + // + // - Default: [`Default`] + // + // [`Default`]: enum.MemorySizeOptions.html#variant.Default + // + // # Arguments + // * `value`: New value + Formatter_SetMemorySizeOptions : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TMemorySizeOptions ) : boolean; cdecl = nil; + + // Show `RIP+displ` or the virtual address + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rip+12345678h]` + // X | `false` | `mov eax,[1029384756AFBECDh]` + Formatter_GetRipRelativeAddresses : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show `RIP+displ` or the virtual address + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rip+12345678h]` + // X | `false` | `mov eax,[1029384756AFBECDh]` + // + // # Arguments + // * `value`: New value + Formatter_SetRipRelativeAddresses : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show `NEAR`, `SHORT`, etc if it's a branch instruction + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `je short 1234h` + // _ | `false` | `je 1234h` + Formatter_GetShowBranchSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show `NEAR`, `SHORT`, etc if it's a branch instruction + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `je short 1234h` + // _ | `false` | `je 1234h` + // + // # Arguments + // * `value`: New value + Formatter_SetShowBranchSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Use pseudo instructions + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `vcmpnltsd xmm2,xmm6,xmm3` + // _ | `false` | `vcmpsd xmm2,xmm6,xmm3,5` + Formatter_GetUsePseudoOps : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Use pseudo instructions + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `vcmpnltsd xmm2,xmm6,xmm3` + // _ | `false` | `vcmpsd xmm2,xmm6,xmm3,5` + // + // # Arguments + // * `value`: New value + Formatter_SetUsePseudoOps : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show the original value after the symbol name + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[myfield ( 12345678 )]` + // X | `false` | `mov eax,[myfield]` + Formatter_GetShowSymbolAddress : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show the original value after the symbol name + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[myfield ( 12345678 )]` + // X | `false` | `mov eax,[myfield]` + // + // # Arguments + // + // * `value`: New value + Formatter_SetShowSymbolAddress : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // ( gas only ) : If `true`, the formatter doesn't add `%` to registers + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,ecx` + // X | `false` | `mov %eax,%ecx` + GasFormatter_GetNakedRegisters : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( gas only ) : If `true`, the formatter doesn't add `%` to registers + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,ecx` + // X | `false` | `mov %eax,%ecx` + // + // # Arguments + // * `value`: New value + GasFormatter_SetNakedRegisters : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( gas only ) : Shows the mnemonic size suffix even when not needed + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `movl %eax,%ecx` + // X | `false` | `mov %eax,%ecx` + GasFormatter_GetShowMnemonicSizeSuffix : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( gas only ) : Shows the mnemonic size suffix even when not needed + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `movl %eax,%ecx` + // X | `false` | `mov %eax,%ecx` + // + // # Arguments + // * `value`: New value + GasFormatter_SetShowMnemonicSizeSuffix : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( gas only ) : Add a space after the comma if it's a memory operand + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `( %eax, %ecx, 2 )` + // X | `false` | `( %eax,%ecx,2 )` + GasFormatter_GetSpaceAfterMemoryOperandComma : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( gas only ) : Add a space after the comma if it's a memory operand + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `( %eax, %ecx, 2 )` + // X | `false` | `( %eax,%ecx,2 )` + // + // # Arguments + // * `value`: New value + GasFormatter_SetSpaceAfterMemoryOperandComma : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( masm only ) : Add a `DS` segment override even if it's not present. Used if it's 16/32-bit code and mem op is a displ + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `mov eax,ds:[12345678]` + // _ | `false` | `mov eax,[12345678]` + MasmFormatter_GetAddDsPrefix32 : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( masm only ) : Add a `DS` segment override even if it's not present. Used if it's 16/32-bit code and mem op is a displ + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `mov eax,ds:[12345678]` + // _ | `false` | `mov eax,[12345678]` + // + // # Arguments + // * `value`: New value + MasmFormatter_SetAddDsPrefix32 : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( masm only ) : Show symbols in brackets + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `[ecx+symbol]` / `[symbol]` + // _ | `false` | `symbol[ecx]` / `symbol` + MasmFormatter_GetSymbolDisplacementInBrackets : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( masm only ) : Show symbols in brackets + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `[ecx+symbol]` / `[symbol]` + // _ | `false` | `symbol[ecx]` / `symbol` + // + // # Arguments + // * `value`: New value + MasmFormatter_SetSymbolDisplacementInBrackets : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( masm only ) : Show displacements in brackets + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `[ecx+1234h]` + // _ | `false` | `1234h[ecx]` + MasmFormatter_GetDisplacementInBrackets : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( masm only ) : Show displacements in brackets + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `[ecx+1234h]` + // _ | `false` | `1234h[ecx]` + // + // # Arguments + // * `value`: New value + MasmFormatter_SetDisplacementInBrackets : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( nasm only ) : Shows `BYTE`, `WORD`, `DWORD` or `QWORD` if it's a sign extended immediate operand value + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `or rcx,byte -1` + // X | `false` | `or rcx,-1` + NasmFormatter_GetShowSignExtendedImmediateSize : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( nasm only ) : Shows `BYTE`, `WORD`, `DWORD` or `QWORD` if it's a sign extended immediate operand value + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `or rcx,byte -1` + // X | `false` | `or rcx,-1` + // + // # Arguments + // * `value`: New value + NasmFormatter_SetShowSignExtendedImmediateSize : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // Use `st( 0 )` instead of `st` if `st` can be used. Ignored by the nasm formatter. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `fadd st( 0 ),st( 3 )` + // X | `false` | `fadd st,st( 3 )` + Formatter_GetPreferST0 : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Use `st( 0 )` instead of `st` if `st` can be used. Ignored by the nasm formatter. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `fadd st( 0 ),st( 3 )` + // X | `false` | `fadd st,st( 3 )` + // + // # Arguments + // * `value`: New value + Formatter_SetPreferST0 : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show useless prefixes. If it has useless prefixes, it could be data and not code. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `es rep add eax,ecx` + // X | `false` | `add eax,ecx` + Formatter_GetShowUselessPrefixes : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show useless prefixes. If it has useless prefixes, it could be data and not code. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `es rep add eax,ecx` + // X | `false` | `add eax,ecx` + // + // # Arguments + // * `value`: New value + Formatter_SetShowUselessPrefixes : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JB` / `JC` / `JNAE` ) + // + // Default: `JB`, `CMOVB`, `SETB` + Formatter_GetCC_b : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_b; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JB` / `JC` / `JNAE` ) + // + // Default: `JB`, `CMOVB`, `SETB` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_b : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_b ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JAE` / `JNB` / `JNC` ) + // + // Default: `JAE`, `CMOVAE`, `SETAE` + Formatter_GetCC_ae : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_ae; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JAE` / `JNB` / `JNC` ) + // + // Default: `JAE`, `CMOVAE`, `SETAE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_ae : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_ae ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JE` / `JZ` ) + // + // Default: `JE`, `CMOVE`, `SETE`, `LOOPE`, `REPE` + Formatter_GetCC_e : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_e; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JE` / `JZ` ) + // + // Default: `JE`, `CMOVE`, `SETE`, `LOOPE`, `REPE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_e : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_e ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JNE` / `JNZ` ) + // + // Default: `JNE`, `CMOVNE`, `SETNE`, `LOOPNE`, `REPNE` + Formatter_GetCC_ne : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_ne; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JNE` / `JNZ` ) + // + // Default: `JNE`, `CMOVNE`, `SETNE`, `LOOPNE`, `REPNE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_ne : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_ne ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JBE` / `JNA` ) + // + // Default: `JBE`, `CMOVBE`, `SETBE` + Formatter_GetCC_be : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_be; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JBE` / `JNA` ) + // + // Default: `JBE`, `CMOVBE`, `SETBE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_be : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_be ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JA` / `JNBE` ) + // + // Default: `JA`, `CMOVA`, `SETA` + Formatter_GetCC_a : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_a; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JA` / `JNBE` ) + // + // Default: `JA`, `CMOVA`, `SETA` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_a : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_a ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JP` / `JPE` ) + // + // Default: `JP`, `CMOVP`, `SETP` + Formatter_GetCC_p : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_p; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JP` / `JPE` ) + // + // Default: `JP`, `CMOVP`, `SETP` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_p : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_p ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JNP` / `JPO` ) + // + // Default: `JNP`, `CMOVNP`, `SETNP` + Formatter_GetCC_np : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_np; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JNP` / `JPO` ) + // + // Default: `JNP`, `CMOVNP`, `SETNP` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_np : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_np ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JL` / `JNGE` ) + // + // Default: `JL`, `CMOVL`, `SETL` + Formatter_GetCC_l : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_l; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JL` / `JNGE` ) + // + // Default: `JL`, `CMOVL`, `SETL` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_l : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_l ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JGE` / `JNL` ) + // + // Default: `JGE`, `CMOVGE`, `SETGE` + Formatter_GetCC_ge : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_ge; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JGE` / `JNL` ) + // + // Default: `JGE`, `CMOVGE`, `SETGE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_ge : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_ge ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JLE` / `JNG` ) + // + // Default: `JLE`, `CMOVLE`, `SETLE` + Formatter_GetCC_le : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_le; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JLE` / `JNG` ) + // + // Default: `JLE`, `CMOVLE`, `SETLE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_le : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_le ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JG` / `JNLE` ) + // + // Default: `JG`, `CMOVG`, `SETG` + Formatter_GetCC_g : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_g; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JG` / `JNLE` ) + // + // Default: `JG`, `CMOVG`, `SETG` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_g : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_g ) : boolean; cdecl = nil; + + + // Encoder + // Creates an encoder + // + // Returns NULL if `bitness` is not one of 16, 32, 64. + // + // # Arguments + // * `bitness`: 16, 32 or 64 + // * `capacity`: Initial capacity of the `u8` buffer + Encoder_Create : function( Bitness : Cardinal; Capacity : NativeUInt = 0 ) : Pointer; cdecl = nil; + + // Encodes an instruction and returns the size of the encoded instruction + // + // # Result + // * Returns written amount of encoded Bytes + // + // # Arguments + // * `instruction`: Instruction to encode + // * `rip`: `RIP` of the encoded instruction + Encoder_Encode : function( Encoder : Pointer; const Instruction : TInstruction ) : NativeUInt; cdecl = nil; + + // Writes a byte to the output buffer + // + // # Arguments + // + // `value`: Value to write + Encoder_WriteByte : function ( Encoder : Pointer; Value : Byte ) : boolean; cdecl = nil; + + // Returns the buffer and initializes the internal buffer to an empty vector. Should be called when + // you've encoded all instructions and need the raw instruction bytes. See also [`set_buffer()`]. + Encoder_GetBuffer : function ( Encoder : Pointer; Value : PByte; Size : NativeUInt ) : boolean; cdecl = nil; + + // Overwrites the buffer with a new vector. The old buffer is dropped. See also [`Encoder_GetBuffer`]. + // NOTE: Monitor the result of [`Encoder_Encode`] (Encoded Bytes). + // DO NOT Encode more Bytes than fitting your provided Buffer as this would cause a realloc - which will lead to an access violation. +// Encoder_SetBuffer : function ( Encoder : Pointer; Value : PByte; Size : NativeUInt ) : boolean; cdecl = nil; + + // Gets the offsets of the constants (memory displacement and immediate) in the encoded instruction. + // The caller can use this information to add relocations if needed. + Encoder_GetConstantOffsets : procedure( Decoder : Pointer; var ConstantOffsets : TConstantOffsets ); cdecl = nil; + + // Disables 2-byte VEX encoding and encodes all VEX instructions with the 3-byte VEX encoding + Encoder_GetPreventVex2 : function( Encoder : Pointer ) : Boolean; cdecl = nil; + + // Disables 2-byte VEX encoding and encodes all VEX instructions with the 3-byte VEX encoding + // + // # Arguments + // * `new_value`: new value + Encoder_SetPreventVex2 : function ( Encoder : Pointer; Value : Boolean ) : boolean; cdecl = nil; + + // Value of the `VEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + Encoder_GetVexWig : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Value of the `VEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + // + // # Arguments + // * `new_value`: new value (0 or 1) + Encoder_SetVexWig : function ( Encoder : Pointer; Value : Cardinal ) : boolean; cdecl = nil; + + // Value of the `VEX.L` bit to use if it's an instruction that ignores the bit. Default is 0. + Encoder_GetVexLig : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Value of the `VEX.L` bit to use if it's an instruction that ignores the bit. Default is 0. + // + // # Arguments + // * `new_value`: new value (0 or 1) + Encoder_SetVexLig : function ( Encoder : Pointer; Value : Cardinal ) : boolean; cdecl = nil; + + // Value of the `EVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + Encoder_GetEvexWig : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Value of the `EVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + // + // # Arguments + // * `new_value`: new value (0 or 1) + Encoder_SetEvexWig : function ( Encoder : Pointer; Value : Cardinal ) : boolean; cdecl = nil; + + // Value of the `EVEX.L'L` bits to use if it's an instruction that ignores the bits. Default is 0. + Encoder_GetEvexLig : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Value of the `EVEX.L'L` bits to use if it's an instruction that ignores the bits. Default is 0. + // + // # Arguments + // * `new_value`: new value (0 or 3) + Encoder_SetEvexLig : function ( Encoder : Pointer; Value : Cardinal ) : boolean; cdecl = nil; + + // Value of the `MVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + Encoder_GetMvexWig : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Value of the `MVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + // + // # Arguments + // * `new_value`: new value (0 or 1) + Encoder_SetMvexWig : function ( Encoder : Pointer; Value : Cardinal ) : boolean; cdecl = nil; + + // Gets the bitness (16, 32 or 64) + Encoder_GetBitness : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Encodes instructions. Any number of branches can be part of this block. + // You can use this function to move instructions from one location to another location. + // If the target of a branch is too far away, it'll be rewritten to a longer branch. + // You can disable this by passing in [`BlockEncoderOptions::DONT_FIX_BRANCHES`]. + // If the block has any `RIP`-relative memory operands, make sure the data isn't too + // far away from the new location of the encoded instructions. Every OS should have + // some API to allocate memory close (+/-2GB) to the original code location. + // + // # Errors + // Returns 0-Data if it failed to encode one or more instructions. + // + // # Arguments + // * `bitness`: 16, 32, or 64 + // * `Instructions`: First Instruction to encode + // * `Count`: Instruction-Count + // * `Results`: Result-Structure + // * `Options`: Encoder options, see [`TBlockEncoderOptions`] + // + // # Result + // * Pointer to Result-Data. Musst be free'd using FreeMemory() + BlockEncoder : function( Bitness : Cardinal; RIP : UInt64; const Instructions : TInstruction; Count : NativeUInt; var Result : TBlockEncoderResult; Options : Cardinal = beoNONE ) : Pointer; cdecl = nil; + + // Instruction + // Gets the FPU status word's `TOP` increment and whether it's a conditional or unconditional push/pop + // and whether `TOP` is written. + Instruction_FPU_StackIncrementInfo : function( const Instruction : TInstruction; var Info : TFpuStackIncrementInfo ) : Boolean; cdecl = nil; + + // Gets the number of bytes added to `SP`/`ESP`/`RSP` or 0 if it's not an instruction that pushes or pops data. This method assumes + // the instruction doesn't change the privilege level (eg. `IRET/D/Q`). If it's the `LEAVE` instruction, this method returns 0. + Instruction_StackPointerIncrement : function( const Instruction : TInstruction ) : Integer; cdecl = nil; + + // All flags that are read by the CPU when executing the instruction. + // This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. + Instruction_RFlagsRead : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // All flags that are written by the CPU, except those flags that are known to be undefined, always set or always cleared. + // This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. + Instruction_RFlagsWritten : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // All flags that are always cleared by the CPU. + // This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. + Instruction_RFlagsCleared : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // All flags that are always set by the CPU. + // This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. + Instruction_RFlagsSet : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // All flags that are undefined after executing the instruction. + // This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. + Instruction_RFlagsUndefined : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // All flags that are modified by the CPU. This is `rflags_written() + rflags_cleared() + rflags_set() + rflags_undefined()`. This method returns an [`RflagsBits`] value. + Instruction_RFlagsModified : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // Gets all op kinds ([`op_count()`] values) + Instruction_OPKinds : function( const Instruction : TInstruction; var OPKindsArray : TOPKindsArray ) : TFlowControl; cdecl = nil; + + // Gets the size of the memory location that is referenced by the operand. See also [`is_broadcast()`]. + // Use this method if the operand has kind [`OpKind::Memory`], + Instruction_MemorySize : function( const Instruction : TInstruction ) : TMemorySize; cdecl = nil; + + // Gets the operand count. An instruction can have 0-5 operands. + Instruction_OPCount : function( const Instruction : TInstruction ) : Cardinal; cdecl = nil; + + // Virtual-Address Resolver + // Gets the virtual address of a memory operand + // + // # Arguments + // * `operand`: Operand number, 0-4, must be a memory operand + // * `element_index`: Only used if it's a vsib memory operand. This is the element index of the vector index register. + // * `get_register_value`: Function that returns the value of a register or the base address of a segment register, or `None` for unsupported + // registers. + // + // # Call-back function args + // * Arg 1: `register`: Register (GPR8, GPR16, GPR32, GPR64, XMM, YMM, ZMM, seg). If it's a segment register, the call-back function should return the segment's base address, not the segment's register value. + // * Arg 2: `element_index`: Only used if it's a vsib memory operand. This is the element index of the vector index register. + // * Arg 3: `element_size`: Only used if it's a vsib memory operand. Size in bytes of elements in vector index register (4 or 8). + Instruction_VirtualAddress : function ( const Instruction: TInstruction; Callback : TVirtualAddressResolverCallback; Operand : Cardinal = 0; Index : NativeUInt = 0; UserData : Pointer = nil ) : UInt64; cdecl = nil; + + // `true` if eviction hint bit is set (`{eh}`) (MVEX instructions only) + Instruction_IsMvexEvictionHint : function( const Instruction: TInstruction ) : Boolean; cdecl = nil; + + // (MVEX) Register/memory operand conversion function + Instruction_MvexRegMemConv : function( const Instruction: TInstruction ) : TMvexRegMemConv; cdecl = nil; + + // Gets the opcode string, eg. `VEX.128.66.0F38.W0 78 /r`, see also [`instruction_string()`] + OpCodeInfo_OpCodeString : procedure( const Code: TCodeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + + // Gets the instruction string, eg. `VPBROADCASTB xmm1, xmm2/m8`, see also [`op_code_string()`] + OpCodeInfo_InstructionString : procedure( const Code: TCodeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + + // `true` if it's an instruction available in 16-bit mode + OpCodeInfo_Mode16 : function( const Code : TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's an instruction available in 32-bit mode + OpCodeInfo_Mode32 : function( const Code : TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's an instruction available in 64-bit mode + OpCodeInfo_Mode64 : function( const Code : TCodeType ) : Boolean; cdecl = nil; + + // `true` if an `FWAIT` (`9B`) instruction is added before the instruction + OpCodeInfo_Fwait : function( const Code : TCodeType ) : Boolean; cdecl = nil; + + // (VEX/XOP/EVEX/MVEX) `W` value or default value if [`is_wig()`] or [`is_wig32()`] is `true` + OpCodeInfo_W : function( const Code : TCodeType ) : Cardinal; cdecl = nil; + + // (VEX/XOP/EVEX) `true` if the `L` / `L'L` fields are ignored. + // + // EVEX: if reg-only ops and `{er}` (`EVEX.b` is set), `L'L` is the rounding control and not ignored. + OpCodeInfo_IsLig : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (VEX/XOP/EVEX/MVEX) `true` if the `W` field is ignored in 16/32/64-bit modes + OpCodeInfo_IsWig : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (VEX/XOP/EVEX/MVEX) `true` if the `W` field is ignored in 16/32-bit modes (but not 64-bit mode) + OpCodeInfo_IsWig32 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // OpCodeInfo + // (MVEX) Gets the `EH` bit that's required to encode this instruction + OpCodeInfo_MvexEhBit : function( const Code: TCodeType ) : TMvexEHBit; cdecl = nil; + + // (MVEX) `true` if the instruction supports eviction hint (if it has a memory operand) + OpCodeInfo_MvexCanUseEvictionHint : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (MVEX) `true` if the instruction's rounding control bits are stored in `imm8[1:0]` + OpCodeInfo_MvexCanUseImmRoundingControl : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (MVEX) `true` if the instruction ignores op mask registers (eg. `{k1}`) + OpCodeInfo_MvexIgnoresOpMaskRegister : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (MVEX) `true` if the instruction must have `MVEX.SSS=000` if `MVEX.EH=1` + OpCodeInfo_MvexNoSaeRc : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (MVEX) Gets the tuple type / conv lut kind + OpCodeInfo_MvexTupleTypeLutKind : function( const Code: TCodeType ) : TMvexTupleTypeLutKind; cdecl = nil; + + // (MVEX) Gets the conversion function, eg. `Sf32` + OpCodeInfo_MvexConversionFunc : function( const Code: TCodeType ) : TMvexConvFn; cdecl = nil; + + // (MVEX) Gets flags indicating which conversion functions are valid (bit 0 == func 0) + OpCodeInfo_MvexValidConversionFuncsMask : function( const Code: TCodeType ) : Byte; cdecl = nil; + + // (MVEX) Gets flags indicating which swizzle functions are valid (bit 0 == func 0) + OpCodeInfo_MvexValidSwizzleFuncsMask : function( const Code: TCodeType ) : Byte; cdecl = nil; + + // If it has a memory operand, gets the [`MemorySize`] (non-broadcast memory type) + OpCodeInfo_MemorySize : function( const Code: TCodeType ) : TMemorySize; cdecl = nil; + + // If it has a memory operand, gets the [`MemorySize`] (broadcast memory type) + OpCodeInfo_BroadcastMemorySize : function( const Code: TCodeType ) : TMemorySize; cdecl = nil; + + // (EVEX) `true` if the instruction supports broadcasting (`EVEX.b` bit) (if it has a memory operand) + OpCodeInfo_CanBroadcast : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (EVEX/MVEX) `true` if the instruction supports rounding control + OpCodeInfo_CanUseRoundingControl : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (EVEX/MVEX) `true` if the instruction supports suppress all exceptions + OpCodeInfo_CanSuppressAllExceptions : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (EVEX/MVEX) `true` if an opmask register can be used + OpCodeInfo_CanUseOpMaskRegister : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (EVEX/MVEX) `true` if a non-zero opmask register must be used + OpCodeInfo_RequireOpMaskRegister : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (EVEX) `true` if the instruction supports zeroing masking (if one of the opmask registers `K1`-`K7` is used and destination operand is not a memory operand) + OpCodeInfo_CanUseZeroingMasking : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `LOCK` (`F0`) prefix can be used + OpCodeInfo_CanUseLockPrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `XACQUIRE` (`F2`) prefix can be used + OpCodeInfo_CanUseXacquirePrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `XRELEASE` (`F3`) prefix can be used + OpCodeInfo_CanUseXreleasePrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `REP` / `REPE` (`F3`) prefixes can be used + OpCodeInfo_CanUseRepPrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `REPNE` (`F2`) prefix can be used + OpCodeInfo_CanUseRepnePrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `BND` (`F2`) prefix can be used + OpCodeInfo_CanUseBndPrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `HINT-TAKEN` (`3E`) and `HINT-NOT-TAKEN` (`2E`) prefixes can be used + OpCodeInfo_CanUseHintTakenPrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `NOTRACK` (`3E`) prefix can be used + OpCodeInfo_CanUseNotrackPrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if rounding control is ignored (#UD is not generated) + OpCodeInfo_IgnoresRoundingControl : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `LOCK` prefix can be used as an extra register bit (bit 3) to access registers 8-15 without a `REX` prefix (eg. in 32-bit mode) + OpCodeInfo_AmdLockRegBit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the default operand size is 64 in 64-bit mode. A `66` prefix can switch to 16-bit operand size. + OpCodeInfo_DefaultOpSize64 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the operand size is always 64 in 64-bit mode. A `66` prefix is ignored. + OpCodeInfo_ForceOpSize64 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the Intel decoder forces 64-bit operand size. A `66` prefix is ignored. + OpCodeInfo_IntelForceOpSize64 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can only be executed when CPL=0 + OpCodeInfo_MustBeCpl0 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed when CPL=0 + OpCodeInfo_Cpl0 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed when CPL=1 + OpCodeInfo_Cpl1 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed when CPL=2 + OpCodeInfo_Cpl2 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed when CPL=3 + OpCodeInfo_Cpl3 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the instruction accesses the I/O address space (eg. `IN`, `OUT`, `INS`, `OUTS`) + OpCodeInfo_IsInputOutput : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's one of the many nop instructions (does not include FPU nop instructions, eg. `FNOP`) + OpCodeInfo_IsNop : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's one of the many reserved nop instructions (eg. `0F0D`, `0F18-0F1F`) + OpCodeInfo_IsReservedNop : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a serializing instruction (Intel CPUs) + OpCodeInfo_IsSerializingIntel : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a serializing instruction (AMD CPUs) + OpCodeInfo_IsSerializingAmd : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the instruction requires either CPL=0 or CPL<=3 depending on some CPU option (eg. `CR4.TSD`, `CR4.PCE`, `CR4.UMIP`) + OpCodeInfo_MayRequireCpl0 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a tracked `JMP`/`CALL` indirect instruction (CET) + OpCodeInfo_IsCetTracked : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a non-temporal hint memory access (eg. `MOVNTDQ`) + OpCodeInfo_IsNonTemporal : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a no-wait FPU instruction, eg. `FNINIT` + OpCodeInfo_IsFpuNoWait : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the mod bits are ignored and it's assumed `modrm[7:6] == 11b` + OpCodeInfo_IgnoresModBits : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `66` prefix is not allowed (it will #UD) + OpCodeInfo_No66 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `F2`/`F3` prefixes aren't allowed + OpCodeInfo_Nfx : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the index reg's reg-num (vsib op) (if any) and register ops' reg-nums must be unique, + // eg. `MNEMONIC XMM1,YMM1,[RAX+ZMM1*2]` is invalid. Registers = `XMM`/`YMM`/`ZMM`/`TMM`. + OpCodeInfo_RequiresUniqueRegNums : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the destination register's reg-num must not be present in any other operand, eg. `MNEMONIC XMM1,YMM1,[RAX+ZMM1*2]` + // is invalid. Registers = `XMM`/`YMM`/`ZMM`/`TMM`. + OpCodeInfo_RequiresUniqueDestRegNum : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a privileged instruction (all CPL=0 instructions (except `VMCALL`) and IOPL instructions `IN`, `INS`, `OUT`, `OUTS`, `CLI`, `STI`) + OpCodeInfo_IsPrivileged : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it reads/writes too many registers + OpCodeInfo_IsSaveRestore : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's an instruction that implicitly uses the stack register, eg. `CALL`, `POP`, etc + OpCodeInfo_IsStackInstruction : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the instruction doesn't read the segment register if it uses a memory operand + OpCodeInfo_IgnoresSegment : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the opmask register is read and written (instead of just read). This also implies that it can't be `K0`. + OpCodeInfo_IsOpMaskReadWrite : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed in real mode + OpCodeInfo_RealMode : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed in protected mode + OpCodeInfo_ProtectedMode : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed in virtual 8086 mode + OpCodeInfo_Virtual8086Mode : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed in compatibility mode + OpCodeInfo_CompatibilityMode : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed in 64-bit mode + OpCodeInfo_LongMode : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used outside SMM + OpCodeInfo_UseOutsideSmm : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used in SMM + OpCodeInfo_UseInSmm : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used outside an enclave (SGX) + OpCodeInfo_UseOutsideEnclaveSgx : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used inside an enclave (SGX1) + OpCodeInfo_UseInEnclaveSgx1 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used inside an enclave (SGX2) + OpCodeInfo_UseInEnclaveSgx2 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used outside VMX operation + OpCodeInfo_UseOutsideVmxOp : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used in VMX root operation + OpCodeInfo_UseInVmxRootOp : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used in VMX non-root operation + OpCodeInfo_UseInVmxNonRootOp : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used outside SEAM + OpCodeInfo_UseOutsideSeam : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used in SEAM + OpCodeInfo_UseInSeam : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if #UD is generated in TDX non-root operation + OpCodeInfo_TdxNonRootGenUd : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if #VE is generated in TDX non-root operation + OpCodeInfo_TdxNonRootGenVe : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if an exception (eg. #GP(0), #VE) may be generated in TDX non-root operation + OpCodeInfo_TdxNonRootMayGenEx : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (Intel VMX) `true` if it causes a VM exit in VMX non-root operation + OpCodeInfo_IntelVMExit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (Intel VMX) `true` if it may cause a VM exit in VMX non-root operation + OpCodeInfo_IntelMayVMExit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (Intel VMX) `true` if it causes an SMM VM exit in VMX root operation (if dual-monitor treatment is activated) + OpCodeInfo_IntelSmmVMExit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (AMD SVM) `true` if it causes a #VMEXIT in guest mode + OpCodeInfo_AmdVMExit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (AMD SVM) `true` if it may cause a #VMEXIT in guest mode + OpCodeInfo_AmdMayVMExit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it causes a TSX abort inside a TSX transaction + OpCodeInfo_TsxAbort : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it causes a TSX abort inside a TSX transaction depending on the implementation + OpCodeInfo_TsxImplAbort : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it may cause a TSX abort inside a TSX transaction depending on some condition + OpCodeInfo_TsxMayAbort : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 16-bit Intel decoder + OpCodeInfo_IntelDecoder16 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 32-bit Intel decoder + OpCodeInfo_IntelDecoder32 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 64-bit Intel decoder + OpCodeInfo_IntelDecoder64 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 16-bit AMD decoder + OpCodeInfo_AmdDecoder16 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 32-bit AMD decoder + OpCodeInfo_AmdDecoder32 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 64-bit AMD decoder + OpCodeInfo_AmdDecoder64 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // Gets the decoder option that's needed to decode the instruction or [`DecoderOptions::NONE`]. + // The return value is a [`DecoderOptions`] value. + OpCodeInfo_DecoderOption : function( const Code: TCodeType ) : Cardinal; cdecl = nil; + + // Gets the length of the opcode bytes ([`op_code()`]). The low bytes is the opcode value. + OpCodeInfo_OpCodeLen : function( const Code: TCodeType ) : Cardinal; cdecl = nil; + + // Gets the number of operands + OpCodeInfo_OPCount : function( const Code: TCodeType ) : Cardinal; cdecl = nil; + + // InstructionInfoFactory + // Creates a new instance. + // + // If you don't need to know register and memory usage, it's faster to call [`Instruction`] and + // [`Code`] methods such as [`Instruction::flow_control()`] instead of getting that info from this struct. + // + // [`Instruction`]: struct.Instruction.html + // [`Code`]: enum.Code.html + // [`Instruction::flow_control()`]: struct.Instruction.html#method.flow_control + InstructionInfoFactory_Create : function : Pointer; cdecl = nil; + + // Creates a new [`InstructionInfo`], see also [`info()`]. + // + // If you don't need to know register and memory usage, it's faster to call [`Instruction`] and + // [`Code`] methods such as [`Instruction::flow_control()`] instead of getting that info from this struct. + InstructionInfoFactory_Info : function( InstructionInfoFactory : Pointer; const Instruction: TInstruction; const InstructionInfo : TInstructionInfo; Options : Cardinal = iioNone ) : Boolean; cdecl = nil; + + // Instruction 'WITH' + // Creates an instruction with no operands + Instruction_With : function( const Instruction : TInstruction; Code : TCodeType ) : Boolean; cdecl = nil; + + // Creates an instruction with 1 operand + // + // # Errors + // Fails if one of the operands is invalid (basic checks) + Instruction_With1_Register : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With1_i32 : function( const Instruction : TInstruction; Code : TCodeType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With1_u32 : function( const Instruction : TInstruction; Code : TCodeType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With1_Memory : function( const Instruction : TInstruction; Code : TCodeType; var Memory : TMemoryOperand ) : Boolean; cdecl = nil; + Instruction_With2_Register_Register : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With2_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With2_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With2_Register_i64 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate : Int64 ) : Boolean; cdecl = nil; + Instruction_With2_Register_u64 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate : UInt64 ) : Boolean; cdecl = nil; + Instruction_With2_Register_MemoryOperand : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; var Memory : TMemoryOperand ) : Boolean; cdecl = nil; + Instruction_With2_i32_Register : function( const Instruction : TInstruction; Code : TCodeType; Immediate : Integer; Register : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With2_u32_Register : function( const Instruction : TInstruction; Code : TCodeType; Immediate : Cardinal; Register : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With2_i32_i32 : function( const Instruction : TInstruction; Code : TCodeType; Immediate1 : Integer; Immediate2 : Integer ) : Boolean; cdecl = nil; + Instruction_With2_u32_u32 : function( const Instruction : TInstruction; Code : TCodeType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With2_MemoryOperand_Register : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Register : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With2_MemoryOperand_i32 : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With2_MemoryOperand_u32 : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With3_Register_Register_Register : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With3_Register_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With3_Register_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With3_Register_Register_MemoryOperand : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; var Memory : TMemoryOperand ) : Boolean; cdecl = nil; + Instruction_With3_Register_i32_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate1 : Integer; Immediate2 : Integer ) : Boolean; cdecl = nil; + Instruction_With3_Register_u32_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With3_Register_MemoryOperand_Register : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Memory : TMemoryOperand; Register2 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With3_Register_MemoryOperand_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With3_Register_MemoryOperand_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With3_MemoryOperand_Register_Register : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Register1 : TRegisterType; Register2 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With3_MemoryOperand_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Register : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With3_MemoryOperand_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Register : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_Register_Register : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_Register_MemoryOperand : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; var Memory : TMemoryOperand ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_i32_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate1 : Integer; Immediate2 : Integer ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_u32_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_MemoryOperand_Register : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_MemoryOperand_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_MemoryOperand_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_Register_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_Register_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_Register_MemoryOperand_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_Register_MemoryOperand_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_MemoryOperand_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_MemoryOperand_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Branch : function( const Instruction : TInstruction; Code : TCodeType; Target : UInt64 ) : Boolean; cdecl = nil; + Instruction_With_Far_Branch : function( const Instruction : TInstruction; Code : TCodeType; Selector : Word; Offset : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_xbegin : function( const Instruction : TInstruction; Bitness : Cardinal; Target : UInt64 ) : Boolean; cdecl = nil; + Instruction_With_outsb : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_outsb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_outsw : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_outsw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_outsd : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_outsd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_lodsb : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_lodsb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_lodsw : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_lodsw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_lodsd : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_lodsd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_lodsq : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_lodsq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_scasb : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_scasb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_scasb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_scasw : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_scasw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_scasw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_scasd : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_scasd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_scasd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_scasq : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_scasq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_scasq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_insb : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_insb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_insw : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_insw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_insd : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_insd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_stosb : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_stosb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_stosw : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_stosw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_stosd : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_stosd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_stosq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_cmpsb : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_cmpsb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_cmpsb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_cmpsw : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_cmpsw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_cmpsw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_cmpsd : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_cmpsd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_cmpsd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_cmpsq : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_cmpsq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_cmpsq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_movsb : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_movsb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_movsw : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_movsw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_movsd : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_movsd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_movsq : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_movsq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_maskmovq : function( const Instruction : TInstruction; AddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; SegmentPrefix : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_maskmovdqu : function( const Instruction : TInstruction; AddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; SegmentPrefix : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_vmaskmovdqu : function( const Instruction : TInstruction; AddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; SegmentPrefix : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_1 : function( const Instruction : TInstruction; B0 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_2 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_3 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_4 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_5 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_6 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_7 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_8 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_9 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_10 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_11 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_12 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_13 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_14 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_15 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_16 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte; B15 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_1 : function( const Instruction : TInstruction; W0 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_2 : function( const Instruction : TInstruction; W0 : Word; W1 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_3 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_4 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word; W3 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_5 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_6 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_7 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_8 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word; W7 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_DWord_1 : function( const Instruction : TInstruction; D0 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Declare_DWord_2 : function( const Instruction : TInstruction; D0 : Cardinal; D1 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Declare_DWord_3 : function( const Instruction : TInstruction; D0 : Cardinal; D1 : Cardinal; D2 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Declare_DWord_4 : function( const Instruction : TInstruction; D0 : Cardinal; D1 : Cardinal; D2 : Cardinal; D3 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Declare_QWord_1 : function( const Instruction : TInstruction; Q0 : UInt64 ) : Boolean; cdecl = nil; + Instruction_With_Declare_QWord_2 : function( const Instruction : TInstruction; Q0 : UInt64; Q1 : UInt64 ) : Boolean; cdecl = nil; + + Code_AsString : procedure( const Code : TCodeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + Code_Mnemonic : function( const Code : TCodeType ) : TMnemonic; cdecl = nil; + Code_OPCode : procedure( const Code : TCodeType; var Info : TOpCodeInfo ); cdecl = nil; + Code_Encoding : function( const Code : TCodeType ) : TEncodingKind; cdecl = nil; + Code_CPUidFeature : function( const Code : TCodeType; var CPUIDFeatures : TCPUIDFeaturesArray ) : boolean; cdecl = nil; + Code_FlowControl : function( const Code : TCodeType ) : TFlowControl; cdecl = nil; + Code_IsPrivileged : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsStackInstruction : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsSaveRestoreInstruction : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJccShort : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpShort : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpShortOrNear : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpNear : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpFar : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsCallNear : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsCallFar : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpNearIndirect : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpFarIndirect : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsCallNearIndirect : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsCallFarIndirect : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_ConditionCode : function( const Code : TCodeType ) : TConditionCode; cdecl = nil; + Code_IsJcxShort : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsLoopCC : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsLoop : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJccShortOrNear : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_NegateConditionCode : function( const Code : TCodeType ) : TCode; cdecl = nil; + Code_AsShortBranch : function( const Code : TCodeType ) : TCode; cdecl = nil; + Code_AsNearBranch : function( const Code : TCodeType ) : TCode; cdecl = nil; + + Mnemonic_AsString : procedure( const Mnemonic : TMnemonicType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + OpKind_AsString : procedure( const OpKind : TOpKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + EncodingKind_AsString : procedure( const EncodingKind : TEncodingKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + CPUidFeature_AsString : procedure( const CPUidFeature : TCPUidFeatureType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + ConditionCode_AsString : procedure( const ConditionCode : TConditionCodeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + FlowControl_AsString : procedure( const FlowControl : TFlowControlType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + TupleType_AsString : procedure( const TupleType : TTupleTypeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MvexEHBit_AsString : procedure( const MvexEHBit : TMvexEHBitType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MvexTupleTypeLutKind_AsString : procedure( const MvexTupleTypeLutKind : TMvexTupleTypeLutKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MvexConvFn_AsString : procedure( const MvexConvFn : TMvexConvFnType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MvexRegMemConv_AsString : procedure( const MvexRegMemConv : TMvexRegMemConvType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + RoundingControl_AsString : procedure( const RoundingControl : TRoundingControlType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + NumberBase_AsString : procedure( const NumberBase : TNumberBaseType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + RepPrefixKind_AsString : procedure( const RepPrefixKind : TRepPrefixKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MemorySizeOptions_AsString : procedure( const MemorySizeOptions : TMemorySizeOptionsType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + + MemorySize_AsString : procedure( const MemorySize : TMemorySizeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MemorySize_Info : procedure( const MemorySize : TMemorySizeType; var Info : TMemorySizeInfo ); cdecl = nil; + + OpCodeTableKind_AsString : procedure( const OpCodeTableKind : TOpCodeTableKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MandatoryPrefix_AsString : procedure( const MandatoryPrefix : TMandatoryPrefixType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + OpCodeOperandKind_AsString : procedure( const OpCodeOperandKind : TOpCodeOperandKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + OpAccess_AsString : procedure( const OpAccess : TOpAccessType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + CodeSize_AsString : procedure( const CodeSize : TCodeSizeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + FormatterTextKind_AsString : procedure( const FormatterTextKind : TFormatterTextKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + + Register_Base : function( const Register: TRegisterType ) : TRegister; cdecl = nil; + Register_Number : function( const Register: TRegisterType ) : NativeUInt; cdecl = nil; + Register_FullRegister : function( const Register: TRegisterType ) : TRegister; cdecl = nil; + Register_FullRegister32 : function( const Register: TRegisterType ) : TRegister; cdecl = nil; + Register_Size : function( const Register: TRegisterType ) : NativeUInt; cdecl = nil; + Register_AsString : procedure( const Register: TRegisterType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + +function IsInitDLL : Boolean; + +{$WARNINGS ON} +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +implementation + +uses + Windows; + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +var + Handle : THandle = 0; + +function IsInitDLL : Boolean; +begin + result := ( Handle <> 0 ) AND ( Handle <> INVALID_HANDLE_VALUE ); +end; + +procedure Load; +const + {$IFDEF Win64} + Name = 'Iced64.dll'; + {$ELSE} + Name = 'Iced.dll'; + {$ENDIF} +begin + if ( Handle <> 0 ) AND ( Handle <> INVALID_HANDLE_VALUE ) then + Exit; + + Handle := LoadLibrary( Name ); + if ( Handle = 0 ) OR ( Handle = INVALID_HANDLE_VALUE ) then + Exit; + + {$WARNINGS OFF} + @IcedFreeMemory := GetProcAddress( Handle, 'IcedFreeMemory' ); + + // Decoder + @Decoder_Create := GetProcAddress( Handle, 'Decoder_Create' ); + @Decoder_CanDecode := GetProcAddress( Handle, 'Decoder_CanDecode' ); + @Decoder_GetIP := GetProcAddress( Handle, 'Decoder_GetIP' ); + @Decoder_SetIP := GetProcAddress( Handle, 'Decoder_SetIP' ); + @Decoder_GetBitness := GetProcAddress( Handle, 'Decoder_GetBitness' ); + @Decoder_GetMaxPosition := GetProcAddress( Handle, 'Decoder_GetMaxPosition' ); + @Decoder_GetPosition := GetProcAddress( Handle, 'Decoder_GetPosition' ); + @Decoder_SetPosition := GetProcAddress( Handle, 'Decoder_SetPosition' ); + @Decoder_GetLastError := GetProcAddress( Handle, 'Decoder_GetLastError' ); + @DecoderError_AsString := GetProcAddress( Handle, 'DecoderError_AsString' ); + @Decoder_Decode := GetProcAddress( Handle, 'Decoder_Decode' ); + @Decoder_DecodeToEnd := GetProcAddress( Handle, 'Decoder_DecodeToEnd' ); + @Decoder_GetConstantOffsets := GetProcAddress( Handle, 'Decoder_GetConstantOffsets' ); + + @FormatterOutput_Create := GetProcAddress( Handle, 'FormatterOutput_Create' ); + + // MasmFormatter + @MasmFormatter_Create := GetProcAddress( Handle, 'MasmFormatter_Create' ); + @MasmFormatter_DecodeFormat := GetProcAddress( Handle, 'MasmFormatter_DecodeFormat' ); + @MasmFormatter_DecodeFormatCallback := GetProcAddress( Handle, 'MasmFormatter_DecodeFormatCallback' ); + @MasmFormatter_Format := GetProcAddress( Handle, 'MasmFormatter_Format' ); + @MasmFormatter_FormatCallback := GetProcAddress( Handle, 'MasmFormatter_FormatCallback' ); + @MasmFormatter_DecodeFormatToEnd := GetProcAddress( Handle, 'MasmFormatter_DecodeFormatToEnd' ); + + // NasmFormatter + @NasmFormatter_Create := GetProcAddress( Handle, 'NasmFormatter_Create' ); + @NasmFormatter_DecodeFormat := GetProcAddress( Handle, 'NasmFormatter_DecodeFormat' ); + @NasmFormatter_DecodeFormatCallback := GetProcAddress( Handle, 'NasmFormatter_DecodeFormatCallback' ); + @NasmFormatter_Format := GetProcAddress( Handle, 'NasmFormatter_Format' ); + @NasmFormatter_FormatCallback := GetProcAddress( Handle, 'NasmFormatter_FormatCallback' ); + @NasmFormatter_DecodeFormatToEnd := GetProcAddress( Handle, 'NasmFormatter_DecodeFormatToEnd' ); + + // GasFormatter + @GasFormatter_Create := GetProcAddress( Handle, 'GasFormatter_Create' ); + @GasFormatter_DecodeFormat := GetProcAddress( Handle, 'GasFormatter_DecodeFormat' ); + @GasFormatter_DecodeFormatCallback := GetProcAddress( Handle, 'GasFormatter_DecodeFormatCallback' ); + @GasFormatter_Format := GetProcAddress( Handle, 'GasFormatter_Format' ); + @GasFormatter_FormatCallback := GetProcAddress( Handle, 'GasFormatter_FormatCallback' ); + @GasFormatter_DecodeFormatToEnd := GetProcAddress( Handle, 'GasFormatter_DecodeFormatToEnd' ); + + + // IntelFormatter + @IntelFormatter_Create := GetProcAddress( Handle, 'IntelFormatter_Create' ); + @IntelFormatter_DecodeFormat := GetProcAddress( Handle, 'IntelFormatter_DecodeFormat' ); + @IntelFormatter_DecodeFormatCallback := GetProcAddress( Handle, 'IntelFormatter_DecodeFormatCallback' ); + @IntelFormatter_Format := GetProcAddress( Handle, 'IntelFormatter_Format' ); + @IntelFormatter_FormatCallback := GetProcAddress( Handle, 'IntelFormatter_FormatCallback' ); + @IntelFormatter_DecodeFormatToEnd := GetProcAddress( Handle, 'IntelFormatter_DecodeFormatToEnd' ); + + // FastFormatter + @FastFormatter_Create := GetProcAddress( Handle, 'FastFormatter_Create' ); + @FastFormatter_DecodeFormat := GetProcAddress( Handle, 'FastFormatter_DecodeFormat' ); + @FastFormatter_Format := GetProcAddress( Handle, 'FastFormatter_Format' ); + @FastFormatter_DecodeFormatToEnd := GetProcAddress( Handle, 'FastFormatter_DecodeFormatToEnd' ); + + // SpecializedFormatter + @SpecializedFormatter_Create := GetProcAddress( Handle, 'SpecializedFormatter_Create' ); + @SpecializedFormatter_DecodeFormat := GetProcAddress( Handle, 'SpecializedFormatter_DecodeFormat' ); + @SpecializedFormatter_Format := GetProcAddress( Handle, 'SpecializedFormatter_Format' ); + @SpecializedFormatter_DecodeFormatToEnd := GetProcAddress( Handle, 'SpecializedFormatter_DecodeFormatToEnd' ); + + // Options + @SpecializedFormatter_GetAlwaysShowMemorySize := GetProcAddress( Handle, 'SpecializedFormatter_GetAlwaysShowMemorySize' ); + @SpecializedFormatter_SetAlwaysShowMemorySize := GetProcAddress( Handle, 'SpecializedFormatter_SetAlwaysShowMemorySize' ); + @SpecializedFormatter_GetUseHexPrefix := GetProcAddress( Handle, 'SpecializedFormatter_GetUseHexPrefix' ); + @SpecializedFormatter_SetUseHexPrefix := GetProcAddress( Handle, 'SpecializedFormatter_SetUseHexPrefix' ); + + // Formatter Options + @Formatter_Format := GetProcAddress( Handle, 'Formatter_Format' ); + @Formatter_FormatCallback := GetProcAddress( Handle, 'Formatter_FormatCallback' ); + + @Formatter_GetUpperCasePrefixes := GetProcAddress( Handle, 'Formatter_GetUpperCasePrefixes' ); + @Formatter_SetUpperCasePrefixes := GetProcAddress( Handle, 'Formatter_SetUpperCasePrefixes' ); + @Formatter_GetUpperCaseMnemonics := GetProcAddress( Handle, 'Formatter_GetUpperCaseMnemonics' ); + @Formatter_SetUpperCaseMnemonics := GetProcAddress( Handle, 'Formatter_SetUpperCaseMnemonics' ); + @Formatter_GetUpperCaseRegisters := GetProcAddress( Handle, 'Formatter_GetUpperCaseRegisters' ); + @Formatter_SetUpperCaseRegisters := GetProcAddress( Handle, 'Formatter_SetUpperCaseRegisters' ); + @Formatter_GetUpperCaseKeyWords := GetProcAddress( Handle, 'Formatter_GetUpperCaseKeyWords' ); + @Formatter_SetUpperCaseKeyWords := GetProcAddress( Handle, 'Formatter_SetUpperCaseKeyWords' ); + @Formatter_GetUpperCaseDecorators := GetProcAddress( Handle, 'Formatter_GetUpperCaseDecorators' ); + @Formatter_SetUpperCaseDecorators := GetProcAddress( Handle, 'Formatter_SetUpperCaseDecorators' ); + @Formatter_GetUpperCaseEverything := GetProcAddress( Handle, 'Formatter_GetUpperCaseEverything' ); + @Formatter_SetUpperCaseEverything := GetProcAddress( Handle, 'Formatter_SetUpperCaseEverything' ); + @Formatter_GetFirstOperandCharIndex := GetProcAddress( Handle, 'Formatter_GetFirstOperandCharIndex' ); + @Formatter_SetFirstOperandCharIndex := GetProcAddress( Handle, 'Formatter_SetFirstOperandCharIndex' ); + @Formatter_GetTabSize := GetProcAddress( Handle, 'Formatter_GetTabSize' ); + @Formatter_SetTabSize := GetProcAddress( Handle, 'Formatter_SetTabSize' ); + @Formatter_GetSpaceAfterOperandSeparator := GetProcAddress( Handle, 'Formatter_GetSpaceAfterOperandSeparator' ); + @Formatter_SetSpaceAfterOperandSeparator := GetProcAddress( Handle, 'Formatter_SetSpaceAfterOperandSeparator' ); + @Formatter_GetSpaceAfterMemoryBracket := GetProcAddress( Handle, 'Formatter_GetSpaceAfterMemoryBracket' ); + @Formatter_SetSpaceAfterMemoryBracket := GetProcAddress( Handle, 'Formatter_SetSpaceAfterMemoryBracket' ); + @Formatter_GetSpaceBetweenMemoryAddOperators := GetProcAddress( Handle, 'Formatter_GetSpaceBetweenMemoryAddOperators' ); + @Formatter_SetSpaceBetweenMemoryAddOperators := GetProcAddress( Handle, 'Formatter_SetSpaceBetweenMemoryAddOperators' ); + @Formatter_GetSpaceBetweenMemoryMulOperators := GetProcAddress( Handle, 'Formatter_GetSpaceBetweenMemoryMulOperators' ); + @Formatter_SetSpaceBetweenMemoryMulOperators := GetProcAddress( Handle, 'Formatter_SetSpaceBetweenMemoryMulOperators' ); + @Formatter_GetScaleBeforeIndex := GetProcAddress( Handle, 'Formatter_GetScaleBeforeIndex' ); + @Formatter_SetScaleBeforeIndex := GetProcAddress( Handle, 'Formatter_SetScaleBeforeIndex' ); + @Formatter_GetAlwaysShowScale := GetProcAddress( Handle, 'Formatter_GetAlwaysShowScale' ); + @Formatter_SetAlwaysShowScale := GetProcAddress( Handle, 'Formatter_SetAlwaysShowScale' ); + @Formatter_GetAlwaysShowSegmentRegister := GetProcAddress( Handle, 'Formatter_GetAlwaysShowSegmentRegister' ); + @Formatter_SetAlwaysShowSegmentRegister := GetProcAddress( Handle, 'Formatter_SetAlwaysShowSegmentRegister' ); + @Formatter_GetShowZeroDisplacements := GetProcAddress( Handle, 'Formatter_GetShowZeroDisplacements' ); + @Formatter_SetShowZeroDisplacements := GetProcAddress( Handle, 'Formatter_SetShowZeroDisplacements' ); + @Formatter_GetHexPrefix := GetProcAddress( Handle, 'Formatter_GetHexPrefix' ); + @Formatter_SetHexPrefix := GetProcAddress( Handle, 'Formatter_SetHexPrefix' ); + @Formatter_GetHexSuffix := GetProcAddress( Handle, 'Formatter_GetHexSuffix' ); + @Formatter_SetHexSuffix := GetProcAddress( Handle, 'Formatter_SetHexSuffix' ); + @Formatter_GetHexDigitGroupSize := GetProcAddress( Handle, 'Formatter_GetHexDigitGroupSize' ); + @Formatter_SetHexDigitGroupSize := GetProcAddress( Handle, 'Formatter_SetHexDigitGroupSize' ); + @Formatter_GetDecimalPrefix := GetProcAddress( Handle, 'Formatter_GetDecimalPrefix' ); + @Formatter_SetDecimalPrefix := GetProcAddress( Handle, 'Formatter_SetDecimalPrefix' ); + @Formatter_GetDecimalSuffix := GetProcAddress( Handle, 'Formatter_GetDecimalSuffix' ); + @Formatter_SetDecimalSuffix := GetProcAddress( Handle, 'Formatter_SetDecimalSuffix' ); + @Formatter_GetDecimalDigitGroupSize := GetProcAddress( Handle, 'Formatter_GetDecimalDigitGroupSize' ); + @Formatter_SetDecimalDigitGroupSize := GetProcAddress( Handle, 'Formatter_SetDecimalDigitGroupSize' ); + @Formatter_GetOctalPrefix := GetProcAddress( Handle, 'Formatter_GetOctalPrefix' ); + @Formatter_SetOctalPrefix := GetProcAddress( Handle, 'Formatter_SetOctalPrefix' ); + @Formatter_GetOctalSuffix := GetProcAddress( Handle, 'Formatter_GetOctalSuffix' ); + @Formatter_SetOctalSuffix := GetProcAddress( Handle, 'Formatter_SetOctalSuffix' ); + @Formatter_GetOctalDigitGroupSize := GetProcAddress( Handle, 'Formatter_GetOctalDigitGroupSize' ); + @Formatter_SetOctalDigitGroupSize := GetProcAddress( Handle, 'Formatter_SetOctalDigitGroupSize' ); + @Formatter_GetBinaryPrefix := GetProcAddress( Handle, 'Formatter_GetBinaryPrefix' ); + @Formatter_SetBinaryPrefix := GetProcAddress( Handle, 'Formatter_SetBinaryPrefix' ); + @Formatter_GetBinarySuffix := GetProcAddress( Handle, 'Formatter_GetBinarySuffix' ); + @Formatter_SetBinarySuffix := GetProcAddress( Handle, 'Formatter_SetBinarySuffix' ); + @Formatter_GetBinaryDigitGroupSize := GetProcAddress( Handle, 'Formatter_GetBinaryDigitGroupSize' ); + @Formatter_SetBinaryDigitGroupSize := GetProcAddress( Handle, 'Formatter_SetBinaryDigitGroupSize' ); + @Formatter_GetDigitSeparator := GetProcAddress( Handle, 'Formatter_GetDigitSeparator' ); + @Formatter_SetDigitSeparator := GetProcAddress( Handle, 'Formatter_SetDigitSeparator' ); + @Formatter_GetLeadingZeros := GetProcAddress( Handle, 'Formatter_GetLeadingZeros' ); + @Formatter_SetLeadingZeros := GetProcAddress( Handle, 'Formatter_SetLeadingZeros' ); + @Formatter_GetUppercaseHex := GetProcAddress( Handle, 'Formatter_GetUppercaseHex' ); + @Formatter_SetUppercaseHex := GetProcAddress( Handle, 'Formatter_SetUppercaseHex' ); + @Formatter_GetSmallHexNumbersInDecimal := GetProcAddress( Handle, 'Formatter_GetSmallHexNumbersInDecimal' ); + @Formatter_SetSmallHexNumbersInDecimal := GetProcAddress( Handle, 'Formatter_SetSmallHexNumbersInDecimal' ); + @Formatter_GetAddLeadingZeroToHexNumbers := GetProcAddress( Handle, 'Formatter_GetAddLeadingZeroToHexNumbers' ); + @Formatter_SetAddLeadingZeroToHexNumbers := GetProcAddress( Handle, 'Formatter_SetAddLeadingZeroToHexNumbers' ); + @Formatter_GetNumberBase := GetProcAddress( Handle, 'Formatter_GetNumberBase' ); + @Formatter_SetNumberBase := GetProcAddress( Handle, 'Formatter_SetNumberBase' ); + @Formatter_GetBranchLeadingZeros := GetProcAddress( Handle, 'Formatter_GetBranchLeadingZeros' ); + @Formatter_SetBranchLeadingZeros := GetProcAddress( Handle, 'Formatter_SetBranchLeadingZeros' ); + @Formatter_GetSignedImmediateOperands := GetProcAddress( Handle, 'Formatter_GetSignedImmediateOperands' ); + @Formatter_SetSignedImmediateOperands := GetProcAddress( Handle, 'Formatter_SetSignedImmediateOperands' ); + @Formatter_GetSignedMemoryDisplacements := GetProcAddress( Handle, 'Formatter_GetSignedMemoryDisplacements' ); + @Formatter_SetSignedMemoryDisplacements := GetProcAddress( Handle, 'Formatter_SetSignedMemoryDisplacements' ); + @Formatter_GetDisplacementLeadingZeros := GetProcAddress( Handle, 'Formatter_GetDisplacementLeadingZeros' ); + @Formatter_SetDisplacementLeadingZeros := GetProcAddress( Handle, 'Formatter_SetDisplacementLeadingZeros' ); + @Formatter_GetMemorySizeOptions := GetProcAddress( Handle, 'Formatter_GetMemorySizeOptions' ); + @Formatter_SetMemorySizeOptions := GetProcAddress( Handle, 'Formatter_SetMemorySizeOptions' ); + @Formatter_GetRipRelativeAddresses := GetProcAddress( Handle, 'Formatter_GetRipRelativeAddresses' ); + @Formatter_SetRipRelativeAddresses := GetProcAddress( Handle, 'Formatter_SetRipRelativeAddresses' ); + @Formatter_GetShowBranchSize := GetProcAddress( Handle, 'Formatter_GetShowBranchSize' ); + @Formatter_SetShowBranchSize := GetProcAddress( Handle, 'Formatter_SetShowBranchSize' ); + @Formatter_GetUsePseudoOps := GetProcAddress( Handle, 'Formatter_GetUsePseudoOps' ); + @Formatter_SetUsePseudoOps := GetProcAddress( Handle, 'Formatter_SetUsePseudoOps' ); + @Formatter_GetShowSymbolAddress := GetProcAddress( Handle, 'Formatter_GetShowSymbolAddress' ); + @Formatter_SetShowSymbolAddress := GetProcAddress( Handle, 'Formatter_SetShowSymbolAddress' ); + @GasFormatter_GetNakedRegisters := GetProcAddress( Handle, 'GasFormatter_GetNakedRegisters' ); + @GasFormatter_SetNakedRegisters := GetProcAddress( Handle, 'GasFormatter_SetNakedRegisters' ); + @GasFormatter_GetShowMnemonicSizeSuffix := GetProcAddress( Handle, 'GasFormatter_GetShowMnemonicSizeSuffix' ); + @GasFormatter_SetShowMnemonicSizeSuffix := GetProcAddress( Handle, 'GasFormatter_SetShowMnemonicSizeSuffix' ); + @GasFormatter_GetSpaceAfterMemoryOperandComma := GetProcAddress( Handle, 'GasFormatter_GetSpaceAfterMemoryOperandComma' ); + @GasFormatter_SetSpaceAfterMemoryOperandComma := GetProcAddress( Handle, 'GasFormatter_SetSpaceAfterMemoryOperandComma' ); + @MasmFormatter_GetAddDsPrefix32 := GetProcAddress( Handle, 'MasmFormatter_GetAddDsPrefix32' ); + @MasmFormatter_SetAddDsPrefix32 := GetProcAddress( Handle, 'MasmFormatter_SetAddDsPrefix32' ); + @MasmFormatter_GetSymbolDisplacementInBrackets := GetProcAddress( Handle, 'MasmFormatter_GetSymbolDisplacementInBrackets' ); + @MasmFormatter_SetSymbolDisplacementInBrackets := GetProcAddress( Handle, 'MasmFormatter_SetSymbolDisplacementInBrackets' ); + @MasmFormatter_GetDisplacementInBrackets := GetProcAddress( Handle, 'MasmFormatter_GetDisplacementInBrackets' ); + @MasmFormatter_SetDisplacementInBrackets := GetProcAddress( Handle, 'MasmFormatter_SetDisplacementInBrackets' ); + @NasmFormatter_GetShowSignExtendedImmediateSize := GetProcAddress( Handle, 'NasmFormatter_GetShowSignExtendedImmediateSize' ); + @NasmFormatter_SetShowSignExtendedImmediateSize := GetProcAddress( Handle, 'NasmFormatter_SetShowSignExtendedImmediateSize' ); + @Formatter_GetPreferST0 := GetProcAddress( Handle, 'Formatter_GetPreferST0' ); + @Formatter_SetPreferST0 := GetProcAddress( Handle, 'Formatter_SetPreferST0' ); + @Formatter_GetShowUselessPrefixes := GetProcAddress( Handle, 'Formatter_GetShowUselessPrefixes' ); + @Formatter_SetShowUselessPrefixes := GetProcAddress( Handle, 'Formatter_SetShowUselessPrefixes' ); + @Formatter_GetCC_b := GetProcAddress( Handle, 'Formatter_GetCC_b' ); + @Formatter_SetCC_b := GetProcAddress( Handle, 'Formatter_SetCC_b' ); + @Formatter_GetCC_ae := GetProcAddress( Handle, 'Formatter_GetCC_ae' ); + @Formatter_SetCC_ae := GetProcAddress( Handle, 'Formatter_SetCC_ae' ); + @Formatter_GetCC_e := GetProcAddress( Handle, 'Formatter_GetCC_e' ); + @Formatter_SetCC_e := GetProcAddress( Handle, 'Formatter_SetCC_e' ); + @Formatter_GetCC_ne := GetProcAddress( Handle, 'Formatter_GetCC_ne' ); + @Formatter_SetCC_ne := GetProcAddress( Handle, 'Formatter_SetCC_ne' ); + @Formatter_GetCC_be := GetProcAddress( Handle, 'Formatter_GetCC_be' ); + @Formatter_SetCC_be := GetProcAddress( Handle, 'Formatter_SetCC_be' ); + @Formatter_GetCC_a := GetProcAddress( Handle, 'Formatter_GetCC_a' ); + @Formatter_SetCC_a := GetProcAddress( Handle, 'Formatter_SetCC_a' ); + @Formatter_GetCC_p := GetProcAddress( Handle, 'Formatter_GetCC_p' ); + @Formatter_SetCC_p := GetProcAddress( Handle, 'Formatter_SetCC_p' ); + @Formatter_GetCC_np := GetProcAddress( Handle, 'Formatter_GetCC_np' ); + @Formatter_SetCC_np := GetProcAddress( Handle, 'Formatter_SetCC_np' ); + @Formatter_GetCC_l := GetProcAddress( Handle, 'Formatter_GetCC_l' ); + @Formatter_SetCC_l := GetProcAddress( Handle, 'Formatter_SetCC_l' ); + @Formatter_GetCC_ge := GetProcAddress( Handle, 'Formatter_GetCC_ge' ); + @Formatter_SetCC_ge := GetProcAddress( Handle, 'Formatter_SetCC_ge' ); + @Formatter_GetCC_le := GetProcAddress( Handle, 'Formatter_GetCC_le' ); + @Formatter_SetCC_le := GetProcAddress( Handle, 'Formatter_SetCC_le' ); + @Formatter_GetCC_g := GetProcAddress( Handle, 'Formatter_GetCC_g' ); + @Formatter_SetCC_g := GetProcAddress( Handle, 'Formatter_SetCC_g' ); + + // Encoder + @Encoder_Create := GetProcAddress( Handle, 'Encoder_Create' ); + @Encoder_Encode := GetProcAddress( Handle, 'Encoder_Encode' ); + @Encoder_WriteByte := GetProcAddress( Handle, 'Encoder_WriteByte' ); + @Encoder_GetBuffer := GetProcAddress( Handle, 'Encoder_GetBuffer' ); +// @Encoder_SetBuffer := GetProcAddress( Handle, ''Encoder_SetBuffer' ); + @Encoder_GetConstantOffsets := GetProcAddress( Handle, 'Encoder_GetConstantOffsets' ); + @Encoder_GetPreventVex2 := GetProcAddress( Handle, 'Encoder_GetPreventVex2' ); + @Encoder_SetPreventVex2 := GetProcAddress( Handle, 'Encoder_SetPreventVex2' ); + @Encoder_GetVexWig := GetProcAddress( Handle, 'Encoder_GetVexWig' ); + @Encoder_SetVexWig := GetProcAddress( Handle, 'Encoder_SetVexWig' ); + @Encoder_GetVexLig := GetProcAddress( Handle, 'Encoder_GetVexLig' ); + @Encoder_SetVexLig := GetProcAddress( Handle, 'Encoder_SetVexLig' ); + @Encoder_GetEvexWig := GetProcAddress( Handle, 'Encoder_GetEvexWig' ); + @Encoder_SetEvexWig := GetProcAddress( Handle, 'Encoder_SetEvexWig' ); + @Encoder_GetEvexLig := GetProcAddress( Handle, 'Encoder_GetEvexLig' ); + @Encoder_SetEvexLig := GetProcAddress( Handle, 'Encoder_SetEvexLig' ); + @Encoder_GetMvexWig := GetProcAddress( Handle, 'Encoder_GetMvexWig' ); + @Encoder_SetMvexWig := GetProcAddress( Handle, 'Encoder_SetMvexWig' ); + @Encoder_GetBitness := GetProcAddress( Handle, 'Encoder_GetBitness' ); + + @BlockEncoder := GetProcAddress( Handle, 'BlockEncoder' ); + + // Instruction + @Instruction_StackPointerIncrement := GetProcAddress( Handle, 'Instruction_StackPointerIncrement' ); + @Instruction_RFlagsRead := GetProcAddress( Handle, 'Instruction_RFlagsRead' ); + @Instruction_RFlagsWritten := GetProcAddress( Handle, 'Instruction_RFlagsWritten' ); + @Instruction_RFlagsCleared := GetProcAddress( Handle, 'Instruction_RFlagsCleared' ); + @Instruction_RFlagsSet := GetProcAddress( Handle, 'Instruction_RFlagsSet' ); + @Instruction_RFlagsUndefined := GetProcAddress( Handle, 'Instruction_RFlagsUndefined' ); + @Instruction_RFlagsModified := GetProcAddress( Handle, 'Instruction_RFlagsModified' ); + + @Instruction_FPU_StackIncrementInfo := GetProcAddress( Handle, 'Instruction_FPU_StackIncrementInfo' ); + @Instruction_OPKinds := GetProcAddress( Handle, 'Instruction_OPKinds' ); + @Instruction_MemorySize := GetProcAddress( Handle, 'Instruction_MemorySize' ); + @Instruction_OPCount := GetProcAddress( Handle, 'Instruction_OPCount' ); + @Instruction_VirtualAddress := GetProcAddress( Handle, 'Instruction_VirtualAddress' ); + @Instruction_IsMvexEvictionHint := GetProcAddress( Handle, 'Instruction_IsMvexEvictionHint' ); + @Instruction_MvexRegMemConv := GetProcAddress( Handle, 'Instruction_MvexRegMemConv' ); + + @InstructionInfoFactory_Create := GetProcAddress( Handle, 'InstructionInfoFactory_Create' ); + @InstructionInfoFactory_Info := GetProcAddress( Handle, 'InstructionInfoFactory_Info' ); + + // Instruction + @Instruction_With := GetProcAddress( Handle, 'Instruction_With' ); + @Instruction_With1_Register := GetProcAddress( Handle, 'Instruction_With1_Register' ); + @Instruction_With1_i32 := GetProcAddress( Handle, 'Instruction_With1_i32' ); + @Instruction_With1_u32 := GetProcAddress( Handle, 'Instruction_With1_u32' ); + @Instruction_With1_Memory := GetProcAddress( Handle, 'Instruction_With1_Memory' ); + @Instruction_With2_Register_Register := GetProcAddress( Handle, 'Instruction_With2_Register_Register' ); + @Instruction_With2_Register_i32 := GetProcAddress( Handle, 'Instruction_With2_Register_i32' ); + @Instruction_With2_Register_u32 := GetProcAddress( Handle, 'Instruction_With2_Register_u32' ); + @Instruction_With2_Register_i64 := GetProcAddress( Handle, 'Instruction_With2_Register_i64' ); + @Instruction_With2_Register_u64 := GetProcAddress( Handle, 'Instruction_With2_Register_u64' ); + @Instruction_With2_Register_MemoryOperand := GetProcAddress( Handle, 'Instruction_With2_Register_MemoryOperand' ); + @Instruction_With2_i32_Register := GetProcAddress( Handle, 'Instruction_With2_i32_Register' ); + @Instruction_With2_u32_Register := GetProcAddress( Handle, 'Instruction_With2_u32_Register' ); + @Instruction_With2_i32_i32 := GetProcAddress( Handle, 'Instruction_With2_i32_i32' ); + @Instruction_With2_u32_u32 := GetProcAddress( Handle, 'Instruction_With2_u32_u32' ); + @Instruction_With2_MemoryOperand_Register := GetProcAddress( Handle, 'Instruction_With2_MemoryOperand_Register' ); + @Instruction_With2_MemoryOperand_i32 := GetProcAddress( Handle, 'Instruction_With2_MemoryOperand_i32' ); + @Instruction_With2_MemoryOperand_u32 := GetProcAddress( Handle, 'Instruction_With2_MemoryOperand_u32' ); + @Instruction_With3_Register_Register_Register := GetProcAddress( Handle, 'Instruction_With3_Register_Register_Register' ); + @Instruction_With3_Register_Register_i32 := GetProcAddress( Handle, 'Instruction_With3_Register_Register_i32' ); + @Instruction_With3_Register_Register_u32 := GetProcAddress( Handle, 'Instruction_With3_Register_Register_u32' ); + @Instruction_With3_Register_Register_MemoryOperand := GetProcAddress( Handle, 'Instruction_With3_Register_Register_MemoryOperand' ); + @Instruction_With3_Register_i32_i32 := GetProcAddress( Handle, 'Instruction_With3_Register_i32_i32' ); + @Instruction_With3_Register_u32_u32 := GetProcAddress( Handle, 'Instruction_With3_Register_u32_u32' ); + @Instruction_With3_Register_MemoryOperand_Register := GetProcAddress( Handle, 'Instruction_With3_Register_MemoryOperand_Register' ); + @Instruction_With3_Register_MemoryOperand_i32 := GetProcAddress( Handle, 'Instruction_With3_Register_MemoryOperand_i32' ); + @Instruction_With3_Register_MemoryOperand_u32 := GetProcAddress( Handle, 'Instruction_With3_Register_MemoryOperand_u32' ); + @Instruction_With3_MemoryOperand_Register_Register := GetProcAddress( Handle, 'Instruction_With3_MemoryOperand_Register_Register' ); + @Instruction_With3_MemoryOperand_Register_i32 := GetProcAddress( Handle, 'Instruction_With3_MemoryOperand_Register_i32' ); + @Instruction_With3_MemoryOperand_Register_u32 := GetProcAddress( Handle, 'Instruction_With3_MemoryOperand_Register_u32' ); + @Instruction_With4_Register_Register_Register_Register := GetProcAddress( Handle, 'Instruction_With4_Register_Register_Register_Register' ); + @Instruction_With4_Register_Register_Register_i32 := GetProcAddress( Handle, 'Instruction_With4_Register_Register_Register_i32' ); + @Instruction_With4_Register_Register_Register_u32 := GetProcAddress( Handle, 'Instruction_With4_Register_Register_Register_u32' ); + @Instruction_With4_Register_Register_Register_MemoryOperand := GetProcAddress( Handle, 'Instruction_With4_Register_Register_Register_MemoryOperand' ); + @Instruction_With4_Register_Register_i32_i32 := GetProcAddress( Handle, 'Instruction_With4_Register_Register_i32_i32' ); + @Instruction_With4_Register_Register_u32_u32 := GetProcAddress( Handle, 'Instruction_With4_Register_Register_u32_u32' ); + @Instruction_With4_Register_Register_MemoryOperand_Register := GetProcAddress( Handle, 'Instruction_With4_Register_Register_MemoryOperand_Register' ); + @Instruction_With4_Register_Register_MemoryOperand_i32 := GetProcAddress( Handle, 'Instruction_With4_Register_Register_MemoryOperand_i32' ); + @Instruction_With4_Register_Register_MemoryOperand_u32 := GetProcAddress( Handle, 'Instruction_With4_Register_Register_MemoryOperand_u32' ); + @Instruction_With5_Register_Register_Register_Register_i32 := GetProcAddress( Handle, 'Instruction_With5_Register_Register_Register_Register_i32' ); + @Instruction_With5_Register_Register_Register_Register_u32 := GetProcAddress( Handle, 'Instruction_With5_Register_Register_Register_Register_u32' ); + @Instruction_With5_Register_Register_Register_MemoryOperand_i32 := GetProcAddress( Handle, 'Instruction_With5_Register_Register_Register_MemoryOperand_i32' ); + @Instruction_With5_Register_Register_Register_MemoryOperand_u32 := GetProcAddress( Handle, 'Instruction_With5_Register_Register_Register_MemoryOperand_u32' ); + @Instruction_With5_Register_Register_MemoryOperand_Register_i32 := GetProcAddress( Handle, 'Instruction_With5_Register_Register_MemoryOperand_Register_i32' ); + @Instruction_With5_Register_Register_MemoryOperand_Register_u32 := GetProcAddress( Handle, 'Instruction_With5_Register_Register_MemoryOperand_Register_u32' ); + @Instruction_With_Branch := GetProcAddress( Handle, 'Instruction_With_Branch' ); + @Instruction_With_Far_Branch := GetProcAddress( Handle, 'Instruction_With_Far_Branch' ); + @Instruction_With_xbegin := GetProcAddress( Handle, 'Instruction_With_xbegin' ); + @Instruction_With_outsb := GetProcAddress( Handle, 'Instruction_With_outsb' ); + @Instruction_With_Rep_outsb := GetProcAddress( Handle, 'Instruction_With_Rep_outsb' ); + @Instruction_With_outsw := GetProcAddress( Handle, 'Instruction_With_outsw' ); + @Instruction_With_Rep_outsw := GetProcAddress( Handle, 'Instruction_With_Rep_outsw' ); + @Instruction_With_outsd := GetProcAddress( Handle, 'Instruction_With_outsd' ); + @Instruction_With_Rep_outsd := GetProcAddress( Handle, 'Instruction_With_Rep_outsd' ); + @Instruction_With_lodsb := GetProcAddress( Handle, 'Instruction_With_lodsb' ); + @Instruction_With_Rep_lodsb := GetProcAddress( Handle, 'Instruction_With_Rep_lodsb' ); + @Instruction_With_lodsw := GetProcAddress( Handle, 'Instruction_With_lodsw' ); + @Instruction_With_Rep_lodsw := GetProcAddress( Handle, 'Instruction_With_Rep_lodsw' ); + @Instruction_With_lodsd := GetProcAddress( Handle, 'Instruction_With_lodsd' ); + @Instruction_With_Rep_lodsd := GetProcAddress( Handle, 'Instruction_With_Rep_lodsd' ); + @Instruction_With_lodsq := GetProcAddress( Handle, 'Instruction_With_lodsq' ); + @Instruction_With_Rep_lodsq := GetProcAddress( Handle, 'Instruction_With_Rep_lodsq' ); + @Instruction_With_scasb := GetProcAddress( Handle, 'Instruction_With_scasb' ); + @Instruction_With_Repe_scasb := GetProcAddress( Handle, 'Instruction_With_Repe_scasb' ); + @Instruction_With_Repne_scasb := GetProcAddress( Handle, 'Instruction_With_Repne_scasb' ); + @Instruction_With_scasw := GetProcAddress( Handle, 'Instruction_With_scasw' ); + @Instruction_With_Repe_scasw := GetProcAddress( Handle, 'Instruction_With_Repe_scasw' ); + @Instruction_With_Repne_scasw := GetProcAddress( Handle, 'Instruction_With_Repne_scasw' ); + @Instruction_With_scasd := GetProcAddress( Handle, 'Instruction_With_scasd' ); + @Instruction_With_Repe_scasd := GetProcAddress( Handle, 'Instruction_With_Repe_scasd' ); + @Instruction_With_Repne_scasd := GetProcAddress( Handle, 'Instruction_With_Repne_scasd' ); + @Instruction_With_scasq := GetProcAddress( Handle, 'Instruction_With_scasq' ); + @Instruction_With_Repe_scasq := GetProcAddress( Handle, 'Instruction_With_Repe_scasq' ); + @Instruction_With_Repne_scasq := GetProcAddress( Handle, 'Instruction_With_Repne_scasq' ); + @Instruction_With_insb := GetProcAddress( Handle, 'Instruction_With_insb' ); + @Instruction_With_Rep_insb := GetProcAddress( Handle, 'Instruction_With_Rep_insb' ); + @Instruction_With_insw := GetProcAddress( Handle, 'Instruction_With_insw' ); + @Instruction_With_Rep_insw := GetProcAddress( Handle, 'Instruction_With_Rep_insw' ); + @Instruction_With_insd := GetProcAddress( Handle, 'Instruction_With_insd' ); + @Instruction_With_Rep_insd := GetProcAddress( Handle, 'Instruction_With_Rep_insd' ); + @Instruction_With_stosb := GetProcAddress( Handle, 'Instruction_With_stosb' ); + @Instruction_With_Rep_stosb := GetProcAddress( Handle, 'Instruction_With_Rep_stosb' ); + @Instruction_With_stosw := GetProcAddress( Handle, 'Instruction_With_stosw' ); + @Instruction_With_Rep_stosw := GetProcAddress( Handle, 'Instruction_With_Rep_stosw' ); + @Instruction_With_stosd := GetProcAddress( Handle, 'Instruction_With_stosd' ); + @Instruction_With_Rep_stosd := GetProcAddress( Handle, 'Instruction_With_Rep_stosd' ); + @Instruction_With_Rep_stosq := GetProcAddress( Handle, 'Instruction_With_Rep_stosq' ); + @Instruction_With_cmpsb := GetProcAddress( Handle, 'Instruction_With_cmpsb' ); + @Instruction_With_Repe_cmpsb := GetProcAddress( Handle, 'Instruction_With_Repe_cmpsb' ); + @Instruction_With_Repne_cmpsb := GetProcAddress( Handle, 'Instruction_With_Repne_cmpsb' ); + @Instruction_With_cmpsw := GetProcAddress( Handle, 'Instruction_With_cmpsw' ); + @Instruction_With_Repe_cmpsw := GetProcAddress( Handle, 'Instruction_With_Repe_cmpsw' ); + @Instruction_With_Repne_cmpsw := GetProcAddress( Handle, 'Instruction_With_Repne_cmpsw' ); + @Instruction_With_cmpsd := GetProcAddress( Handle, 'Instruction_With_cmpsd' ); + @Instruction_With_Repe_cmpsd := GetProcAddress( Handle, 'Instruction_With_Repe_cmpsd' ); + @Instruction_With_Repne_cmpsd := GetProcAddress( Handle, 'Instruction_With_Repne_cmpsd' ); + @Instruction_With_cmpsq := GetProcAddress( Handle, 'Instruction_With_cmpsq' ); + @Instruction_With_Repe_cmpsq := GetProcAddress( Handle, 'Instruction_With_Repe_cmpsq' ); + @Instruction_With_Repne_cmpsq := GetProcAddress( Handle, 'Instruction_With_Repne_cmpsq' ); + @Instruction_With_movsb := GetProcAddress( Handle, 'Instruction_With_movsb' ); + @Instruction_With_Rep_movsb := GetProcAddress( Handle, 'Instruction_With_Rep_movsb' ); + @Instruction_With_movsw := GetProcAddress( Handle, 'Instruction_With_movsw' ); + @Instruction_With_Rep_movsw := GetProcAddress( Handle, 'Instruction_With_Rep_movsw' ); + @Instruction_With_movsd := GetProcAddress( Handle, 'Instruction_With_movsd' ); + @Instruction_With_Rep_movsd := GetProcAddress( Handle, 'Instruction_With_Rep_movsd' ); + @Instruction_With_movsq := GetProcAddress( Handle, 'Instruction_With_movsq' ); + @Instruction_With_Rep_movsq := GetProcAddress( Handle, 'Instruction_With_Rep_movsq' ); + @Instruction_With_maskmovq := GetProcAddress( Handle, 'Instruction_With_maskmovq' ); + @Instruction_With_maskmovdqu := GetProcAddress( Handle, 'Instruction_With_maskmovdqu' ); + @Instruction_With_vmaskmovdqu := GetProcAddress( Handle, 'Instruction_With_vmaskmovdqu' ); + @Instruction_With_Declare_Byte_1 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_1' ); + @Instruction_With_Declare_Byte_2 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_2' ); + @Instruction_With_Declare_Byte_3 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_3' ); + @Instruction_With_Declare_Byte_4 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_4' ); + @Instruction_With_Declare_Byte_5 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_5' ); + @Instruction_With_Declare_Byte_6 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_6' ); + @Instruction_With_Declare_Byte_7 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_7' ); + @Instruction_With_Declare_Byte_8 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_8' ); + @Instruction_With_Declare_Byte_9 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_9' ); + @Instruction_With_Declare_Byte_10 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_10' ); + @Instruction_With_Declare_Byte_11 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_11' ); + @Instruction_With_Declare_Byte_12 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_12' ); + @Instruction_With_Declare_Byte_13 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_13' ); + @Instruction_With_Declare_Byte_14 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_14' ); + @Instruction_With_Declare_Byte_15 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_15' ); + @Instruction_With_Declare_Byte_16 := GetProcAddress( Handle, 'Instruction_With_Declare_Byte_16' ); + @Instruction_With_Declare_Word_1 := GetProcAddress( Handle, 'Instruction_With_Declare_Word_1' ); + @Instruction_With_Declare_Word_2 := GetProcAddress( Handle, 'Instruction_With_Declare_Word_2' ); + @Instruction_With_Declare_Word_3 := GetProcAddress( Handle, 'Instruction_With_Declare_Word_3' ); + @Instruction_With_Declare_Word_4 := GetProcAddress( Handle, 'Instruction_With_Declare_Word_4' ); + @Instruction_With_Declare_Word_5 := GetProcAddress( Handle, 'Instruction_With_Declare_Word_5' ); + @Instruction_With_Declare_Word_6 := GetProcAddress( Handle, 'Instruction_With_Declare_Word_6' ); + @Instruction_With_Declare_Word_7 := GetProcAddress( Handle, 'Instruction_With_Declare_Word_7' ); + @Instruction_With_Declare_Word_8 := GetProcAddress( Handle, 'Instruction_With_Declare_Word_8' ); + @Instruction_With_Declare_DWord_1 := GetProcAddress( Handle, 'Instruction_With_Declare_DWord_1' ); + @Instruction_With_Declare_DWord_2 := GetProcAddress( Handle, 'Instruction_With_Declare_DWord_2' ); + @Instruction_With_Declare_DWord_3 := GetProcAddress( Handle, 'Instruction_With_Declare_DWord_3' ); + @Instruction_With_Declare_DWord_4 := GetProcAddress( Handle, 'Instruction_With_Declare_DWord_4' ); + @Instruction_With_Declare_QWord_1 := GetProcAddress( Handle, 'Instruction_With_Declare_QWord_1' ); + @Instruction_With_Declare_QWord_2 := GetProcAddress( Handle, 'Instruction_With_Declare_QWord_2' ); + + @OpCodeInfo_OpCodeString := GetProcAddress( Handle, 'OpCodeInfo_OpCodeString' ); + @OpCodeInfo_InstructionString := GetProcAddress( Handle, 'OpCodeInfo_InstructionString' ); + @OpCodeInfo_Mode16 := GetProcAddress( Handle, 'OpCodeInfo_Mode16' ); + @OpCodeInfo_Mode32 := GetProcAddress( Handle, 'OpCodeInfo_Mode32' ); + @OpCodeInfo_Mode64 := GetProcAddress( Handle, 'OpCodeInfo_Mode64' ); + @OpCodeInfo_Fwait := GetProcAddress( Handle, 'OpCodeInfo_Fwait' ); + @OpCodeInfo_W := GetProcAddress( Handle, 'OpCodeInfo_W' ); + @OpCodeInfo_IsLig := GetProcAddress( Handle, 'OpCodeInfo_IsLig' ); + @OpCodeInfo_IsWig := GetProcAddress( Handle, 'OpCodeInfo_IsWig' ); + @OpCodeInfo_IsWig32 := GetProcAddress( Handle, 'OpCodeInfo_IsWig32' ); + @OpCodeInfo_MvexEhBit := GetProcAddress( Handle, 'OpCodeInfo_MvexEhBit' ); + @OpCodeInfo_MvexCanUseEvictionHint := GetProcAddress( Handle, 'OpCodeInfo_MvexCanUseEvictionHint' ); + @OpCodeInfo_MvexCanUseImmRoundingControl := GetProcAddress( Handle, 'OpCodeInfo_MvexCanUseImmRoundingControl' ); + @OpCodeInfo_MvexIgnoresOpMaskRegister := GetProcAddress( Handle, 'OpCodeInfo_MvexIgnoresOpMaskRegister' ); + @OpCodeInfo_MvexNoSaeRc := GetProcAddress( Handle, 'OpCodeInfo_MvexNoSaeRc' ); + @OpCodeInfo_MvexTupleTypeLutKind := GetProcAddress( Handle, 'OpCodeInfo_MvexTupleTypeLutKind' ); + @OpCodeInfo_MvexConversionFunc := GetProcAddress( Handle, 'OpCodeInfo_MvexConversionFunc' ); + @OpCodeInfo_MvexValidConversionFuncsMask := GetProcAddress( Handle, 'OpCodeInfo_MvexValidConversionFuncsMask' ); + @OpCodeInfo_MvexValidSwizzleFuncsMask := GetProcAddress( Handle, 'OpCodeInfo_MvexValidSwizzleFuncsMask' ); + @OpCodeInfo_MemorySize := GetProcAddress( Handle, 'OpCodeInfo_MemorySize' ); + @OpCodeInfo_BroadcastMemorySize := GetProcAddress( Handle, 'OpCodeInfo_BroadcastMemorySize' ); + @OpCodeInfo_CanBroadcast := GetProcAddress( Handle, 'OpCodeInfo_CanBroadcast' ); + @OpCodeInfo_CanUseRoundingControl := GetProcAddress( Handle, 'OpCodeInfo_CanUseRoundingControl' ); + @OpCodeInfo_CanSuppressAllExceptions := GetProcAddress( Handle, 'OpCodeInfo_CanSuppressAllExceptions' ); + @OpCodeInfo_CanUseOpMaskRegister := GetProcAddress( Handle, 'OpCodeInfo_CanUseOpMaskRegister' ); + @OpCodeInfo_RequireOpMaskRegister := GetProcAddress( Handle, 'OpCodeInfo_RequireOpMaskRegister' ); + @OpCodeInfo_CanUseZeroingMasking := GetProcAddress( Handle, 'OpCodeInfo_CanUseZeroingMasking' ); + @OpCodeInfo_CanUseLockPrefix := GetProcAddress( Handle, 'OpCodeInfo_CanUseLockPrefix' ); + @OpCodeInfo_CanUseXacquirePrefix := GetProcAddress( Handle, 'OpCodeInfo_CanUseXacquirePrefix' ); + @OpCodeInfo_CanUseXreleasePrefix := GetProcAddress( Handle, 'OpCodeInfo_CanUseXreleasePrefix' ); + @OpCodeInfo_CanUseRepPrefix := GetProcAddress( Handle, 'OpCodeInfo_CanUseRepPrefix' ); + @OpCodeInfo_CanUseRepnePrefix := GetProcAddress( Handle, 'OpCodeInfo_CanUseRepnePrefix' ); + @OpCodeInfo_CanUseBndPrefix := GetProcAddress( Handle, 'OpCodeInfo_CanUseBndPrefix' ); + @OpCodeInfo_CanUseHintTakenPrefix := GetProcAddress( Handle, 'OpCodeInfo_CanUseHintTakenPrefix' ); + @OpCodeInfo_CanUseNotrackPrefix := GetProcAddress( Handle, 'OpCodeInfo_CanUseNotrackPrefix' ); + @OpCodeInfo_IgnoresRoundingControl := GetProcAddress( Handle, 'OpCodeInfo_IgnoresRoundingControl' ); + @OpCodeInfo_AmdLockRegBit := GetProcAddress( Handle, 'OpCodeInfo_AmdLockRegBit' ); + @OpCodeInfo_DefaultOpSize64 := GetProcAddress( Handle, 'OpCodeInfo_DefaultOpSize64' ); + @OpCodeInfo_ForceOpSize64 := GetProcAddress( Handle, 'OpCodeInfo_ForceOpSize64' ); + @OpCodeInfo_IntelForceOpSize64 := GetProcAddress( Handle, 'OpCodeInfo_IntelForceOpSize64' ); + @OpCodeInfo_MustBeCpl0 := GetProcAddress( Handle, 'OpCodeInfo_MustBeCpl0' ); + @OpCodeInfo_Cpl0 := GetProcAddress( Handle, 'OpCodeInfo_Cpl0' ); + @OpCodeInfo_Cpl1 := GetProcAddress( Handle, 'OpCodeInfo_Cpl1' ); + @OpCodeInfo_Cpl2 := GetProcAddress( Handle, 'OpCodeInfo_Cpl2' ); + @OpCodeInfo_Cpl3 := GetProcAddress( Handle, 'OpCodeInfo_Cpl3' ); + @OpCodeInfo_IsInputOutput := GetProcAddress( Handle, 'OpCodeInfo_IsInputOutput' ); + @OpCodeInfo_IsNop := GetProcAddress( Handle, 'OpCodeInfo_IsNop' ); + @OpCodeInfo_IsReservedNop := GetProcAddress( Handle, 'OpCodeInfo_IsReservedNop' ); + @OpCodeInfo_IsSerializingIntel := GetProcAddress( Handle, 'OpCodeInfo_IsSerializingIntel' ); + @OpCodeInfo_IsSerializingAmd := GetProcAddress( Handle, 'OpCodeInfo_IsSerializingAmd' ); + @OpCodeInfo_MayRequireCpl0 := GetProcAddress( Handle, 'OpCodeInfo_MayRequireCpl0' ); + @OpCodeInfo_IsCetTracked := GetProcAddress( Handle, 'OpCodeInfo_IsCetTracked' ); + @OpCodeInfo_IsNonTemporal := GetProcAddress( Handle, 'OpCodeInfo_IsNonTemporal' ); + @OpCodeInfo_IsFpuNoWait := GetProcAddress( Handle, 'OpCodeInfo_IsFpuNoWait' ); + @OpCodeInfo_IgnoresModBits := GetProcAddress( Handle, 'OpCodeInfo_IgnoresModBits' ); + @OpCodeInfo_No66 := GetProcAddress( Handle, 'OpCodeInfo_No66' ); + @OpCodeInfo_Nfx := GetProcAddress( Handle, 'OpCodeInfo_Nfx' ); + @OpCodeInfo_RequiresUniqueRegNums := GetProcAddress( Handle, 'OpCodeInfo_RequiresUniqueRegNums' ); + @OpCodeInfo_RequiresUniqueDestRegNum := GetProcAddress( Handle, 'OpCodeInfo_RequiresUniqueDestRegNum' ); + @OpCodeInfo_IsPrivileged := GetProcAddress( Handle, 'OpCodeInfo_IsPrivileged' ); + @OpCodeInfo_IsSaveRestore := GetProcAddress( Handle, 'OpCodeInfo_IsSaveRestore' ); + @OpCodeInfo_IsStackInstruction := GetProcAddress( Handle, 'OpCodeInfo_IsStackInstruction' ); + @OpCodeInfo_IgnoresSegment := GetProcAddress( Handle, 'OpCodeInfo_IgnoresSegment' ); + @OpCodeInfo_IsOpMaskReadWrite := GetProcAddress( Handle, 'OpCodeInfo_IsOpMaskReadWrite' ); + @OpCodeInfo_RealMode := GetProcAddress( Handle, 'OpCodeInfo_RealMode' ); + @OpCodeInfo_ProtectedMode := GetProcAddress( Handle, 'OpCodeInfo_ProtectedMode' ); + @OpCodeInfo_Virtual8086Mode := GetProcAddress( Handle, 'OpCodeInfo_Virtual8086Mode' ); + @OpCodeInfo_CompatibilityMode := GetProcAddress( Handle, 'OpCodeInfo_CompatibilityMode' ); + @OpCodeInfo_LongMode := GetProcAddress( Handle, 'OpCodeInfo_LongMode' ); + @OpCodeInfo_UseOutsideSmm := GetProcAddress( Handle, 'OpCodeInfo_UseOutsideSmm' ); + @OpCodeInfo_UseInSmm := GetProcAddress( Handle, 'OpCodeInfo_UseInSmm' ); + @OpCodeInfo_UseOutsideEnclaveSgx := GetProcAddress( Handle, 'OpCodeInfo_UseOutsideEnclaveSgx' ); + @OpCodeInfo_UseInEnclaveSgx1 := GetProcAddress( Handle, 'OpCodeInfo_UseInEnclaveSgx1' ); + @OpCodeInfo_UseInEnclaveSgx2 := GetProcAddress( Handle, 'OpCodeInfo_UseInEnclaveSgx2' ); + @OpCodeInfo_UseOutsideVmxOp := GetProcAddress( Handle, 'OpCodeInfo_UseOutsideVmxOp' ); + @OpCodeInfo_UseInVmxRootOp := GetProcAddress( Handle, 'OpCodeInfo_UseInVmxRootOp' ); + @OpCodeInfo_UseInVmxNonRootOp := GetProcAddress( Handle, 'OpCodeInfo_UseInVmxNonRootOp' ); + @OpCodeInfo_UseOutsideSeam := GetProcAddress( Handle, 'OpCodeInfo_UseOutsideSeam' ); + @OpCodeInfo_UseInSeam := GetProcAddress( Handle, 'OpCodeInfo_UseInSeam' ); + @OpCodeInfo_TdxNonRootGenUd := GetProcAddress( Handle, 'OpCodeInfo_TdxNonRootGenUd' ); + @OpCodeInfo_TdxNonRootGenVe := GetProcAddress( Handle, 'OpCodeInfo_TdxNonRootGenVe' ); + @OpCodeInfo_TdxNonRootMayGenEx := GetProcAddress( Handle, 'OpCodeInfo_TdxNonRootMayGenEx' ); + @OpCodeInfo_IntelVMExit := GetProcAddress( Handle, 'OpCodeInfo_IntelVMExit' ); + @OpCodeInfo_IntelMayVMExit := GetProcAddress( Handle, 'OpCodeInfo_IntelMayVMExit' ); + @OpCodeInfo_IntelSmmVMExit := GetProcAddress( Handle, 'OpCodeInfo_IntelSmmVMExit' ); + @OpCodeInfo_AmdVMExit := GetProcAddress( Handle, 'OpCodeInfo_AmdVMExit' ); + @OpCodeInfo_AmdMayVMExit := GetProcAddress( Handle, 'OpCodeInfo_AmdMayVMExit' ); + @OpCodeInfo_TsxAbort := GetProcAddress( Handle, 'OpCodeInfo_TsxAbort' ); + @OpCodeInfo_TsxImplAbort := GetProcAddress( Handle, 'OpCodeInfo_TsxImplAbort' ); + @OpCodeInfo_TsxMayAbort := GetProcAddress( Handle, 'OpCodeInfo_TsxMayAbort' ); + @OpCodeInfo_IntelDecoder16 := GetProcAddress( Handle, 'OpCodeInfo_IntelDecoder16' ); + @OpCodeInfo_IntelDecoder32 := GetProcAddress( Handle, 'OpCodeInfo_IntelDecoder32' ); + @OpCodeInfo_IntelDecoder64 := GetProcAddress( Handle, 'OpCodeInfo_IntelDecoder64' ); + @OpCodeInfo_AmdDecoder16 := GetProcAddress( Handle, 'OpCodeInfo_AmdDecoder16' ); + @OpCodeInfo_AmdDecoder32 := GetProcAddress( Handle, 'OpCodeInfo_AmdDecoder32' ); + @OpCodeInfo_AmdDecoder64 := GetProcAddress( Handle, 'OpCodeInfo_AmdDecoder64' ); + @OpCodeInfo_DecoderOption := GetProcAddress( Handle, 'OpCodeInfo_DecoderOption' ); + @OpCodeInfo_OpCodeLen := GetProcAddress( Handle, 'OpCodeInfo_OpCodeLen' ); + @OpCodeInfo_OPCount := GetProcAddress( Handle, 'OpCodeInfo_OPCount' ); + + @Code_AsString := GetProcAddress( Handle, 'Code_AsString' ); + @Code_Mnemonic := GetProcAddress( Handle, 'Code_Mnemonic' ); + @Code_OPCode := GetProcAddress( Handle, 'Code_OPCode' ); + @Code_Encoding := GetProcAddress( Handle, 'Code_Encoding' ); + @Code_CPUidFeature := GetProcAddress( Handle, 'Code_CPUidFeature' ); + @Code_FlowControl := GetProcAddress( Handle, 'Code_FlowControl' ); + @Code_IsPrivileged := GetProcAddress( Handle, 'Code_IsPrivileged' ); + @Code_IsStackInstruction := GetProcAddress( Handle, 'Code_IsStackInstruction' ); + @Code_IsSaveRestoreInstruction := GetProcAddress( Handle, 'Code_IsSaveRestoreInstruction' ); + @Code_IsJccShort := GetProcAddress( Handle, 'Code_IsJccShort' ); + @Code_IsJmpShort := GetProcAddress( Handle, 'Code_IsJmpShort' ); + @Code_IsJmpShortOrNear := GetProcAddress( Handle, 'Code_IsJmpShortOrNear' ); + @Code_IsJmpNear := GetProcAddress( Handle, 'Code_IsJmpNear' ); + @Code_IsJmpFar := GetProcAddress( Handle, 'Code_IsJmpFar' ); + @Code_IsCallNear := GetProcAddress( Handle, 'Code_IsCallNear' ); + @Code_IsCallFar := GetProcAddress( Handle, 'Code_IsCallFar' ); + @Code_IsJmpNearIndirect := GetProcAddress( Handle, 'Code_IsJmpNearIndirect' ); + @Code_IsJmpFarIndirect := GetProcAddress( Handle, 'Code_IsJmpFarIndirect' ); + @Code_IsCallNearIndirect := GetProcAddress( Handle, 'Code_IsCallNearIndirect' ); + @Code_IsCallFarIndirect := GetProcAddress( Handle, 'Code_IsCallFarIndirect' ); + @Code_ConditionCode := GetProcAddress( Handle, 'Code_ConditionCode' ); + @Code_IsJcxShort := GetProcAddress( Handle, 'Code_IsJcxShort' ); + @Code_IsLoopCC := GetProcAddress( Handle, 'Code_IsLoopCC' ); + @Code_IsLoop := GetProcAddress( Handle, 'Code_IsLoop' ); + @Code_IsJccShortOrNear := GetProcAddress( Handle, 'Code_IsJccShortOrNear' ); + @Code_NegateConditionCode := GetProcAddress( Handle, 'Code_NegateConditionCode' ); + @Code_AsShortBranch := GetProcAddress( Handle, 'Code_AsShortBranch' ); + @Code_AsNearBranch := GetProcAddress( Handle, 'Code_AsNearBranch' ); + + @Mnemonic_AsString := GetProcAddress( Handle, 'Mnemonic_AsString' ); + @OpKind_AsString := GetProcAddress( Handle, 'OpKind_AsString' ); + @EncodingKind_AsString := GetProcAddress( Handle, 'EncodingKind_AsString' ); + @CPUidFeature_AsString := GetProcAddress( Handle, 'CPUidFeature_AsString' ); + @ConditionCode_AsString := GetProcAddress( Handle, 'ConditionCode_AsString' ); + @FlowControl_AsString := GetProcAddress( Handle, 'FlowControl_AsString' ); + @TupleType_AsString := GetProcAddress( Handle, 'TupleType_AsString' ); + @MvexEHBit_AsString := GetProcAddress( Handle, 'MvexEHBit_AsString' ); + @MvexTupleTypeLutKind_AsString := GetProcAddress( Handle, 'MvexTupleTypeLutKind_AsString' ); + @MvexConvFn_AsString := GetProcAddress( Handle, 'MvexConvFn_AsString' ); + @MvexRegMemConv_AsString := GetProcAddress( Handle, 'MvexRegMemConv_AsString' ); + @RoundingControl_AsString := GetProcAddress( Handle, 'RoundingControl_AsString' ); + @NumberBase_AsString := GetProcAddress( Handle, 'NumberBase_AsString' ); + @RepPrefixKind_AsString := GetProcAddress( Handle, 'RepPrefixKind_AsString' ); + @MemorySize_AsString := GetProcAddress( Handle, 'MemorySize_AsString' ); + @MemorySizeOptions_AsString := GetProcAddress( Handle, 'MemorySizeOptions_AsString' ); + @MemorySize_Info := GetProcAddress( Handle, 'MemorySize_Info' ); + @OpCodeTableKind_AsString := GetProcAddress( Handle, 'OpCodeTableKind_AsString' ); + @MandatoryPrefix_AsString := GetProcAddress( Handle, 'MandatoryPrefix_AsString' ); + @OpCodeOperandKind_AsString := GetProcAddress( Handle, 'OpCodeOperandKind_AsString' ); + @OpAccess_AsString := GetProcAddress( Handle, 'OpAccess_AsString' ); + @CodeSize_AsString := GetProcAddress( Handle, 'CodeSize_AsString' ); + @FormatterTextKind_AsString := GetProcAddress( Handle, 'FormatterTextKind_AsString' ); + + @Register_Base := GetProcAddress( Handle, 'Register_Base' ); + @Register_Number := GetProcAddress( Handle, 'Register_Number' ); + @Register_FullRegister := GetProcAddress( Handle, 'Register_FullRegister' ); + @Register_FullRegister32 := GetProcAddress( Handle, 'Register_FullRegister32' ); + @Register_Size := GetProcAddress( Handle, 'Register_Size' ); + @Register_AsString := GetProcAddress( Handle, 'Register_AsString' ); + {$WARNINGS ON} +end; + +procedure Unload; +begin + if ( Handle = 0 ) OR ( Handle = INVALID_HANDLE_VALUE ) then + Exit; + FreeLibrary( Handle ); + Handle := 0; +end; + +initialization + Load; + +finalization + Unload; + +end. diff --git a/src/Delphi/uIced.Imports_.pas b/src/Delphi/uIced.Imports_.pas new file mode 100644 index 000000000..40199629f --- /dev/null +++ b/src/Delphi/uIced.Imports_.pas @@ -0,0 +1,2696 @@ +unit uIced.Imports; + +{ + Iced (Dis)Assembler + + TetzkatLipHoka 2022-2024 +} + +interface + +{$DEFINE AUTO_INIT} // AutoInit/DeInit DLL(s) during initialization/finalization +{.$DEFINE VERCHECK} // Perform Version-Check and inform on missmatch +{$DEFINE OnlyWarnOnLowerVersions} +{.$DEFINE SILENT} // Don't show any warnings (missing DLL, Version-Missmatch) but Linking Errors +{.$DEFINE CLOSE_APP_ON_FAIL} +{$DEFINE WARN_DLLs_IN_FOLDER} // Warning if DLLs are present in Application-Folder +{.$DEFINE IGNORE_LINKING_ERRORS} // Ignore linking errors (DEBUG) +{.$DEFINE LIST_MISSING_MODULES} // uses MemoryModule + +// ResourceFile +{$DEFINE ResourceMode} // Load DLL from Resourcefile +{$IFDEF ResourceMode} + {.$R Iced.res} // DLL-ResourceFile (each DLLName without extension as RCDATA) + {$IFDEF Win64} + {$R Iced64.res} // DLL-ResourceFile (each DLLName without extension as RCDATA) + {$ELSE} + {$R Iced86.res} // DLL-ResourceFile (each DLLName without extension as RCDATA) + {$ENDIF} +{$ENDIF} + +{$DEFINE ResourceCompression} // DLLs in ResourceFile are 7zip compressed (JEDI-Unit) +{$DEFINE PREFER_DLL_IN_FOLDER} // If DLL is present in ApplicationFolder use it +{$DEFINE MemoryModule} // use MemoryModule (Load without HDD-caching) + +{$DEFINE GetModuleHandle} // Try GetModuleHandle before LoadLibrary +{.$DEFINE ONLY_LOADLIBRARY_ERRORS} // Ignore 'GetLastError <> ERROR_SUCCESS' unless LoadLibrary actually failed + +{$IF CompilerVersion >= 22} + {$LEGACYIFEND ON} +{$IFEND} + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +{$DEFINE section_INTERFACE_USES} +{$I DynamicDLL.inc} +{$UNDEF section_INTERFACE_USES} +,uIced.Types +; + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +{$DEFINE section_INTERFACE} +{$I DynamicDLL.inc} +{$UNDEF section_INTERFACE} + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Constantes~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +const + DLLCount_ = 1; +var + DLLPath_ : Array [0..DLLCount_-1] of String = ( '' ); + +const + DLLLoadDLL_ : Array [0..DLLCount_-1] of boolean = ( True ); + {$IFDEF Win64} + DLLName_ : Array [0..DLLCount_-1] of String = ( 'Iced64.dll' ); + {$ELSE} + DLLName_ : Array [0..DLLCount_-1] of String = ( 'Iced.dll' ); + {$ENDIF} + DLLVersion_ : Array [0..DLLCount_-1] of String = ( '1.0.4.0' ); + {$IFDEF ResourceMode} + DLLPass_ : Array [0..DLLCount_-1] of String = ( '' ); + {$ENDIF} + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~DLL Declarations~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +{$WARNINGS OFF} + +{$DEFINE section_Declaration} // Include +{.$I Iced.inc} +{$UNDEF section_Declaration} + +var + // Free Memory + IcedFreeMemory : function( Pointer : Pointer ) : Boolean; cdecl = nil; + + // Creates a decoder + // + // # Errors + // Fails if `bitness` is not one of 16, 32, 64. + // + // # Arguments + // * `bitness`: 16, 32 or 64 + // * `data`: Data to decode + // * `data`: ByteSize of `Data` + // * `options`: Decoder options, `0` or eg. `DecoderOptions::NO_INVALID_CHECK | DecoderOptions::AMD` + Decoder_Create : function( Bitness : Cardinal; Data : PByte; DataSize : NativeUInt; IP : UInt64; Options : Cardinal = doNONE ) : Pointer; cdecl = nil; + + // Returns `true` if there's at least one more byte to decode. It doesn't verify that the + // next instruction is valid, it only checks if there's at least one more byte to read. + // See also [`position()`] and [`max_position()`] + // + // It's not required to call this method. If this method returns `false`, then [`decode_out()`] + // and [`decode()`] will return an instruction whose [`code()`] == [`Code::INVALID`]. + Decoder_CanDecode : function( Decoder : Pointer ) : Boolean; cdecl = nil; + + // Gets the current `IP`/`EIP`/`RIP` value, see also [`position()`] + Decoder_GetIP : function( Decoder : Pointer ) : UInt64; cdecl = nil; + + // Sets the current `IP`/`EIP`/`RIP` value, see also [`try_set_position()`] + // This method only updates the IP value, it does not change the data position, use [`try_set_position()`] to change the position. + Decoder_SetIP : function ( Decoder : Pointer; Value : UInt64 ) : boolean; cdecl = nil; + + // Gets the bitness (16, 32 or 64) + Decoder_GetBitness : function( Decoder : Pointer ) : Cardinal; cdecl = nil; + + // Gets the max value that can be passed to [`try_set_position()`]. This is the size of the data that gets + // decoded to instructions and it's the length of the slice that was passed to the constructor. + Decoder_GetMaxPosition : function( Decoder : Pointer ) : NativeUInt; cdecl = nil; + + // Gets the current data position. This value is always <= [`max_position()`]. + // When [`position()`] == [`max_position()`], it's not possible to decode more + // instructions and [`can_decode()`] returns `false`. + Decoder_GetPosition : function( Decoder : Pointer ) : NativeUInt; cdecl = nil; + + // Sets the current data position, which is the index into the data passed to the constructor. + // This value is always <= [`max_position()`] + Decoder_SetPosition : function ( Decoder : Pointer; Value : NativeUInt ) : boolean; cdecl = nil; + + // Gets the last decoder error. Unless you need to know the reason it failed, + // it's better to check [`instruction.is_invalid()`]. + Decoder_GetLastError : function( Decoder : Pointer ) : TDecoderError; cdecl = nil; + DecoderError_AsString : procedure( const DecoderError : TDecoderErrorType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + + // Decodes and returns the next instruction, see also [`decode_out(&mut Instruction)`] + // which avoids copying the decoded instruction to the caller's return variable. + // See also [`last_error()`]. + Decoder_Decode : procedure( Decoder : Pointer; const Instruction : TInstruction ); cdecl = nil; + Decoder_DecodeToEnd : procedure( Decoder : Pointer; Callback : TDecoderCallback; UserData : Pointer = nil ); cdecl = nil; + + // Gets the offsets of the constants (memory displacement and immediate) in the decoded instruction. + // The caller can check if there are any relocations at those addresses. + // + // # Arguments + // * `instruction`: The latest instruction that was decoded by this decoder + Decoder_GetConstantOffsets : function( Decoder : Pointer; const Instruction : TInstruction; var ConstantOffsets : TConstantOffsets ) : Boolean; cdecl = nil; + + // Creates a formatter Output Callback + FormatterOutput_Create : function( Callback : TFormatterOutputCallback; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Creates a masm formatter + // + // # Arguments + // - `symbol_resolver`: Symbol resolver or `None` + // - `options_provider`: Operand options provider or `None` + MasmFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; OptionsProvider : TFormatterOptionsProviderCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + MasmFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + MasmFormatter_DecodeFormatCallback : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + MasmFormatter_Format : procedure( Formatter : Pointer; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + MasmFormatter_FormatCallback : procedure( Formatter : Pointer; const Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + MasmFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + + // Creates a Nasm formatter + // + // # Arguments + // - `symbol_resolver`: Symbol resolver or `None` + // - `options_provider`: Operand options provider or `None` + NasmFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; OptionsProvider : TFormatterOptionsProviderCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + NasmFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + NasmFormatter_DecodeFormatCallback : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + NasmFormatter_Format : procedure( Formatter : Pointer; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + NasmFormatter_FormatCallback : procedure( Formatter : Pointer; const Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + NasmFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + + // Creates a Gas formatter + // + // # Arguments + // - `symbol_resolver`: Symbol resolver or `None` + // - `options_provider`: Operand options provider or `None` + GasFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; OptionsProvider : TFormatterOptionsProviderCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + GasFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + GasFormatter_DecodeFormatCallback : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + GasFormatter_Format : procedure( Formatter : Pointer; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + GasFormatter_FormatCallback : procedure( Formatter : Pointer; const Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + GasFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + + // Creates a Intel formatter + // + // # Arguments + // - `symbol_resolver`: Symbol resolver or `None` + // - `options_provider`: Operand options provider or `None` + IntelFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; OptionsProvider : TFormatterOptionsProviderCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + IntelFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + IntelFormatter_DecodeFormatCallback : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + IntelFormatter_Format : procedure( Formatter : Pointer; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + IntelFormatter_FormatCallback : procedure( Formatter : Pointer; const Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + IntelFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + + // Creates a Fast formatter (Specialized) + // NOTE: Fast Formatter only supports Specialized-Options + FastFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + FastFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + FastFormatter_Format : procedure( Formatter : Pointer; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + FastFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + + // Creates a Specialized formatter + SpecializedFormatter_Create : function( SymbolResolver : TSymbolResolverCallback = nil; UserData : Pointer = nil ) : Pointer; cdecl = nil; + + // Format Instruction + SpecializedFormatter_DecodeFormat : procedure( Decoder : Pointer; Formatter : Pointer; Options : Byte; var Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + SpecializedFormatter_Format : procedure( Formatter : Pointer; Options : Byte; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + SpecializedFormatter_DecodeFormatToEnd : procedure( Decoder : Pointer; Formatter : Pointer; Options : Byte; Callback : TDecoderFormatCallback; UserData : Pointer = nil ); cdecl = nil; + +// Options + // NOTE: Specialized Formatter only supports the following Options + + // Always show the size of memory operands + // + // Default | Value | Example | Example + // --------|-------|---------|-------- + // _ | `true` | `mov eax,dword ptr [ebx]` | `add byte ptr [eax],0x12` + // X | `false` | `mov eax,[ebx]` | `add byte ptr [eax],0x12` + SpecializedFormatter_GetAlwaysShowMemorySize : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // Always show the size of memory operands + // + // Default | Value | Example | Example + // --------|-------|---------|-------- + // _ | `true` | `mov eax,dword ptr [ebx]` | `add byte ptr [eax],0x12` + // X | `false` | `mov eax,[ebx]` | `add byte ptr [eax],0x12` + // + // # Arguments + // * `value`: New value + SpecializedFormatter_SetAlwaysShowMemorySize : function( Formatter: Pointer; Value : Boolean ) : boolean; cdecl = nil; + + // Use a hex prefix ( `0x` ) or a hex suffix ( `h` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `0x5A` + // X | `false` | `5Ah` + SpecializedFormatter_GetUseHexPrefix : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // Use a hex prefix ( `0x` ) or a hex suffix ( `h` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `0x5A` + // X | `false` | `5Ah` + // + // # Arguments + // * `value`: New value + SpecializedFormatter_SetUseHexPrefix : function( Formatter: Pointer; Value : Boolean ) : boolean; cdecl = nil; + + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Formatter Options + // Format Instruction + Formatter_Format : procedure( Formatter : Pointer; FormatterType : TIcedFormatterType; const Instruction: TInstruction; var Output: PAnsiChar; var Size : NativeUInt ); cdecl = nil; + Formatter_FormatCallback : procedure( Formatter : Pointer; FormatterType : TIcedFormatterType; const Instruction: TInstruction; FormatterOutput: Pointer ); cdecl = nil; + + // Prefixes are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `REP stosd` + // X | `false` | `rep stosd` + Formatter_GetUpperCasePrefixes : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Prefixes are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `REP stosd` + // X | `false` | `rep stosd` + // + // # Arguments + // + // * `value`: New value + Formatter_SetUpperCasePrefixes : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Mnemonics are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `MOV rcx,rax` + // X | `false` | `mov rcx,rax` + Formatter_GetUpperCaseMnemonics : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Mnemonics are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `MOV rcx,rax` + // X | `false` | `mov rcx,rax` + // + // # Arguments + // * `value`: New value + Formatter_SetUpperCaseMnemonics : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Registers are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov RCX,[RAX+RDX*8]` + // X | `false` | `mov rcx,[rax+rdx*8]` + Formatter_GetUpperCaseRegisters : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Registers are uppercased + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov RCX,[RAX+RDX*8]` + // X | `false` | `mov rcx,[rax+rdx*8]` + // + // # Arguments + // * `value`: New value + Formatter_SetUpperCaseRegisters : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Keywords are uppercased ( eg. `BYTE PTR`, `SHORT` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov BYTE PTR [rcx],12h` + // X | `false` | `mov byte ptr [rcx],12h` + Formatter_GetUpperCaseKeyWords : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Keywords are uppercased ( eg. `BYTE PTR`, `SHORT` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov BYTE PTR [rcx],12h` + // X | `false` | `mov byte ptr [rcx],12h` + // + // # Arguments + // * `value`: New value + Formatter_SetUpperCaseKeyWords : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Uppercase decorators, eg. `{z ); `, `{sae ); `, `{rd-sae ); ` ( but not opmask registers: `{k1 ); ` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `vunpcklps xmm2{k5 ); {Z ); ,xmm6,dword bcst [rax+4]` + // X | `false` | `vunpcklps xmm2{k5 ); {z ); ,xmm6,dword bcst [rax+4]` + Formatter_GetUpperCaseDecorators : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Uppercase decorators, eg. `{z ); `, `{sae ); `, `{rd-sae ); ` ( but not opmask registers: `{k1 ); ` ) + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `vunpcklps xmm2{k5 ); {Z ); ,xmm6,dword bcst [rax+4]` + // X | `false` | `vunpcklps xmm2{k5 ); {z ); ,xmm6,dword bcst [rax+4]` + // + // # Arguments + // * `value`: New value + Formatter_SetUpperCaseDecorators : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Everything is uppercased, except numbers and their prefixes/suffixes + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `MOV EAX,GS:[RCX*4+0ffh]` + // X | `false` | `mov eax,gs:[rcx*4+0ffh]` + Formatter_GetUpperCaseEverything : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Everything is uppercased, except numbers and their prefixes/suffixes + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `MOV EAX,GS:[RCX*4+0ffh]` + // X | `false` | `mov eax,gs:[rcx*4+0ffh]` + // + // # Arguments + // + // * `value`: New value + Formatter_SetUpperCaseEverything : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Character index ( 0-based ) where the first operand is formatted. Can be set to 0 to format it immediately after the mnemonic. + // At least one space or tab is always added between the mnemonic and the first operand. + // + // Default | Value | Example + // --------|-------|-------- + // X | `0` | `movrcx,rbp` + // _ | `8` | `movrcx,rbp` + Formatter_GetFirstOperandCharIndex : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Character index ( 0-based ) where the first operand is formatted. Can be set to 0 to format it immediately after the mnemonic. + // At least one space or tab is always added between the mnemonic and the first operand. + // + // Default | Value | Example + // --------|-------|-------- + // X | `0` | `movrcx,rbp` + // _ | `8` | `movrcx,rbp` + // + // # Arguments + // * `value`: New value + Formatter_SetFirstOperandCharIndex : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Size of a tab character or 0 to use spaces + // + // - Default: `0` + Formatter_GetTabSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Size of a tab character or 0 to use spaces + // + // - Default: `0` + // + // # Arguments + // + // * `value`: New value + Formatter_SetTabSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Add a space after the operand separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov rax, rcx` + // X | `false` | `mov rax,rcx` + Formatter_GetSpaceAfterOperandSeparator : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add a space after the operand separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov rax, rcx` + // X | `false` | `mov rax,rcx` + // + // # Arguments + // * `value`: New value + Formatter_SetSpaceAfterOperandSeparator : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Add a space between the memory expression and the brackets + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[ rcx+rdx ]` + // X | `false` | `mov eax,[rcx+rdx]` + Formatter_GetSpaceAfterMemoryBracket : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add a space between the memory expression and the brackets + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[ rcx+rdx ]` + // X | `false` | `mov eax,[rcx+rdx]` + // + // # Arguments + // * `value`: New value + Formatter_SetSpaceAfterMemoryBracket : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Add spaces between memory operand `+` and `-` operators + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx + rdx*8 - 80h]` + // X | `false` | `mov eax,[rcx+rdx*8-80h]` + Formatter_GetSpaceBetweenMemoryAddOperators : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add spaces between memory operand `+` and `-` operators + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx + rdx*8 - 80h]` + // X | `false` | `mov eax,[rcx+rdx*8-80h]` + // + // # Arguments + // * `value`: New value + Formatter_SetSpaceBetweenMemoryAddOperators : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Add spaces between memory operand `*` operator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx+rdx * 8-80h]` + // X | `false` | `mov eax,[rcx+rdx*8-80h]` + Formatter_GetSpaceBetweenMemoryMulOperators : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add spaces between memory operand `*` operator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx+rdx * 8-80h]` + // X | `false` | `mov eax,[rcx+rdx*8-80h]` + // + // # Arguments + // * `value`: New value + Formatter_SetSpaceBetweenMemoryMulOperators : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show memory operand scale value before the index register + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[8*rdx]` + // X | `false` | `mov eax,[rdx*8]` + Formatter_GetScaleBeforeIndex : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show memory operand scale value before the index register + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[8*rdx]` + // X | `false` | `mov eax,[rdx*8]` + // + // # Arguments + // * `value`: New value + Formatter_SetScaleBeforeIndex : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Always show the scale value even if it's `*1` + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rbx+rcx*1]` + // X | `false` | `mov eax,[rbx+rcx]` + Formatter_GetAlwaysShowScale : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Always show the scale value even if it's `*1` + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rbx+rcx*1]` + // X | `false` | `mov eax,[rbx+rcx]` + // + // # Arguments + // * `value`: New value + Formatter_SetAlwaysShowScale : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Always show the effective segment register. If the option is `false`, only show the segment register if + // there's a segment override prefix. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,ds:[ecx]` + // X | `false` | `mov eax,[ecx]` + Formatter_GetAlwaysShowSegmentRegister : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Always show the effective segment register. If the option is `false`, only show the segment register if + // there's a segment override prefix. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,ds:[ecx]` + // X | `false` | `mov eax,[ecx]` + // + // # Arguments + // * `value`: New value + Formatter_SetAlwaysShowSegmentRegister : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show zero displacements + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx*2+0]` + // X | `false` | `mov eax,[rcx*2]` + Formatter_GetShowZeroDisplacements : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show zero displacements + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rcx*2+0]` + // X | `false` | `mov eax,[rcx*2]` + // + // # Arguments + // * `value`: New value + Formatter_SetShowZeroDisplacements : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Hex number prefix or an empty string, eg. `"0x"` + // + // - Default: `""` ( masm/nasm/intel ), `"0x"` ( gas ) + Formatter_GetHexPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Hex number prefix or an empty string, eg. `"0x"` + // + // - Default: `""` ( masm/nasm/intel ), `"0x"` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetHexPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Hex number suffix or an empty string, eg. `"h"` + // + // - Default: `"h"` ( masm/nasm/intel ), `""` ( gas ) + Formatter_GetHexSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Hex number suffix or an empty string, eg. `"h"` + // + // - Default: `"h"` ( masm/nasm/intel ), `""` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetHexSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `0x12345678` + // X | `4` | `0x1234_5678` + Formatter_GetHexDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `0x12345678` + // X | `4` | `0x1234_5678` + // + // # Arguments + // * `value`: New value + Formatter_SetHexDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Decimal number prefix or an empty string + // + // - Default: `""` + Formatter_GetDecimalPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Decimal number prefix or an empty string + // + // - Default: `""` + // + // # Arguments + // * `value`: New value + Formatter_SetDecimalPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Decimal number suffix or an empty string + // + // - Default: `""` + Formatter_GetDecimalSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Decimal number suffix or an empty string + // + // - Default: `""` + // + // # Arguments + // * `value`: New value + Formatter_SetDecimalSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `12345678` + // X | `3` | `12_345_678` + Formatter_GetDecimalDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `12345678` + // X | `3` | `12_345_678` + // + // # Arguments + // * `value`: New value + Formatter_SetDecimalDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Octal number prefix or an empty string + // + // - Default: `""` ( masm/nasm/intel ), `"0"` ( gas ) + Formatter_GetOctalPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Octal number prefix or an empty string + // + // - Default: `""` ( masm/nasm/intel ), `"0"` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetOctalPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Octal number suffix or an empty string + // + // - Default: `"o"` ( masm/nasm/intel ), `""` ( gas ) + Formatter_GetOctalSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Octal number suffix or an empty string + // + // - Default: `"o"` ( masm/nasm/intel ), `""` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetOctalSuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `12345670` + // X | `4` | `1234_5670` + Formatter_GetOctalDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `12345670` + // X | `4` | `1234_5670` + // + // # Arguments + // * `value`: New value + Formatter_SetOctalDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Binary number prefix or an empty string + // + // - Default: `""` ( masm/nasm/intel ), `"0b"` ( gas ) + Formatter_GetBinaryPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Binary number prefix or an empty string + // + // - Default: `""` ( masm/nasm/intel ), `"0b"` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetBinaryPrefix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Binary number suffix or an empty string + // + // - Default: `"b"` ( masm/nasm/intel ), `""` ( gas ) + Formatter_GetBinarySuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Binary number suffix or an empty string + // + // - Default: `"b"` ( masm/nasm/intel ), `""` ( gas ) + // + // # Arguments + // * `value`: New value + Formatter_SetBinarySuffix : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `11010111` + // X | `4` | `1101_0111` + Formatter_GetBinaryDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : Cardinal; cdecl = nil; + + // Size of a digit group, see also [`digit_separator( )`] + // + // [`digit_separator( )`]: #method.digit_separator + // + // Default | Value | Example + // --------|-------|-------- + // _ | `0` | `11010111` + // X | `4` | `1101_0111` + // + // # Arguments + // * `value`: New value + Formatter_SetBinaryDigitGroupSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Cardinal ) : boolean; cdecl = nil; + + // Digit separator or an empty string. See also eg. [`hex_digit_group_size( )`] + // + // [`hex_digit_group_size( )`]: #method.hex_digit_group_size + // + // Default | Value | Example + // --------|-------|-------- + // X | `""` | `0x12345678` + // _ | `"_"` | `0x1234_5678` + Formatter_GetDigitSeparator : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar; Size : NativeUInt ) : NativeUInt; cdecl = nil; + + // Digit separator or an empty string. See also eg. [`hex_digit_group_size( )`] + // + // [`hex_digit_group_size( )`]: #method.hex_digit_group_size + // + // Default | Value | Example + // --------|-------|-------- + // X | `""` | `0x12345678` + // _ | `"_"` | `0x1234_5678` + // + // # Arguments + // * `value`: New value + Formatter_SetDigitSeparator : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : PAnsiChar ) : boolean; cdecl = nil; + + // Add leading zeros to hexadecimal/octal/binary numbers. + // This option has no effect on branch targets and displacements, use [`branch_leading_zeros`] + // and [`displacement_leading_zeros`]. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `0x0000000A`/`0000000Ah` + // X | `false` | `0xA`/`0Ah` + Formatter_GetLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add leading zeros to hexadecimal/octal/binary numbers. + // This option has no effect on branch targets and displacements, use [`branch_leading_zeros`] + // and [`displacement_leading_zeros`]. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `0x0000000A`/`0000000Ah` + // X | `false` | `0xA`/`0Ah` + // + // # Arguments + // * `value`: New value + Formatter_SetLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Use uppercase hex digits + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `0xFF` + // _ | `false` | `0xff` + Formatter_GetUppercaseHex : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Use uppercase hex digits + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `0xFF` + // _ | `false` | `0xff` + // + // # Arguments + // * `value`: New value + Formatter_SetUppercaseHex : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Small hex numbers ( -9 .. 9 ) are shown in decimal + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `9` + // _ | `false` | `0x9` + Formatter_GetSmallHexNumbersInDecimal : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Small hex numbers ( -9 .. 9 ) are shown in decimal + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `9` + // _ | `false` | `0x9` + // + // # Arguments + // * `value`: New value + Formatter_SetSmallHexNumbersInDecimal : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Add a leading zero to hex numbers if there's no prefix and the number starts with hex digits `A-F` + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `0FFh` + // _ | `false` | `FFh` + Formatter_GetAddLeadingZeroToHexNumbers : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add a leading zero to hex numbers if there's no prefix and the number starts with hex digits `A-F` + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `0FFh` + // _ | `false` | `FFh` + // + // # Arguments + // * `value`: New value + Formatter_SetAddLeadingZeroToHexNumbers : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Number base + // + // - Default: [`Hexadecimal`] + // + // [`Hexadecimal`]: enum.NumberBase.html#variant.Hexadecimal + Formatter_GetNumberBase : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TNumberBase; cdecl = nil; + + // Number base + // + // - Default: [`Hexadecimal`] + // + // [`Hexadecimal`]: enum.NumberBase.html#variant.Hexadecimal + // + // # Arguments + // * `value`: New value + Formatter_SetNumberBase : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TNumberBase ) : boolean; cdecl = nil; + + // Add leading zeros to branch offsets. Used by `CALL NEAR`, `CALL FAR`, `JMP NEAR`, `JMP FAR`, `Jcc`, `LOOP`, `LOOPcc`, `XBEGIN` + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `je 00000123h` + // _ | `false` | `je 123h` + Formatter_GetBranchLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add leading zeros to branch offsets. Used by `CALL NEAR`, `CALL FAR`, `JMP NEAR`, `JMP FAR`, `Jcc`, `LOOP`, `LOOPcc`, `XBEGIN` + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `je 00000123h` + // _ | `false` | `je 123h` + // + // # Arguments + // * `value`: New value + Formatter_SetBranchLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show immediate operands as signed numbers + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,-1` + // X | `false` | `mov eax,FFFFFFFF` + Formatter_GetSignedImmediateOperands : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show immediate operands as signed numbers + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,-1` + // X | `false` | `mov eax,FFFFFFFF` + // + // # Arguments + // * `value`: New value + Formatter_SetSignedImmediateOperands : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Displacements are signed numbers + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `mov al,[eax-2000h]` + // _ | `false` | `mov al,[eax+0FFFFE000h]` + Formatter_GetSignedMemoryDisplacements : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Displacements are signed numbers + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `mov al,[eax-2000h]` + // _ | `false` | `mov al,[eax+0FFFFE000h]` + // + // # Arguments + // + // * `value`: New value + Formatter_SetSignedMemoryDisplacements : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Add leading zeros to displacements + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov al,[eax+00000012h]` + // X | `false` | `mov al,[eax+12h]` + Formatter_GetDisplacementLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Add leading zeros to displacements + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov al,[eax+00000012h]` + // X | `false` | `mov al,[eax+12h]` + // + // # Arguments + // * `value`: New value + Formatter_SetDisplacementLeadingZeros : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Options that control if the memory size ( eg. `DWORD PTR` ) is shown or not. + // This is ignored by the gas ( AT&T ) formatter. + // + // - Default: [`Default`] + // + // [`Default`]: enum.MemorySizeOptions.html#variant.Default + Formatter_GetMemorySizeOptions : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TMemorySizeOptions; cdecl = nil; + + // Options that control if the memory size ( eg. `DWORD PTR` ) is shown or not. + // This is ignored by the gas ( AT&T ) formatter. + // + // - Default: [`Default`] + // + // [`Default`]: enum.MemorySizeOptions.html#variant.Default + // + // # Arguments + // * `value`: New value + Formatter_SetMemorySizeOptions : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TMemorySizeOptions ) : boolean; cdecl = nil; + + // Show `RIP+displ` or the virtual address + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rip+12345678h]` + // X | `false` | `mov eax,[1029384756AFBECDh]` + Formatter_GetRipRelativeAddresses : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show `RIP+displ` or the virtual address + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[rip+12345678h]` + // X | `false` | `mov eax,[1029384756AFBECDh]` + // + // # Arguments + // * `value`: New value + Formatter_SetRipRelativeAddresses : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show `NEAR`, `SHORT`, etc if it's a branch instruction + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `je short 1234h` + // _ | `false` | `je 1234h` + Formatter_GetShowBranchSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show `NEAR`, `SHORT`, etc if it's a branch instruction + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `je short 1234h` + // _ | `false` | `je 1234h` + // + // # Arguments + // * `value`: New value + Formatter_SetShowBranchSize : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Use pseudo instructions + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `vcmpnltsd xmm2,xmm6,xmm3` + // _ | `false` | `vcmpsd xmm2,xmm6,xmm3,5` + Formatter_GetUsePseudoOps : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Use pseudo instructions + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `vcmpnltsd xmm2,xmm6,xmm3` + // _ | `false` | `vcmpsd xmm2,xmm6,xmm3,5` + // + // # Arguments + // * `value`: New value + Formatter_SetUsePseudoOps : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show the original value after the symbol name + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[myfield ( 12345678 )]` + // X | `false` | `mov eax,[myfield]` + Formatter_GetShowSymbolAddress : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show the original value after the symbol name + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,[myfield ( 12345678 )]` + // X | `false` | `mov eax,[myfield]` + // + // # Arguments + // + // * `value`: New value + Formatter_SetShowSymbolAddress : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // ( gas only ) : If `true`, the formatter doesn't add `%` to registers + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,ecx` + // X | `false` | `mov %eax,%ecx` + GasFormatter_GetNakedRegisters : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( gas only ) : If `true`, the formatter doesn't add `%` to registers + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `mov eax,ecx` + // X | `false` | `mov %eax,%ecx` + // + // # Arguments + // * `value`: New value + GasFormatter_SetNakedRegisters : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( gas only ) : Shows the mnemonic size suffix even when not needed + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `movl %eax,%ecx` + // X | `false` | `mov %eax,%ecx` + GasFormatter_GetShowMnemonicSizeSuffix : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( gas only ) : Shows the mnemonic size suffix even when not needed + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `movl %eax,%ecx` + // X | `false` | `mov %eax,%ecx` + // + // # Arguments + // * `value`: New value + GasFormatter_SetShowMnemonicSizeSuffix : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( gas only ) : Add a space after the comma if it's a memory operand + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `( %eax, %ecx, 2 )` + // X | `false` | `( %eax,%ecx,2 )` + GasFormatter_GetSpaceAfterMemoryOperandComma : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( gas only ) : Add a space after the comma if it's a memory operand + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `( %eax, %ecx, 2 )` + // X | `false` | `( %eax,%ecx,2 )` + // + // # Arguments + // * `value`: New value + GasFormatter_SetSpaceAfterMemoryOperandComma : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( masm only ) : Add a `DS` segment override even if it's not present. Used if it's 16/32-bit code and mem op is a displ + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `mov eax,ds:[12345678]` + // _ | `false` | `mov eax,[12345678]` + MasmFormatter_GetAddDsPrefix32 : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( masm only ) : Add a `DS` segment override even if it's not present. Used if it's 16/32-bit code and mem op is a displ + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `mov eax,ds:[12345678]` + // _ | `false` | `mov eax,[12345678]` + // + // # Arguments + // * `value`: New value + MasmFormatter_SetAddDsPrefix32 : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( masm only ) : Show symbols in brackets + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `[ecx+symbol]` / `[symbol]` + // _ | `false` | `symbol[ecx]` / `symbol` + MasmFormatter_GetSymbolDisplacementInBrackets : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( masm only ) : Show symbols in brackets + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `[ecx+symbol]` / `[symbol]` + // _ | `false` | `symbol[ecx]` / `symbol` + // + // # Arguments + // * `value`: New value + MasmFormatter_SetSymbolDisplacementInBrackets : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( masm only ) : Show displacements in brackets + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `[ecx+1234h]` + // _ | `false` | `1234h[ecx]` + MasmFormatter_GetDisplacementInBrackets : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( masm only ) : Show displacements in brackets + // + // Default | Value | Example + // --------|-------|-------- + // X | `true` | `[ecx+1234h]` + // _ | `false` | `1234h[ecx]` + // + // # Arguments + // * `value`: New value + MasmFormatter_SetDisplacementInBrackets : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // ( nasm only ) : Shows `BYTE`, `WORD`, `DWORD` or `QWORD` if it's a sign extended immediate operand value + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `or rcx,byte -1` + // X | `false` | `or rcx,-1` + NasmFormatter_GetShowSignExtendedImmediateSize : function( Formatter: Pointer ) : boolean; cdecl = nil; + + // ( nasm only ) : Shows `BYTE`, `WORD`, `DWORD` or `QWORD` if it's a sign extended immediate operand value + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `or rcx,byte -1` + // X | `false` | `or rcx,-1` + // + // # Arguments + // * `value`: New value + NasmFormatter_SetShowSignExtendedImmediateSize : function( Formatter: Pointer; Value : Boolean ) : Boolean; cdecl = nil; + + // Use `st( 0 )` instead of `st` if `st` can be used. Ignored by the nasm formatter. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `fadd st( 0 ),st( 3 )` + // X | `false` | `fadd st,st( 3 )` + Formatter_GetPreferST0 : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Use `st( 0 )` instead of `st` if `st` can be used. Ignored by the nasm formatter. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `fadd st( 0 ),st( 3 )` + // X | `false` | `fadd st,st( 3 )` + // + // # Arguments + // * `value`: New value + Formatter_SetPreferST0 : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Show useless prefixes. If it has useless prefixes, it could be data and not code. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `es rep add eax,ecx` + // X | `false` | `add eax,ecx` + Formatter_GetShowUselessPrefixes : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : boolean; cdecl = nil; + + // Show useless prefixes. If it has useless prefixes, it could be data and not code. + // + // Default | Value | Example + // --------|-------|-------- + // _ | `true` | `es rep add eax,ecx` + // X | `false` | `add eax,ecx` + // + // # Arguments + // * `value`: New value + Formatter_SetShowUselessPrefixes : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : Boolean ) : Boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JB` / `JC` / `JNAE` ) + // + // Default: `JB`, `CMOVB`, `SETB` + Formatter_GetCC_b : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_b; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JB` / `JC` / `JNAE` ) + // + // Default: `JB`, `CMOVB`, `SETB` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_b : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_b ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JAE` / `JNB` / `JNC` ) + // + // Default: `JAE`, `CMOVAE`, `SETAE` + Formatter_GetCC_ae : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_ae; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JAE` / `JNB` / `JNC` ) + // + // Default: `JAE`, `CMOVAE`, `SETAE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_ae : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_ae ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JE` / `JZ` ) + // + // Default: `JE`, `CMOVE`, `SETE`, `LOOPE`, `REPE` + Formatter_GetCC_e : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_e; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JE` / `JZ` ) + // + // Default: `JE`, `CMOVE`, `SETE`, `LOOPE`, `REPE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_e : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_e ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JNE` / `JNZ` ) + // + // Default: `JNE`, `CMOVNE`, `SETNE`, `LOOPNE`, `REPNE` + Formatter_GetCC_ne : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_ne; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JNE` / `JNZ` ) + // + // Default: `JNE`, `CMOVNE`, `SETNE`, `LOOPNE`, `REPNE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_ne : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_ne ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JBE` / `JNA` ) + // + // Default: `JBE`, `CMOVBE`, `SETBE` + Formatter_GetCC_be : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_be; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JBE` / `JNA` ) + // + // Default: `JBE`, `CMOVBE`, `SETBE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_be : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_be ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JA` / `JNBE` ) + // + // Default: `JA`, `CMOVA`, `SETA` + Formatter_GetCC_a : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_a; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JA` / `JNBE` ) + // + // Default: `JA`, `CMOVA`, `SETA` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_a : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_a ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JP` / `JPE` ) + // + // Default: `JP`, `CMOVP`, `SETP` + Formatter_GetCC_p : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_p; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JP` / `JPE` ) + // + // Default: `JP`, `CMOVP`, `SETP` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_p : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_p ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JNP` / `JPO` ) + // + // Default: `JNP`, `CMOVNP`, `SETNP` + Formatter_GetCC_np : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_np; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JNP` / `JPO` ) + // + // Default: `JNP`, `CMOVNP`, `SETNP` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_np : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_np ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JL` / `JNGE` ) + // + // Default: `JL`, `CMOVL`, `SETL` + Formatter_GetCC_l : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_l; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JL` / `JNGE` ) + // + // Default: `JL`, `CMOVL`, `SETL` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_l : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_l ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JGE` / `JNL` ) + // + // Default: `JGE`, `CMOVGE`, `SETGE` + Formatter_GetCC_ge : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_ge; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JGE` / `JNL` ) + // + // Default: `JGE`, `CMOVGE`, `SETGE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_ge : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_ge ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JLE` / `JNG` ) + // + // Default: `JLE`, `CMOVLE`, `SETLE` + Formatter_GetCC_le : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_le; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JLE` / `JNG` ) + // + // Default: `JLE`, `CMOVLE`, `SETLE` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_le : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_le ) : boolean; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JG` / `JNLE` ) + // + // Default: `JG`, `CMOVG`, `SETG` + Formatter_GetCC_g : function( Formatter: Pointer; FormatterType : TIcedFormatterType ) : TCC_g; cdecl = nil; + + // Mnemonic condition code selector ( eg. `JG` / `JNLE` ) + // + // Default: `JG`, `CMOVG`, `SETG` + // + // # Arguments + // * `value`: New value + Formatter_SetCC_g : function( Formatter: Pointer; FormatterType : TIcedFormatterType; Value : TCC_g ) : boolean; cdecl = nil; + + + // Encoder + // Creates an encoder + // + // Returns NULL if `bitness` is not one of 16, 32, 64. + // + // # Arguments + // * `bitness`: 16, 32 or 64 + // * `capacity`: Initial capacity of the `u8` buffer + Encoder_Create : function( Bitness : Cardinal; Capacity : NativeUInt = 0 ) : Pointer; cdecl = nil; + + // Encodes an instruction and returns the size of the encoded instruction + // + // # Result + // * Returns written amount of encoded Bytes + // + // # Arguments + // * `instruction`: Instruction to encode + // * `rip`: `RIP` of the encoded instruction + Encoder_Encode : function( Encoder : Pointer; const Instruction : TInstruction ) : NativeUInt; cdecl = nil; + + // Writes a byte to the output buffer + // + // # Arguments + // + // `value`: Value to write + Encoder_WriteByte : function ( Encoder : Pointer; Value : Byte ) : boolean; cdecl = nil; + + // Returns the buffer and initializes the internal buffer to an empty vector. Should be called when + // you've encoded all instructions and need the raw instruction bytes. See also [`set_buffer()`]. + Encoder_GetBuffer : function ( Encoder : Pointer; Value : PByte; Size : NativeUInt ) : boolean; cdecl = nil; + + // Overwrites the buffer with a new vector. The old buffer is dropped. See also [`Encoder_GetBuffer`]. + // NOTE: Monitor the result of [`Encoder_Encode`] (Encoded Bytes). + // DO NOT Encode more Bytes than fitting your provided Buffer as this would cause a realloc - which will lead to an access violation. +// Encoder_SetBuffer : function ( Encoder : Pointer; Value : PByte; Size : NativeUInt ) : boolean; cdecl = nil; + + // Gets the offsets of the constants (memory displacement and immediate) in the encoded instruction. + // The caller can use this information to add relocations if needed. + Encoder_GetConstantOffsets : procedure( Decoder : Pointer; var ConstantOffsets : TConstantOffsets ); cdecl = nil; + + // Disables 2-byte VEX encoding and encodes all VEX instructions with the 3-byte VEX encoding + Encoder_GetPreventVex2 : function( Encoder : Pointer ) : Boolean; cdecl = nil; + + // Disables 2-byte VEX encoding and encodes all VEX instructions with the 3-byte VEX encoding + // + // # Arguments + // * `new_value`: new value + Encoder_SetPreventVex2 : function ( Encoder : Pointer; Value : Boolean ) : boolean; cdecl = nil; + + // Value of the `VEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + Encoder_GetVexWig : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Value of the `VEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + // + // # Arguments + // * `new_value`: new value (0 or 1) + Encoder_SetVexWig : function ( Encoder : Pointer; Value : Cardinal ) : boolean; cdecl = nil; + + // Value of the `VEX.L` bit to use if it's an instruction that ignores the bit. Default is 0. + Encoder_GetVexLig : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Value of the `VEX.L` bit to use if it's an instruction that ignores the bit. Default is 0. + // + // # Arguments + // * `new_value`: new value (0 or 1) + Encoder_SetVexLig : function ( Encoder : Pointer; Value : Cardinal ) : boolean; cdecl = nil; + + // Value of the `EVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + Encoder_GetEvexWig : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Value of the `EVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + // + // # Arguments + // * `new_value`: new value (0 or 1) + Encoder_SetEvexWig : function ( Encoder : Pointer; Value : Cardinal ) : boolean; cdecl = nil; + + // Value of the `EVEX.L'L` bits to use if it's an instruction that ignores the bits. Default is 0. + Encoder_GetEvexLig : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Value of the `EVEX.L'L` bits to use if it's an instruction that ignores the bits. Default is 0. + // + // # Arguments + // * `new_value`: new value (0 or 3) + Encoder_SetEvexLig : function ( Encoder : Pointer; Value : Cardinal ) : boolean; cdecl = nil; + + // Value of the `MVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + Encoder_GetMvexWig : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Value of the `MVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. + // + // # Arguments + // * `new_value`: new value (0 or 1) + Encoder_SetMvexWig : function ( Encoder : Pointer; Value : Cardinal ) : boolean; cdecl = nil; + + // Gets the bitness (16, 32 or 64) + Encoder_GetBitness : function( Encoder : Pointer ) : Cardinal; cdecl = nil; + + // Encodes instructions. Any number of branches can be part of this block. + // You can use this function to move instructions from one location to another location. + // If the target of a branch is too far away, it'll be rewritten to a longer branch. + // You can disable this by passing in [`BlockEncoderOptions::DONT_FIX_BRANCHES`]. + // If the block has any `RIP`-relative memory operands, make sure the data isn't too + // far away from the new location of the encoded instructions. Every OS should have + // some API to allocate memory close (+/-2GB) to the original code location. + // + // # Errors + // Returns 0-Data if it failed to encode one or more instructions. + // + // # Arguments + // * `bitness`: 16, 32, or 64 + // * `Instructions`: First Instruction to encode + // * `Count`: Instruction-Count + // * `Results`: Result-Structure + // * `Options`: Encoder options, see [`TBlockEncoderOptions`] + // + // # Result + // * Pointer to Result-Data. Musst be free'd using FreeMemory() + BlockEncoder : function( Bitness : Cardinal; RIP : UInt64; const Instructions : TInstruction; Count : NativeUInt; var Result : TBlockEncoderResult; Options : Cardinal = beoNONE ) : Pointer; cdecl = nil; + + // Instruction + // Gets the FPU status word's `TOP` increment and whether it's a conditional or unconditional push/pop + // and whether `TOP` is written. + Instruction_FPU_StackIncrementInfo : function( const Instruction : TInstruction; var Info : TFpuStackIncrementInfo ) : Boolean; cdecl = nil; + + // Gets the number of bytes added to `SP`/`ESP`/`RSP` or 0 if it's not an instruction that pushes or pops data. This method assumes + // the instruction doesn't change the privilege level (eg. `IRET/D/Q`). If it's the `LEAVE` instruction, this method returns 0. + Instruction_StackPointerIncrement : function( const Instruction : TInstruction ) : Integer; cdecl = nil; + + // All flags that are read by the CPU when executing the instruction. + // This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. + Instruction_RFlagsRead : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // All flags that are written by the CPU, except those flags that are known to be undefined, always set or always cleared. + // This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. + Instruction_RFlagsWritten : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // All flags that are always cleared by the CPU. + // This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. + Instruction_RFlagsCleared : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // All flags that are always set by the CPU. + // This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. + Instruction_RFlagsSet : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // All flags that are undefined after executing the instruction. + // This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. + Instruction_RFlagsUndefined : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // All flags that are modified by the CPU. This is `rflags_written() + rflags_cleared() + rflags_set() + rflags_undefined()`. This method returns an [`RflagsBits`] value. + Instruction_RFlagsModified : function( const Instruction : TInstruction ) : TRFlag{Cardinal}; cdecl = nil; + + // Gets all op kinds ([`op_count()`] values) + Instruction_OPKinds : function( const Instruction : TInstruction; var OPKindsArray : TOPKindsArray ) : TFlowControl; cdecl = nil; + + // Gets the size of the memory location that is referenced by the operand. See also [`is_broadcast()`]. + // Use this method if the operand has kind [`OpKind::Memory`], + Instruction_MemorySize : function( const Instruction : TInstruction ) : TMemorySize; cdecl = nil; + + // Gets the operand count. An instruction can have 0-5 operands. + Instruction_OPCount : function( const Instruction : TInstruction ) : Cardinal; cdecl = nil; + + // Virtual-Address Resolver + // Gets the virtual address of a memory operand + // + // # Arguments + // * `operand`: Operand number, 0-4, must be a memory operand + // * `element_index`: Only used if it's a vsib memory operand. This is the element index of the vector index register. + // * `get_register_value`: Function that returns the value of a register or the base address of a segment register, or `None` for unsupported + // registers. + // + // # Call-back function args + // * Arg 1: `register`: Register (GPR8, GPR16, GPR32, GPR64, XMM, YMM, ZMM, seg). If it's a segment register, the call-back function should return the segment's base address, not the segment's register value. + // * Arg 2: `element_index`: Only used if it's a vsib memory operand. This is the element index of the vector index register. + // * Arg 3: `element_size`: Only used if it's a vsib memory operand. Size in bytes of elements in vector index register (4 or 8). + Instruction_VirtualAddress : function ( const Instruction: TInstruction; Callback : TVirtualAddressResolverCallback; Operand : Cardinal = 0; Index : NativeUInt = 0; UserData : Pointer = nil ) : UInt64; cdecl = nil; + + // `true` if eviction hint bit is set (`{eh}`) (MVEX instructions only) + Instruction_IsMvexEvictionHint : function( const Instruction: TInstruction ) : Boolean; cdecl = nil; + + // (MVEX) Register/memory operand conversion function + Instruction_MvexRegMemConv : function( const Instruction: TInstruction ) : TMvexRegMemConv; cdecl = nil; + + // Gets the opcode string, eg. `VEX.128.66.0F38.W0 78 /r`, see also [`instruction_string()`] + OpCodeInfo_OpCodeString : procedure( const Code: TCodeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + + // Gets the instruction string, eg. `VPBROADCASTB xmm1, xmm2/m8`, see also [`op_code_string()`] + OpCodeInfo_InstructionString : procedure( const Code: TCodeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + + // `true` if it's an instruction available in 16-bit mode + OpCodeInfo_Mode16 : function( const Code : TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's an instruction available in 32-bit mode + OpCodeInfo_Mode32 : function( const Code : TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's an instruction available in 64-bit mode + OpCodeInfo_Mode64 : function( const Code : TCodeType ) : Boolean; cdecl = nil; + + // `true` if an `FWAIT` (`9B`) instruction is added before the instruction + OpCodeInfo_Fwait : function( const Code : TCodeType ) : Boolean; cdecl = nil; + + // (VEX/XOP/EVEX/MVEX) `W` value or default value if [`is_wig()`] or [`is_wig32()`] is `true` + OpCodeInfo_W : function( const Code : TCodeType ) : Cardinal; cdecl = nil; + + // (VEX/XOP/EVEX) `true` if the `L` / `L'L` fields are ignored. + // + // EVEX: if reg-only ops and `{er}` (`EVEX.b` is set), `L'L` is the rounding control and not ignored. + OpCodeInfo_IsLig : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (VEX/XOP/EVEX/MVEX) `true` if the `W` field is ignored in 16/32/64-bit modes + OpCodeInfo_IsWig : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (VEX/XOP/EVEX/MVEX) `true` if the `W` field is ignored in 16/32-bit modes (but not 64-bit mode) + OpCodeInfo_IsWig32 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // OpCodeInfo + // (MVEX) Gets the `EH` bit that's required to encode this instruction + OpCodeInfo_MvexEhBit : function( const Code: TCodeType ) : TMvexEHBit; cdecl = nil; + + // (MVEX) `true` if the instruction supports eviction hint (if it has a memory operand) + OpCodeInfo_MvexCanUseEvictionHint : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (MVEX) `true` if the instruction's rounding control bits are stored in `imm8[1:0]` + OpCodeInfo_MvexCanUseImmRoundingControl : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (MVEX) `true` if the instruction ignores op mask registers (eg. `{k1}`) + OpCodeInfo_MvexIgnoresOpMaskRegister : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (MVEX) `true` if the instruction must have `MVEX.SSS=000` if `MVEX.EH=1` + OpCodeInfo_MvexNoSaeRc : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (MVEX) Gets the tuple type / conv lut kind + OpCodeInfo_MvexTupleTypeLutKind : function( const Code: TCodeType ) : TMvexTupleTypeLutKind; cdecl = nil; + + // (MVEX) Gets the conversion function, eg. `Sf32` + OpCodeInfo_MvexConversionFunc : function( const Code: TCodeType ) : TMvexConvFn; cdecl = nil; + + // (MVEX) Gets flags indicating which conversion functions are valid (bit 0 == func 0) + OpCodeInfo_MvexValidConversionFuncsMask : function( const Code: TCodeType ) : Byte; cdecl = nil; + + // (MVEX) Gets flags indicating which swizzle functions are valid (bit 0 == func 0) + OpCodeInfo_MvexValidSwizzleFuncsMask : function( const Code: TCodeType ) : Byte; cdecl = nil; + + // If it has a memory operand, gets the [`MemorySize`] (non-broadcast memory type) + OpCodeInfo_MemorySize : function( const Code: TCodeType ) : TMemorySize; cdecl = nil; + + // If it has a memory operand, gets the [`MemorySize`] (broadcast memory type) + OpCodeInfo_BroadcastMemorySize : function( const Code: TCodeType ) : TMemorySize; cdecl = nil; + + // (EVEX) `true` if the instruction supports broadcasting (`EVEX.b` bit) (if it has a memory operand) + OpCodeInfo_CanBroadcast : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (EVEX/MVEX) `true` if the instruction supports rounding control + OpCodeInfo_CanUseRoundingControl : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (EVEX/MVEX) `true` if the instruction supports suppress all exceptions + OpCodeInfo_CanSuppressAllExceptions : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (EVEX/MVEX) `true` if an opmask register can be used + OpCodeInfo_CanUseOpMaskRegister : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (EVEX/MVEX) `true` if a non-zero opmask register must be used + OpCodeInfo_RequireOpMaskRegister : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (EVEX) `true` if the instruction supports zeroing masking (if one of the opmask registers `K1`-`K7` is used and destination operand is not a memory operand) + OpCodeInfo_CanUseZeroingMasking : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `LOCK` (`F0`) prefix can be used + OpCodeInfo_CanUseLockPrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `XACQUIRE` (`F2`) prefix can be used + OpCodeInfo_CanUseXacquirePrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `XRELEASE` (`F3`) prefix can be used + OpCodeInfo_CanUseXreleasePrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `REP` / `REPE` (`F3`) prefixes can be used + OpCodeInfo_CanUseRepPrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `REPNE` (`F2`) prefix can be used + OpCodeInfo_CanUseRepnePrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `BND` (`F2`) prefix can be used + OpCodeInfo_CanUseBndPrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `HINT-TAKEN` (`3E`) and `HINT-NOT-TAKEN` (`2E`) prefixes can be used + OpCodeInfo_CanUseHintTakenPrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `NOTRACK` (`3E`) prefix can be used + OpCodeInfo_CanUseNotrackPrefix : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if rounding control is ignored (#UD is not generated) + OpCodeInfo_IgnoresRoundingControl : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `LOCK` prefix can be used as an extra register bit (bit 3) to access registers 8-15 without a `REX` prefix (eg. in 32-bit mode) + OpCodeInfo_AmdLockRegBit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the default operand size is 64 in 64-bit mode. A `66` prefix can switch to 16-bit operand size. + OpCodeInfo_DefaultOpSize64 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the operand size is always 64 in 64-bit mode. A `66` prefix is ignored. + OpCodeInfo_ForceOpSize64 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the Intel decoder forces 64-bit operand size. A `66` prefix is ignored. + OpCodeInfo_IntelForceOpSize64 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can only be executed when CPL=0 + OpCodeInfo_MustBeCpl0 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed when CPL=0 + OpCodeInfo_Cpl0 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed when CPL=1 + OpCodeInfo_Cpl1 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed when CPL=2 + OpCodeInfo_Cpl2 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed when CPL=3 + OpCodeInfo_Cpl3 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the instruction accesses the I/O address space (eg. `IN`, `OUT`, `INS`, `OUTS`) + OpCodeInfo_IsInputOutput : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's one of the many nop instructions (does not include FPU nop instructions, eg. `FNOP`) + OpCodeInfo_IsNop : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's one of the many reserved nop instructions (eg. `0F0D`, `0F18-0F1F`) + OpCodeInfo_IsReservedNop : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a serializing instruction (Intel CPUs) + OpCodeInfo_IsSerializingIntel : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a serializing instruction (AMD CPUs) + OpCodeInfo_IsSerializingAmd : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the instruction requires either CPL=0 or CPL<=3 depending on some CPU option (eg. `CR4.TSD`, `CR4.PCE`, `CR4.UMIP`) + OpCodeInfo_MayRequireCpl0 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a tracked `JMP`/`CALL` indirect instruction (CET) + OpCodeInfo_IsCetTracked : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a non-temporal hint memory access (eg. `MOVNTDQ`) + OpCodeInfo_IsNonTemporal : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a no-wait FPU instruction, eg. `FNINIT` + OpCodeInfo_IsFpuNoWait : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the mod bits are ignored and it's assumed `modrm[7:6] == 11b` + OpCodeInfo_IgnoresModBits : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `66` prefix is not allowed (it will #UD) + OpCodeInfo_No66 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the `F2`/`F3` prefixes aren't allowed + OpCodeInfo_Nfx : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the index reg's reg-num (vsib op) (if any) and register ops' reg-nums must be unique, + // eg. `MNEMONIC XMM1,YMM1,[RAX+ZMM1*2]` is invalid. Registers = `XMM`/`YMM`/`ZMM`/`TMM`. + OpCodeInfo_RequiresUniqueRegNums : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the destination register's reg-num must not be present in any other operand, eg. `MNEMONIC XMM1,YMM1,[RAX+ZMM1*2]` + // is invalid. Registers = `XMM`/`YMM`/`ZMM`/`TMM`. + OpCodeInfo_RequiresUniqueDestRegNum : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's a privileged instruction (all CPL=0 instructions (except `VMCALL`) and IOPL instructions `IN`, `INS`, `OUT`, `OUTS`, `CLI`, `STI`) + OpCodeInfo_IsPrivileged : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it reads/writes too many registers + OpCodeInfo_IsSaveRestore : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's an instruction that implicitly uses the stack register, eg. `CALL`, `POP`, etc + OpCodeInfo_IsStackInstruction : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the instruction doesn't read the segment register if it uses a memory operand + OpCodeInfo_IgnoresSegment : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if the opmask register is read and written (instead of just read). This also implies that it can't be `K0`. + OpCodeInfo_IsOpMaskReadWrite : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed in real mode + OpCodeInfo_RealMode : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed in protected mode + OpCodeInfo_ProtectedMode : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed in virtual 8086 mode + OpCodeInfo_Virtual8086Mode : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed in compatibility mode + OpCodeInfo_CompatibilityMode : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be executed in 64-bit mode + OpCodeInfo_LongMode : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used outside SMM + OpCodeInfo_UseOutsideSmm : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used in SMM + OpCodeInfo_UseInSmm : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used outside an enclave (SGX) + OpCodeInfo_UseOutsideEnclaveSgx : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used inside an enclave (SGX1) + OpCodeInfo_UseInEnclaveSgx1 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used inside an enclave (SGX2) + OpCodeInfo_UseInEnclaveSgx2 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used outside VMX operation + OpCodeInfo_UseOutsideVmxOp : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used in VMX root operation + OpCodeInfo_UseInVmxRootOp : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used in VMX non-root operation + OpCodeInfo_UseInVmxNonRootOp : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used outside SEAM + OpCodeInfo_UseOutsideSeam : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it can be used in SEAM + OpCodeInfo_UseInSeam : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if #UD is generated in TDX non-root operation + OpCodeInfo_TdxNonRootGenUd : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if #VE is generated in TDX non-root operation + OpCodeInfo_TdxNonRootGenVe : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if an exception (eg. #GP(0), #VE) may be generated in TDX non-root operation + OpCodeInfo_TdxNonRootMayGenEx : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (Intel VMX) `true` if it causes a VM exit in VMX non-root operation + OpCodeInfo_IntelVMExit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (Intel VMX) `true` if it may cause a VM exit in VMX non-root operation + OpCodeInfo_IntelMayVMExit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (Intel VMX) `true` if it causes an SMM VM exit in VMX root operation (if dual-monitor treatment is activated) + OpCodeInfo_IntelSmmVMExit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (AMD SVM) `true` if it causes a #VMEXIT in guest mode + OpCodeInfo_AmdVMExit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // (AMD SVM) `true` if it may cause a #VMEXIT in guest mode + OpCodeInfo_AmdMayVMExit : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it causes a TSX abort inside a TSX transaction + OpCodeInfo_TsxAbort : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it causes a TSX abort inside a TSX transaction depending on the implementation + OpCodeInfo_TsxImplAbort : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it may cause a TSX abort inside a TSX transaction depending on some condition + OpCodeInfo_TsxMayAbort : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 16-bit Intel decoder + OpCodeInfo_IntelDecoder16 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 32-bit Intel decoder + OpCodeInfo_IntelDecoder32 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 64-bit Intel decoder + OpCodeInfo_IntelDecoder64 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 16-bit AMD decoder + OpCodeInfo_AmdDecoder16 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 32-bit AMD decoder + OpCodeInfo_AmdDecoder32 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // `true` if it's decoded by iced's 64-bit AMD decoder + OpCodeInfo_AmdDecoder64 : function( const Code: TCodeType ) : Boolean; cdecl = nil; + + // Gets the decoder option that's needed to decode the instruction or [`DecoderOptions::NONE`]. + // The return value is a [`DecoderOptions`] value. + OpCodeInfo_DecoderOption : function( const Code: TCodeType ) : Cardinal; cdecl = nil; + + // Gets the length of the opcode bytes ([`op_code()`]). The low bytes is the opcode value. + OpCodeInfo_OpCodeLen : function( const Code: TCodeType ) : Cardinal; cdecl = nil; + + // Gets the number of operands + OpCodeInfo_OPCount : function( const Code: TCodeType ) : Cardinal; cdecl = nil; + + // InstructionInfoFactory + // Creates a new instance. + // + // If you don't need to know register and memory usage, it's faster to call [`Instruction`] and + // [`Code`] methods such as [`Instruction::flow_control()`] instead of getting that info from this struct. + // + // [`Instruction`]: struct.Instruction.html + // [`Code`]: enum.Code.html + // [`Instruction::flow_control()`]: struct.Instruction.html#method.flow_control + InstructionInfoFactory_Create : function : Pointer; cdecl = nil; + + // Creates a new [`InstructionInfo`], see also [`info()`]. + // + // If you don't need to know register and memory usage, it's faster to call [`Instruction`] and + // [`Code`] methods such as [`Instruction::flow_control()`] instead of getting that info from this struct. + InstructionInfoFactory_Info : function( InstructionInfoFactory : Pointer; const Instruction: TInstruction; const InstructionInfo : TInstructionInfo; Options : Cardinal = iioNone ) : Boolean; cdecl = nil; + + // Instruction 'WITH' + // Creates an instruction with no operands + Instruction_With : function( const Instruction : TInstruction; Code : TCodeType ) : Boolean; cdecl = nil; + + // Creates an instruction with 1 operand + // + // # Errors + // Fails if one of the operands is invalid (basic checks) + Instruction_With1_Register : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With1_i32 : function( const Instruction : TInstruction; Code : TCodeType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With1_u32 : function( const Instruction : TInstruction; Code : TCodeType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With1_Memory : function( const Instruction : TInstruction; Code : TCodeType; var Memory : TMemoryOperand ) : Boolean; cdecl = nil; + Instruction_With2_Register_Register : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With2_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With2_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With2_Register_i64 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate : Int64 ) : Boolean; cdecl = nil; + Instruction_With2_Register_u64 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate : UInt64 ) : Boolean; cdecl = nil; + Instruction_With2_Register_MemoryOperand : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; var Memory : TMemoryOperand ) : Boolean; cdecl = nil; + Instruction_With2_i32_Register : function( const Instruction : TInstruction; Code : TCodeType; Immediate : Integer; Register : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With2_u32_Register : function( const Instruction : TInstruction; Code : TCodeType; Immediate : Cardinal; Register : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With2_i32_i32 : function( const Instruction : TInstruction; Code : TCodeType; Immediate1 : Integer; Immediate2 : Integer ) : Boolean; cdecl = nil; + Instruction_With2_u32_u32 : function( const Instruction : TInstruction; Code : TCodeType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With2_MemoryOperand_Register : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Register : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With2_MemoryOperand_i32 : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With2_MemoryOperand_u32 : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With3_Register_Register_Register : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With3_Register_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With3_Register_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With3_Register_Register_MemoryOperand : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; var Memory : TMemoryOperand ) : Boolean; cdecl = nil; + Instruction_With3_Register_i32_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate1 : Integer; Immediate2 : Integer ) : Boolean; cdecl = nil; + Instruction_With3_Register_u32_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With3_Register_MemoryOperand_Register : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Memory : TMemoryOperand; Register2 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With3_Register_MemoryOperand_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With3_Register_MemoryOperand_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With3_MemoryOperand_Register_Register : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Register1 : TRegisterType; Register2 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With3_MemoryOperand_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Register : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With3_MemoryOperand_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Memory : TMemoryOperand; Register : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_Register_Register : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_Register_MemoryOperand : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; var Memory : TMemoryOperand ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_i32_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate1 : Integer; Immediate2 : Integer ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_u32_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_MemoryOperand_Register : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_MemoryOperand_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With4_Register_Register_MemoryOperand_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_Register_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_Register_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_Register_MemoryOperand_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_Register_MemoryOperand_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_MemoryOperand_Register_i32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType; Immediate : Integer ) : Boolean; cdecl = nil; + Instruction_With5_Register_Register_MemoryOperand_Register_u32 : function( const Instruction : TInstruction; Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType; Immediate : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Branch : function( const Instruction : TInstruction; Code : TCodeType; Target : UInt64 ) : Boolean; cdecl = nil; + Instruction_With_Far_Branch : function( const Instruction : TInstruction; Code : TCodeType; Selector : Word; Offset : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_xbegin : function( const Instruction : TInstruction; Bitness : Cardinal; Target : UInt64 ) : Boolean; cdecl = nil; + Instruction_With_outsb : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_outsb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_outsw : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_outsw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_outsd : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_outsd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_lodsb : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_lodsb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_lodsw : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_lodsw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_lodsd : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_lodsd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_lodsq : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_lodsq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_scasb : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_scasb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_scasb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_scasw : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_scasw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_scasw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_scasd : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_scasd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_scasd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_scasq : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_scasq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_scasq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_insb : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_insb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_insw : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_insw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_insd : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_insd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_stosb : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_stosb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_stosw : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_stosw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_stosd : function( const Instruction : TInstruction; AddressSize: Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_stosd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_stosq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_cmpsb : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_cmpsb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_cmpsb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_cmpsw : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_cmpsw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_cmpsw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_cmpsd : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_cmpsd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_cmpsd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_cmpsq : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repe_cmpsq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Repne_cmpsq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_movsb : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_movsb : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_movsw : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_movsw : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_movsd : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_movsd : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_movsq : function( const Instruction : TInstruction; AddressSize: Cardinal; SegmentPrefix : Cardinal; RepPrefix: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Rep_movsq : function( const Instruction : TInstruction; AddressSize: Cardinal ) : Boolean; cdecl = nil; + Instruction_With_maskmovq : function( const Instruction : TInstruction; AddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; SegmentPrefix : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_maskmovdqu : function( const Instruction : TInstruction; AddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; SegmentPrefix : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_vmaskmovdqu : function( const Instruction : TInstruction; AddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; SegmentPrefix : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_1 : function( const Instruction : TInstruction; B0 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_2 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_3 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_4 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_5 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_6 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_7 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_8 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_9 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_10 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_11 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_12 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_13 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_14 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_15 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Byte_16 : function( const Instruction : TInstruction; B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte; B15 : Byte ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_1 : function( const Instruction : TInstruction; W0 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_2 : function( const Instruction : TInstruction; W0 : Word; W1 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_3 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_4 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word; W3 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_5 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_6 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_7 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_Word_8 : function( const Instruction : TInstruction; W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word; W7 : Word ) : Boolean; cdecl = nil; + Instruction_With_Declare_DWord_1 : function( const Instruction : TInstruction; D0 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Declare_DWord_2 : function( const Instruction : TInstruction; D0 : Cardinal; D1 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Declare_DWord_3 : function( const Instruction : TInstruction; D0 : Cardinal; D1 : Cardinal; D2 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Declare_DWord_4 : function( const Instruction : TInstruction; D0 : Cardinal; D1 : Cardinal; D2 : Cardinal; D3 : Cardinal ) : Boolean; cdecl = nil; + Instruction_With_Declare_QWord_1 : function( const Instruction : TInstruction; Q0 : UInt64 ) : Boolean; cdecl = nil; + Instruction_With_Declare_QWord_2 : function( const Instruction : TInstruction; Q0 : UInt64; Q1 : UInt64 ) : Boolean; cdecl = nil; + + Code_AsString : procedure( const Code : TCodeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + Code_Mnemonic : function( const Code : TCodeType ) : TMnemonic; cdecl = nil; + Code_OPCode : procedure( const Code : TCodeType; var Info : TOpCodeInfo ); cdecl = nil; + Code_Encoding : function( const Code : TCodeType ) : TEncodingKind; cdecl = nil; + Code_CPUidFeature : function( const Code : TCodeType; var CPUIDFeatures : TCPUIDFeaturesArray ) : boolean; cdecl = nil; + Code_FlowControl : function( const Code : TCodeType ) : TFlowControl; cdecl = nil; + Code_IsPrivileged : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsStackInstruction : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsSaveRestoreInstruction : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJccShort : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpShort : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpShortOrNear : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpNear : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpFar : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsCallNear : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsCallFar : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpNearIndirect : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJmpFarIndirect : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsCallNearIndirect : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsCallFarIndirect : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_ConditionCode : function( const Code : TCodeType ) : TConditionCode; cdecl = nil; + Code_IsJcxShort : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsLoopCC : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsLoop : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_IsJccShortOrNear : function( const Code : TCodeType ) : Boolean; cdecl = nil; + Code_NegateConditionCode : function( const Code : TCodeType ) : TCode; cdecl = nil; + Code_AsShortBranch : function( const Code : TCodeType ) : TCode; cdecl = nil; + Code_AsNearBranch : function( const Code : TCodeType ) : TCode; cdecl = nil; + + Mnemonic_AsString : procedure( const Mnemonic : TMnemonicType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + OpKind_AsString : procedure( const OpKind : TOpKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + EncodingKind_AsString : procedure( const EncodingKind : TEncodingKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + CPUidFeature_AsString : procedure( const CPUidFeature : TCPUidFeatureType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + ConditionCode_AsString : procedure( const ConditionCode : TConditionCodeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + FlowControl_AsString : procedure( const FlowControl : TFlowControlType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + TupleType_AsString : procedure( const TupleType : TTupleTypeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MvexEHBit_AsString : procedure( const MvexEHBit : TMvexEHBitType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MvexTupleTypeLutKind_AsString : procedure( const MvexTupleTypeLutKind : TMvexTupleTypeLutKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MvexConvFn_AsString : procedure( const MvexConvFn : TMvexConvFnType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MvexRegMemConv_AsString : procedure( const MvexRegMemConv : TMvexRegMemConvType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + RoundingControl_AsString : procedure( const RoundingControl : TRoundingControlType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + NumberBase_AsString : procedure( const NumberBase : TNumberBaseType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + RepPrefixKind_AsString : procedure( const RepPrefixKind : TRepPrefixKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MemorySizeOptions_AsString : procedure( const MemorySizeOptions : TMemorySizeOptionsType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + + MemorySize_AsString : procedure( const MemorySize : TMemorySizeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MemorySize_Info : procedure( const MemorySize : TMemorySizeType; var Info : TMemorySizeInfo ); cdecl = nil; + + OpCodeTableKind_AsString : procedure( const OpCodeTableKind : TOpCodeTableKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + MandatoryPrefix_AsString : procedure( const MandatoryPrefix : TMandatoryPrefixType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + OpCodeOperandKind_AsString : procedure( const OpCodeOperandKind : TOpCodeOperandKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + OpAccess_AsString : procedure( const OpAccess : TOpAccessType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + CodeSize_AsString : procedure( const CodeSize : TCodeSizeType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + FormatterTextKind_AsString : procedure( const FormatterTextKind : TFormatterTextKindType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + + Register_Base : function( const Register: TRegisterType ) : TRegister; cdecl = nil; + Register_Number : function( const Register: TRegisterType ) : NativeUInt; cdecl = nil; + Register_FullRegister : function( const Register: TRegisterType ) : TRegister; cdecl = nil; + Register_FullRegister32 : function( const Register: TRegisterType ) : TRegister; cdecl = nil; + Register_Size : function( const Register: TRegisterType ) : NativeUInt; cdecl = nil; + Register_AsString : procedure( const Register: TRegisterType; Output: PAnsiChar; Size : NativeUInt ); cdecl = nil; + +{$WARNINGS ON} +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +implementation + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +{$DEFINE section_IMPLEMENTATION_USES} +{$I DynamicDLL.inc} +{$UNDEF section_IMPLEMENTATION_USES} +; + +{$DEFINE section_IMPLEMENTATION_INITVAR} +{$I DynamicDLL.inc} +{$UNDEF section_IMPLEMENTATION_INITVAR} + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +procedure PreInitialization; +begin + // Code needed before Init, likely change DLL OS-Dependent +end; + +procedure InitDLL( ID : Byte; StrL : TStringList ); +begin + {$DEFINE section_InitVar} + {$WARNINGS OFF} + + case ID of + 0 : begin + InitVar( @IcedFreeMemory, 'IcedFreeMemory', ID, StrL ); + + // Decoder + InitVar( @Decoder_Create, 'Decoder_Create', ID, StrL ); + InitVar( @Decoder_CanDecode, 'Decoder_CanDecode', ID, StrL ); + InitVar( @Decoder_GetIP, 'Decoder_GetIP', ID, StrL ); + InitVar( @Decoder_SetIP, 'Decoder_SetIP', ID, StrL ); + InitVar( @Decoder_GetBitness, 'Decoder_GetBitness', ID, StrL ); + InitVar( @Decoder_GetMaxPosition, 'Decoder_GetMaxPosition', ID, StrL ); + InitVar( @Decoder_GetPosition, 'Decoder_GetPosition', ID, StrL ); + InitVar( @Decoder_SetPosition, 'Decoder_SetPosition', ID, StrL ); + InitVar( @Decoder_GetLastError, 'Decoder_GetLastError', ID, StrL ); + InitVar( @DecoderError_AsString, 'DecoderError_AsString', ID, StrL ); + InitVar( @Decoder_Decode, 'Decoder_Decode', ID, StrL ); + InitVar( @Decoder_DecodeToEnd, 'Decoder_DecodeToEnd', ID, StrL ); + InitVar( @Decoder_GetConstantOffsets, 'Decoder_GetConstantOffsets', ID, StrL ); + + InitVar( @FormatterOutput_Create, 'FormatterOutput_Create', ID, StrL ); + + // MasmFormatter + InitVar( @MasmFormatter_Create, 'MasmFormatter_Create', ID, StrL ); + InitVar( @MasmFormatter_DecodeFormat, 'MasmFormatter_DecodeFormat', ID, StrL ); + InitVar( @MasmFormatter_DecodeFormatCallback, 'MasmFormatter_DecodeFormatCallback', ID, StrL ); + InitVar( @MasmFormatter_Format, 'MasmFormatter_Format', ID, StrL ); + InitVar( @MasmFormatter_FormatCallback, 'MasmFormatter_FormatCallback', ID, StrL ); + InitVar( @MasmFormatter_DecodeFormatToEnd, 'MasmFormatter_DecodeFormatToEnd', ID, StrL ); + + // NasmFormatter + InitVar( @NasmFormatter_Create, 'NasmFormatter_Create', ID, StrL ); + InitVar( @NasmFormatter_DecodeFormat, 'NasmFormatter_DecodeFormat', ID, StrL ); + InitVar( @NasmFormatter_DecodeFormatCallback, 'NasmFormatter_DecodeFormatCallback', ID, StrL ); + InitVar( @NasmFormatter_Format, 'NasmFormatter_Format', ID, StrL ); + InitVar( @NasmFormatter_FormatCallback, 'NasmFormatter_FormatCallback', ID, StrL ); + InitVar( @NasmFormatter_DecodeFormatToEnd, 'NasmFormatter_DecodeFormatToEnd', ID, StrL ); + + // GasFormatter + InitVar( @GasFormatter_Create, 'GasFormatter_Create', ID, StrL ); + InitVar( @GasFormatter_DecodeFormat, 'GasFormatter_DecodeFormat', ID, StrL ); + InitVar( @GasFormatter_DecodeFormatCallback, 'GasFormatter_DecodeFormatCallback', ID, StrL ); + InitVar( @GasFormatter_Format, 'GasFormatter_Format', ID, StrL ); + InitVar( @GasFormatter_FormatCallback, 'GasFormatter_FormatCallback', ID, StrL ); + InitVar( @GasFormatter_DecodeFormatToEnd, 'GasFormatter_DecodeFormatToEnd', ID, StrL ); + + // IntelFormatter + InitVar( @IntelFormatter_Create, 'IntelFormatter_Create', ID, StrL ); + InitVar( @IntelFormatter_DecodeFormat, 'IntelFormatter_DecodeFormat', ID, StrL ); + InitVar( @IntelFormatter_DecodeFormatCallback, 'IntelFormatter_DecodeFormatCallback', ID, StrL ); + InitVar( @IntelFormatter_Format, 'IntelFormatter_Format', ID, StrL ); + InitVar( @IntelFormatter_FormatCallback, 'IntelFormatter_FormatCallback', ID, StrL ); + InitVar( @IntelFormatter_DecodeFormatToEnd, 'IntelFormatter_DecodeFormatToEnd', ID, StrL ); + + // FastFormatter + InitVar( @FastFormatter_Create, 'FastFormatter_Create', ID, StrL ); + InitVar( @FastFormatter_DecodeFormat, 'FastFormatter_DecodeFormat', ID, StrL ); + InitVar( @FastFormatter_Format, 'FastFormatter_Format', ID, StrL ); + InitVar( @FastFormatter_DecodeFormatToEnd, 'FastFormatter_DecodeFormatToEnd', ID, StrL ); + + // SpecializedFormatter + InitVar( @SpecializedFormatter_Create, 'SpecializedFormatter_Create', ID, StrL ); + InitVar( @SpecializedFormatter_DecodeFormat, 'SpecializedFormatter_DecodeFormat', ID, StrL ); + InitVar( @SpecializedFormatter_Format, 'SpecializedFormatter_Format', ID, StrL ); + InitVar( @SpecializedFormatter_DecodeFormatToEnd, 'SpecializedFormatter_DecodeFormatToEnd', ID, StrL ); + + // Options + InitVar( @SpecializedFormatter_GetAlwaysShowMemorySize, 'SpecializedFormatter_GetAlwaysShowMemorySize', ID, StrL ); + InitVar( @SpecializedFormatter_SetAlwaysShowMemorySize, 'SpecializedFormatter_SetAlwaysShowMemorySize', ID, StrL ); + InitVar( @SpecializedFormatter_GetUseHexPrefix, 'SpecializedFormatter_GetUseHexPrefix', ID, StrL ); + InitVar( @SpecializedFormatter_SetUseHexPrefix, 'SpecializedFormatter_SetUseHexPrefix', ID, StrL ); + + // Formatter Options + InitVar( @Formatter_Format, 'Formatter_Format', ID, StrL ); + InitVar( @Formatter_FormatCallback, 'Formatter_FormatCallback', ID, StrL ); + + InitVar( @Formatter_GetUpperCasePrefixes, 'Formatter_GetUpperCasePrefixes', ID, StrL ); + InitVar( @Formatter_SetUpperCasePrefixes, 'Formatter_SetUpperCasePrefixes', ID, StrL ); + InitVar( @Formatter_GetUpperCaseMnemonics, 'Formatter_GetUpperCaseMnemonics', ID, StrL ); + InitVar( @Formatter_SetUpperCaseMnemonics, 'Formatter_SetUpperCaseMnemonics', ID, StrL ); + InitVar( @Formatter_GetUpperCaseRegisters, 'Formatter_GetUpperCaseRegisters', ID, StrL ); + InitVar( @Formatter_SetUpperCaseRegisters, 'Formatter_SetUpperCaseRegisters', ID, StrL ); + InitVar( @Formatter_GetUpperCaseKeyWords, 'Formatter_GetUpperCaseKeyWords', ID, StrL ); + InitVar( @Formatter_SetUpperCaseKeyWords, 'Formatter_SetUpperCaseKeyWords', ID, StrL ); + InitVar( @Formatter_GetUpperCaseDecorators, 'Formatter_GetUpperCaseDecorators', ID, StrL ); + InitVar( @Formatter_SetUpperCaseDecorators, 'Formatter_SetUpperCaseDecorators', ID, StrL ); + InitVar( @Formatter_GetUpperCaseEverything, 'Formatter_GetUpperCaseEverything', ID, StrL ); + InitVar( @Formatter_SetUpperCaseEverything, 'Formatter_SetUpperCaseEverything', ID, StrL ); + InitVar( @Formatter_GetFirstOperandCharIndex, 'Formatter_GetFirstOperandCharIndex', ID, StrL ); + InitVar( @Formatter_SetFirstOperandCharIndex, 'Formatter_SetFirstOperandCharIndex', ID, StrL ); + InitVar( @Formatter_GetTabSize, 'Formatter_GetTabSize', ID, StrL ); + InitVar( @Formatter_SetTabSize, 'Formatter_SetTabSize', ID, StrL ); + InitVar( @Formatter_GetSpaceAfterOperandSeparator, 'Formatter_GetSpaceAfterOperandSeparator', ID, StrL ); + InitVar( @Formatter_SetSpaceAfterOperandSeparator, 'Formatter_SetSpaceAfterOperandSeparator', ID, StrL ); + InitVar( @Formatter_GetSpaceAfterMemoryBracket, 'Formatter_GetSpaceAfterMemoryBracket', ID, StrL ); + InitVar( @Formatter_SetSpaceAfterMemoryBracket, 'Formatter_SetSpaceAfterMemoryBracket', ID, StrL ); + InitVar( @Formatter_GetSpaceBetweenMemoryAddOperators, 'Formatter_GetSpaceBetweenMemoryAddOperators', ID, StrL ); + InitVar( @Formatter_SetSpaceBetweenMemoryAddOperators, 'Formatter_SetSpaceBetweenMemoryAddOperators', ID, StrL ); + InitVar( @Formatter_GetSpaceBetweenMemoryMulOperators, 'Formatter_GetSpaceBetweenMemoryMulOperators', ID, StrL ); + InitVar( @Formatter_SetSpaceBetweenMemoryMulOperators, 'Formatter_SetSpaceBetweenMemoryMulOperators', ID, StrL ); + InitVar( @Formatter_GetScaleBeforeIndex, 'Formatter_GetScaleBeforeIndex', ID, StrL ); + InitVar( @Formatter_SetScaleBeforeIndex, 'Formatter_SetScaleBeforeIndex', ID, StrL ); + InitVar( @Formatter_GetAlwaysShowScale, 'Formatter_GetAlwaysShowScale', ID, StrL ); + InitVar( @Formatter_SetAlwaysShowScale, 'Formatter_SetAlwaysShowScale', ID, StrL ); + InitVar( @Formatter_GetAlwaysShowSegmentRegister, 'Formatter_GetAlwaysShowSegmentRegister', ID, StrL ); + InitVar( @Formatter_SetAlwaysShowSegmentRegister, 'Formatter_SetAlwaysShowSegmentRegister', ID, StrL ); + InitVar( @Formatter_GetShowZeroDisplacements, 'Formatter_GetShowZeroDisplacements', ID, StrL ); + InitVar( @Formatter_SetShowZeroDisplacements, 'Formatter_SetShowZeroDisplacements', ID, StrL ); + InitVar( @Formatter_GetHexPrefix, 'Formatter_GetHexPrefix', ID, StrL ); + InitVar( @Formatter_SetHexPrefix, 'Formatter_SetHexPrefix', ID, StrL ); + InitVar( @Formatter_GetHexSuffix, 'Formatter_GetHexSuffix', ID, StrL ); + InitVar( @Formatter_SetHexSuffix, 'Formatter_SetHexSuffix', ID, StrL ); + InitVar( @Formatter_GetHexDigitGroupSize, 'Formatter_GetHexDigitGroupSize', ID, StrL ); + InitVar( @Formatter_SetHexDigitGroupSize, 'Formatter_SetHexDigitGroupSize', ID, StrL ); + InitVar( @Formatter_GetDecimalPrefix, 'Formatter_GetDecimalPrefix', ID, StrL ); + InitVar( @Formatter_SetDecimalPrefix, 'Formatter_SetDecimalPrefix', ID, StrL ); + InitVar( @Formatter_GetDecimalSuffix, 'Formatter_GetDecimalSuffix', ID, StrL ); + InitVar( @Formatter_SetDecimalSuffix, 'Formatter_SetDecimalSuffix', ID, StrL ); + InitVar( @Formatter_GetDecimalDigitGroupSize, 'Formatter_GetDecimalDigitGroupSize', ID, StrL ); + InitVar( @Formatter_SetDecimalDigitGroupSize, 'Formatter_SetDecimalDigitGroupSize', ID, StrL ); + InitVar( @Formatter_GetOctalPrefix, 'Formatter_GetOctalPrefix', ID, StrL ); + InitVar( @Formatter_SetOctalPrefix, 'Formatter_SetOctalPrefix', ID, StrL ); + InitVar( @Formatter_GetOctalSuffix, 'Formatter_GetOctalSuffix', ID, StrL ); + InitVar( @Formatter_SetOctalSuffix, 'Formatter_SetOctalSuffix', ID, StrL ); + InitVar( @Formatter_GetOctalDigitGroupSize, 'Formatter_GetOctalDigitGroupSize', ID, StrL ); + InitVar( @Formatter_SetOctalDigitGroupSize, 'Formatter_SetOctalDigitGroupSize', ID, StrL ); + InitVar( @Formatter_GetBinaryPrefix, 'Formatter_GetBinaryPrefix', ID, StrL ); + InitVar( @Formatter_SetBinaryPrefix, 'Formatter_SetBinaryPrefix', ID, StrL ); + InitVar( @Formatter_GetBinarySuffix, 'Formatter_GetBinarySuffix', ID, StrL ); + InitVar( @Formatter_SetBinarySuffix, 'Formatter_SetBinarySuffix', ID, StrL ); + InitVar( @Formatter_GetBinaryDigitGroupSize, 'Formatter_GetBinaryDigitGroupSize', ID, StrL ); + InitVar( @Formatter_SetBinaryDigitGroupSize, 'Formatter_SetBinaryDigitGroupSize', ID, StrL ); + InitVar( @Formatter_GetDigitSeparator, 'Formatter_GetDigitSeparator', ID, StrL ); + InitVar( @Formatter_SetDigitSeparator, 'Formatter_SetDigitSeparator', ID, StrL ); + InitVar( @Formatter_GetLeadingZeros, 'Formatter_GetLeadingZeros', ID, StrL ); + InitVar( @Formatter_SetLeadingZeros, 'Formatter_SetLeadingZeros', ID, StrL ); + InitVar( @Formatter_GetUppercaseHex, 'Formatter_GetUppercaseHex', ID, StrL ); + InitVar( @Formatter_SetUppercaseHex, 'Formatter_SetUppercaseHex', ID, StrL ); + InitVar( @Formatter_GetSmallHexNumbersInDecimal, 'Formatter_GetSmallHexNumbersInDecimal', ID, StrL ); + InitVar( @Formatter_SetSmallHexNumbersInDecimal, 'Formatter_SetSmallHexNumbersInDecimal', ID, StrL ); + InitVar( @Formatter_GetAddLeadingZeroToHexNumbers, 'Formatter_GetAddLeadingZeroToHexNumbers', ID, StrL ); + InitVar( @Formatter_SetAddLeadingZeroToHexNumbers, 'Formatter_SetAddLeadingZeroToHexNumbers', ID, StrL ); + InitVar( @Formatter_GetNumberBase, 'Formatter_GetNumberBase', ID, StrL ); + InitVar( @Formatter_SetNumberBase, 'Formatter_SetNumberBase', ID, StrL ); + InitVar( @Formatter_GetBranchLeadingZeros, 'Formatter_GetBranchLeadingZeros', ID, StrL ); + InitVar( @Formatter_SetBranchLeadingZeros, 'Formatter_SetBranchLeadingZeros', ID, StrL ); + InitVar( @Formatter_GetSignedImmediateOperands, 'Formatter_GetSignedImmediateOperands', ID, StrL ); + InitVar( @Formatter_SetSignedImmediateOperands, 'Formatter_SetSignedImmediateOperands', ID, StrL ); + InitVar( @Formatter_GetSignedMemoryDisplacements, 'Formatter_GetSignedMemoryDisplacements', ID, StrL ); + InitVar( @Formatter_SetSignedMemoryDisplacements, 'Formatter_SetSignedMemoryDisplacements', ID, StrL ); + InitVar( @Formatter_GetDisplacementLeadingZeros, 'Formatter_GetDisplacementLeadingZeros', ID, StrL ); + InitVar( @Formatter_SetDisplacementLeadingZeros, 'Formatter_SetDisplacementLeadingZeros', ID, StrL ); + InitVar( @Formatter_GetMemorySizeOptions, 'Formatter_GetMemorySizeOptions', ID, StrL ); + InitVar( @Formatter_SetMemorySizeOptions, 'Formatter_SetMemorySizeOptions', ID, StrL ); + InitVar( @Formatter_GetRipRelativeAddresses, 'Formatter_GetRipRelativeAddresses', ID, StrL ); + InitVar( @Formatter_SetRipRelativeAddresses, 'Formatter_SetRipRelativeAddresses', ID, StrL ); + InitVar( @Formatter_GetShowBranchSize, 'Formatter_GetShowBranchSize', ID, StrL ); + InitVar( @Formatter_SetShowBranchSize, 'Formatter_SetShowBranchSize', ID, StrL ); + InitVar( @Formatter_GetUsePseudoOps, 'Formatter_GetUsePseudoOps', ID, StrL ); + InitVar( @Formatter_SetUsePseudoOps, 'Formatter_SetUsePseudoOps', ID, StrL ); + InitVar( @Formatter_GetShowSymbolAddress, 'Formatter_GetShowSymbolAddress', ID, StrL ); + InitVar( @Formatter_SetShowSymbolAddress, 'Formatter_SetShowSymbolAddress', ID, StrL ); + InitVar( @GasFormatter_GetNakedRegisters, 'GasFormatter_GetNakedRegisters', ID, StrL ); + InitVar( @GasFormatter_SetNakedRegisters, 'GasFormatter_SetNakedRegisters', ID, StrL ); + InitVar( @GasFormatter_GetShowMnemonicSizeSuffix, 'GasFormatter_GetShowMnemonicSizeSuffix', ID, StrL ); + InitVar( @GasFormatter_SetShowMnemonicSizeSuffix, 'GasFormatter_SetShowMnemonicSizeSuffix', ID, StrL ); + InitVar( @GasFormatter_GetSpaceAfterMemoryOperandComma, 'GasFormatter_GetSpaceAfterMemoryOperandComma', ID, StrL ); + InitVar( @GasFormatter_SetSpaceAfterMemoryOperandComma, 'GasFormatter_SetSpaceAfterMemoryOperandComma', ID, StrL ); + InitVar( @MasmFormatter_GetAddDsPrefix32, 'MasmFormatter_GetAddDsPrefix32', ID, StrL ); + InitVar( @MasmFormatter_SetAddDsPrefix32, 'MasmFormatter_SetAddDsPrefix32', ID, StrL ); + InitVar( @MasmFormatter_GetSymbolDisplacementInBrackets, 'MasmFormatter_GetSymbolDisplacementInBrackets', ID, StrL ); + InitVar( @MasmFormatter_SetSymbolDisplacementInBrackets, 'MasmFormatter_SetSymbolDisplacementInBrackets', ID, StrL ); + InitVar( @MasmFormatter_GetDisplacementInBrackets, 'MasmFormatter_GetDisplacementInBrackets', ID, StrL ); + InitVar( @MasmFormatter_SetDisplacementInBrackets, 'MasmFormatter_SetDisplacementInBrackets', ID, StrL ); + InitVar( @NasmFormatter_GetShowSignExtendedImmediateSize, 'NasmFormatter_GetShowSignExtendedImmediateSize', ID, StrL ); + InitVar( @NasmFormatter_SetShowSignExtendedImmediateSize, 'NasmFormatter_SetShowSignExtendedImmediateSize', ID, StrL ); + InitVar( @Formatter_GetPreferST0, 'Formatter_GetPreferST0', ID, StrL ); + InitVar( @Formatter_SetPreferST0, 'Formatter_SetPreferST0', ID, StrL ); + InitVar( @Formatter_GetShowUselessPrefixes, 'Formatter_GetShowUselessPrefixes', ID, StrL ); + InitVar( @Formatter_SetShowUselessPrefixes, 'Formatter_SetShowUselessPrefixes', ID, StrL ); + InitVar( @Formatter_GetCC_b, 'Formatter_GetCC_b', ID, StrL ); + InitVar( @Formatter_SetCC_b, 'Formatter_SetCC_b', ID, StrL ); + InitVar( @Formatter_GetCC_ae, 'Formatter_GetCC_ae', ID, StrL ); + InitVar( @Formatter_SetCC_ae, 'Formatter_SetCC_ae', ID, StrL ); + InitVar( @Formatter_GetCC_e, 'Formatter_GetCC_e', ID, StrL ); + InitVar( @Formatter_SetCC_e, 'Formatter_SetCC_e', ID, StrL ); + InitVar( @Formatter_GetCC_ne, 'Formatter_GetCC_ne', ID, StrL ); + InitVar( @Formatter_SetCC_ne, 'Formatter_SetCC_ne', ID, StrL ); + InitVar( @Formatter_GetCC_be, 'Formatter_GetCC_be', ID, StrL ); + InitVar( @Formatter_SetCC_be, 'Formatter_SetCC_be', ID, StrL ); + InitVar( @Formatter_GetCC_a, 'Formatter_GetCC_a', ID, StrL ); + InitVar( @Formatter_SetCC_a, 'Formatter_SetCC_a', ID, StrL ); + InitVar( @Formatter_GetCC_p, 'Formatter_GetCC_p', ID, StrL ); + InitVar( @Formatter_SetCC_p, 'Formatter_SetCC_p', ID, StrL ); + InitVar( @Formatter_GetCC_np, 'Formatter_GetCC_np', ID, StrL ); + InitVar( @Formatter_SetCC_np, 'Formatter_SetCC_np', ID, StrL ); + InitVar( @Formatter_GetCC_l, 'Formatter_GetCC_l', ID, StrL ); + InitVar( @Formatter_SetCC_l, 'Formatter_SetCC_l', ID, StrL ); + InitVar( @Formatter_GetCC_ge, 'Formatter_GetCC_ge', ID, StrL ); + InitVar( @Formatter_SetCC_ge, 'Formatter_SetCC_ge', ID, StrL ); + InitVar( @Formatter_GetCC_le, 'Formatter_GetCC_le', ID, StrL ); + InitVar( @Formatter_SetCC_le, 'Formatter_SetCC_le', ID, StrL ); + InitVar( @Formatter_GetCC_g, 'Formatter_GetCC_g', ID, StrL ); + InitVar( @Formatter_SetCC_g, 'Formatter_SetCC_g', ID, StrL ); + + // Encoder + InitVar( @Encoder_Create, 'Encoder_Create', ID, StrL ); + InitVar( @Encoder_Encode, 'Encoder_Encode', ID, StrL ); + InitVar( @Encoder_WriteByte, 'Encoder_WriteByte', ID, StrL ); + InitVar( @Encoder_GetBuffer, 'Encoder_GetBuffer', ID, StrL ); +// InitVar( @Encoder_SetBuffer, 'Encoder_SetBuffer', ID, StrL ); + InitVar( @Encoder_GetConstantOffsets, 'Encoder_GetConstantOffsets', ID, StrL ); + InitVar( @Encoder_GetPreventVex2, 'Encoder_GetPreventVex2', ID, StrL ); + InitVar( @Encoder_SetPreventVex2, 'Encoder_SetPreventVex2', ID, StrL ); + InitVar( @Encoder_GetVexWig, 'Encoder_GetVexWig', ID, StrL ); + InitVar( @Encoder_SetVexWig, 'Encoder_SetVexWig', ID, StrL ); + InitVar( @Encoder_GetVexLig, 'Encoder_GetVexLig', ID, StrL ); + InitVar( @Encoder_SetVexLig, 'Encoder_SetVexLig', ID, StrL ); + InitVar( @Encoder_GetEvexWig, 'Encoder_GetEvexWig', ID, StrL ); + InitVar( @Encoder_SetEvexWig, 'Encoder_SetEvexWig', ID, StrL ); + InitVar( @Encoder_GetEvexLig, 'Encoder_GetEvexLig', ID, StrL ); + InitVar( @Encoder_SetEvexLig, 'Encoder_SetEvexLig', ID, StrL ); + InitVar( @Encoder_GetMvexWig, 'Encoder_GetMvexWig', ID, StrL ); + InitVar( @Encoder_SetMvexWig, 'Encoder_SetMvexWig', ID, StrL ); + InitVar( @Encoder_GetBitness, 'Encoder_GetBitness', ID, StrL ); + + InitVar( @BlockEncoder, 'BlockEncoder', ID, StrL ); + + // Instruction + InitVar( @Instruction_StackPointerIncrement, 'Instruction_StackPointerIncrement', ID, StrL ); + InitVar( @Instruction_RFlagsRead, 'Instruction_RFlagsRead', ID, StrL ); + InitVar( @Instruction_RFlagsWritten, 'Instruction_RFlagsWritten', ID, StrL ); + InitVar( @Instruction_RFlagsCleared, 'Instruction_RFlagsCleared', ID, StrL ); + InitVar( @Instruction_RFlagsSet, 'Instruction_RFlagsSet', ID, StrL ); + InitVar( @Instruction_RFlagsUndefined, 'Instruction_RFlagsUndefined', ID, StrL ); + InitVar( @Instruction_RFlagsModified, 'Instruction_RFlagsModified', ID, StrL ); + + InitVar( @Instruction_FPU_StackIncrementInfo, 'Instruction_FPU_StackIncrementInfo', ID, StrL ); + InitVar( @Instruction_OPKinds, 'Instruction_OPKinds', ID, StrL ); + InitVar( @Instruction_MemorySize, 'Instruction_MemorySize', ID, StrL ); + InitVar( @Instruction_OPCount, 'Instruction_OPCount', ID, StrL ); + InitVar( @Instruction_VirtualAddress, 'Instruction_VirtualAddress', ID, StrL ); + InitVar( @Instruction_IsMvexEvictionHint, 'Instruction_IsMvexEvictionHint', ID, StrL ); + InitVar( @Instruction_MvexRegMemConv, 'Instruction_MvexRegMemConv', ID, StrL ); + + InitVar( @InstructionInfoFactory_Create, 'InstructionInfoFactory_Create', ID, StrL ); + InitVar( @InstructionInfoFactory_Info, 'InstructionInfoFactory_Info', ID, StrL ); + + // Instruction + InitVar( @Instruction_With, 'Instruction_With', ID, StrL ); + InitVar( @Instruction_With1_Register, 'Instruction_With1_Register', ID, StrL ); + InitVar( @Instruction_With1_i32, 'Instruction_With1_i32', ID, StrL ); + InitVar( @Instruction_With1_u32, 'Instruction_With1_u32', ID, StrL ); + InitVar( @Instruction_With1_Memory, 'Instruction_With1_Memory', ID, StrL ); + InitVar( @Instruction_With2_Register_Register, 'Instruction_With2_Register_Register', ID, StrL ); + InitVar( @Instruction_With2_Register_i32, 'Instruction_With2_Register_i32', ID, StrL ); + InitVar( @Instruction_With2_Register_u32, 'Instruction_With2_Register_u32', ID, StrL ); + InitVar( @Instruction_With2_Register_i64, 'Instruction_With2_Register_i64', ID, StrL ); + InitVar( @Instruction_With2_Register_u64, 'Instruction_With2_Register_u64', ID, StrL ); + InitVar( @Instruction_With2_Register_MemoryOperand, 'Instruction_With2_Register_MemoryOperand', ID, StrL ); + InitVar( @Instruction_With2_i32_Register, 'Instruction_With2_i32_Register', ID, StrL ); + InitVar( @Instruction_With2_u32_Register, 'Instruction_With2_u32_Register', ID, StrL ); + InitVar( @Instruction_With2_i32_i32, 'Instruction_With2_i32_i32', ID, StrL ); + InitVar( @Instruction_With2_u32_u32, 'Instruction_With2_u32_u32', ID, StrL ); + InitVar( @Instruction_With2_MemoryOperand_Register, 'Instruction_With2_MemoryOperand_Register', ID, StrL ); + InitVar( @Instruction_With2_MemoryOperand_i32, 'Instruction_With2_MemoryOperand_i32', ID, StrL ); + InitVar( @Instruction_With2_MemoryOperand_u32, 'Instruction_With2_MemoryOperand_u32', ID, StrL ); + InitVar( @Instruction_With3_Register_Register_Register, 'Instruction_With3_Register_Register_Register', ID, StrL ); + InitVar( @Instruction_With3_Register_Register_i32, 'Instruction_With3_Register_Register_i32', ID, StrL ); + InitVar( @Instruction_With3_Register_Register_u32, 'Instruction_With3_Register_Register_u32', ID, StrL ); + InitVar( @Instruction_With3_Register_Register_MemoryOperand, 'Instruction_With3_Register_Register_MemoryOperand', ID, StrL ); + InitVar( @Instruction_With3_Register_i32_i32, 'Instruction_With3_Register_i32_i32', ID, StrL ); + InitVar( @Instruction_With3_Register_u32_u32, 'Instruction_With3_Register_u32_u32', ID, StrL ); + InitVar( @Instruction_With3_Register_MemoryOperand_Register, 'Instruction_With3_Register_MemoryOperand_Register', ID, StrL ); + InitVar( @Instruction_With3_Register_MemoryOperand_i32, 'Instruction_With3_Register_MemoryOperand_i32', ID, StrL ); + InitVar( @Instruction_With3_Register_MemoryOperand_u32, 'Instruction_With3_Register_MemoryOperand_u32', ID, StrL ); + InitVar( @Instruction_With3_MemoryOperand_Register_Register, 'Instruction_With3_MemoryOperand_Register_Register', ID, StrL ); + InitVar( @Instruction_With3_MemoryOperand_Register_i32, 'Instruction_With3_MemoryOperand_Register_i32', ID, StrL ); + InitVar( @Instruction_With3_MemoryOperand_Register_u32, 'Instruction_With3_MemoryOperand_Register_u32', ID, StrL ); + InitVar( @Instruction_With4_Register_Register_Register_Register, 'Instruction_With4_Register_Register_Register_Register', ID, StrL ); + InitVar( @Instruction_With4_Register_Register_Register_i32, 'Instruction_With4_Register_Register_Register_i32', ID, StrL ); + InitVar( @Instruction_With4_Register_Register_Register_u32, 'Instruction_With4_Register_Register_Register_u32', ID, StrL ); + InitVar( @Instruction_With4_Register_Register_Register_MemoryOperand, 'Instruction_With4_Register_Register_Register_MemoryOperand', ID, StrL ); + InitVar( @Instruction_With4_Register_Register_i32_i32, 'Instruction_With4_Register_Register_i32_i32', ID, StrL ); + InitVar( @Instruction_With4_Register_Register_u32_u32, 'Instruction_With4_Register_Register_u32_u32', ID, StrL ); + InitVar( @Instruction_With4_Register_Register_MemoryOperand_Register, 'Instruction_With4_Register_Register_MemoryOperand_Register', ID, StrL ); + InitVar( @Instruction_With4_Register_Register_MemoryOperand_i32, 'Instruction_With4_Register_Register_MemoryOperand_i32', ID, StrL ); + InitVar( @Instruction_With4_Register_Register_MemoryOperand_u32, 'Instruction_With4_Register_Register_MemoryOperand_u32', ID, StrL ); + InitVar( @Instruction_With5_Register_Register_Register_Register_i32, 'Instruction_With5_Register_Register_Register_Register_i32', ID, StrL ); + InitVar( @Instruction_With5_Register_Register_Register_Register_u32, 'Instruction_With5_Register_Register_Register_Register_u32', ID, StrL ); + InitVar( @Instruction_With5_Register_Register_Register_MemoryOperand_i32, 'Instruction_With5_Register_Register_Register_MemoryOperand_i32', ID, StrL ); + InitVar( @Instruction_With5_Register_Register_Register_MemoryOperand_u32, 'Instruction_With5_Register_Register_Register_MemoryOperand_u32', ID, StrL ); + InitVar( @Instruction_With5_Register_Register_MemoryOperand_Register_i32, 'Instruction_With5_Register_Register_MemoryOperand_Register_i32', ID, StrL ); + InitVar( @Instruction_With5_Register_Register_MemoryOperand_Register_u32, 'Instruction_With5_Register_Register_MemoryOperand_Register_u32', ID, StrL ); + InitVar( @Instruction_With_Branch, 'Instruction_With_Branch', ID, StrL ); + InitVar( @Instruction_With_Far_Branch, 'Instruction_With_Far_Branch', ID, StrL ); + InitVar( @Instruction_With_xbegin, 'Instruction_With_xbegin', ID, StrL ); + InitVar( @Instruction_With_outsb, 'Instruction_With_outsb', ID, StrL ); + InitVar( @Instruction_With_Rep_outsb, 'Instruction_With_Rep_outsb', ID, StrL ); + InitVar( @Instruction_With_outsw, 'Instruction_With_outsw', ID, StrL ); + InitVar( @Instruction_With_Rep_outsw, 'Instruction_With_Rep_outsw', ID, StrL ); + InitVar( @Instruction_With_outsd, 'Instruction_With_outsd', ID, StrL ); + InitVar( @Instruction_With_Rep_outsd, 'Instruction_With_Rep_outsd', ID, StrL ); + InitVar( @Instruction_With_lodsb, 'Instruction_With_lodsb', ID, StrL ); + InitVar( @Instruction_With_Rep_lodsb, 'Instruction_With_Rep_lodsb', ID, StrL ); + InitVar( @Instruction_With_lodsw, 'Instruction_With_lodsw', ID, StrL ); + InitVar( @Instruction_With_Rep_lodsw, 'Instruction_With_Rep_lodsw', ID, StrL ); + InitVar( @Instruction_With_lodsd, 'Instruction_With_lodsd', ID, StrL ); + InitVar( @Instruction_With_Rep_lodsd, 'Instruction_With_Rep_lodsd', ID, StrL ); + InitVar( @Instruction_With_lodsq, 'Instruction_With_lodsq', ID, StrL ); + InitVar( @Instruction_With_Rep_lodsq, 'Instruction_With_Rep_lodsq', ID, StrL ); + InitVar( @Instruction_With_scasb, 'Instruction_With_scasb', ID, StrL ); + InitVar( @Instruction_With_Repe_scasb, 'Instruction_With_Repe_scasb', ID, StrL ); + InitVar( @Instruction_With_Repne_scasb, 'Instruction_With_Repne_scasb', ID, StrL ); + InitVar( @Instruction_With_scasw, 'Instruction_With_scasw', ID, StrL ); + InitVar( @Instruction_With_Repe_scasw, 'Instruction_With_Repe_scasw', ID, StrL ); + InitVar( @Instruction_With_Repne_scasw, 'Instruction_With_Repne_scasw', ID, StrL ); + InitVar( @Instruction_With_scasd, 'Instruction_With_scasd', ID, StrL ); + InitVar( @Instruction_With_Repe_scasd, 'Instruction_With_Repe_scasd', ID, StrL ); + InitVar( @Instruction_With_Repne_scasd, 'Instruction_With_Repne_scasd', ID, StrL ); + InitVar( @Instruction_With_scasq, 'Instruction_With_scasq', ID, StrL ); + InitVar( @Instruction_With_Repe_scasq, 'Instruction_With_Repe_scasq', ID, StrL ); + InitVar( @Instruction_With_Repne_scasq, 'Instruction_With_Repne_scasq', ID, StrL ); + InitVar( @Instruction_With_insb, 'Instruction_With_insb', ID, StrL ); + InitVar( @Instruction_With_Rep_insb, 'Instruction_With_Rep_insb', ID, StrL ); + InitVar( @Instruction_With_insw, 'Instruction_With_insw', ID, StrL ); + InitVar( @Instruction_With_Rep_insw, 'Instruction_With_Rep_insw', ID, StrL ); + InitVar( @Instruction_With_insd, 'Instruction_With_insd', ID, StrL ); + InitVar( @Instruction_With_Rep_insd, 'Instruction_With_Rep_insd', ID, StrL ); + InitVar( @Instruction_With_stosb, 'Instruction_With_stosb', ID, StrL ); + InitVar( @Instruction_With_Rep_stosb, 'Instruction_With_Rep_stosb', ID, StrL ); + InitVar( @Instruction_With_stosw, 'Instruction_With_stosw', ID, StrL ); + InitVar( @Instruction_With_Rep_stosw, 'Instruction_With_Rep_stosw', ID, StrL ); + InitVar( @Instruction_With_stosd, 'Instruction_With_stosd', ID, StrL ); + InitVar( @Instruction_With_Rep_stosd, 'Instruction_With_Rep_stosd', ID, StrL ); + InitVar( @Instruction_With_Rep_stosq, 'Instruction_With_Rep_stosq', ID, StrL ); + InitVar( @Instruction_With_cmpsb, 'Instruction_With_cmpsb', ID, StrL ); + InitVar( @Instruction_With_Repe_cmpsb, 'Instruction_With_Repe_cmpsb', ID, StrL ); + InitVar( @Instruction_With_Repne_cmpsb, 'Instruction_With_Repne_cmpsb', ID, StrL ); + InitVar( @Instruction_With_cmpsw, 'Instruction_With_cmpsw', ID, StrL ); + InitVar( @Instruction_With_Repe_cmpsw, 'Instruction_With_Repe_cmpsw', ID, StrL ); + InitVar( @Instruction_With_Repne_cmpsw, 'Instruction_With_Repne_cmpsw', ID, StrL ); + InitVar( @Instruction_With_cmpsd, 'Instruction_With_cmpsd', ID, StrL ); + InitVar( @Instruction_With_Repe_cmpsd, 'Instruction_With_Repe_cmpsd', ID, StrL ); + InitVar( @Instruction_With_Repne_cmpsd, 'Instruction_With_Repne_cmpsd', ID, StrL ); + InitVar( @Instruction_With_cmpsq, 'Instruction_With_cmpsq', ID, StrL ); + InitVar( @Instruction_With_Repe_cmpsq, 'Instruction_With_Repe_cmpsq', ID, StrL ); + InitVar( @Instruction_With_Repne_cmpsq, 'Instruction_With_Repne_cmpsq', ID, StrL ); + InitVar( @Instruction_With_movsb, 'Instruction_With_movsb', ID, StrL ); + InitVar( @Instruction_With_Rep_movsb, 'Instruction_With_Rep_movsb', ID, StrL ); + InitVar( @Instruction_With_movsw, 'Instruction_With_movsw', ID, StrL ); + InitVar( @Instruction_With_Rep_movsw, 'Instruction_With_Rep_movsw', ID, StrL ); + InitVar( @Instruction_With_movsd, 'Instruction_With_movsd', ID, StrL ); + InitVar( @Instruction_With_Rep_movsd, 'Instruction_With_Rep_movsd', ID, StrL ); + InitVar( @Instruction_With_movsq, 'Instruction_With_movsq', ID, StrL ); + InitVar( @Instruction_With_Rep_movsq, 'Instruction_With_Rep_movsq', ID, StrL ); + InitVar( @Instruction_With_maskmovq, 'Instruction_With_maskmovq', ID, StrL ); + InitVar( @Instruction_With_maskmovdqu, 'Instruction_With_maskmovdqu', ID, StrL ); + InitVar( @Instruction_With_vmaskmovdqu, 'Instruction_With_vmaskmovdqu', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_1, 'Instruction_With_Declare_Byte_1', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_2, 'Instruction_With_Declare_Byte_2', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_3, 'Instruction_With_Declare_Byte_3', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_4, 'Instruction_With_Declare_Byte_4', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_5, 'Instruction_With_Declare_Byte_5', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_6, 'Instruction_With_Declare_Byte_6', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_7, 'Instruction_With_Declare_Byte_7', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_8, 'Instruction_With_Declare_Byte_8', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_9, 'Instruction_With_Declare_Byte_9', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_10, 'Instruction_With_Declare_Byte_10', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_11, 'Instruction_With_Declare_Byte_11', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_12, 'Instruction_With_Declare_Byte_12', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_13, 'Instruction_With_Declare_Byte_13', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_14, 'Instruction_With_Declare_Byte_14', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_15, 'Instruction_With_Declare_Byte_15', ID, StrL ); + InitVar( @Instruction_With_Declare_Byte_16, 'Instruction_With_Declare_Byte_16', ID, StrL ); + InitVar( @Instruction_With_Declare_Word_1, 'Instruction_With_Declare_Word_1', ID, StrL ); + InitVar( @Instruction_With_Declare_Word_2, 'Instruction_With_Declare_Word_2', ID, StrL ); + InitVar( @Instruction_With_Declare_Word_3, 'Instruction_With_Declare_Word_3', ID, StrL ); + InitVar( @Instruction_With_Declare_Word_4, 'Instruction_With_Declare_Word_4', ID, StrL ); + InitVar( @Instruction_With_Declare_Word_5, 'Instruction_With_Declare_Word_5', ID, StrL ); + InitVar( @Instruction_With_Declare_Word_6, 'Instruction_With_Declare_Word_6', ID, StrL ); + InitVar( @Instruction_With_Declare_Word_7, 'Instruction_With_Declare_Word_7', ID, StrL ); + InitVar( @Instruction_With_Declare_Word_8, 'Instruction_With_Declare_Word_8', ID, StrL ); + InitVar( @Instruction_With_Declare_DWord_1, 'Instruction_With_Declare_DWord_1', ID, StrL ); + InitVar( @Instruction_With_Declare_DWord_2, 'Instruction_With_Declare_DWord_2', ID, StrL ); + InitVar( @Instruction_With_Declare_DWord_3, 'Instruction_With_Declare_DWord_3', ID, StrL ); + InitVar( @Instruction_With_Declare_DWord_4, 'Instruction_With_Declare_DWord_4', ID, StrL ); + InitVar( @Instruction_With_Declare_QWord_1, 'Instruction_With_Declare_QWord_1', ID, StrL ); + InitVar( @Instruction_With_Declare_QWord_2, 'Instruction_With_Declare_QWord_2', ID, StrL ); + + InitVar( @OpCodeInfo_OpCodeString, 'OpCodeInfo_OpCodeString', ID, StrL ); + InitVar( @OpCodeInfo_InstructionString, 'OpCodeInfo_InstructionString', ID, StrL ); + InitVar( @OpCodeInfo_Mode16, 'OpCodeInfo_Mode16', ID, StrL ); + InitVar( @OpCodeInfo_Mode32, 'OpCodeInfo_Mode32', ID, StrL ); + InitVar( @OpCodeInfo_Mode64, 'OpCodeInfo_Mode64', ID, StrL ); + InitVar( @OpCodeInfo_Fwait, 'OpCodeInfo_Fwait', ID, StrL ); + InitVar( @OpCodeInfo_W, 'OpCodeInfo_W', ID, StrL ); + InitVar( @OpCodeInfo_IsLig, 'OpCodeInfo_IsLig', ID, StrL ); + InitVar( @OpCodeInfo_IsWig, 'OpCodeInfo_IsWig', ID, StrL ); + InitVar( @OpCodeInfo_IsWig32, 'OpCodeInfo_IsWig32', ID, StrL ); + InitVar( @OpCodeInfo_MvexEhBit, 'OpCodeInfo_MvexEhBit', ID, StrL ); + InitVar( @OpCodeInfo_MvexCanUseEvictionHint, 'OpCodeInfo_MvexCanUseEvictionHint', ID, StrL ); + InitVar( @OpCodeInfo_MvexCanUseImmRoundingControl, 'OpCodeInfo_MvexCanUseImmRoundingControl', ID, StrL ); + InitVar( @OpCodeInfo_MvexIgnoresOpMaskRegister, 'OpCodeInfo_MvexIgnoresOpMaskRegister', ID, StrL ); + InitVar( @OpCodeInfo_MvexNoSaeRc, 'OpCodeInfo_MvexNoSaeRc', ID, StrL ); + InitVar( @OpCodeInfo_MvexTupleTypeLutKind, 'OpCodeInfo_MvexTupleTypeLutKind', ID, StrL ); + InitVar( @OpCodeInfo_MvexConversionFunc, 'OpCodeInfo_MvexConversionFunc', ID, StrL ); + InitVar( @OpCodeInfo_MvexValidConversionFuncsMask, 'OpCodeInfo_MvexValidConversionFuncsMask', ID, StrL ); + InitVar( @OpCodeInfo_MvexValidSwizzleFuncsMask, 'OpCodeInfo_MvexValidSwizzleFuncsMask', ID, StrL ); + InitVar( @OpCodeInfo_MemorySize, 'OpCodeInfo_MemorySize', ID, StrL ); + InitVar( @OpCodeInfo_BroadcastMemorySize, 'OpCodeInfo_BroadcastMemorySize', ID, StrL ); + InitVar( @OpCodeInfo_CanBroadcast, 'OpCodeInfo_CanBroadcast', ID, StrL ); + InitVar( @OpCodeInfo_CanUseRoundingControl, 'OpCodeInfo_CanUseRoundingControl', ID, StrL ); + InitVar( @OpCodeInfo_CanSuppressAllExceptions, 'OpCodeInfo_CanSuppressAllExceptions', ID, StrL ); + InitVar( @OpCodeInfo_CanUseOpMaskRegister, 'OpCodeInfo_CanUseOpMaskRegister', ID, StrL ); + InitVar( @OpCodeInfo_RequireOpMaskRegister, 'OpCodeInfo_RequireOpMaskRegister', ID, StrL ); + InitVar( @OpCodeInfo_CanUseZeroingMasking, 'OpCodeInfo_CanUseZeroingMasking', ID, StrL ); + InitVar( @OpCodeInfo_CanUseLockPrefix, 'OpCodeInfo_CanUseLockPrefix', ID, StrL ); + InitVar( @OpCodeInfo_CanUseXacquirePrefix, 'OpCodeInfo_CanUseXacquirePrefix', ID, StrL ); + InitVar( @OpCodeInfo_CanUseXreleasePrefix, 'OpCodeInfo_CanUseXreleasePrefix', ID, StrL ); + InitVar( @OpCodeInfo_CanUseRepPrefix, 'OpCodeInfo_CanUseRepPrefix', ID, StrL ); + InitVar( @OpCodeInfo_CanUseRepnePrefix, 'OpCodeInfo_CanUseRepnePrefix', ID, StrL ); + InitVar( @OpCodeInfo_CanUseBndPrefix, 'OpCodeInfo_CanUseBndPrefix', ID, StrL ); + InitVar( @OpCodeInfo_CanUseHintTakenPrefix, 'OpCodeInfo_CanUseHintTakenPrefix', ID, StrL ); + InitVar( @OpCodeInfo_CanUseNotrackPrefix, 'OpCodeInfo_CanUseNotrackPrefix', ID, StrL ); + InitVar( @OpCodeInfo_IgnoresRoundingControl, 'OpCodeInfo_IgnoresRoundingControl', ID, StrL ); + InitVar( @OpCodeInfo_AmdLockRegBit, 'OpCodeInfo_AmdLockRegBit', ID, StrL ); + InitVar( @OpCodeInfo_DefaultOpSize64, 'OpCodeInfo_DefaultOpSize64', ID, StrL ); + InitVar( @OpCodeInfo_ForceOpSize64, 'OpCodeInfo_ForceOpSize64', ID, StrL ); + InitVar( @OpCodeInfo_IntelForceOpSize64, 'OpCodeInfo_IntelForceOpSize64', ID, StrL ); + InitVar( @OpCodeInfo_MustBeCpl0, 'OpCodeInfo_MustBeCpl0', ID, StrL ); + InitVar( @OpCodeInfo_Cpl0, 'OpCodeInfo_Cpl0', ID, StrL ); + InitVar( @OpCodeInfo_Cpl1, 'OpCodeInfo_Cpl1', ID, StrL ); + InitVar( @OpCodeInfo_Cpl2, 'OpCodeInfo_Cpl2', ID, StrL ); + InitVar( @OpCodeInfo_Cpl3, 'OpCodeInfo_Cpl3', ID, StrL ); + InitVar( @OpCodeInfo_IsInputOutput, 'OpCodeInfo_IsInputOutput', ID, StrL ); + InitVar( @OpCodeInfo_IsNop, 'OpCodeInfo_IsNop', ID, StrL ); + InitVar( @OpCodeInfo_IsReservedNop, 'OpCodeInfo_IsReservedNop', ID, StrL ); + InitVar( @OpCodeInfo_IsSerializingIntel, 'OpCodeInfo_IsSerializingIntel', ID, StrL ); + InitVar( @OpCodeInfo_IsSerializingAmd, 'OpCodeInfo_IsSerializingAmd', ID, StrL ); + InitVar( @OpCodeInfo_MayRequireCpl0, 'OpCodeInfo_MayRequireCpl0', ID, StrL ); + InitVar( @OpCodeInfo_IsCetTracked, 'OpCodeInfo_IsCetTracked', ID, StrL ); + InitVar( @OpCodeInfo_IsNonTemporal, 'OpCodeInfo_IsNonTemporal', ID, StrL ); + InitVar( @OpCodeInfo_IsFpuNoWait, 'OpCodeInfo_IsFpuNoWait', ID, StrL ); + InitVar( @OpCodeInfo_IgnoresModBits, 'OpCodeInfo_IgnoresModBits', ID, StrL ); + InitVar( @OpCodeInfo_No66, 'OpCodeInfo_No66', ID, StrL ); + InitVar( @OpCodeInfo_Nfx, 'OpCodeInfo_Nfx', ID, StrL ); + InitVar( @OpCodeInfo_RequiresUniqueRegNums, 'OpCodeInfo_RequiresUniqueRegNums', ID, StrL ); + InitVar( @OpCodeInfo_RequiresUniqueDestRegNum, 'OpCodeInfo_RequiresUniqueDestRegNum', ID, StrL ); + InitVar( @OpCodeInfo_IsPrivileged, 'OpCodeInfo_IsPrivileged', ID, StrL ); + InitVar( @OpCodeInfo_IsSaveRestore, 'OpCodeInfo_IsSaveRestore', ID, StrL ); + InitVar( @OpCodeInfo_IsStackInstruction, 'OpCodeInfo_IsStackInstruction', ID, StrL ); + InitVar( @OpCodeInfo_IgnoresSegment, 'OpCodeInfo_IgnoresSegment', ID, StrL ); + InitVar( @OpCodeInfo_IsOpMaskReadWrite, 'OpCodeInfo_IsOpMaskReadWrite', ID, StrL ); + InitVar( @OpCodeInfo_RealMode, 'OpCodeInfo_RealMode', ID, StrL ); + InitVar( @OpCodeInfo_ProtectedMode, 'OpCodeInfo_ProtectedMode', ID, StrL ); + InitVar( @OpCodeInfo_Virtual8086Mode, 'OpCodeInfo_Virtual8086Mode', ID, StrL ); + InitVar( @OpCodeInfo_CompatibilityMode, 'OpCodeInfo_CompatibilityMode', ID, StrL ); + InitVar( @OpCodeInfo_LongMode, 'OpCodeInfo_LongMode', ID, StrL ); + InitVar( @OpCodeInfo_UseOutsideSmm, 'OpCodeInfo_UseOutsideSmm', ID, StrL ); + InitVar( @OpCodeInfo_UseInSmm, 'OpCodeInfo_UseInSmm', ID, StrL ); + InitVar( @OpCodeInfo_UseOutsideEnclaveSgx, 'OpCodeInfo_UseOutsideEnclaveSgx', ID, StrL ); + InitVar( @OpCodeInfo_UseInEnclaveSgx1, 'OpCodeInfo_UseInEnclaveSgx1', ID, StrL ); + InitVar( @OpCodeInfo_UseInEnclaveSgx2, 'OpCodeInfo_UseInEnclaveSgx2', ID, StrL ); + InitVar( @OpCodeInfo_UseOutsideVmxOp, 'OpCodeInfo_UseOutsideVmxOp', ID, StrL ); + InitVar( @OpCodeInfo_UseInVmxRootOp, 'OpCodeInfo_UseInVmxRootOp', ID, StrL ); + InitVar( @OpCodeInfo_UseInVmxNonRootOp, 'OpCodeInfo_UseInVmxNonRootOp', ID, StrL ); + InitVar( @OpCodeInfo_UseOutsideSeam, 'OpCodeInfo_UseOutsideSeam', ID, StrL ); + InitVar( @OpCodeInfo_UseInSeam, 'OpCodeInfo_UseInSeam', ID, StrL ); + InitVar( @OpCodeInfo_TdxNonRootGenUd, 'OpCodeInfo_TdxNonRootGenUd', ID, StrL ); + InitVar( @OpCodeInfo_TdxNonRootGenVe, 'OpCodeInfo_TdxNonRootGenVe', ID, StrL ); + InitVar( @OpCodeInfo_TdxNonRootMayGenEx, 'OpCodeInfo_TdxNonRootMayGenEx', ID, StrL ); + InitVar( @OpCodeInfo_IntelVMExit, 'OpCodeInfo_IntelVMExit', ID, StrL ); + InitVar( @OpCodeInfo_IntelMayVMExit, 'OpCodeInfo_IntelMayVMExit', ID, StrL ); + InitVar( @OpCodeInfo_IntelSmmVMExit, 'OpCodeInfo_IntelSmmVMExit', ID, StrL ); + InitVar( @OpCodeInfo_AmdVMExit, 'OpCodeInfo_AmdVMExit', ID, StrL ); + InitVar( @OpCodeInfo_AmdMayVMExit, 'OpCodeInfo_AmdMayVMExit', ID, StrL ); + InitVar( @OpCodeInfo_TsxAbort, 'OpCodeInfo_TsxAbort', ID, StrL ); + InitVar( @OpCodeInfo_TsxImplAbort, 'OpCodeInfo_TsxImplAbort', ID, StrL ); + InitVar( @OpCodeInfo_TsxMayAbort, 'OpCodeInfo_TsxMayAbort', ID, StrL ); + InitVar( @OpCodeInfo_IntelDecoder16, 'OpCodeInfo_IntelDecoder16', ID, StrL ); + InitVar( @OpCodeInfo_IntelDecoder32, 'OpCodeInfo_IntelDecoder32', ID, StrL ); + InitVar( @OpCodeInfo_IntelDecoder64, 'OpCodeInfo_IntelDecoder64', ID, StrL ); + InitVar( @OpCodeInfo_AmdDecoder16, 'OpCodeInfo_AmdDecoder16', ID, StrL ); + InitVar( @OpCodeInfo_AmdDecoder32, 'OpCodeInfo_AmdDecoder32', ID, StrL ); + InitVar( @OpCodeInfo_AmdDecoder64, 'OpCodeInfo_AmdDecoder64', ID, StrL ); + InitVar( @OpCodeInfo_DecoderOption, 'OpCodeInfo_DecoderOption', ID, StrL ); + InitVar( @OpCodeInfo_OpCodeLen, 'OpCodeInfo_OpCodeLen', ID, StrL ); + InitVar( @OpCodeInfo_OPCount, 'OpCodeInfo_OPCount', ID, StrL ); + + InitVar( @Code_AsString, 'Code_AsString', ID, StrL ); + InitVar( @Code_Mnemonic, 'Code_Mnemonic', ID, StrL ); + InitVar( @Code_OPCode, 'Code_OPCode', ID, StrL ); + InitVar( @Code_Encoding, 'Code_Encoding', ID, StrL ); + InitVar( @Code_CPUidFeature, 'Code_CPUidFeature', ID, StrL ); + InitVar( @Code_FlowControl, 'Code_FlowControl', ID, StrL ); + InitVar( @Code_IsPrivileged, 'Code_IsPrivileged', ID, StrL ); + InitVar( @Code_IsStackInstruction, 'Code_IsStackInstruction', ID, StrL ); + InitVar( @Code_IsSaveRestoreInstruction, 'Code_IsSaveRestoreInstruction', ID, StrL ); + InitVar( @Code_IsJccShort, 'Code_IsJccShort', ID, StrL ); + InitVar( @Code_IsJmpShort, 'Code_IsJmpShort', ID, StrL ); + InitVar( @Code_IsJmpShortOrNear, 'Code_IsJmpShortOrNear', ID, StrL ); + InitVar( @Code_IsJmpNear, 'Code_IsJmpNear', ID, StrL ); + InitVar( @Code_IsJmpFar, 'Code_IsJmpFar', ID, StrL ); + InitVar( @Code_IsCallNear, 'Code_IsCallNear', ID, StrL ); + InitVar( @Code_IsCallFar, 'Code_IsCallFar', ID, StrL ); + InitVar( @Code_IsJmpNearIndirect, 'Code_IsJmpNearIndirect', ID, StrL ); + InitVar( @Code_IsJmpFarIndirect, 'Code_IsJmpFarIndirect', ID, StrL ); + InitVar( @Code_IsCallNearIndirect, 'Code_IsCallNearIndirect', ID, StrL ); + InitVar( @Code_IsCallFarIndirect, 'Code_IsCallFarIndirect', ID, StrL ); + InitVar( @Code_ConditionCode, 'Code_ConditionCode', ID, StrL ); + InitVar( @Code_IsJcxShort, 'Code_IsJcxShort', ID, StrL ); + InitVar( @Code_IsLoopCC, 'Code_IsLoopCC', ID, StrL ); + InitVar( @Code_IsLoop, 'Code_IsLoop', ID, StrL ); + InitVar( @Code_IsJccShortOrNear, 'Code_IsJccShortOrNear', ID, StrL ); + InitVar( @Code_NegateConditionCode, 'Code_NegateConditionCode', ID, StrL ); + InitVar( @Code_AsShortBranch, 'Code_AsShortBranch', ID, StrL ); + InitVar( @Code_AsNearBranch, 'Code_AsNearBranch', ID, StrL ); + + InitVar( @Mnemonic_AsString, 'Mnemonic_AsString', ID, StrL ); + InitVar( @OpKind_AsString, 'OpKind_AsString', ID, StrL ); + InitVar( @EncodingKind_AsString, 'EncodingKind_AsString', ID, StrL ); + InitVar( @CPUidFeature_AsString, 'CPUidFeature_AsString', ID, StrL ); + InitVar( @ConditionCode_AsString, 'ConditionCode_AsString', ID, StrL ); + InitVar( @FlowControl_AsString, 'FlowControl_AsString', ID, StrL ); + InitVar( @TupleType_AsString, 'TupleType_AsString', ID, StrL ); + InitVar( @MvexEHBit_AsString, 'MvexEHBit_AsString', ID, StrL ); + InitVar( @MvexTupleTypeLutKind_AsString, 'MvexTupleTypeLutKind_AsString', ID, StrL ); + InitVar( @MvexConvFn_AsString, 'MvexConvFn_AsString', ID, StrL ); + InitVar( @MvexRegMemConv_AsString, 'MvexRegMemConv_AsString', ID, StrL ); + InitVar( @RoundingControl_AsString, 'RoundingControl_AsString', ID, StrL ); + InitVar( @NumberBase_AsString, 'NumberBase_AsString', ID, StrL ); + InitVar( @RepPrefixKind_AsString, 'RepPrefixKind_AsString', ID, StrL ); + InitVar( @MemorySizeOptions_AsString, 'MemorySizeOptions_AsString', ID, StrL ); + InitVar( @MemorySize_AsString, 'MemorySize_AsString', ID, StrL ); + InitVar( @MemorySize_Info, 'MemorySize_Info', ID, StrL ); + InitVar( @OpCodeTableKind_AsString, 'OpCodeTableKind_AsString', ID, StrL ); + InitVar( @MandatoryPrefix_AsString, 'MandatoryPrefix_AsString', ID, StrL ); + InitVar( @OpCodeOperandKind_AsString, 'OpCodeOperandKind_AsString', ID, StrL ); + InitVar( @OpAccess_AsString, 'OpAccess_AsString', ID, StrL ); + InitVar( @CodeSize_AsString, 'CodeSize_AsString', ID, StrL ); + InitVar( @FormatterTextKind_AsString, 'FormatterTextKind_AsString', ID, StrL ); + + InitVar( @Register_Base, 'Register_Base', ID, StrL ); + InitVar( @Register_Number, 'Register_Number', ID, StrL ); + InitVar( @Register_FullRegister, 'Register_FullRegister', ID, StrL ); + InitVar( @Register_FullRegister32, 'Register_FullRegister32', ID, StrL ); + InitVar( @Register_Size, 'Register_Size', ID, StrL ); + InitVar( @Register_AsString, 'Register_AsString', ID, StrL ); + end; + end; + + {$WARNINGS ON} + {$UNDEF section_InitVar} +end; + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Redirects~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +{$DEFINE section_Redirects} +{.$I Iced.inc} +{$UNDEF section_Redirects} + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +{$DEFINE section_IMPLEMENTATION} +{$I DynamicDLL.inc} +{$UNDEF section_IMPLEMENTATION} + +end. diff --git a/src/Delphi/uIced.Types.pas b/src/Delphi/uIced.Types.pas new file mode 100644 index 000000000..c3f3e52f9 --- /dev/null +++ b/src/Delphi/uIced.Types.pas @@ -0,0 +1,57089 @@ +unit uIced.Types; + +{ + Iced (Dis)Assembler + + TetzkatLipHoka 2022-2024 +} + +(* + Callback Samples + --- + +function SymbolResolverCallback( const Instruction: TInstruction; Operand: Cardinal; InstructionOperand : Cardinal; Address: UInt64; Size: Cardinal; UserData : Pointer ) : PAnsiChar; cdecl; +begin + result := ''; +end; + +procedure FormatterOptionsProviderCallback( const Instruction: TInstruction; Operand: Cardinal; InstructionOperand : Cardinal; var Options: TFormatterOperandOptions; var NumberOptions: TNumberFormattingOptions; UserData : Pointer ); cdecl; +begin + NumberOptions.prefix := 0x; // Number prefix or an empty string + NumberOptions.suffix := ''; // Number suffix or an empty string + NumberOptions.digit_separator := ''; // Digit separator or an empty string to not use a digit separator + NumberOptions.digit_group_size := 0; // Size of a digit group or 0 to not use a digit separator + NumberOptions.number_base := Hexadecimal; // Number base + NumberOptions.uppercase_hex := True; // Use uppercase hex digits + NumberOptions.small_hex_numbers_in_decimal := True; // Small hex numbers (-9 .. 9) are shown in decimal + NumberOptions.add_leading_zero_to_hex_numbers := False; // Add a leading zero to hex numbers if there's no prefix and the number starts with hex digits `A-F` + NumberOptions.leading_zeros := False; // If `true`, add leading zeros to numbers, eg. `1h` vs `00000001h` + NumberOptions.signed_number := False; // If `true`, the number is signed, and if `false` it's an unsigned number + NumberOptions.displacement_leading_zeros := False; // Add leading zeros to displacements +end; + +procedure FormatterOutputCallback( Text : PAnsiChar; Kind : TFormatterTextKind; UserData : Pointer ); +begin + case Kind of + ftkDirective, + ftkKeyword : FrmIced.redt1.SelAttributes.Color := clYellow; + + ftkPrefix, + ftkMnemonic : FrmIced.redt1.SelAttributes.Color := clRed; + + ftkRegister : FrmIced.redt1.SelAttributes.Color := clAqua; + ftkNumber : FrmIced.redt1.SelAttributes.Color := clWebLightCyan; + +// ftkText : FrmIced.redt1.SelAttributes.Color := ; +// ftkOperator : FrmIced.redt1.SelAttributes.Color := ; +// ftkPunctuation : FrmIced.redt1.SelAttributes.Color := ; +// +// ftkDecorator : FrmIced.redt1.SelAttributes.Color := ; +// ftkSelectorValue : FrmIced.redt1.SelAttributes.Color := ; +// ftkLabelAddress : FrmIced.redt1.SelAttributes.Color := ; +// ftkFunctionAddress : FrmIced.redt1.SelAttributes.Color := ; +// ftkData : FrmIced.redt1.SelAttributes.Color := ; +// ftkLabel : FrmIced.redt1.SelAttributes.Color := ; +// ftkFunction : FrmIced.redt1.SelAttributes.Color := ; + else + FrmIced.redt1.SelAttributes.Color := clWindowText; + end; + + FrmIced.redt1.SelText := Text; +end; + +function VirtualAddressResolverCallback( Register: TRegister; Index : NativeUInt; Size : NativeUInt; var Address : UInt64; UserData : Pointer ) : boolean; cdecl; +begin + result := True; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + case Register of + // The base address of ES, CS, SS and DS is always 0 in 64-bit mode + ES, CS, SS, DS: Address := 0; + + RDI : Address := $10000000; + R12 : Address := $000400000000; + +// AL : Address := ; +// CL : Address := ; +// DL : Address := ; +// BL : Address := ; +// AH : Address := ; +// CH : Address := ; +// DH : Address := ; +// BH : Address := ; +// SPL : Address := ; +// BPL : Address := ; +// SIL : Address := ; +// DIL : Address := ; +// R8L : Address := ; +// R9L : Address := ; +// R10L : Address := ; +// R11L : Address := ; +// R12L : Address := ; +// R13L : Address := ; +// R14L : Address := ; +// R15L : Address := ; +// AX : Address := ; +// CX : Address := ; +// DX : Address := ; +// BX : Address := ; +// SP : Address := ; +// BP : Address := ; +// SI : Address := ; +// DI : Address := ; +// R8W : Address := ; +// R9W : Address := ; +// R10W : Address := ; +// R11W : Address := ; +// R12W : Address := ; +// R13W : Address := ; +// R14W : Address := ; +// R15W : Address := ; +// EAX : Address := ; +// ECX : Address := ; +// EDX : Address := ; +// EBX : Address := ; +// ESP : Address := ; +// EBP : Address := ; +// ESI : Address := ; +// EDI : Address := ; +// R8D : Address := ; +// R9D : Address := ; +// R10D : Address := ; +// R11D : Address := ; +// R12D : Address := ; +// R13D : Address := ; +// R14D : Address := ; +// R15D : Address := ; +// RAX : Address := ; +// RCX : Address := ; +// RDX : Address := ; +// RBX : Address := ; +// RSP : Address := ; +// RBP : Address := ; +// RSI : Address := ; +// RDI : Address := ; +// R8 : Address := ; +// R9 : Address := ; +// R10 : Address := ; +// R11 : Address := ; +// R12 : Address := ; +// R13 : Address := ; +// R14 : Address := ; +// R15 : Address := ; +// EIP : Address := ; +// RIP : Address := ; +// FS : Address := ; +// GS : Address := ; +// XMM0 : Address := ; +// XMM1 : Address := ; +// XMM2 : Address := ; +// XMM3 : Address := ; +// XMM4 : Address := ; +// XMM5 : Address := ; +// XMM6 : Address := ; +// XMM7 : Address := ; +// XMM8 : Address := ; +// XMM9 : Address := ; +// XMM10 : Address := ; +// XMM11 : Address := ; +// XMM12 : Address := ; +// XMM13 : Address := ; +// XMM14 : Address := ; +// XMM15 : Address := ; +// XMM16 : Address := ; +// XMM17 : Address := ; +// XMM18 : Address := ; +// XMM19 : Address := ; +// XMM20 : Address := ; +// XMM21 : Address := ; +// XMM22 : Address := ; +// XMM23 : Address := ; +// XMM24 : Address := ; +// XMM25 : Address := ; +// XMM26 : Address := ; +// XMM27 : Address := ; +// XMM28 : Address := ; +// XMM29 : Address := ; +// XMM30 : Address := ; +// XMM31 : Address := ; +// YMM0 : Address := ; +// YMM1 : Address := ; +// YMM2 : Address := ; +// YMM3 : Address := ; +// YMM4 : Address := ; +// YMM5 : Address := ; +// YMM6 : Address := ; +// YMM7 : Address := ; +// YMM8 : Address := ; +// YMM9 : Address := ; +// YMM10 : Address := ; +// YMM11 : Address := ; +// YMM12 : Address := ; +// YMM13 : Address := ; +// YMM14 : Address := ; +// YMM15 : Address := ; +// YMM16 : Address := ; +// YMM17 : Address := ; +// YMM18 : Address := ; +// YMM19 : Address := ; +// YMM20 : Address := ; +// YMM21 : Address := ; +// YMM22 : Address := ; +// YMM23 : Address := ; +// YMM24 : Address := ; +// YMM25 : Address := ; +// YMM26 : Address := ; +// YMM27 : Address := ; +// YMM28 : Address := ; +// YMM29 : Address := ; +// YMM30 : Address := ; +// YMM31 : Address := ; +// ZMM0 : Address := ; +// ZMM1 : Address := ; +// ZMM2 : Address := ; +// ZMM3 : Address := ; +// ZMM4 : Address := ; +// ZMM5 : Address := ; +// ZMM6 : Address := ; +// ZMM7 : Address := ; +// ZMM8 : Address := ; +// ZMM9 : Address := ; +// ZMM10 : Address := ; +// ZMM11 : Address := ; +// ZMM12 : Address := ; +// ZMM13 : Address := ; +// ZMM14 : Address := ; +// ZMM15 : Address := ; +// ZMM16 : Address := ; +// ZMM17 : Address := ; +// ZMM18 : Address := ; +// ZMM19 : Address := ; +// ZMM20 : Address := ; +// ZMM21 : Address := ; +// ZMM22 : Address := ; +// ZMM23 : Address := ; +// ZMM24 : Address := ; +// ZMM25 : Address := ; +// ZMM26 : Address := ; +// ZMM27 : Address := ; +// ZMM28 : Address := ; +// ZMM29 : Address := ; +// ZMM30 : Address := ; +// ZMM31 : Address := ; +// K0 : Address := ; +// K1 : Address := ; +// K2 : Address := ; +// K3 : Address := ; +// K4 : Address := ; +// K5 : Address := ; +// K6 : Address := ; +// K7 : Address := ; +// BND0 : Address := ; +// BND1 : Address := ; +// BND2 : Address := ; +// BND3 : Address := ; +// CR0 : Address := ; +// CR1 : Address := ; +// CR2 : Address := ; +// CR3 : Address := ; +// CR4 : Address := ; +// CR5 : Address := ; +// CR6 : Address := ; +// CR7 : Address := ; +// CR8 : Address := ; +// CR9 : Address := ; +// CR10 : Address := ; +// CR11 : Address := ; +// CR12 : Address := ; +// CR13 : Address := ; +// CR14 : Address := ; +// CR15 : Address := ; +// DR0 : Address := ; +// DR1 : Address := ; +// DR2 : Address := ; +// DR3 : Address := ; +// DR4 : Address := ; +// DR5 : Address := ; +// DR6 : Address := ; +// DR7 : Address := ; +// DR8 : Address := ; +// DR9 : Address := ; +// DR10 : Address := ; +// DR11 : Address := ; +// DR12 : Address := ; +// DR13 : Address := ; +// DR14 : Address := ; +// DR15 : Address := ; +// ST0 : Address := ; +// ST1 : Address := ; +// ST2 : Address := ; +// ST3 : Address := ; +// ST4 : Address := ; +// ST5 : Address := ; +// ST6 : Address := ; +// ST7 : Address := ; +// MM0 : Address := ; +// MM1 : Address := ; +// MM2 : Address := ; +// MM3 : Address := ; +// MM4 : Address := ; +// MM5 : Address := ; +// MM6 : Address := ; +// MM7 : Address := ; +// TR0 : Address := ; +// TR1 : Address := ; +// TR2 : Address := ; +// TR3 : Address := ; +// TR4 : Address := ; +// TR5 : Address := ; +// TR6 : Address := ; +// TR7 : Address := ; +// TMM0 : Address := ; +// TMM1 : Address := ; +// TMM2 : Address := ; +// TMM3 : Address := ; +// TMM4 : Address := ; +// TMM5 : Address := ; +// TMM6 : Address := ; +// TMM7 : Address := ; + else + result := False; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; +*) + +interface + +{$IF CompilerVersion >= 22} + {$LEGACYIFEND ON} + {$WARN DUPLICATE_CTOR_DTOR OFF} +{$ELSE} + {$WARN UNSAFE_CODE OFF} +{$IFEND} +{$WARN UNSAFE_TYPE OFF} + +{$DEFINE ICED_1210} // v1.2.1.0 changed TInstruction-Layout +{.$DEFINE ICED_1190} // v1.1.9.0 changed TInstruction-Layout + +{$IF CompilerVersion >= 22} // XE +uses + System.Generics.Collections; +{$IFEND} + +{$IF CompilerVersion < 23} +type + NativeUInt = Cardinal; +// NativeInt = Integer; + PNativeUInt = ^NativeUInt; +{$IFEND} + +{$IF NOT Declared( PUInt64 )} + PUInt64 = ^UInt64; +{$IFEND} + +type + TIcedBitness = ( + bt16 = 16, + bt32 = 32, + bt64 = 64 + ); + + TIcedFormatterType = ( + ftMasm, + ftNasm, + ftGas, + ftIntel, + ftFast, + ftSpecialized, + ftCapstone // Masm with adapted Options + ); + + TIcedSpecializedFormatterOptions = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + ENABLE_SYMBOL_RESOLVER : Boolean; + ENABLE_DB_DW_DD_DQ : Boolean; + verify_output_has_enough_bytes_left : Boolean; + + function Options : Byte; + end; + +const + DEFAULT_FORMATTER = ftCapstone; // ftMasm; + +type + TDecoderErrorType = ( + // No error. The last decoded instruction is a valid instruction + deNone = 0, + // It's an invalid instruction or an invalid encoding of an existing instruction (eg. some reserved bit is set/cleared) + deInvalidInstruction = 1, + // There's not enough bytes left to decode the instruction + deNoMoreBytes = 2 + ); + + TDecoderError = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + DecoderError : TDecoderErrorType; + {$IFDEF UNICODE} + class operator Equal( const self, ADecoderError : TDecoderError ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, ADecoderError : TDecoderError ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TDecoderError; const ADecoderError : array of TDecoderErrorType ) : Boolean; + class operator GreaterThan( const self, ADecoderError : TDecoderError ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, ADecoderError : TDecoderError ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, ADecoderError : TDecoderError ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, ADecoderError : TDecoderError ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ADecoderError : TDecoderError ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ADecoderError : TDecoderError ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ADecoderError : Byte ) : TDecoderError; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ADecoderError : TDecoderError ) : TDecoderErrorType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ADecoderError : TDecoderErrorType ) : TDecoderError; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + +const +// TDecoderOptions = ( + // No option is enabled + doNONE = $00000000{,}; + // Disable some checks for invalid encodings of instructions, eg. most instructions can't use a `LOCK` prefix so if one is found, they're decoded as [`Code::INVALID`] unless this option is enabled. + // + // [`Code::INVALID`]: enum.Code.html#variant.INVALID + doNO_INVALID_CHECK = $00000001{,}; + // AMD decoder: allow 16-bit branch/ret instructions in 64-bit mode, no `o64 CALL/JMP FAR [mem], o64 LSS/LFS/LGS`, `UD0` has no modr/m byte, decode `LOCK MOV CR`. The AMD decoder can still decode Intel instructions. + doAMD = $00000002{,}; + // Decode opcodes `0F0D` and `0F18-0F1F` as reserved-nop instructions (eg. [`Code::Reservednop_rm32_r32_0F1D`]) + // + // [`Code::Reservednop_rm32_r32_0F1D`]: enum.Code.html#variant.Reservednop_rm32_r32_0F1D + doFORCE_RESERVED_NOP = $00000004{,}; + // Decode `UMOV` instructions + doUMOV = $00000008{,}; + // Decode `XBTS`/`IBTS` + doXBTS = $00000010{,}; + // Decode `0FA6`/`0FA7` as `CMPXCHG` + doCMPXCHG486A = $00000020{,}; + // Decode some old removed FPU instructions (eg. `FRSTPM`) + doOLD_FPU = $00000040{,}; + // Decode `PCOMMIT` + doPCOMMIT = $00000080{,}; + // Decode 286 `STOREALL`/`LOADALL` (`0F04` and `0F05`) + doLOADALL286 = $00000100{,}; + // Decode 386 `LOADALL` + doLOADALL386 = $00000200{,}; + // Decode `CL1INVMB` + doCL1INVMB = $00000400{,}; + // Decode `MOV r32,tr` and `MOV tr,r32` + doMOV_TR = $00000800{,}; + // Decode `JMPE` instructions + doJMPE = $00001000{,}; + // Don't decode `PAUSE`, decode `NOP` instead + doNO_PAUSE = $00002000{,}; + // Don't decode `WBNOINVD`, decode `WBINVD` instead + doNO_WBNOINVD = $00004000{,}; + // Decode undocumented Intel `RDUDBG` and `WRUDBG` instructions + doUDBG = $00008000{,}; + // Don't decode `TZCNT`, decode `BSF` instead + doNO_MPFX_0FBC = $00010000{,}; + // Don't decode `LZCNT`, decode `BSR` instead + doNO_MPFX_0FBD = $00020000{,}; + // Don't decode `LAHF` and `SAHF` in 64-bit mode + doNO_LAHF_SAHF_64 = $00040000{,}; + // Decode `MPX` instructions + doMPX = $00080000{,}; + // Decode most Cyrix instructions: `FPU`, `EMMI`, `SMM`, `DDI` + doCYRIX = $00100000{,}; + // Decode Cyrix `SMINT 0F7E` (Cyrix 6x86 or earlier) + doCYRIX_SMINT_0F7E = $00200000{,}; + // Decode Cyrix `DMI` instructions (AMD Geode GX/LX) + doCYRIX_DMI = $00400000{,}; + // Decode Centaur `ALTINST` + doALTINST = $00800000{,}; + // Decode Intel Knights Corner instructions (requires the `mvex` feature) + doKNC = $01000000; +// ); + +// TBlockEncoderOptions = ( + // No option is set + beoNONE = $00000000{,}; + // By default{,}; branches get updated if the target is too far away{,}; eg. `Jcc SHORT` -> `Jcc NEAR` or if 64-bit mode{,}; `Jcc + JMP [RIP+mem]`. If this option is enabled{,}; no branches are fixed. + beoDONT_FIX_BRANCHES = $00000001{,}; + // The [`BlockEncoder`] should return [`RelocInfo`]s + // + // [`BlockEncoder`]: struct.BlockEncoder.html + // [`RelocInfo`]: struct.RelocInfo.html + beoRETURN_RELOC_INFOS = $00000002{,}; + // The [`BlockEncoder`] should return new instruction offsets + // + // [`BlockEncoder`]: struct.BlockEncoder.html + beoRETURN_NEW_INSTRUCTION_OFFSETS = $00000004{,}; + // The [`BlockEncoder`] should return [`ConstantOffsets`] + // + // [`BlockEncoder`]: struct.BlockEncoder.html + // [`ConstantOffsets`]: struct.ConstantOffsets.html + beoRETURN_CONSTANT_OFFSETS = $00000008; +// ); + +type + TCodeType = ( + // It's an invalid instruction, eg. it's a new unknown instruction, garbage or there's not enough bytes to decode the instruction etc. + INVALID_CODE = 0, + // A `db`/`.byte` asm directive that can store 1-16 bytes + DeclareByte = 1, + // A `dw`/`.word` asm directive that can store 1-8 words + DeclareWord = 2, + // A `dd`/`.int` asm directive that can store 1-4 dwords + DeclareDword = 3, + // A `dq`/`.quad` asm directive that can store 1-2 qwords + DeclareQword = 4, + // `ADD r/m8, r8` + // + // `00 /r` + // + // `8086+` + // + // `16/32/64-bit` + Add_rm8_r8 = 5, + // `ADD r/m16, r16` + // + // `o16 01 /r` + // + // `8086+` + // + // `16/32/64-bit` + Add_rm16_r16 = 6, + // `ADD r/m32, r32` + // + // `o32 01 /r` + // + // `386+` + // + // `16/32/64-bit` + Add_rm32_r32 = 7, + // `ADD r/m64, r64` + // + // `o64 01 /r` + // + // `X64` + // + // `64-bit` + Add_rm64_r64 = 8, + // `ADD r8, r/m8` + // + // `02 /r` + // + // `8086+` + // + // `16/32/64-bit` + Add_r8_rm8 = 9, + // `ADD r16, r/m16` + // + // `o16 03 /r` + // + // `8086+` + // + // `16/32/64-bit` + Add_r16_rm16 = 10, + // `ADD r32, r/m32` + // + // `o32 03 /r` + // + // `386+` + // + // `16/32/64-bit` + Add_r32_rm32 = 11, + // `ADD r64, r/m64` + // + // `o64 03 /r` + // + // `X64` + // + // `64-bit` + Add_r64_rm64 = 12, + // `ADD AL, imm8` + // + // `04 ib` + // + // `8086+` + // + // `16/32/64-bit` + Add_AL_imm8 = 13, + // `ADD AX, imm16` + // + // `o16 05 iw` + // + // `8086+` + // + // `16/32/64-bit` + Add_AX_imm16 = 14, + // `ADD EAX, imm32` + // + // `o32 05 id` + // + // `386+` + // + // `16/32/64-bit` + Add_EAX_imm32 = 15, + // `ADD RAX, imm32` + // + // `o64 05 id` + // + // `X64` + // + // `64-bit` + Add_RAX_imm32 = 16, + // `PUSH ES` + // + // `o16 06` + // + // `8086+` + // + // `16/32-bit` + Pushw_ES = 17, + // `PUSH ES` + // + // `o32 06` + // + // `386+` + // + // `16/32-bit` + Pushd_ES = 18, + // `POP ES` + // + // `o16 07` + // + // `8086+` + // + // `16/32-bit` + Popw_ES = 19, + // `POP ES` + // + // `o32 07` + // + // `386+` + // + // `16/32-bit` + Popd_ES = 20, + // `OR r/m8, r8` + // + // `08 /r` + // + // `8086+` + // + // `16/32/64-bit` + Or_rm8_r8 = 21, + // `OR r/m16, r16` + // + // `o16 09 /r` + // + // `8086+` + // + // `16/32/64-bit` + Or_rm16_r16 = 22, + // `OR r/m32, r32` + // + // `o32 09 /r` + // + // `386+` + // + // `16/32/64-bit` + Or_rm32_r32 = 23, + // `OR r/m64, r64` + // + // `o64 09 /r` + // + // `X64` + // + // `64-bit` + Or_rm64_r64 = 24, + // `OR r8, r/m8` + // + // `0A /r` + // + // `8086+` + // + // `16/32/64-bit` + Or_r8_rm8 = 25, + // `OR r16, r/m16` + // + // `o16 0B /r` + // + // `8086+` + // + // `16/32/64-bit` + Or_r16_rm16 = 26, + // `OR r32, r/m32` + // + // `o32 0B /r` + // + // `386+` + // + // `16/32/64-bit` + Or_r32_rm32 = 27, + // `OR r64, r/m64` + // + // `o64 0B /r` + // + // `X64` + // + // `64-bit` + Or_r64_rm64 = 28, + // `OR AL, imm8` + // + // `0C ib` + // + // `8086+` + // + // `16/32/64-bit` + Or_AL_imm8 = 29, + // `OR AX, imm16` + // + // `o16 0D iw` + // + // `8086+` + // + // `16/32/64-bit` + Or_AX_imm16 = 30, + // `OR EAX, imm32` + // + // `o32 0D id` + // + // `386+` + // + // `16/32/64-bit` + Or_EAX_imm32 = 31, + // `OR RAX, imm32` + // + // `o64 0D id` + // + // `X64` + // + // `64-bit` + Or_RAX_imm32 = 32, + // `PUSH CS` + // + // `o16 0E` + // + // `8086+` + // + // `16/32-bit` + Pushw_CS = 33, + // `PUSH CS` + // + // `o32 0E` + // + // `386+` + // + // `16/32-bit` + Pushd_CS = 34, + // `POP CS` + // + // `o16 0F` + // + // `8086` + // + // `16-bit` + Popw_CS = 35, + // `ADC r/m8, r8` + // + // `10 /r` + // + // `8086+` + // + // `16/32/64-bit` + Adc_rm8_r8 = 36, + // `ADC r/m16, r16` + // + // `o16 11 /r` + // + // `8086+` + // + // `16/32/64-bit` + Adc_rm16_r16 = 37, + // `ADC r/m32, r32` + // + // `o32 11 /r` + // + // `386+` + // + // `16/32/64-bit` + Adc_rm32_r32 = 38, + // `ADC r/m64, r64` + // + // `o64 11 /r` + // + // `X64` + // + // `64-bit` + Adc_rm64_r64 = 39, + // `ADC r8, r/m8` + // + // `12 /r` + // + // `8086+` + // + // `16/32/64-bit` + Adc_r8_rm8 = 40, + // `ADC r16, r/m16` + // + // `o16 13 /r` + // + // `8086+` + // + // `16/32/64-bit` + Adc_r16_rm16 = 41, + // `ADC r32, r/m32` + // + // `o32 13 /r` + // + // `386+` + // + // `16/32/64-bit` + Adc_r32_rm32 = 42, + // `ADC r64, r/m64` + // + // `o64 13 /r` + // + // `X64` + // + // `64-bit` + Adc_r64_rm64 = 43, + // `ADC AL, imm8` + // + // `14 ib` + // + // `8086+` + // + // `16/32/64-bit` + Adc_AL_imm8 = 44, + // `ADC AX, imm16` + // + // `o16 15 iw` + // + // `8086+` + // + // `16/32/64-bit` + Adc_AX_imm16 = 45, + // `ADC EAX, imm32` + // + // `o32 15 id` + // + // `386+` + // + // `16/32/64-bit` + Adc_EAX_imm32 = 46, + // `ADC RAX, imm32` + // + // `o64 15 id` + // + // `X64` + // + // `64-bit` + Adc_RAX_imm32 = 47, + // `PUSH SS` + // + // `o16 16` + // + // `8086+` + // + // `16/32-bit` + Pushw_SS = 48, + // `PUSH SS` + // + // `o32 16` + // + // `386+` + // + // `16/32-bit` + Pushd_SS = 49, + // `POP SS` + // + // `o16 17` + // + // `8086+` + // + // `16/32-bit` + Popw_SS = 50, + // `POP SS` + // + // `o32 17` + // + // `386+` + // + // `16/32-bit` + Popd_SS = 51, + // `SBB r/m8, r8` + // + // `18 /r` + // + // `8086+` + // + // `16/32/64-bit` + Sbb_rm8_r8 = 52, + // `SBB r/m16, r16` + // + // `o16 19 /r` + // + // `8086+` + // + // `16/32/64-bit` + Sbb_rm16_r16 = 53, + // `SBB r/m32, r32` + // + // `o32 19 /r` + // + // `386+` + // + // `16/32/64-bit` + Sbb_rm32_r32 = 54, + // `SBB r/m64, r64` + // + // `o64 19 /r` + // + // `X64` + // + // `64-bit` + Sbb_rm64_r64 = 55, + // `SBB r8, r/m8` + // + // `1A /r` + // + // `8086+` + // + // `16/32/64-bit` + Sbb_r8_rm8 = 56, + // `SBB r16, r/m16` + // + // `o16 1B /r` + // + // `8086+` + // + // `16/32/64-bit` + Sbb_r16_rm16 = 57, + // `SBB r32, r/m32` + // + // `o32 1B /r` + // + // `386+` + // + // `16/32/64-bit` + Sbb_r32_rm32 = 58, + // `SBB r64, r/m64` + // + // `o64 1B /r` + // + // `X64` + // + // `64-bit` + Sbb_r64_rm64 = 59, + // `SBB AL, imm8` + // + // `1C ib` + // + // `8086+` + // + // `16/32/64-bit` + Sbb_AL_imm8 = 60, + // `SBB AX, imm16` + // + // `o16 1D iw` + // + // `8086+` + // + // `16/32/64-bit` + Sbb_AX_imm16 = 61, + // `SBB EAX, imm32` + // + // `o32 1D id` + // + // `386+` + // + // `16/32/64-bit` + Sbb_EAX_imm32 = 62, + // `SBB RAX, imm32` + // + // `o64 1D id` + // + // `X64` + // + // `64-bit` + Sbb_RAX_imm32 = 63, + // `PUSH DS` + // + // `o16 1E` + // + // `8086+` + // + // `16/32-bit` + Pushw_DS = 64, + // `PUSH DS` + // + // `o32 1E` + // + // `386+` + // + // `16/32-bit` + Pushd_DS = 65, + // `POP DS` + // + // `o16 1F` + // + // `8086+` + // + // `16/32-bit` + Popw_DS = 66, + // `POP DS` + // + // `o32 1F` + // + // `386+` + // + // `16/32-bit` + Popd_DS = 67, + // `AND r/m8, r8` + // + // `20 /r` + // + // `8086+` + // + // `16/32/64-bit` + And_rm8_r8 = 68, + // `AND r/m16, r16` + // + // `o16 21 /r` + // + // `8086+` + // + // `16/32/64-bit` + And_rm16_r16 = 69, + // `AND r/m32, r32` + // + // `o32 21 /r` + // + // `386+` + // + // `16/32/64-bit` + And_rm32_r32 = 70, + // `AND r/m64, r64` + // + // `o64 21 /r` + // + // `X64` + // + // `64-bit` + And_rm64_r64 = 71, + // `AND r8, r/m8` + // + // `22 /r` + // + // `8086+` + // + // `16/32/64-bit` + And_r8_rm8 = 72, + // `AND r16, r/m16` + // + // `o16 23 /r` + // + // `8086+` + // + // `16/32/64-bit` + And_r16_rm16 = 73, + // `AND r32, r/m32` + // + // `o32 23 /r` + // + // `386+` + // + // `16/32/64-bit` + And_r32_rm32 = 74, + // `AND r64, r/m64` + // + // `o64 23 /r` + // + // `X64` + // + // `64-bit` + And_r64_rm64 = 75, + // `AND AL, imm8` + // + // `24 ib` + // + // `8086+` + // + // `16/32/64-bit` + And_AL_imm8 = 76, + // `AND AX, imm16` + // + // `o16 25 iw` + // + // `8086+` + // + // `16/32/64-bit` + And_AX_imm16 = 77, + // `AND EAX, imm32` + // + // `o32 25 id` + // + // `386+` + // + // `16/32/64-bit` + And_EAX_imm32 = 78, + // `AND RAX, imm32` + // + // `o64 25 id` + // + // `X64` + // + // `64-bit` + And_RAX_imm32 = 79, + // `DAA` + // + // `27` + // + // `8086+` + // + // `16/32-bit` + Daa = 80, + // `SUB r/m8, r8` + // + // `28 /r` + // + // `8086+` + // + // `16/32/64-bit` + Sub_rm8_r8 = 81, + // `SUB r/m16, r16` + // + // `o16 29 /r` + // + // `8086+` + // + // `16/32/64-bit` + Sub_rm16_r16 = 82, + // `SUB r/m32, r32` + // + // `o32 29 /r` + // + // `386+` + // + // `16/32/64-bit` + Sub_rm32_r32 = 83, + // `SUB r/m64, r64` + // + // `o64 29 /r` + // + // `X64` + // + // `64-bit` + Sub_rm64_r64 = 84, + // `SUB r8, r/m8` + // + // `2A /r` + // + // `8086+` + // + // `16/32/64-bit` + Sub_r8_rm8 = 85, + // `SUB r16, r/m16` + // + // `o16 2B /r` + // + // `8086+` + // + // `16/32/64-bit` + Sub_r16_rm16 = 86, + // `SUB r32, r/m32` + // + // `o32 2B /r` + // + // `386+` + // + // `16/32/64-bit` + Sub_r32_rm32 = 87, + // `SUB r64, r/m64` + // + // `o64 2B /r` + // + // `X64` + // + // `64-bit` + Sub_r64_rm64 = 88, + // `SUB AL, imm8` + // + // `2C ib` + // + // `8086+` + // + // `16/32/64-bit` + Sub_AL_imm8 = 89, + // `SUB AX, imm16` + // + // `o16 2D iw` + // + // `8086+` + // + // `16/32/64-bit` + Sub_AX_imm16 = 90, + // `SUB EAX, imm32` + // + // `o32 2D id` + // + // `386+` + // + // `16/32/64-bit` + Sub_EAX_imm32 = 91, + // `SUB RAX, imm32` + // + // `o64 2D id` + // + // `X64` + // + // `64-bit` + Sub_RAX_imm32 = 92, + // `DAS` + // + // `2F` + // + // `8086+` + // + // `16/32-bit` + Das = 93, + // `XOR r/m8, r8` + // + // `30 /r` + // + // `8086+` + // + // `16/32/64-bit` + Xor_rm8_r8 = 94, + // `XOR r/m16, r16` + // + // `o16 31 /r` + // + // `8086+` + // + // `16/32/64-bit` + Xor_rm16_r16 = 95, + // `XOR r/m32, r32` + // + // `o32 31 /r` + // + // `386+` + // + // `16/32/64-bit` + Xor_rm32_r32 = 96, + // `XOR r/m64, r64` + // + // `o64 31 /r` + // + // `X64` + // + // `64-bit` + Xor_rm64_r64 = 97, + // `XOR r8, r/m8` + // + // `32 /r` + // + // `8086+` + // + // `16/32/64-bit` + Xor_r8_rm8 = 98, + // `XOR r16, r/m16` + // + // `o16 33 /r` + // + // `8086+` + // + // `16/32/64-bit` + Xor_r16_rm16 = 99, + // `XOR r32, r/m32` + // + // `o32 33 /r` + // + // `386+` + // + // `16/32/64-bit` + Xor_r32_rm32 = 100, + // `XOR r64, r/m64` + // + // `o64 33 /r` + // + // `X64` + // + // `64-bit` + Xor_r64_rm64 = 101, + // `XOR AL, imm8` + // + // `34 ib` + // + // `8086+` + // + // `16/32/64-bit` + Xor_AL_imm8 = 102, + // `XOR AX, imm16` + // + // `o16 35 iw` + // + // `8086+` + // + // `16/32/64-bit` + Xor_AX_imm16 = 103, + // `XOR EAX, imm32` + // + // `o32 35 id` + // + // `386+` + // + // `16/32/64-bit` + Xor_EAX_imm32 = 104, + // `XOR RAX, imm32` + // + // `o64 35 id` + // + // `X64` + // + // `64-bit` + Xor_RAX_imm32 = 105, + // `AAA` + // + // `37` + // + // `8086+` + // + // `16/32-bit` + Aaa = 106, + // `CMP r/m8, r8` + // + // `38 /r` + // + // `8086+` + // + // `16/32/64-bit` + Cmp_rm8_r8 = 107, + // `CMP r/m16, r16` + // + // `o16 39 /r` + // + // `8086+` + // + // `16/32/64-bit` + Cmp_rm16_r16 = 108, + // `CMP r/m32, r32` + // + // `o32 39 /r` + // + // `386+` + // + // `16/32/64-bit` + Cmp_rm32_r32 = 109, + // `CMP r/m64, r64` + // + // `o64 39 /r` + // + // `X64` + // + // `64-bit` + Cmp_rm64_r64 = 110, + // `CMP r8, r/m8` + // + // `3A /r` + // + // `8086+` + // + // `16/32/64-bit` + Cmp_r8_rm8 = 111, + // `CMP r16, r/m16` + // + // `o16 3B /r` + // + // `8086+` + // + // `16/32/64-bit` + Cmp_r16_rm16 = 112, + // `CMP r32, r/m32` + // + // `o32 3B /r` + // + // `386+` + // + // `16/32/64-bit` + Cmp_r32_rm32 = 113, + // `CMP r64, r/m64` + // + // `o64 3B /r` + // + // `X64` + // + // `64-bit` + Cmp_r64_rm64 = 114, + // `CMP AL, imm8` + // + // `3C ib` + // + // `8086+` + // + // `16/32/64-bit` + Cmp_AL_imm8 = 115, + // `CMP AX, imm16` + // + // `o16 3D iw` + // + // `8086+` + // + // `16/32/64-bit` + Cmp_AX_imm16 = 116, + // `CMP EAX, imm32` + // + // `o32 3D id` + // + // `386+` + // + // `16/32/64-bit` + Cmp_EAX_imm32 = 117, + // `CMP RAX, imm32` + // + // `o64 3D id` + // + // `X64` + // + // `64-bit` + Cmp_RAX_imm32 = 118, + // `AAS` + // + // `3F` + // + // `8086+` + // + // `16/32-bit` + Aas = 119, + // `INC r16` + // + // `o16 40+rw` + // + // `8086+` + // + // `16/32-bit` + Inc_r16 = 120, + // `INC r32` + // + // `o32 40+rd` + // + // `386+` + // + // `16/32-bit` + Inc_r32 = 121, + // `DEC r16` + // + // `o16 48+rw` + // + // `8086+` + // + // `16/32-bit` + Dec_r16 = 122, + // `DEC r32` + // + // `o32 48+rd` + // + // `386+` + // + // `16/32-bit` + Dec_r32 = 123, + // `PUSH r16` + // + // `o16 50+rw` + // + // `8086+` + // + // `16/32/64-bit` + Push_r16 = 124, + // `PUSH r32` + // + // `o32 50+rd` + // + // `386+` + // + // `16/32-bit` + Push_r32 = 125, + // `PUSH r64` + // + // `o64 50+ro` + // + // `X64` + // + // `64-bit` + Push_r64 = 126, + // `POP r16` + // + // `o16 58+rw` + // + // `8086+` + // + // `16/32/64-bit` + Pop_r16 = 127, + // `POP r32` + // + // `o32 58+rd` + // + // `386+` + // + // `16/32-bit` + Pop_r32 = 128, + // `POP r64` + // + // `o64 58+ro` + // + // `X64` + // + // `64-bit` + Pop_r64 = 129, + // `PUSHA` + // + // `o16 60` + // + // `186+` + // + // `16/32-bit` + Pushaw = 130, + // `PUSHAD` + // + // `o32 60` + // + // `386+` + // + // `16/32-bit` + Pushad = 131, + // `POPA` + // + // `o16 61` + // + // `186+` + // + // `16/32-bit` + Popaw = 132, + // `POPAD` + // + // `o32 61` + // + // `386+` + // + // `16/32-bit` + Popad = 133, + // `BOUND r16, m16&16` + // + // `o16 62 /r` + // + // `186+` + // + // `16/32-bit` + Bound_r16_m1616 = 134, + // `BOUND r32, m32&32` + // + // `o32 62 /r` + // + // `386+` + // + // `16/32-bit` + Bound_r32_m3232 = 135, + // `ARPL r/m16, r16` + // + // `o16 63 /r` + // + // `286+` + // + // `16/32-bit` + Arpl_rm16_r16 = 136, + // `ARPL r32/m16, r32` + // + // `o32 63 /r` + // + // `386+` + // + // `16/32-bit` + Arpl_r32m16_r32 = 137, + // `MOVSXD r16, r/m16` + // + // `o16 63 /r` + // + // `X64` + // + // `64-bit` + Movsxd_r16_rm16 = 138, + // `MOVSXD r32, r/m32` + // + // `o32 63 /r` + // + // `X64` + // + // `64-bit` + Movsxd_r32_rm32 = 139, + // `MOVSXD r64, r/m32` + // + // `o64 63 /r` + // + // `X64` + // + // `64-bit` + Movsxd_r64_rm32 = 140, + // `PUSH imm16` + // + // `o16 68 iw` + // + // `186+` + // + // `16/32/64-bit` + Push_imm16 = 141, + // `PUSH imm32` + // + // `o32 68 id` + // + // `386+` + // + // `16/32-bit` + Pushd_imm32 = 142, + // `PUSH imm32` + // + // `o64 68 id` + // + // `X64` + // + // `64-bit` + Pushq_imm32 = 143, + // `IMUL r16, r/m16, imm16` + // + // `o16 69 /r iw` + // + // `186+` + // + // `16/32/64-bit` + Imul_r16_rm16_imm16 = 144, + // `IMUL r32, r/m32, imm32` + // + // `o32 69 /r id` + // + // `386+` + // + // `16/32/64-bit` + Imul_r32_rm32_imm32 = 145, + // `IMUL r64, r/m64, imm32` + // + // `o64 69 /r id` + // + // `X64` + // + // `64-bit` + Imul_r64_rm64_imm32 = 146, + // `PUSH imm8` + // + // `o16 6A ib` + // + // `186+` + // + // `16/32/64-bit` + Pushw_imm8 = 147, + // `PUSH imm8` + // + // `o32 6A ib` + // + // `386+` + // + // `16/32-bit` + Pushd_imm8 = 148, + // `PUSH imm8` + // + // `o64 6A ib` + // + // `X64` + // + // `64-bit` + Pushq_imm8 = 149, + // `IMUL r16, r/m16, imm8` + // + // `o16 6B /r ib` + // + // `186+` + // + // `16/32/64-bit` + Imul_r16_rm16_imm8 = 150, + // `IMUL r32, r/m32, imm8` + // + // `o32 6B /r ib` + // + // `386+` + // + // `16/32/64-bit` + Imul_r32_rm32_imm8 = 151, + // `IMUL r64, r/m64, imm8` + // + // `o64 6B /r ib` + // + // `X64` + // + // `64-bit` + Imul_r64_rm64_imm8 = 152, + // `INSB` + // + // `6C` + // + // `186+` + // + // `16/32/64-bit` + Insb_m8_DX = 153, + // `INSW` + // + // `o16 6D` + // + // `186+` + // + // `16/32/64-bit` + Insw_m16_DX = 154, + // `INSD` + // + // `o32 6D` + // + // `386+` + // + // `16/32/64-bit` + Insd_m32_DX = 155, + // `OUTSB` + // + // `6E` + // + // `186+` + // + // `16/32/64-bit` + Outsb_DX_m8 = 156, + // `OUTSW` + // + // `o16 6F` + // + // `186+` + // + // `16/32/64-bit` + Outsw_DX_m16 = 157, + // `OUTSD` + // + // `o32 6F` + // + // `386+` + // + // `16/32/64-bit` + Outsd_DX_m32 = 158, + // `JO rel8` + // + // `o16 70 cb` + // + // `8086+` + // + // `16/32/64-bit` + Jo_rel8_16 = 159, + // `JO rel8` + // + // `o32 70 cb` + // + // `386+` + // + // `16/32-bit` + Jo_rel8_32 = 160, + // `JO rel8` + // + // `o64 70 cb` + // + // `X64` + // + // `64-bit` + Jo_rel8_64 = 161, + // `JNO rel8` + // + // `o16 71 cb` + // + // `8086+` + // + // `16/32/64-bit` + Jno_rel8_16 = 162, + // `JNO rel8` + // + // `o32 71 cb` + // + // `386+` + // + // `16/32-bit` + Jno_rel8_32 = 163, + // `JNO rel8` + // + // `o64 71 cb` + // + // `X64` + // + // `64-bit` + Jno_rel8_64 = 164, + // `JB rel8` + // + // `o16 72 cb` + // + // `8086+` + // + // `16/32/64-bit` + Jb_rel8_16 = 165, + // `JB rel8` + // + // `o32 72 cb` + // + // `386+` + // + // `16/32-bit` + Jb_rel8_32 = 166, + // `JB rel8` + // + // `o64 72 cb` + // + // `X64` + // + // `64-bit` + Jb_rel8_64 = 167, + // `JAE rel8` + // + // `o16 73 cb` + // + // `8086+` + // + // `16/32/64-bit` + Jae_rel8_16 = 168, + // `JAE rel8` + // + // `o32 73 cb` + // + // `386+` + // + // `16/32-bit` + Jae_rel8_32 = 169, + // `JAE rel8` + // + // `o64 73 cb` + // + // `X64` + // + // `64-bit` + Jae_rel8_64 = 170, + // `JE rel8` + // + // `o16 74 cb` + // + // `8086+` + // + // `16/32/64-bit` + Je_rel8_16 = 171, + // `JE rel8` + // + // `o32 74 cb` + // + // `386+` + // + // `16/32-bit` + Je_rel8_32 = 172, + // `JE rel8` + // + // `o64 74 cb` + // + // `X64` + // + // `64-bit` + Je_rel8_64 = 173, + // `JNE rel8` + // + // `o16 75 cb` + // + // `8086+` + // + // `16/32/64-bit` + Jne_rel8_16 = 174, + // `JNE rel8` + // + // `o32 75 cb` + // + // `386+` + // + // `16/32-bit` + Jne_rel8_32 = 175, + // `JNE rel8` + // + // `o64 75 cb` + // + // `X64` + // + // `64-bit` + Jne_rel8_64 = 176, + // `JBE rel8` + // + // `o16 76 cb` + // + // `8086+` + // + // `16/32/64-bit` + Jbe_rel8_16 = 177, + // `JBE rel8` + // + // `o32 76 cb` + // + // `386+` + // + // `16/32-bit` + Jbe_rel8_32 = 178, + // `JBE rel8` + // + // `o64 76 cb` + // + // `X64` + // + // `64-bit` + Jbe_rel8_64 = 179, + // `JA rel8` + // + // `o16 77 cb` + // + // `8086+` + // + // `16/32/64-bit` + Ja_rel8_16 = 180, + // `JA rel8` + // + // `o32 77 cb` + // + // `386+` + // + // `16/32-bit` + Ja_rel8_32 = 181, + // `JA rel8` + // + // `o64 77 cb` + // + // `X64` + // + // `64-bit` + Ja_rel8_64 = 182, + // `JS rel8` + // + // `o16 78 cb` + // + // `8086+` + // + // `16/32/64-bit` + Js_rel8_16 = 183, + // `JS rel8` + // + // `o32 78 cb` + // + // `386+` + // + // `16/32-bit` + Js_rel8_32 = 184, + // `JS rel8` + // + // `o64 78 cb` + // + // `X64` + // + // `64-bit` + Js_rel8_64 = 185, + // `JNS rel8` + // + // `o16 79 cb` + // + // `8086+` + // + // `16/32/64-bit` + Jns_rel8_16 = 186, + // `JNS rel8` + // + // `o32 79 cb` + // + // `386+` + // + // `16/32-bit` + Jns_rel8_32 = 187, + // `JNS rel8` + // + // `o64 79 cb` + // + // `X64` + // + // `64-bit` + Jns_rel8_64 = 188, + // `JP rel8` + // + // `o16 7A cb` + // + // `8086+` + // + // `16/32/64-bit` + Jp_rel8_16 = 189, + // `JP rel8` + // + // `o32 7A cb` + // + // `386+` + // + // `16/32-bit` + Jp_rel8_32 = 190, + // `JP rel8` + // + // `o64 7A cb` + // + // `X64` + // + // `64-bit` + Jp_rel8_64 = 191, + // `JNP rel8` + // + // `o16 7B cb` + // + // `8086+` + // + // `16/32/64-bit` + Jnp_rel8_16 = 192, + // `JNP rel8` + // + // `o32 7B cb` + // + // `386+` + // + // `16/32-bit` + Jnp_rel8_32 = 193, + // `JNP rel8` + // + // `o64 7B cb` + // + // `X64` + // + // `64-bit` + Jnp_rel8_64 = 194, + // `JL rel8` + // + // `o16 7C cb` + // + // `8086+` + // + // `16/32/64-bit` + Jl_rel8_16 = 195, + // `JL rel8` + // + // `o32 7C cb` + // + // `386+` + // + // `16/32-bit` + Jl_rel8_32 = 196, + // `JL rel8` + // + // `o64 7C cb` + // + // `X64` + // + // `64-bit` + Jl_rel8_64 = 197, + // `JGE rel8` + // + // `o16 7D cb` + // + // `8086+` + // + // `16/32/64-bit` + Jge_rel8_16 = 198, + // `JGE rel8` + // + // `o32 7D cb` + // + // `386+` + // + // `16/32-bit` + Jge_rel8_32 = 199, + // `JGE rel8` + // + // `o64 7D cb` + // + // `X64` + // + // `64-bit` + Jge_rel8_64 = 200, + // `JLE rel8` + // + // `o16 7E cb` + // + // `8086+` + // + // `16/32/64-bit` + Jle_rel8_16 = 201, + // `JLE rel8` + // + // `o32 7E cb` + // + // `386+` + // + // `16/32-bit` + Jle_rel8_32 = 202, + // `JLE rel8` + // + // `o64 7E cb` + // + // `X64` + // + // `64-bit` + Jle_rel8_64 = 203, + // `JG rel8` + // + // `o16 7F cb` + // + // `8086+` + // + // `16/32/64-bit` + Jg_rel8_16 = 204, + // `JG rel8` + // + // `o32 7F cb` + // + // `386+` + // + // `16/32-bit` + Jg_rel8_32 = 205, + // `JG rel8` + // + // `o64 7F cb` + // + // `X64` + // + // `64-bit` + Jg_rel8_64 = 206, + // `ADD r/m8, imm8` + // + // `80 /0 ib` + // + // `8086+` + // + // `16/32/64-bit` + Add_rm8_imm8 = 207, + // `OR r/m8, imm8` + // + // `80 /1 ib` + // + // `8086+` + // + // `16/32/64-bit` + Or_rm8_imm8 = 208, + // `ADC r/m8, imm8` + // + // `80 /2 ib` + // + // `8086+` + // + // `16/32/64-bit` + Adc_rm8_imm8 = 209, + // `SBB r/m8, imm8` + // + // `80 /3 ib` + // + // `8086+` + // + // `16/32/64-bit` + Sbb_rm8_imm8 = 210, + // `AND r/m8, imm8` + // + // `80 /4 ib` + // + // `8086+` + // + // `16/32/64-bit` + And_rm8_imm8 = 211, + // `SUB r/m8, imm8` + // + // `80 /5 ib` + // + // `8086+` + // + // `16/32/64-bit` + Sub_rm8_imm8 = 212, + // `XOR r/m8, imm8` + // + // `80 /6 ib` + // + // `8086+` + // + // `16/32/64-bit` + Xor_rm8_imm8 = 213, + // `CMP r/m8, imm8` + // + // `80 /7 ib` + // + // `8086+` + // + // `16/32/64-bit` + Cmp_rm8_imm8 = 214, + // `ADD r/m16, imm16` + // + // `o16 81 /0 iw` + // + // `8086+` + // + // `16/32/64-bit` + Add_rm16_imm16 = 215, + // `ADD r/m32, imm32` + // + // `o32 81 /0 id` + // + // `386+` + // + // `16/32/64-bit` + Add_rm32_imm32 = 216, + // `ADD r/m64, imm32` + // + // `o64 81 /0 id` + // + // `X64` + // + // `64-bit` + Add_rm64_imm32 = 217, + // `OR r/m16, imm16` + // + // `o16 81 /1 iw` + // + // `8086+` + // + // `16/32/64-bit` + Or_rm16_imm16 = 218, + // `OR r/m32, imm32` + // + // `o32 81 /1 id` + // + // `386+` + // + // `16/32/64-bit` + Or_rm32_imm32 = 219, + // `OR r/m64, imm32` + // + // `o64 81 /1 id` + // + // `X64` + // + // `64-bit` + Or_rm64_imm32 = 220, + // `ADC r/m16, imm16` + // + // `o16 81 /2 iw` + // + // `8086+` + // + // `16/32/64-bit` + Adc_rm16_imm16 = 221, + // `ADC r/m32, imm32` + // + // `o32 81 /2 id` + // + // `386+` + // + // `16/32/64-bit` + Adc_rm32_imm32 = 222, + // `ADC r/m64, imm32` + // + // `o64 81 /2 id` + // + // `X64` + // + // `64-bit` + Adc_rm64_imm32 = 223, + // `SBB r/m16, imm16` + // + // `o16 81 /3 iw` + // + // `8086+` + // + // `16/32/64-bit` + Sbb_rm16_imm16 = 224, + // `SBB r/m32, imm32` + // + // `o32 81 /3 id` + // + // `386+` + // + // `16/32/64-bit` + Sbb_rm32_imm32 = 225, + // `SBB r/m64, imm32` + // + // `o64 81 /3 id` + // + // `X64` + // + // `64-bit` + Sbb_rm64_imm32 = 226, + // `AND r/m16, imm16` + // + // `o16 81 /4 iw` + // + // `8086+` + // + // `16/32/64-bit` + And_rm16_imm16 = 227, + // `AND r/m32, imm32` + // + // `o32 81 /4 id` + // + // `386+` + // + // `16/32/64-bit` + And_rm32_imm32 = 228, + // `AND r/m64, imm32` + // + // `o64 81 /4 id` + // + // `X64` + // + // `64-bit` + And_rm64_imm32 = 229, + // `SUB r/m16, imm16` + // + // `o16 81 /5 iw` + // + // `8086+` + // + // `16/32/64-bit` + Sub_rm16_imm16 = 230, + // `SUB r/m32, imm32` + // + // `o32 81 /5 id` + // + // `386+` + // + // `16/32/64-bit` + Sub_rm32_imm32 = 231, + // `SUB r/m64, imm32` + // + // `o64 81 /5 id` + // + // `X64` + // + // `64-bit` + Sub_rm64_imm32 = 232, + // `XOR r/m16, imm16` + // + // `o16 81 /6 iw` + // + // `8086+` + // + // `16/32/64-bit` + Xor_rm16_imm16 = 233, + // `XOR r/m32, imm32` + // + // `o32 81 /6 id` + // + // `386+` + // + // `16/32/64-bit` + Xor_rm32_imm32 = 234, + // `XOR r/m64, imm32` + // + // `o64 81 /6 id` + // + // `X64` + // + // `64-bit` + Xor_rm64_imm32 = 235, + // `CMP r/m16, imm16` + // + // `o16 81 /7 iw` + // + // `8086+` + // + // `16/32/64-bit` + Cmp_rm16_imm16 = 236, + // `CMP r/m32, imm32` + // + // `o32 81 /7 id` + // + // `386+` + // + // `16/32/64-bit` + Cmp_rm32_imm32 = 237, + // `CMP r/m64, imm32` + // + // `o64 81 /7 id` + // + // `X64` + // + // `64-bit` + Cmp_rm64_imm32 = 238, + // `ADD r/m8, imm8` + // + // `82 /0 ib` + // + // `8086+` + // + // `16/32-bit` + Add_rm8_imm8_82 = 239, + // `OR r/m8, imm8` + // + // `82 /1 ib` + // + // `8086+` + // + // `16/32-bit` + Or_rm8_imm8_82 = 240, + // `ADC r/m8, imm8` + // + // `82 /2 ib` + // + // `8086+` + // + // `16/32-bit` + Adc_rm8_imm8_82 = 241, + // `SBB r/m8, imm8` + // + // `82 /3 ib` + // + // `8086+` + // + // `16/32-bit` + Sbb_rm8_imm8_82 = 242, + // `AND r/m8, imm8` + // + // `82 /4 ib` + // + // `8086+` + // + // `16/32-bit` + And_rm8_imm8_82 = 243, + // `SUB r/m8, imm8` + // + // `82 /5 ib` + // + // `8086+` + // + // `16/32-bit` + Sub_rm8_imm8_82 = 244, + // `XOR r/m8, imm8` + // + // `82 /6 ib` + // + // `8086+` + // + // `16/32-bit` + Xor_rm8_imm8_82 = 245, + // `CMP r/m8, imm8` + // + // `82 /7 ib` + // + // `8086+` + // + // `16/32-bit` + Cmp_rm8_imm8_82 = 246, + // `ADD r/m16, imm8` + // + // `o16 83 /0 ib` + // + // `8086+` + // + // `16/32/64-bit` + Add_rm16_imm8 = 247, + // `ADD r/m32, imm8` + // + // `o32 83 /0 ib` + // + // `386+` + // + // `16/32/64-bit` + Add_rm32_imm8 = 248, + // `ADD r/m64, imm8` + // + // `o64 83 /0 ib` + // + // `X64` + // + // `64-bit` + Add_rm64_imm8 = 249, + // `OR r/m16, imm8` + // + // `o16 83 /1 ib` + // + // `8086+` + // + // `16/32/64-bit` + Or_rm16_imm8 = 250, + // `OR r/m32, imm8` + // + // `o32 83 /1 ib` + // + // `386+` + // + // `16/32/64-bit` + Or_rm32_imm8 = 251, + // `OR r/m64, imm8` + // + // `o64 83 /1 ib` + // + // `X64` + // + // `64-bit` + Or_rm64_imm8 = 252, + // `ADC r/m16, imm8` + // + // `o16 83 /2 ib` + // + // `8086+` + // + // `16/32/64-bit` + Adc_rm16_imm8 = 253, + // `ADC r/m32, imm8` + // + // `o32 83 /2 ib` + // + // `386+` + // + // `16/32/64-bit` + Adc_rm32_imm8 = 254, + // `ADC r/m64, imm8` + // + // `o64 83 /2 ib` + // + // `X64` + // + // `64-bit` + Adc_rm64_imm8 = 255, + // `SBB r/m16, imm8` + // + // `o16 83 /3 ib` + // + // `8086+` + // + // `16/32/64-bit` + Sbb_rm16_imm8 = 256, + // `SBB r/m32, imm8` + // + // `o32 83 /3 ib` + // + // `386+` + // + // `16/32/64-bit` + Sbb_rm32_imm8 = 257, + // `SBB r/m64, imm8` + // + // `o64 83 /3 ib` + // + // `X64` + // + // `64-bit` + Sbb_rm64_imm8 = 258, + // `AND r/m16, imm8` + // + // `o16 83 /4 ib` + // + // `8086+` + // + // `16/32/64-bit` + And_rm16_imm8 = 259, + // `AND r/m32, imm8` + // + // `o32 83 /4 ib` + // + // `386+` + // + // `16/32/64-bit` + And_rm32_imm8 = 260, + // `AND r/m64, imm8` + // + // `o64 83 /4 ib` + // + // `X64` + // + // `64-bit` + And_rm64_imm8 = 261, + // `SUB r/m16, imm8` + // + // `o16 83 /5 ib` + // + // `8086+` + // + // `16/32/64-bit` + Sub_rm16_imm8 = 262, + // `SUB r/m32, imm8` + // + // `o32 83 /5 ib` + // + // `386+` + // + // `16/32/64-bit` + Sub_rm32_imm8 = 263, + // `SUB r/m64, imm8` + // + // `o64 83 /5 ib` + // + // `X64` + // + // `64-bit` + Sub_rm64_imm8 = 264, + // `XOR r/m16, imm8` + // + // `o16 83 /6 ib` + // + // `8086+` + // + // `16/32/64-bit` + Xor_rm16_imm8 = 265, + // `XOR r/m32, imm8` + // + // `o32 83 /6 ib` + // + // `386+` + // + // `16/32/64-bit` + Xor_rm32_imm8 = 266, + // `XOR r/m64, imm8` + // + // `o64 83 /6 ib` + // + // `X64` + // + // `64-bit` + Xor_rm64_imm8 = 267, + // `CMP r/m16, imm8` + // + // `o16 83 /7 ib` + // + // `8086+` + // + // `16/32/64-bit` + Cmp_rm16_imm8 = 268, + // `CMP r/m32, imm8` + // + // `o32 83 /7 ib` + // + // `386+` + // + // `16/32/64-bit` + Cmp_rm32_imm8 = 269, + // `CMP r/m64, imm8` + // + // `o64 83 /7 ib` + // + // `X64` + // + // `64-bit` + Cmp_rm64_imm8 = 270, + // `TEST r/m8, r8` + // + // `84 /r` + // + // `8086+` + // + // `16/32/64-bit` + Test_rm8_r8 = 271, + // `TEST r/m16, r16` + // + // `o16 85 /r` + // + // `8086+` + // + // `16/32/64-bit` + Test_rm16_r16 = 272, + // `TEST r/m32, r32` + // + // `o32 85 /r` + // + // `386+` + // + // `16/32/64-bit` + Test_rm32_r32 = 273, + // `TEST r/m64, r64` + // + // `o64 85 /r` + // + // `X64` + // + // `64-bit` + Test_rm64_r64 = 274, + // `XCHG r/m8, r8` + // + // `86 /r` + // + // `8086+` + // + // `16/32/64-bit` + Xchg_rm8_r8 = 275, + // `XCHG r/m16, r16` + // + // `o16 87 /r` + // + // `8086+` + // + // `16/32/64-bit` + Xchg_rm16_r16 = 276, + // `XCHG r/m32, r32` + // + // `o32 87 /r` + // + // `386+` + // + // `16/32/64-bit` + Xchg_rm32_r32 = 277, + // `XCHG r/m64, r64` + // + // `o64 87 /r` + // + // `X64` + // + // `64-bit` + Xchg_rm64_r64 = 278, + // `MOV r/m8, r8` + // + // `88 /r` + // + // `8086+` + // + // `16/32/64-bit` + Mov_rm8_r8 = 279, + // `MOV r/m16, r16` + // + // `o16 89 /r` + // + // `8086+` + // + // `16/32/64-bit` + Mov_rm16_r16 = 280, + // `MOV r/m32, r32` + // + // `o32 89 /r` + // + // `386+` + // + // `16/32/64-bit` + Mov_rm32_r32 = 281, + // `MOV r/m64, r64` + // + // `o64 89 /r` + // + // `X64` + // + // `64-bit` + Mov_rm64_r64 = 282, + // `MOV r8, r/m8` + // + // `8A /r` + // + // `8086+` + // + // `16/32/64-bit` + Mov_r8_rm8 = 283, + // `MOV r16, r/m16` + // + // `o16 8B /r` + // + // `8086+` + // + // `16/32/64-bit` + Mov_r16_rm16 = 284, + // `MOV r32, r/m32` + // + // `o32 8B /r` + // + // `386+` + // + // `16/32/64-bit` + Mov_r32_rm32 = 285, + // `MOV r64, r/m64` + // + // `o64 8B /r` + // + // `X64` + // + // `64-bit` + Mov_r64_rm64 = 286, + // `MOV r/m16, Sreg` + // + // `o16 8C /r` + // + // `8086+` + // + // `16/32/64-bit` + Mov_rm16_Sreg = 287, + // `MOV r32/m16, Sreg` + // + // `o32 8C /r` + // + // `386+` + // + // `16/32/64-bit` + Mov_r32m16_Sreg = 288, + // `MOV r64/m16, Sreg` + // + // `o64 8C /r` + // + // `X64` + // + // `64-bit` + Mov_r64m16_Sreg = 289, + // `LEA r16, m` + // + // `o16 8D /r` + // + // `8086+` + // + // `16/32/64-bit` + Lea_r16_m = 290, + // `LEA r32, m` + // + // `o32 8D /r` + // + // `386+` + // + // `16/32/64-bit` + Lea_r32_m = 291, + // `LEA r64, m` + // + // `o64 8D /r` + // + // `X64` + // + // `64-bit` + Lea_r64_m = 292, + // `MOV Sreg, r/m16` + // + // `o16 8E /r` + // + // `8086+` + // + // `16/32/64-bit` + Mov_Sreg_rm16 = 293, + // `MOV Sreg, r32/m16` + // + // `o32 8E /r` + // + // `386+` + // + // `16/32/64-bit` + Mov_Sreg_r32m16 = 294, + // `MOV Sreg, r64/m16` + // + // `o64 8E /r` + // + // `X64` + // + // `64-bit` + Mov_Sreg_r64m16 = 295, + // `POP r/m16` + // + // `o16 8F /0` + // + // `8086+` + // + // `16/32/64-bit` + Pop_rm16 = 296, + // `POP r/m32` + // + // `o32 8F /0` + // + // `386+` + // + // `16/32-bit` + Pop_rm32 = 297, + // `POP r/m64` + // + // `o64 8F /0` + // + // `X64` + // + // `64-bit` + Pop_rm64 = 298, + // `NOP` + // + // `o16 90` + // + // `8086+` + // + // `16/32/64-bit` + Nopw = 299, + // `NOP` + // + // `o32 90` + // + // `8086+` + // + // `16/32/64-bit` + Nopd = 300, + // `NOP` + // + // `o64 90` + // + // `8086+` + // + // `64-bit` + Nopq = 301, + // `XCHG r16, AX` + // + // `o16 90+rw` + // + // `8086+` + // + // `16/32/64-bit` + Xchg_r16_AX = 302, + // `XCHG r32, EAX` + // + // `o32 90+rd` + // + // `386+` + // + // `16/32/64-bit` + Xchg_r32_EAX = 303, + // `XCHG r64, RAX` + // + // `o64 90+ro` + // + // `X64` + // + // `64-bit` + Xchg_r64_RAX = 304, + // `PAUSE` + // + // `F3 90` + // + // `Pentium 4 or later` + // + // `16/32/64-bit` + Pause = 305, + // `CBW` + // + // `o16 98` + // + // `8086+` + // + // `16/32/64-bit` + Cbw = 306, + // `CWDE` + // + // `o32 98` + // + // `386+` + // + // `16/32/64-bit` + Cwde = 307, + // `CDQE` + // + // `o64 98` + // + // `X64` + // + // `64-bit` + Cdqe = 308, + // `CWD` + // + // `o16 99` + // + // `8086+` + // + // `16/32/64-bit` + Cwd = 309, + // `CDQ` + // + // `o32 99` + // + // `386+` + // + // `16/32/64-bit` + Cdq = 310, + // `CQO` + // + // `o64 99` + // + // `X64` + // + // `64-bit` + Cqo = 311, + // `CALL ptr16:16` + // + // `o16 9A cd` + // + // `8086+` + // + // `16/32-bit` + Call_ptr1616 = 312, + // `CALL ptr16:32` + // + // `o32 9A cp` + // + // `386+` + // + // `16/32-bit` + Call_ptr1632 = 313, + // `WAIT` + // + // `9B` + // + // `8086+` + // + // `16/32/64-bit` + Wait = 314, + // `PUSHF` + // + // `o16 9C` + // + // `8086+` + // + // `16/32/64-bit` + Pushfw = 315, + // `PUSHFD` + // + // `o32 9C` + // + // `386+` + // + // `16/32-bit` + Pushfd = 316, + // `PUSHFQ` + // + // `o64 9C` + // + // `X64` + // + // `64-bit` + Pushfq = 317, + // `POPF` + // + // `o16 9D` + // + // `8086+` + // + // `16/32/64-bit` + Popfw = 318, + // `POPFD` + // + // `o32 9D` + // + // `386+` + // + // `16/32-bit` + Popfd = 319, + // `POPFQ` + // + // `o64 9D` + // + // `X64` + // + // `64-bit` + Popfq = 320, + // `SAHF` + // + // `9E` + // + // `8086+` + // + // `16/32/64-bit` + Sahf = 321, + // `LAHF` + // + // `9F` + // + // `8086+` + // + // `16/32/64-bit` + Lahf = 322, + // `MOV AL, moffs8` + // + // `A0 mo` + // + // `8086+` + // + // `16/32/64-bit` + Mov_AL_moffs8 = 323, + // `MOV AX, moffs16` + // + // `o16 A1 mo` + // + // `8086+` + // + // `16/32/64-bit` + Mov_AX_moffs16 = 324, + // `MOV EAX, moffs32` + // + // `o32 A1 mo` + // + // `386+` + // + // `16/32/64-bit` + Mov_EAX_moffs32 = 325, + // `MOV RAX, moffs64` + // + // `o64 A1 mo` + // + // `X64` + // + // `64-bit` + Mov_RAX_moffs64 = 326, + // `MOV moffs8, AL` + // + // `A2 mo` + // + // `8086+` + // + // `16/32/64-bit` + Mov_moffs8_AL = 327, + // `MOV moffs16, AX` + // + // `o16 A3 mo` + // + // `8086+` + // + // `16/32/64-bit` + Mov_moffs16_AX = 328, + // `MOV moffs32, EAX` + // + // `o32 A3 mo` + // + // `386+` + // + // `16/32/64-bit` + Mov_moffs32_EAX = 329, + // `MOV moffs64, RAX` + // + // `o64 A3 mo` + // + // `X64` + // + // `64-bit` + Mov_moffs64_RAX = 330, + // `MOVSB` + // + // `A4` + // + // `8086+` + // + // `16/32/64-bit` + Movsb_m8_m8 = 331, + // `MOVSW` + // + // `o16 A5` + // + // `8086+` + // + // `16/32/64-bit` + Movsw_m16_m16 = 332, + // `MOVSD` + // + // `o32 A5` + // + // `386+` + // + // `16/32/64-bit` + Movsd_m32_m32 = 333, + // `MOVSQ` + // + // `o64 A5` + // + // `X64` + // + // `64-bit` + Movsq_m64_m64 = 334, + // `CMPSB` + // + // `A6` + // + // `8086+` + // + // `16/32/64-bit` + Cmpsb_m8_m8 = 335, + // `CMPSW` + // + // `o16 A7` + // + // `8086+` + // + // `16/32/64-bit` + Cmpsw_m16_m16 = 336, + // `CMPSD` + // + // `o32 A7` + // + // `386+` + // + // `16/32/64-bit` + Cmpsd_m32_m32 = 337, + // `CMPSQ` + // + // `o64 A7` + // + // `X64` + // + // `64-bit` + Cmpsq_m64_m64 = 338, + // `TEST AL, imm8` + // + // `A8 ib` + // + // `8086+` + // + // `16/32/64-bit` + Test_AL_imm8 = 339, + // `TEST AX, imm16` + // + // `o16 A9 iw` + // + // `8086+` + // + // `16/32/64-bit` + Test_AX_imm16 = 340, + // `TEST EAX, imm32` + // + // `o32 A9 id` + // + // `386+` + // + // `16/32/64-bit` + Test_EAX_imm32 = 341, + // `TEST RAX, imm32` + // + // `o64 A9 id` + // + // `X64` + // + // `64-bit` + Test_RAX_imm32 = 342, + // `STOSB` + // + // `AA` + // + // `8086+` + // + // `16/32/64-bit` + Stosb_m8_AL = 343, + // `STOSW` + // + // `o16 AB` + // + // `8086+` + // + // `16/32/64-bit` + Stosw_m16_AX = 344, + // `STOSD` + // + // `o32 AB` + // + // `386+` + // + // `16/32/64-bit` + Stosd_m32_EAX = 345, + // `STOSQ` + // + // `o64 AB` + // + // `X64` + // + // `64-bit` + Stosq_m64_RAX = 346, + // `LODSB` + // + // `AC` + // + // `8086+` + // + // `16/32/64-bit` + Lodsb_AL_m8 = 347, + // `LODSW` + // + // `o16 AD` + // + // `8086+` + // + // `16/32/64-bit` + Lodsw_AX_m16 = 348, + // `LODSD` + // + // `o32 AD` + // + // `386+` + // + // `16/32/64-bit` + Lodsd_EAX_m32 = 349, + // `LODSQ` + // + // `o64 AD` + // + // `X64` + // + // `64-bit` + Lodsq_RAX_m64 = 350, + // `SCASB` + // + // `AE` + // + // `8086+` + // + // `16/32/64-bit` + Scasb_AL_m8 = 351, + // `SCASW` + // + // `o16 AF` + // + // `8086+` + // + // `16/32/64-bit` + Scasw_AX_m16 = 352, + // `SCASD` + // + // `o32 AF` + // + // `386+` + // + // `16/32/64-bit` + Scasd_EAX_m32 = 353, + // `SCASQ` + // + // `o64 AF` + // + // `X64` + // + // `64-bit` + Scasq_RAX_m64 = 354, + // `MOV r8, imm8` + // + // `B0+rb ib` + // + // `8086+` + // + // `16/32/64-bit` + Mov_r8_imm8 = 355, + // `MOV r16, imm16` + // + // `o16 B8+rw iw` + // + // `8086+` + // + // `16/32/64-bit` + Mov_r16_imm16 = 356, + // `MOV r32, imm32` + // + // `o32 B8+rd id` + // + // `386+` + // + // `16/32/64-bit` + Mov_r32_imm32 = 357, + // `MOV r64, imm64` + // + // `o64 B8+ro io` + // + // `X64` + // + // `64-bit` + Mov_r64_imm64 = 358, + // `ROL r/m8, imm8` + // + // `C0 /0 ib` + // + // `186+` + // + // `16/32/64-bit` + Rol_rm8_imm8 = 359, + // `ROR r/m8, imm8` + // + // `C0 /1 ib` + // + // `186+` + // + // `16/32/64-bit` + Ror_rm8_imm8 = 360, + // `RCL r/m8, imm8` + // + // `C0 /2 ib` + // + // `186+` + // + // `16/32/64-bit` + Rcl_rm8_imm8 = 361, + // `RCR r/m8, imm8` + // + // `C0 /3 ib` + // + // `186+` + // + // `16/32/64-bit` + Rcr_rm8_imm8 = 362, + // `SHL r/m8, imm8` + // + // `C0 /4 ib` + // + // `186+` + // + // `16/32/64-bit` + Shl_rm8_imm8 = 363, + // `SHR r/m8, imm8` + // + // `C0 /5 ib` + // + // `186+` + // + // `16/32/64-bit` + Shr_rm8_imm8 = 364, + // `SAL r/m8, imm8` + // + // `C0 /6 ib` + // + // `186+` + // + // `16/32/64-bit` + Sal_rm8_imm8 = 365, + // `SAR r/m8, imm8` + // + // `C0 /7 ib` + // + // `186+` + // + // `16/32/64-bit` + Sar_rm8_imm8 = 366, + // `ROL r/m16, imm8` + // + // `o16 C1 /0 ib` + // + // `186+` + // + // `16/32/64-bit` + Rol_rm16_imm8 = 367, + // `ROL r/m32, imm8` + // + // `o32 C1 /0 ib` + // + // `386+` + // + // `16/32/64-bit` + Rol_rm32_imm8 = 368, + // `ROL r/m64, imm8` + // + // `o64 C1 /0 ib` + // + // `X64` + // + // `64-bit` + Rol_rm64_imm8 = 369, + // `ROR r/m16, imm8` + // + // `o16 C1 /1 ib` + // + // `186+` + // + // `16/32/64-bit` + Ror_rm16_imm8 = 370, + // `ROR r/m32, imm8` + // + // `o32 C1 /1 ib` + // + // `386+` + // + // `16/32/64-bit` + Ror_rm32_imm8 = 371, + // `ROR r/m64, imm8` + // + // `o64 C1 /1 ib` + // + // `X64` + // + // `64-bit` + Ror_rm64_imm8 = 372, + // `RCL r/m16, imm8` + // + // `o16 C1 /2 ib` + // + // `186+` + // + // `16/32/64-bit` + Rcl_rm16_imm8 = 373, + // `RCL r/m32, imm8` + // + // `o32 C1 /2 ib` + // + // `386+` + // + // `16/32/64-bit` + Rcl_rm32_imm8 = 374, + // `RCL r/m64, imm8` + // + // `o64 C1 /2 ib` + // + // `X64` + // + // `64-bit` + Rcl_rm64_imm8 = 375, + // `RCR r/m16, imm8` + // + // `o16 C1 /3 ib` + // + // `186+` + // + // `16/32/64-bit` + Rcr_rm16_imm8 = 376, + // `RCR r/m32, imm8` + // + // `o32 C1 /3 ib` + // + // `386+` + // + // `16/32/64-bit` + Rcr_rm32_imm8 = 377, + // `RCR r/m64, imm8` + // + // `o64 C1 /3 ib` + // + // `X64` + // + // `64-bit` + Rcr_rm64_imm8 = 378, + // `SHL r/m16, imm8` + // + // `o16 C1 /4 ib` + // + // `186+` + // + // `16/32/64-bit` + Shl_rm16_imm8 = 379, + // `SHL r/m32, imm8` + // + // `o32 C1 /4 ib` + // + // `386+` + // + // `16/32/64-bit` + Shl_rm32_imm8 = 380, + // `SHL r/m64, imm8` + // + // `o64 C1 /4 ib` + // + // `X64` + // + // `64-bit` + Shl_rm64_imm8 = 381, + // `SHR r/m16, imm8` + // + // `o16 C1 /5 ib` + // + // `186+` + // + // `16/32/64-bit` + Shr_rm16_imm8 = 382, + // `SHR r/m32, imm8` + // + // `o32 C1 /5 ib` + // + // `386+` + // + // `16/32/64-bit` + Shr_rm32_imm8 = 383, + // `SHR r/m64, imm8` + // + // `o64 C1 /5 ib` + // + // `X64` + // + // `64-bit` + Shr_rm64_imm8 = 384, + // `SAL r/m16, imm8` + // + // `o16 C1 /6 ib` + // + // `186+` + // + // `16/32/64-bit` + Sal_rm16_imm8 = 385, + // `SAL r/m32, imm8` + // + // `o32 C1 /6 ib` + // + // `386+` + // + // `16/32/64-bit` + Sal_rm32_imm8 = 386, + // `SAL r/m64, imm8` + // + // `o64 C1 /6 ib` + // + // `X64` + // + // `64-bit` + Sal_rm64_imm8 = 387, + // `SAR r/m16, imm8` + // + // `o16 C1 /7 ib` + // + // `186+` + // + // `16/32/64-bit` + Sar_rm16_imm8 = 388, + // `SAR r/m32, imm8` + // + // `o32 C1 /7 ib` + // + // `386+` + // + // `16/32/64-bit` + Sar_rm32_imm8 = 389, + // `SAR r/m64, imm8` + // + // `o64 C1 /7 ib` + // + // `X64` + // + // `64-bit` + Sar_rm64_imm8 = 390, + // `RET imm16` + // + // `o16 C2 iw` + // + // `8086+` + // + // `16/32/64-bit` + Retnw_imm16 = 391, + // `RET imm16` + // + // `o32 C2 iw` + // + // `386+` + // + // `16/32-bit` + Retnd_imm16 = 392, + // `RET imm16` + // + // `o64 C2 iw` + // + // `X64` + // + // `64-bit` + Retnq_imm16 = 393, + // `RET` + // + // `o16 C3` + // + // `8086+` + // + // `16/32/64-bit` + Retnw = 394, + // `RET` + // + // `o32 C3` + // + // `386+` + // + // `16/32-bit` + Retnd = 395, + // `RET` + // + // `o64 C3` + // + // `X64` + // + // `64-bit` + Retnq = 396, + // `LES r16, m16:16` + // + // `o16 C4 /r` + // + // `8086+` + // + // `16/32-bit` + Les_r16_m1616 = 397, + // `LES r32, m16:32` + // + // `o32 C4 /r` + // + // `386+` + // + // `16/32-bit` + Les_r32_m1632 = 398, + // `LDS r16, m16:16` + // + // `o16 C5 /r` + // + // `8086+` + // + // `16/32-bit` + Lds_r16_m1616 = 399, + // `LDS r32, m16:32` + // + // `o32 C5 /r` + // + // `386+` + // + // `16/32-bit` + Lds_r32_m1632 = 400, + // `MOV r/m8, imm8` + // + // `C6 /0 ib` + // + // `8086+` + // + // `16/32/64-bit` + Mov_rm8_imm8 = 401, + // `XABORT imm8` + // + // `C6 F8 ib` + // + // `RTM` + // + // `16/32/64-bit` + Xabort_imm8 = 402, + // `MOV r/m16, imm16` + // + // `o16 C7 /0 iw` + // + // `8086+` + // + // `16/32/64-bit` + Mov_rm16_imm16 = 403, + // `MOV r/m32, imm32` + // + // `o32 C7 /0 id` + // + // `386+` + // + // `16/32/64-bit` + Mov_rm32_imm32 = 404, + // `MOV r/m64, imm32` + // + // `o64 C7 /0 id` + // + // `X64` + // + // `64-bit` + Mov_rm64_imm32 = 405, + // `XBEGIN rel16` + // + // `o16 C7 F8 cw` + // + // `RTM` + // + // `16/32/64-bit` + Xbegin_rel16 = 406, + // `XBEGIN rel32` + // + // `o32 C7 F8 cd` + // + // `RTM` + // + // `16/32/64-bit` + Xbegin_rel32 = 407, + // `ENTER imm16, imm8` + // + // `o16 C8 iw ib` + // + // `186+` + // + // `16/32/64-bit` + Enterw_imm16_imm8 = 408, + // `ENTER imm16, imm8` + // + // `o32 C8 iw ib` + // + // `386+` + // + // `16/32-bit` + Enterd_imm16_imm8 = 409, + // `ENTER imm16, imm8` + // + // `o64 C8 iw ib` + // + // `X64` + // + // `64-bit` + Enterq_imm16_imm8 = 410, + // `LEAVE` + // + // `o16 C9` + // + // `186+` + // + // `16/32/64-bit` + Leavew = 411, + // `LEAVE` + // + // `o32 C9` + // + // `386+` + // + // `16/32-bit` + Leaved = 412, + // `LEAVE` + // + // `o64 C9` + // + // `X64` + // + // `64-bit` + Leaveq = 413, + // `RETF imm16` + // + // `o16 CA iw` + // + // `8086+` + // + // `16/32/64-bit` + Retfw_imm16 = 414, + // `RETF imm16` + // + // `o32 CA iw` + // + // `386+` + // + // `16/32/64-bit` + Retfd_imm16 = 415, + // `RETF imm16` + // + // `o64 CA iw` + // + // `X64` + // + // `64-bit` + Retfq_imm16 = 416, + // `RETF` + // + // `o16 CB` + // + // `8086+` + // + // `16/32/64-bit` + Retfw = 417, + // `RETF` + // + // `o32 CB` + // + // `386+` + // + // `16/32/64-bit` + Retfd = 418, + // `RETF` + // + // `o64 CB` + // + // `X64` + // + // `64-bit` + Retfq = 419, + // `INT3` + // + // `CC` + // + // `8086+` + // + // `16/32/64-bit` + Int3 = 420, + // `INT imm8` + // + // `CD ib` + // + // `8086+` + // + // `16/32/64-bit` + Int_imm8 = 421, + // `INTO` + // + // `CE` + // + // `8086+` + // + // `16/32-bit` + Into = 422, + // `IRET` + // + // `o16 CF` + // + // `8086+` + // + // `16/32/64-bit` + Iretw = 423, + // `IRETD` + // + // `o32 CF` + // + // `386+` + // + // `16/32/64-bit` + Iretd = 424, + // `IRETQ` + // + // `o64 CF` + // + // `X64` + // + // `64-bit` + Iretq = 425, + // `ROL r/m8, 1` + // + // `D0 /0` + // + // `8086+` + // + // `16/32/64-bit` + Rol_rm8_1 = 426, + // `ROR r/m8, 1` + // + // `D0 /1` + // + // `8086+` + // + // `16/32/64-bit` + Ror_rm8_1 = 427, + // `RCL r/m8, 1` + // + // `D0 /2` + // + // `8086+` + // + // `16/32/64-bit` + Rcl_rm8_1 = 428, + // `RCR r/m8, 1` + // + // `D0 /3` + // + // `8086+` + // + // `16/32/64-bit` + Rcr_rm8_1 = 429, + // `SHL r/m8, 1` + // + // `D0 /4` + // + // `8086+` + // + // `16/32/64-bit` + Shl_rm8_1 = 430, + // `SHR r/m8, 1` + // + // `D0 /5` + // + // `8086+` + // + // `16/32/64-bit` + Shr_rm8_1 = 431, + // `SAL r/m8, 1` + // + // `D0 /6` + // + // `8086+` + // + // `16/32/64-bit` + Sal_rm8_1 = 432, + // `SAR r/m8, 1` + // + // `D0 /7` + // + // `8086+` + // + // `16/32/64-bit` + Sar_rm8_1 = 433, + // `ROL r/m16, 1` + // + // `o16 D1 /0` + // + // `8086+` + // + // `16/32/64-bit` + Rol_rm16_1 = 434, + // `ROL r/m32, 1` + // + // `o32 D1 /0` + // + // `386+` + // + // `16/32/64-bit` + Rol_rm32_1 = 435, + // `ROL r/m64, 1` + // + // `o64 D1 /0` + // + // `X64` + // + // `64-bit` + Rol_rm64_1 = 436, + // `ROR r/m16, 1` + // + // `o16 D1 /1` + // + // `8086+` + // + // `16/32/64-bit` + Ror_rm16_1 = 437, + // `ROR r/m32, 1` + // + // `o32 D1 /1` + // + // `386+` + // + // `16/32/64-bit` + Ror_rm32_1 = 438, + // `ROR r/m64, 1` + // + // `o64 D1 /1` + // + // `X64` + // + // `64-bit` + Ror_rm64_1 = 439, + // `RCL r/m16, 1` + // + // `o16 D1 /2` + // + // `8086+` + // + // `16/32/64-bit` + Rcl_rm16_1 = 440, + // `RCL r/m32, 1` + // + // `o32 D1 /2` + // + // `386+` + // + // `16/32/64-bit` + Rcl_rm32_1 = 441, + // `RCL r/m64, 1` + // + // `o64 D1 /2` + // + // `X64` + // + // `64-bit` + Rcl_rm64_1 = 442, + // `RCR r/m16, 1` + // + // `o16 D1 /3` + // + // `8086+` + // + // `16/32/64-bit` + Rcr_rm16_1 = 443, + // `RCR r/m32, 1` + // + // `o32 D1 /3` + // + // `386+` + // + // `16/32/64-bit` + Rcr_rm32_1 = 444, + // `RCR r/m64, 1` + // + // `o64 D1 /3` + // + // `X64` + // + // `64-bit` + Rcr_rm64_1 = 445, + // `SHL r/m16, 1` + // + // `o16 D1 /4` + // + // `8086+` + // + // `16/32/64-bit` + Shl_rm16_1 = 446, + // `SHL r/m32, 1` + // + // `o32 D1 /4` + // + // `386+` + // + // `16/32/64-bit` + Shl_rm32_1 = 447, + // `SHL r/m64, 1` + // + // `o64 D1 /4` + // + // `X64` + // + // `64-bit` + Shl_rm64_1 = 448, + // `SHR r/m16, 1` + // + // `o16 D1 /5` + // + // `8086+` + // + // `16/32/64-bit` + Shr_rm16_1 = 449, + // `SHR r/m32, 1` + // + // `o32 D1 /5` + // + // `386+` + // + // `16/32/64-bit` + Shr_rm32_1 = 450, + // `SHR r/m64, 1` + // + // `o64 D1 /5` + // + // `X64` + // + // `64-bit` + Shr_rm64_1 = 451, + // `SAL r/m16, 1` + // + // `o16 D1 /6` + // + // `8086+` + // + // `16/32/64-bit` + Sal_rm16_1 = 452, + // `SAL r/m32, 1` + // + // `o32 D1 /6` + // + // `386+` + // + // `16/32/64-bit` + Sal_rm32_1 = 453, + // `SAL r/m64, 1` + // + // `o64 D1 /6` + // + // `X64` + // + // `64-bit` + Sal_rm64_1 = 454, + // `SAR r/m16, 1` + // + // `o16 D1 /7` + // + // `8086+` + // + // `16/32/64-bit` + Sar_rm16_1 = 455, + // `SAR r/m32, 1` + // + // `o32 D1 /7` + // + // `386+` + // + // `16/32/64-bit` + Sar_rm32_1 = 456, + // `SAR r/m64, 1` + // + // `o64 D1 /7` + // + // `X64` + // + // `64-bit` + Sar_rm64_1 = 457, + // `ROL r/m8, CL` + // + // `D2 /0` + // + // `8086+` + // + // `16/32/64-bit` + Rol_rm8_CL = 458, + // `ROR r/m8, CL` + // + // `D2 /1` + // + // `8086+` + // + // `16/32/64-bit` + Ror_rm8_CL = 459, + // `RCL r/m8, CL` + // + // `D2 /2` + // + // `8086+` + // + // `16/32/64-bit` + Rcl_rm8_CL = 460, + // `RCR r/m8, CL` + // + // `D2 /3` + // + // `8086+` + // + // `16/32/64-bit` + Rcr_rm8_CL = 461, + // `SHL r/m8, CL` + // + // `D2 /4` + // + // `8086+` + // + // `16/32/64-bit` + Shl_rm8_CL = 462, + // `SHR r/m8, CL` + // + // `D2 /5` + // + // `8086+` + // + // `16/32/64-bit` + Shr_rm8_CL = 463, + // `SAL r/m8, CL` + // + // `D2 /6` + // + // `8086+` + // + // `16/32/64-bit` + Sal_rm8_CL = 464, + // `SAR r/m8, CL` + // + // `D2 /7` + // + // `8086+` + // + // `16/32/64-bit` + Sar_rm8_CL = 465, + // `ROL r/m16, CL` + // + // `o16 D3 /0` + // + // `8086+` + // + // `16/32/64-bit` + Rol_rm16_CL = 466, + // `ROL r/m32, CL` + // + // `o32 D3 /0` + // + // `386+` + // + // `16/32/64-bit` + Rol_rm32_CL = 467, + // `ROL r/m64, CL` + // + // `o64 D3 /0` + // + // `X64` + // + // `64-bit` + Rol_rm64_CL = 468, + // `ROR r/m16, CL` + // + // `o16 D3 /1` + // + // `8086+` + // + // `16/32/64-bit` + Ror_rm16_CL = 469, + // `ROR r/m32, CL` + // + // `o32 D3 /1` + // + // `386+` + // + // `16/32/64-bit` + Ror_rm32_CL = 470, + // `ROR r/m64, CL` + // + // `o64 D3 /1` + // + // `X64` + // + // `64-bit` + Ror_rm64_CL = 471, + // `RCL r/m16, CL` + // + // `o16 D3 /2` + // + // `8086+` + // + // `16/32/64-bit` + Rcl_rm16_CL = 472, + // `RCL r/m32, CL` + // + // `o32 D3 /2` + // + // `386+` + // + // `16/32/64-bit` + Rcl_rm32_CL = 473, + // `RCL r/m64, CL` + // + // `o64 D3 /2` + // + // `X64` + // + // `64-bit` + Rcl_rm64_CL = 474, + // `RCR r/m16, CL` + // + // `o16 D3 /3` + // + // `8086+` + // + // `16/32/64-bit` + Rcr_rm16_CL = 475, + // `RCR r/m32, CL` + // + // `o32 D3 /3` + // + // `386+` + // + // `16/32/64-bit` + Rcr_rm32_CL = 476, + // `RCR r/m64, CL` + // + // `o64 D3 /3` + // + // `X64` + // + // `64-bit` + Rcr_rm64_CL = 477, + // `SHL r/m16, CL` + // + // `o16 D3 /4` + // + // `8086+` + // + // `16/32/64-bit` + Shl_rm16_CL = 478, + // `SHL r/m32, CL` + // + // `o32 D3 /4` + // + // `386+` + // + // `16/32/64-bit` + Shl_rm32_CL = 479, + // `SHL r/m64, CL` + // + // `o64 D3 /4` + // + // `X64` + // + // `64-bit` + Shl_rm64_CL = 480, + // `SHR r/m16, CL` + // + // `o16 D3 /5` + // + // `8086+` + // + // `16/32/64-bit` + Shr_rm16_CL = 481, + // `SHR r/m32, CL` + // + // `o32 D3 /5` + // + // `386+` + // + // `16/32/64-bit` + Shr_rm32_CL = 482, + // `SHR r/m64, CL` + // + // `o64 D3 /5` + // + // `X64` + // + // `64-bit` + Shr_rm64_CL = 483, + // `SAL r/m16, CL` + // + // `o16 D3 /6` + // + // `8086+` + // + // `16/32/64-bit` + Sal_rm16_CL = 484, + // `SAL r/m32, CL` + // + // `o32 D3 /6` + // + // `386+` + // + // `16/32/64-bit` + Sal_rm32_CL = 485, + // `SAL r/m64, CL` + // + // `o64 D3 /6` + // + // `X64` + // + // `64-bit` + Sal_rm64_CL = 486, + // `SAR r/m16, CL` + // + // `o16 D3 /7` + // + // `8086+` + // + // `16/32/64-bit` + Sar_rm16_CL = 487, + // `SAR r/m32, CL` + // + // `o32 D3 /7` + // + // `386+` + // + // `16/32/64-bit` + Sar_rm32_CL = 488, + // `SAR r/m64, CL` + // + // `o64 D3 /7` + // + // `X64` + // + // `64-bit` + Sar_rm64_CL = 489, + // `AAM imm8` + // + // `D4 ib` + // + // `8086+` + // + // `16/32-bit` + Aam_imm8 = 490, + // `AAD imm8` + // + // `D5 ib` + // + // `8086+` + // + // `16/32-bit` + Aad_imm8 = 491, + // `SALC` + // + // `D6` + // + // `8086+` + // + // `16/32-bit` + Salc = 492, + // `XLATB` + // + // `D7` + // + // `8086+` + // + // `16/32/64-bit` + Xlat_m8 = 493, + // `FADD m32fp` + // + // `D8 /0` + // + // `8087+` + // + // `16/32/64-bit` + Fadd_m32fp = 494, + // `FMUL m32fp` + // + // `D8 /1` + // + // `8087+` + // + // `16/32/64-bit` + Fmul_m32fp = 495, + // `FCOM m32fp` + // + // `D8 /2` + // + // `8087+` + // + // `16/32/64-bit` + Fcom_m32fp = 496, + // `FCOMP m32fp` + // + // `D8 /3` + // + // `8087+` + // + // `16/32/64-bit` + Fcomp_m32fp = 497, + // `FSUB m32fp` + // + // `D8 /4` + // + // `8087+` + // + // `16/32/64-bit` + Fsub_m32fp = 498, + // `FSUBR m32fp` + // + // `D8 /5` + // + // `8087+` + // + // `16/32/64-bit` + Fsubr_m32fp = 499, + // `FDIV m32fp` + // + // `D8 /6` + // + // `8087+` + // + // `16/32/64-bit` + Fdiv_m32fp = 500, + // `FDIVR m32fp` + // + // `D8 /7` + // + // `8087+` + // + // `16/32/64-bit` + Fdivr_m32fp = 501, + // `FADD ST(0), ST(i)` + // + // `D8 C0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fadd_st0_sti = 502, + // `FMUL ST(0), ST(i)` + // + // `D8 C8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fmul_st0_sti = 503, + // `FCOM ST(i)` + // + // `D8 D0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fcom_st0_sti = 504, + // `FCOMP ST(i)` + // + // `D8 D8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fcomp_st0_sti = 505, + // `FSUB ST(0), ST(i)` + // + // `D8 E0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fsub_st0_sti = 506, + // `FSUBR ST(0), ST(i)` + // + // `D8 E8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fsubr_st0_sti = 507, + // `FDIV ST(0), ST(i)` + // + // `D8 F0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fdiv_st0_sti = 508, + // `FDIVR ST(0), ST(i)` + // + // `D8 F8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fdivr_st0_sti = 509, + // `FLD m32fp` + // + // `D9 /0` + // + // `8087+` + // + // `16/32/64-bit` + Fld_m32fp = 510, + // `FST m32fp` + // + // `D9 /2` + // + // `8087+` + // + // `16/32/64-bit` + Fst_m32fp = 511, + // `FSTP m32fp` + // + // `D9 /3` + // + // `8087+` + // + // `16/32/64-bit` + Fstp_m32fp = 512, + // `FLDENV m14byte` + // + // `o16 D9 /4` + // + // `8087+` + // + // `16/32/64-bit` + Fldenv_m14byte = 513, + // `FLDENV m28byte` + // + // `o32 D9 /4` + // + // `387+` + // + // `16/32/64-bit` + Fldenv_m28byte = 514, + // `FLDCW m2byte` + // + // `D9 /5` + // + // `8087+` + // + // `16/32/64-bit` + Fldcw_m2byte = 515, + // `FNSTENV m14byte` + // + // `o16 D9 /6` + // + // `8087+` + // + // `16/32/64-bit` + Fnstenv_m14byte = 516, + // `FSTENV m14byte` + // + // `9B o16 D9 /6` + // + // `8087+` + // + // `16/32/64-bit` + Fstenv_m14byte = 517, + // `FNSTENV m28byte` + // + // `o32 D9 /6` + // + // `387+` + // + // `16/32/64-bit` + Fnstenv_m28byte = 518, + // `FSTENV m28byte` + // + // `9B o32 D9 /6` + // + // `387+` + // + // `16/32/64-bit` + Fstenv_m28byte = 519, + // `FNSTCW m2byte` + // + // `D9 /7` + // + // `8087+` + // + // `16/32/64-bit` + Fnstcw_m2byte = 520, + // `FSTCW m2byte` + // + // `9B D9 /7` + // + // `8087+` + // + // `16/32/64-bit` + Fstcw_m2byte = 521, + // `FLD ST(i)` + // + // `D9 C0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fld_sti = 522, + // `FXCH ST(i)` + // + // `D9 C8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fxch_st0_sti = 523, + // `FNOP` + // + // `D9 D0` + // + // `8087+` + // + // `16/32/64-bit` + Fnop = 524, + // `FSTPNCE ST(i)` + // + // `D9 D8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fstpnce_sti = 525, + // `FCHS` + // + // `D9 E0` + // + // `8087+` + // + // `16/32/64-bit` + Fchs = 526, + // `FABS` + // + // `D9 E1` + // + // `8087+` + // + // `16/32/64-bit` + Fabs = 527, + // `FTST` + // + // `D9 E4` + // + // `8087+` + // + // `16/32/64-bit` + Ftst = 528, + // `FXAM` + // + // `D9 E5` + // + // `8087+` + // + // `16/32/64-bit` + Fxam = 529, + // `FLD1` + // + // `D9 E8` + // + // `8087+` + // + // `16/32/64-bit` + Fld1 = 530, + // `FLDL2T` + // + // `D9 E9` + // + // `8087+` + // + // `16/32/64-bit` + Fldl2t = 531, + // `FLDL2E` + // + // `D9 EA` + // + // `8087+` + // + // `16/32/64-bit` + Fldl2e = 532, + // `FLDPI` + // + // `D9 EB` + // + // `8087+` + // + // `16/32/64-bit` + Fldpi = 533, + // `FLDLG2` + // + // `D9 EC` + // + // `8087+` + // + // `16/32/64-bit` + Fldlg2 = 534, + // `FLDLN2` + // + // `D9 ED` + // + // `8087+` + // + // `16/32/64-bit` + Fldln2 = 535, + // `FLDZ` + // + // `D9 EE` + // + // `8087+` + // + // `16/32/64-bit` + Fldz = 536, + // `F2XM1` + // + // `D9 F0` + // + // `8087+` + // + // `16/32/64-bit` + F2xm1 = 537, + // `FYL2X` + // + // `D9 F1` + // + // `8087+` + // + // `16/32/64-bit` + Fyl2x = 538, + // `FPTAN` + // + // `D9 F2` + // + // `8087+` + // + // `16/32/64-bit` + Fptan = 539, + // `FPATAN` + // + // `D9 F3` + // + // `8087+` + // + // `16/32/64-bit` + Fpatan = 540, + // `FXTRACT` + // + // `D9 F4` + // + // `8087+` + // + // `16/32/64-bit` + Fxtract = 541, + // `FPREM1` + // + // `D9 F5` + // + // `387+` + // + // `16/32/64-bit` + Fprem1 = 542, + // `FDECSTP` + // + // `D9 F6` + // + // `8087+` + // + // `16/32/64-bit` + Fdecstp = 543, + // `FINCSTP` + // + // `D9 F7` + // + // `8087+` + // + // `16/32/64-bit` + Fincstp = 544, + // `FPREM` + // + // `D9 F8` + // + // `8087+` + // + // `16/32/64-bit` + Fprem = 545, + // `FYL2XP1` + // + // `D9 F9` + // + // `8087+` + // + // `16/32/64-bit` + Fyl2xp1 = 546, + // `FSQRT` + // + // `D9 FA` + // + // `8087+` + // + // `16/32/64-bit` + Fsqrt = 547, + // `FSINCOS` + // + // `D9 FB` + // + // `387+` + // + // `16/32/64-bit` + Fsincos = 548, + // `FRNDINT` + // + // `D9 FC` + // + // `8087+` + // + // `16/32/64-bit` + Frndint = 549, + // `FSCALE` + // + // `D9 FD` + // + // `8087+` + // + // `16/32/64-bit` + Fscale = 550, + // `FSIN` + // + // `D9 FE` + // + // `387+` + // + // `16/32/64-bit` + Fsin = 551, + // `FCOS` + // + // `D9 FF` + // + // `387+` + // + // `16/32/64-bit` + Fcos = 552, + // `FIADD m32int` + // + // `DA /0` + // + // `8087+` + // + // `16/32/64-bit` + Fiadd_m32int = 553, + // `FIMUL m32int` + // + // `DA /1` + // + // `8087+` + // + // `16/32/64-bit` + Fimul_m32int = 554, + // `FICOM m32int` + // + // `DA /2` + // + // `8087+` + // + // `16/32/64-bit` + Ficom_m32int = 555, + // `FICOMP m32int` + // + // `DA /3` + // + // `8087+` + // + // `16/32/64-bit` + Ficomp_m32int = 556, + // `FISUB m32int` + // + // `DA /4` + // + // `8087+` + // + // `16/32/64-bit` + Fisub_m32int = 557, + // `FISUBR m32int` + // + // `DA /5` + // + // `8087+` + // + // `16/32/64-bit` + Fisubr_m32int = 558, + // `FIDIV m32int` + // + // `DA /6` + // + // `8087+` + // + // `16/32/64-bit` + Fidiv_m32int = 559, + // `FIDIVR m32int` + // + // `DA /7` + // + // `8087+` + // + // `16/32/64-bit` + Fidivr_m32int = 560, + // `FCMOVB ST(0), ST(i)` + // + // `DA C0+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fcmovb_st0_sti = 561, + // `FCMOVE ST(0), ST(i)` + // + // `DA C8+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fcmove_st0_sti = 562, + // `FCMOVBE ST(0), ST(i)` + // + // `DA D0+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fcmovbe_st0_sti = 563, + // `FCMOVU ST(0), ST(i)` + // + // `DA D8+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fcmovu_st0_sti = 564, + // `FUCOMPP` + // + // `DA E9` + // + // `387+` + // + // `16/32/64-bit` + Fucompp = 565, + // `FILD m32int` + // + // `DB /0` + // + // `8087+` + // + // `16/32/64-bit` + Fild_m32int = 566, + // `FISTTP m32int` + // + // `DB /1` + // + // `8087+ and SSE3` + // + // `16/32/64-bit` + Fisttp_m32int = 567, + // `FIST m32int` + // + // `DB /2` + // + // `8087+` + // + // `16/32/64-bit` + Fist_m32int = 568, + // `FISTP m32int` + // + // `DB /3` + // + // `8087+` + // + // `16/32/64-bit` + Fistp_m32int = 569, + // `FLD m80fp` + // + // `DB /5` + // + // `8087+` + // + // `16/32/64-bit` + Fld_m80fp = 570, + // `FSTP m80fp` + // + // `DB /7` + // + // `8087+` + // + // `16/32/64-bit` + Fstp_m80fp = 571, + // `FCMOVNB ST(0), ST(i)` + // + // `DB C0+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fcmovnb_st0_sti = 572, + // `FCMOVNE ST(0), ST(i)` + // + // `DB C8+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fcmovne_st0_sti = 573, + // `FCMOVNBE ST(0), ST(i)` + // + // `DB D0+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fcmovnbe_st0_sti = 574, + // `FCMOVNU ST(0), ST(i)` + // + // `DB D8+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fcmovnu_st0_sti = 575, + // `FNENI` + // + // `DB E0` + // + // `8087+` + // + // `16/32/64-bit` + Fneni = 576, + // `FENI` + // + // `9B DB E0` + // + // `8087+` + // + // `16/32/64-bit` + Feni = 577, + // `FNDISI` + // + // `DB E1` + // + // `8087+` + // + // `16/32/64-bit` + Fndisi = 578, + // `FDISI` + // + // `9B DB E1` + // + // `8087+` + // + // `16/32/64-bit` + Fdisi = 579, + // `FNCLEX` + // + // `DB E2` + // + // `8087+` + // + // `16/32/64-bit` + Fnclex = 580, + // `FCLEX` + // + // `9B DB E2` + // + // `8087+` + // + // `16/32/64-bit` + Fclex = 581, + // `FNINIT` + // + // `DB E3` + // + // `8087+` + // + // `16/32/64-bit` + Fninit = 582, + // `FINIT` + // + // `9B DB E3` + // + // `8087+` + // + // `16/32/64-bit` + Finit = 583, + // `FNSETPM` + // + // `DB E4` + // + // `287+` + // + // `16/32/64-bit` + Fnsetpm = 584, + // `FSETPM` + // + // `9B DB E4` + // + // `287+` + // + // `16/32/64-bit` + Fsetpm = 585, + // `FRSTPM` + // + // `DB E5` + // + // `287 XL` + // + // `16/32-bit` + Frstpm = 586, + // `FUCOMI ST, ST(i)` + // + // `DB E8+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fucomi_st0_sti = 587, + // `FCOMI ST, ST(i)` + // + // `DB F0+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fcomi_st0_sti = 588, + // `FADD m64fp` + // + // `DC /0` + // + // `8087+` + // + // `16/32/64-bit` + Fadd_m64fp = 589, + // `FMUL m64fp` + // + // `DC /1` + // + // `8087+` + // + // `16/32/64-bit` + Fmul_m64fp = 590, + // `FCOM m64fp` + // + // `DC /2` + // + // `8087+` + // + // `16/32/64-bit` + Fcom_m64fp = 591, + // `FCOMP m64fp` + // + // `DC /3` + // + // `8087+` + // + // `16/32/64-bit` + Fcomp_m64fp = 592, + // `FSUB m64fp` + // + // `DC /4` + // + // `8087+` + // + // `16/32/64-bit` + Fsub_m64fp = 593, + // `FSUBR m64fp` + // + // `DC /5` + // + // `8087+` + // + // `16/32/64-bit` + Fsubr_m64fp = 594, + // `FDIV m64fp` + // + // `DC /6` + // + // `8087+` + // + // `16/32/64-bit` + Fdiv_m64fp = 595, + // `FDIVR m64fp` + // + // `DC /7` + // + // `8087+` + // + // `16/32/64-bit` + Fdivr_m64fp = 596, + // `FADD ST(i), ST(0)` + // + // `DC C0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fadd_sti_st0 = 597, + // `FMUL ST(i), ST(0)` + // + // `DC C8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fmul_sti_st0 = 598, + // `FCOM ST(i)` + // + // `DC D0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fcom_st0_sti_DCD0 = 599, + // `FCOMP ST(i)` + // + // `DC D8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fcomp_st0_sti_DCD8 = 600, + // `FSUBR ST(i), ST(0)` + // + // `DC E0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fsubr_sti_st0 = 601, + // `FSUB ST(i), ST(0)` + // + // `DC E8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fsub_sti_st0 = 602, + // `FDIVR ST(i), ST(0)` + // + // `DC F0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fdivr_sti_st0 = 603, + // `FDIV ST(i), ST(0)` + // + // `DC F8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fdiv_sti_st0 = 604, + // `FLD m64fp` + // + // `DD /0` + // + // `8087+` + // + // `16/32/64-bit` + Fld_m64fp = 605, + // `FISTTP m64int` + // + // `DD /1` + // + // `8087+ and SSE3` + // + // `16/32/64-bit` + Fisttp_m64int = 606, + // `FST m64fp` + // + // `DD /2` + // + // `8087+` + // + // `16/32/64-bit` + Fst_m64fp = 607, + // `FSTP m64fp` + // + // `DD /3` + // + // `8087+` + // + // `16/32/64-bit` + Fstp_m64fp = 608, + // `FRSTOR m94byte` + // + // `o16 DD /4` + // + // `8087+` + // + // `16/32/64-bit` + Frstor_m94byte = 609, + // `FRSTOR m108byte` + // + // `o32 DD /4` + // + // `387+` + // + // `16/32/64-bit` + Frstor_m108byte = 610, + // `FNSAVE m94byte` + // + // `o16 DD /6` + // + // `8087+` + // + // `16/32/64-bit` + Fnsave_m94byte = 611, + // `FSAVE m94byte` + // + // `9B o16 DD /6` + // + // `8087+` + // + // `16/32/64-bit` + Fsave_m94byte = 612, + // `FNSAVE m108byte` + // + // `o32 DD /6` + // + // `387+` + // + // `16/32/64-bit` + Fnsave_m108byte = 613, + // `FSAVE m108byte` + // + // `9B o32 DD /6` + // + // `387+` + // + // `16/32/64-bit` + Fsave_m108byte = 614, + // `FNSTSW m2byte` + // + // `DD /7` + // + // `8087+` + // + // `16/32/64-bit` + Fnstsw_m2byte = 615, + // `FSTSW m2byte` + // + // `9B DD /7` + // + // `8087+` + // + // `16/32/64-bit` + Fstsw_m2byte = 616, + // `FFREE ST(i)` + // + // `DD C0+i` + // + // `8087+` + // + // `16/32/64-bit` + Ffree_sti = 617, + // `FXCH ST(i)` + // + // `DD C8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fxch_st0_sti_DDC8 = 618, + // `FST ST(i)` + // + // `DD D0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fst_sti = 619, + // `FSTP ST(i)` + // + // `DD D8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fstp_sti = 620, + // `FUCOM ST(i)` + // + // `DD E0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fucom_st0_sti = 621, + // `FUCOMP ST(i)` + // + // `DD E8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fucomp_st0_sti = 622, + // `FIADD m16int` + // + // `DE /0` + // + // `8087+` + // + // `16/32/64-bit` + Fiadd_m16int = 623, + // `FIMUL m16int` + // + // `DE /1` + // + // `8087+` + // + // `16/32/64-bit` + Fimul_m16int = 624, + // `FICOM m16int` + // + // `DE /2` + // + // `8087+` + // + // `16/32/64-bit` + Ficom_m16int = 625, + // `FICOMP m16int` + // + // `DE /3` + // + // `8087+` + // + // `16/32/64-bit` + Ficomp_m16int = 626, + // `FISUB m16int` + // + // `DE /4` + // + // `8087+` + // + // `16/32/64-bit` + Fisub_m16int = 627, + // `FISUBR m16int` + // + // `DE /5` + // + // `8087+` + // + // `16/32/64-bit` + Fisubr_m16int = 628, + // `FIDIV m16int` + // + // `DE /6` + // + // `8087+` + // + // `16/32/64-bit` + Fidiv_m16int = 629, + // `FIDIVR m16int` + // + // `DE /7` + // + // `8087+` + // + // `16/32/64-bit` + Fidivr_m16int = 630, + // `FADDP ST(i), ST(0)` + // + // `DE C0+i` + // + // `8087+` + // + // `16/32/64-bit` + Faddp_sti_st0 = 631, + // `FMULP ST(i), ST(0)` + // + // `DE C8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fmulp_sti_st0 = 632, + // `FCOMP ST(i)` + // + // `DE D0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fcomp_st0_sti_DED0 = 633, + // `FCOMPP` + // + // `DE D9` + // + // `8087+` + // + // `16/32/64-bit` + Fcompp = 634, + // `FSUBRP ST(i), ST(0)` + // + // `DE E0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fsubrp_sti_st0 = 635, + // `FSUBP ST(i), ST(0)` + // + // `DE E8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fsubp_sti_st0 = 636, + // `FDIVRP ST(i), ST(0)` + // + // `DE F0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fdivrp_sti_st0 = 637, + // `FDIVP ST(i), ST(0)` + // + // `DE F8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fdivp_sti_st0 = 638, + // `FILD m16int` + // + // `DF /0` + // + // `8087+` + // + // `16/32/64-bit` + Fild_m16int = 639, + // `FISTTP m16int` + // + // `DF /1` + // + // `8087+ and SSE3` + // + // `16/32/64-bit` + Fisttp_m16int = 640, + // `FIST m16int` + // + // `DF /2` + // + // `8087+` + // + // `16/32/64-bit` + Fist_m16int = 641, + // `FISTP m16int` + // + // `DF /3` + // + // `8087+` + // + // `16/32/64-bit` + Fistp_m16int = 642, + // `FBLD m80bcd` + // + // `DF /4` + // + // `8087+` + // + // `16/32/64-bit` + Fbld_m80bcd = 643, + // `FILD m64int` + // + // `DF /5` + // + // `8087+` + // + // `16/32/64-bit` + Fild_m64int = 644, + // `FBSTP m80bcd` + // + // `DF /6` + // + // `8087+` + // + // `16/32/64-bit` + Fbstp_m80bcd = 645, + // `FISTP m64int` + // + // `DF /7` + // + // `8087+` + // + // `16/32/64-bit` + Fistp_m64int = 646, + // `FFREEP ST(i)` + // + // `DF C0+i` + // + // `8087+` + // + // `16/32/64-bit` + Ffreep_sti = 647, + // `FXCH ST(i)` + // + // `DF C8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fxch_st0_sti_DFC8 = 648, + // `FSTP ST(i)` + // + // `DF D0+i` + // + // `8087+` + // + // `16/32/64-bit` + Fstp_sti_DFD0 = 649, + // `FSTP ST(i)` + // + // `DF D8+i` + // + // `8087+` + // + // `16/32/64-bit` + Fstp_sti_DFD8 = 650, + // `FNSTSW AX` + // + // `DF E0` + // + // `287+` + // + // `16/32/64-bit` + Fnstsw_AX = 651, + // `FSTSW AX` + // + // `9B DF E0` + // + // `287+` + // + // `16/32/64-bit` + Fstsw_AX = 652, + // `FSTDW AX` + // + // `9B DF E1` + // + // `387 SL` + // + // `16/32-bit` + Fstdw_AX = 653, + // `FSTSG AX` + // + // `9B DF E2` + // + // `387 SL` + // + // `16/32-bit` + Fstsg_AX = 654, + // `FUCOMIP ST, ST(i)` + // + // `DF E8+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fucomip_st0_sti = 655, + // `FCOMIP ST, ST(i)` + // + // `DF F0+i` + // + // `8087+ and CMOV` + // + // `16/32/64-bit` + Fcomip_st0_sti = 656, + // `LOOPNE rel8` + // + // `a16 o16 E0 cb` + // + // `8086+` + // + // `16/32-bit` + Loopne_rel8_16_CX = 657, + // `LOOPNE rel8` + // + // `a16 o32 E0 cb` + // + // `386+` + // + // `16/32-bit` + Loopne_rel8_32_CX = 658, + // `LOOPNE rel8` + // + // `a32 o16 E0 cb` + // + // `386+` + // + // `16/32/64-bit` + Loopne_rel8_16_ECX = 659, + // `LOOPNE rel8` + // + // `a32 o32 E0 cb` + // + // `386+` + // + // `16/32-bit` + Loopne_rel8_32_ECX = 660, + // `LOOPNE rel8` + // + // `a32 o64 E0 cb` + // + // `X64` + // + // `64-bit` + Loopne_rel8_64_ECX = 661, + // `LOOPNE rel8` + // + // `a64 o16 E0 cb` + // + // `X64` + // + // `64-bit` + Loopne_rel8_16_RCX = 662, + // `LOOPNE rel8` + // + // `a64 o64 E0 cb` + // + // `X64` + // + // `64-bit` + Loopne_rel8_64_RCX = 663, + // `LOOPE rel8` + // + // `a16 o16 E1 cb` + // + // `8086+` + // + // `16/32-bit` + Loope_rel8_16_CX = 664, + // `LOOPE rel8` + // + // `a16 o32 E1 cb` + // + // `386+` + // + // `16/32-bit` + Loope_rel8_32_CX = 665, + // `LOOPE rel8` + // + // `a32 o16 E1 cb` + // + // `386+` + // + // `16/32/64-bit` + Loope_rel8_16_ECX = 666, + // `LOOPE rel8` + // + // `a32 o32 E1 cb` + // + // `386+` + // + // `16/32-bit` + Loope_rel8_32_ECX = 667, + // `LOOPE rel8` + // + // `a32 o64 E1 cb` + // + // `X64` + // + // `64-bit` + Loope_rel8_64_ECX = 668, + // `LOOPE rel8` + // + // `a64 o16 E1 cb` + // + // `X64` + // + // `64-bit` + Loope_rel8_16_RCX = 669, + // `LOOPE rel8` + // + // `a64 o64 E1 cb` + // + // `X64` + // + // `64-bit` + Loope_rel8_64_RCX = 670, + // `LOOP rel8` + // + // `a16 o16 E2 cb` + // + // `8086+` + // + // `16/32-bit` + Loop_rel8_16_CX = 671, + // `LOOP rel8` + // + // `a16 o32 E2 cb` + // + // `386+` + // + // `16/32-bit` + Loop_rel8_32_CX = 672, + // `LOOP rel8` + // + // `a32 o16 E2 cb` + // + // `386+` + // + // `16/32/64-bit` + Loop_rel8_16_ECX = 673, + // `LOOP rel8` + // + // `a32 o32 E2 cb` + // + // `386+` + // + // `16/32-bit` + Loop_rel8_32_ECX = 674, + // `LOOP rel8` + // + // `a32 o64 E2 cb` + // + // `X64` + // + // `64-bit` + Loop_rel8_64_ECX = 675, + // `LOOP rel8` + // + // `a64 o16 E2 cb` + // + // `X64` + // + // `64-bit` + Loop_rel8_16_RCX = 676, + // `LOOP rel8` + // + // `a64 o64 E2 cb` + // + // `X64` + // + // `64-bit` + Loop_rel8_64_RCX = 677, + // `JCXZ rel8` + // + // `a16 o16 E3 cb` + // + // `8086+` + // + // `16/32-bit` + Jcxz_rel8_16 = 678, + // `JCXZ rel8` + // + // `a16 o32 E3 cb` + // + // `386+` + // + // `16/32-bit` + Jcxz_rel8_32 = 679, + // `JECXZ rel8` + // + // `a32 o16 E3 cb` + // + // `386+` + // + // `16/32/64-bit` + Jecxz_rel8_16 = 680, + // `JECXZ rel8` + // + // `a32 o32 E3 cb` + // + // `386+` + // + // `16/32-bit` + Jecxz_rel8_32 = 681, + // `JECXZ rel8` + // + // `a32 o64 E3 cb` + // + // `X64` + // + // `64-bit` + Jecxz_rel8_64 = 682, + // `JRCXZ rel8` + // + // `a64 o16 E3 cb` + // + // `X64` + // + // `64-bit` + Jrcxz_rel8_16 = 683, + // `JRCXZ rel8` + // + // `a64 o64 E3 cb` + // + // `X64` + // + // `64-bit` + Jrcxz_rel8_64 = 684, + // `IN AL, imm8` + // + // `E4 ib` + // + // `8086+` + // + // `16/32/64-bit` + In_AL_imm8 = 685, + // `IN AX, imm8` + // + // `o16 E5 ib` + // + // `8086+` + // + // `16/32/64-bit` + In_AX_imm8 = 686, + // `IN EAX, imm8` + // + // `o32 E5 ib` + // + // `386+` + // + // `16/32/64-bit` + In_EAX_imm8 = 687, + // `OUT imm8, AL` + // + // `E6 ib` + // + // `8086+` + // + // `16/32/64-bit` + Out_imm8_AL = 688, + // `OUT imm8, AX` + // + // `o16 E7 ib` + // + // `8086+` + // + // `16/32/64-bit` + Out_imm8_AX = 689, + // `OUT imm8, EAX` + // + // `o32 E7 ib` + // + // `386+` + // + // `16/32/64-bit` + Out_imm8_EAX = 690, + // `CALL rel16` + // + // `o16 E8 cw` + // + // `8086+` + // + // `16/32/64-bit` + Call_rel16 = 691, + // `CALL rel32` + // + // `o32 E8 cd` + // + // `386+` + // + // `16/32-bit` + Call_rel32_32 = 692, + // `CALL rel32` + // + // `o64 E8 cd` + // + // `X64` + // + // `64-bit` + Call_rel32_64 = 693, + // `JMP rel16` + // + // `o16 E9 cw` + // + // `8086+` + // + // `16/32/64-bit` + Jmp_rel16 = 694, + // `JMP rel32` + // + // `o32 E9 cd` + // + // `386+` + // + // `16/32-bit` + Jmp_rel32_32 = 695, + // `JMP rel32` + // + // `o64 E9 cd` + // + // `X64` + // + // `64-bit` + Jmp_rel32_64 = 696, + // `JMP ptr16:16` + // + // `o16 EA cd` + // + // `8086+` + // + // `16/32-bit` + Jmp_ptr1616 = 697, + // `JMP ptr16:32` + // + // `o32 EA cp` + // + // `386+` + // + // `16/32-bit` + Jmp_ptr1632 = 698, + // `JMP rel8` + // + // `o16 EB cb` + // + // `8086+` + // + // `16/32/64-bit` + Jmp_rel8_16 = 699, + // `JMP rel8` + // + // `o32 EB cb` + // + // `386+` + // + // `16/32-bit` + Jmp_rel8_32 = 700, + // `JMP rel8` + // + // `o64 EB cb` + // + // `X64` + // + // `64-bit` + Jmp_rel8_64 = 701, + // `IN AL, DX` + // + // `EC` + // + // `8086+` + // + // `16/32/64-bit` + In_AL_DX = 702, + // `IN AX, DX` + // + // `o16 ED` + // + // `8086+` + // + // `16/32/64-bit` + In_AX_DX = 703, + // `IN EAX, DX` + // + // `o32 ED` + // + // `386+` + // + // `16/32/64-bit` + In_EAX_DX = 704, + // `OUT DX, AL` + // + // `EE` + // + // `8086+` + // + // `16/32/64-bit` + Out_DX_AL = 705, + // `OUT DX, AX` + // + // `o16 EF` + // + // `8086+` + // + // `16/32/64-bit` + Out_DX_AX = 706, + // `OUT DX, EAX` + // + // `o32 EF` + // + // `386+` + // + // `16/32/64-bit` + Out_DX_EAX = 707, + // `INT1` + // + // `F1` + // + // `386+` + // + // `16/32/64-bit` + Int1 = 708, + // `HLT` + // + // `F4` + // + // `8086+` + // + // `16/32/64-bit` + Hlt = 709, + // `CMC` + // + // `F5` + // + // `8086+` + // + // `16/32/64-bit` + Cmc = 710, + // `TEST r/m8, imm8` + // + // `F6 /0 ib` + // + // `8086+` + // + // `16/32/64-bit` + Test_rm8_imm8 = 711, + // `TEST r/m8, imm8` + // + // `F6 /1 ib` + // + // `8086+` + // + // `16/32/64-bit` + Test_rm8_imm8_F6r1 = 712, + // `NOT r/m8` + // + // `F6 /2` + // + // `8086+` + // + // `16/32/64-bit` + Not_rm8 = 713, + // `NEG r/m8` + // + // `F6 /3` + // + // `8086+` + // + // `16/32/64-bit` + Neg_rm8 = 714, + // `MUL r/m8` + // + // `F6 /4` + // + // `8086+` + // + // `16/32/64-bit` + Mul_rm8 = 715, + // `IMUL r/m8` + // + // `F6 /5` + // + // `8086+` + // + // `16/32/64-bit` + Imul_rm8 = 716, + // `DIV r/m8` + // + // `F6 /6` + // + // `8086+` + // + // `16/32/64-bit` + Div_rm8 = 717, + // `IDIV r/m8` + // + // `F6 /7` + // + // `8086+` + // + // `16/32/64-bit` + Idiv_rm8 = 718, + // `TEST r/m16, imm16` + // + // `o16 F7 /0 iw` + // + // `8086+` + // + // `16/32/64-bit` + Test_rm16_imm16 = 719, + // `TEST r/m32, imm32` + // + // `o32 F7 /0 id` + // + // `386+` + // + // `16/32/64-bit` + Test_rm32_imm32 = 720, + // `TEST r/m64, imm32` + // + // `o64 F7 /0 id` + // + // `X64` + // + // `64-bit` + Test_rm64_imm32 = 721, + // `TEST r/m16, imm16` + // + // `o16 F7 /1 iw` + // + // `8086+` + // + // `16/32/64-bit` + Test_rm16_imm16_F7r1 = 722, + // `TEST r/m32, imm32` + // + // `o32 F7 /1 id` + // + // `386+` + // + // `16/32/64-bit` + Test_rm32_imm32_F7r1 = 723, + // `TEST r/m64, imm32` + // + // `o64 F7 /1 id` + // + // `X64` + // + // `64-bit` + Test_rm64_imm32_F7r1 = 724, + // `NOT r/m16` + // + // `o16 F7 /2` + // + // `8086+` + // + // `16/32/64-bit` + Not_rm16 = 725, + // `NOT r/m32` + // + // `o32 F7 /2` + // + // `386+` + // + // `16/32/64-bit` + Not_rm32 = 726, + // `NOT r/m64` + // + // `o64 F7 /2` + // + // `X64` + // + // `64-bit` + Not_rm64 = 727, + // `NEG r/m16` + // + // `o16 F7 /3` + // + // `8086+` + // + // `16/32/64-bit` + Neg_rm16 = 728, + // `NEG r/m32` + // + // `o32 F7 /3` + // + // `386+` + // + // `16/32/64-bit` + Neg_rm32 = 729, + // `NEG r/m64` + // + // `o64 F7 /3` + // + // `X64` + // + // `64-bit` + Neg_rm64 = 730, + // `MUL r/m16` + // + // `o16 F7 /4` + // + // `8086+` + // + // `16/32/64-bit` + Mul_rm16 = 731, + // `MUL r/m32` + // + // `o32 F7 /4` + // + // `386+` + // + // `16/32/64-bit` + Mul_rm32 = 732, + // `MUL r/m64` + // + // `o64 F7 /4` + // + // `X64` + // + // `64-bit` + Mul_rm64 = 733, + // `IMUL r/m16` + // + // `o16 F7 /5` + // + // `8086+` + // + // `16/32/64-bit` + Imul_rm16 = 734, + // `IMUL r/m32` + // + // `o32 F7 /5` + // + // `386+` + // + // `16/32/64-bit` + Imul_rm32 = 735, + // `IMUL r/m64` + // + // `o64 F7 /5` + // + // `X64` + // + // `64-bit` + Imul_rm64 = 736, + // `DIV r/m16` + // + // `o16 F7 /6` + // + // `8086+` + // + // `16/32/64-bit` + Div_rm16 = 737, + // `DIV r/m32` + // + // `o32 F7 /6` + // + // `386+` + // + // `16/32/64-bit` + Div_rm32 = 738, + // `DIV r/m64` + // + // `o64 F7 /6` + // + // `X64` + // + // `64-bit` + Div_rm64 = 739, + // `IDIV r/m16` + // + // `o16 F7 /7` + // + // `8086+` + // + // `16/32/64-bit` + Idiv_rm16 = 740, + // `IDIV r/m32` + // + // `o32 F7 /7` + // + // `386+` + // + // `16/32/64-bit` + Idiv_rm32 = 741, + // `IDIV r/m64` + // + // `o64 F7 /7` + // + // `X64` + // + // `64-bit` + Idiv_rm64 = 742, + // `CLC` + // + // `F8` + // + // `8086+` + // + // `16/32/64-bit` + Clc = 743, + // `STC` + // + // `F9` + // + // `8086+` + // + // `16/32/64-bit` + Stc = 744, + // `CLI` + // + // `FA` + // + // `8086+` + // + // `16/32/64-bit` + Cli = 745, + // `STI` + // + // `FB` + // + // `8086+` + // + // `16/32/64-bit` + Sti = 746, + // `CLD` + // + // `FC` + // + // `8086+` + // + // `16/32/64-bit` + Cld = 747, + // `STD` + // + // `FD` + // + // `8086+` + // + // `16/32/64-bit` + Std = 748, + // `INC r/m8` + // + // `FE /0` + // + // `8086+` + // + // `16/32/64-bit` + Inc_rm8 = 749, + // `DEC r/m8` + // + // `FE /1` + // + // `8086+` + // + // `16/32/64-bit` + Dec_rm8 = 750, + // `INC r/m16` + // + // `o16 FF /0` + // + // `8086+` + // + // `16/32/64-bit` + Inc_rm16 = 751, + // `INC r/m32` + // + // `o32 FF /0` + // + // `386+` + // + // `16/32/64-bit` + Inc_rm32 = 752, + // `INC r/m64` + // + // `o64 FF /0` + // + // `X64` + // + // `64-bit` + Inc_rm64 = 753, + // `DEC r/m16` + // + // `o16 FF /1` + // + // `8086+` + // + // `16/32/64-bit` + Dec_rm16 = 754, + // `DEC r/m32` + // + // `o32 FF /1` + // + // `386+` + // + // `16/32/64-bit` + Dec_rm32 = 755, + // `DEC r/m64` + // + // `o64 FF /1` + // + // `X64` + // + // `64-bit` + Dec_rm64 = 756, + // `CALL r/m16` + // + // `o16 FF /2` + // + // `8086+` + // + // `16/32/64-bit` + Call_rm16 = 757, + // `CALL r/m32` + // + // `o32 FF /2` + // + // `386+` + // + // `16/32-bit` + Call_rm32 = 758, + // `CALL r/m64` + // + // `o64 FF /2` + // + // `X64` + // + // `64-bit` + Call_rm64 = 759, + // `CALL m16:16` + // + // `o16 FF /3` + // + // `8086+` + // + // `16/32/64-bit` + Call_m1616 = 760, + // `CALL m16:32` + // + // `o32 FF /3` + // + // `386+` + // + // `16/32/64-bit` + Call_m1632 = 761, + // `CALL m16:64` + // + // `o64 FF /3` + // + // `X64` + // + // `64-bit` + Call_m1664 = 762, + // `JMP r/m16` + // + // `o16 FF /4` + // + // `8086+` + // + // `16/32/64-bit` + Jmp_rm16 = 763, + // `JMP r/m32` + // + // `o32 FF /4` + // + // `386+` + // + // `16/32-bit` + Jmp_rm32 = 764, + // `JMP r/m64` + // + // `o64 FF /4` + // + // `X64` + // + // `64-bit` + Jmp_rm64 = 765, + // `JMP m16:16` + // + // `o16 FF /5` + // + // `8086+` + // + // `16/32/64-bit` + Jmp_m1616 = 766, + // `JMP m16:32` + // + // `o32 FF /5` + // + // `386+` + // + // `16/32/64-bit` + Jmp_m1632 = 767, + // `JMP m16:64` + // + // `o64 FF /5` + // + // `X64` + // + // `64-bit` + Jmp_m1664 = 768, + // `PUSH r/m16` + // + // `o16 FF /6` + // + // `8086+` + // + // `16/32/64-bit` + Push_rm16 = 769, + // `PUSH r/m32` + // + // `o32 FF /6` + // + // `386+` + // + // `16/32-bit` + Push_rm32 = 770, + // `PUSH r/m64` + // + // `o64 FF /6` + // + // `X64` + // + // `64-bit` + Push_rm64 = 771, + // `SLDT r/m16` + // + // `o16 0F 00 /0` + // + // `286+` + // + // `16/32/64-bit` + Sldt_rm16 = 772, + // `SLDT r32/m16` + // + // `o32 0F 00 /0` + // + // `386+` + // + // `16/32/64-bit` + Sldt_r32m16 = 773, + // `SLDT r64/m16` + // + // `o64 0F 00 /0` + // + // `X64` + // + // `64-bit` + Sldt_r64m16 = 774, + // `STR r/m16` + // + // `o16 0F 00 /1` + // + // `286+` + // + // `16/32/64-bit` + Str_rm16 = 775, + // `STR r32/m16` + // + // `o32 0F 00 /1` + // + // `386+` + // + // `16/32/64-bit` + Str_r32m16 = 776, + // `STR r64/m16` + // + // `o64 0F 00 /1` + // + // `X64` + // + // `64-bit` + Str_r64m16 = 777, + // `LLDT r/m16` + // + // `o16 0F 00 /2` + // + // `286+` + // + // `16/32/64-bit` + Lldt_rm16 = 778, + // `LLDT r32/m16` + // + // `o32 0F 00 /2` + // + // `386+` + // + // `16/32/64-bit` + Lldt_r32m16 = 779, + // `LLDT r64/m16` + // + // `o64 0F 00 /2` + // + // `X64` + // + // `64-bit` + Lldt_r64m16 = 780, + // `LTR r/m16` + // + // `o16 0F 00 /3` + // + // `286+` + // + // `16/32/64-bit` + Ltr_rm16 = 781, + // `LTR r32/m16` + // + // `o32 0F 00 /3` + // + // `386+` + // + // `16/32/64-bit` + Ltr_r32m16 = 782, + // `LTR r64/m16` + // + // `o64 0F 00 /3` + // + // `X64` + // + // `64-bit` + Ltr_r64m16 = 783, + // `VERR r/m16` + // + // `o16 0F 00 /4` + // + // `286+` + // + // `16/32/64-bit` + Verr_rm16 = 784, + // `VERR r32/m16` + // + // `o32 0F 00 /4` + // + // `386+` + // + // `16/32/64-bit` + Verr_r32m16 = 785, + // `VERR r64/m16` + // + // `o64 0F 00 /4` + // + // `X64` + // + // `64-bit` + Verr_r64m16 = 786, + // `VERW r/m16` + // + // `o16 0F 00 /5` + // + // `286+` + // + // `16/32/64-bit` + Verw_rm16 = 787, + // `VERW r32/m16` + // + // `o32 0F 00 /5` + // + // `386+` + // + // `16/32/64-bit` + Verw_r32m16 = 788, + // `VERW r64/m16` + // + // `o64 0F 00 /5` + // + // `X64` + // + // `64-bit` + Verw_r64m16 = 789, + // `JMPE r/m16` + // + // `o16 0F 00 /6` + // + // `IA-64` + // + // `16/32-bit` + Jmpe_rm16 = 790, + // `JMPE r/m32` + // + // `o32 0F 00 /6` + // + // `IA-64` + // + // `16/32-bit` + Jmpe_rm32 = 791, + // `SGDT m` + // + // `o16 0F 01 /0` + // + // `286+` + // + // `16/32-bit` + Sgdt_m1632_16 = 792, + // `SGDT m` + // + // `o32 0F 01 /0` + // + // `386+` + // + // `16/32-bit` + Sgdt_m1632 = 793, + // `SGDT m` + // + // `0F 01 /0` + // + // `X64` + // + // `64-bit` + Sgdt_m1664 = 794, + // `SIDT m` + // + // `o16 0F 01 /1` + // + // `286+` + // + // `16/32-bit` + Sidt_m1632_16 = 795, + // `SIDT m` + // + // `o32 0F 01 /1` + // + // `386+` + // + // `16/32-bit` + Sidt_m1632 = 796, + // `SIDT m` + // + // `0F 01 /1` + // + // `X64` + // + // `64-bit` + Sidt_m1664 = 797, + // `LGDT m16&32` + // + // `o16 0F 01 /2` + // + // `286+` + // + // `16/32-bit` + Lgdt_m1632_16 = 798, + // `LGDT m16&32` + // + // `o32 0F 01 /2` + // + // `386+` + // + // `16/32-bit` + Lgdt_m1632 = 799, + // `LGDT m16&64` + // + // `0F 01 /2` + // + // `X64` + // + // `64-bit` + Lgdt_m1664 = 800, + // `LIDT m16&32` + // + // `o16 0F 01 /3` + // + // `286+` + // + // `16/32-bit` + Lidt_m1632_16 = 801, + // `LIDT m16&32` + // + // `o32 0F 01 /3` + // + // `386+` + // + // `16/32-bit` + Lidt_m1632 = 802, + // `LIDT m16&64` + // + // `0F 01 /3` + // + // `X64` + // + // `64-bit` + Lidt_m1664 = 803, + // `SMSW r/m16` + // + // `o16 0F 01 /4` + // + // `286+` + // + // `16/32/64-bit` + Smsw_rm16 = 804, + // `SMSW r32/m16` + // + // `o32 0F 01 /4` + // + // `386+` + // + // `16/32/64-bit` + Smsw_r32m16 = 805, + // `SMSW r64/m16` + // + // `o64 0F 01 /4` + // + // `X64` + // + // `64-bit` + Smsw_r64m16 = 806, + // `RSTORSSP m64` + // + // `F3 0F 01 /5` + // + // `CET_SS` + // + // `16/32/64-bit` + Rstorssp_m64 = 807, + // `LMSW r/m16` + // + // `o16 0F 01 /6` + // + // `286+` + // + // `16/32/64-bit` + Lmsw_rm16 = 808, + // `LMSW r32/m16` + // + // `o32 0F 01 /6` + // + // `386+` + // + // `16/32/64-bit` + Lmsw_r32m16 = 809, + // `LMSW r64/m16` + // + // `o64 0F 01 /6` + // + // `X64` + // + // `64-bit` + Lmsw_r64m16 = 810, + // `INVLPG m` + // + // `0F 01 /7` + // + // `486+` + // + // `16/32/64-bit` + Invlpg_m = 811, + // `ENCLV` + // + // `NP 0F 01 C0` + // + // `OSS` + // + // `16/32/64-bit` + Enclv = 812, + // `VMCALL` + // + // `NP 0F 01 C1` + // + // `VMX` + // + // `16/32/64-bit` + Vmcall = 813, + // `VMLAUNCH` + // + // `NP 0F 01 C2` + // + // `VMX` + // + // `16/32/64-bit` + Vmlaunch = 814, + // `VMRESUME` + // + // `NP 0F 01 C3` + // + // `VMX` + // + // `16/32/64-bit` + Vmresume = 815, + // `VMXOFF` + // + // `NP 0F 01 C4` + // + // `VMX` + // + // `16/32/64-bit` + Vmxoff = 816, + // `PCONFIG` + // + // `NP 0F 01 C5` + // + // `PCONFIG` + // + // `16/32/64-bit` + Pconfig = 817, + // `MONITOR` + // + // `a16 NP 0F 01 C8` + // + // `MONITOR` + // + // `16/32-bit` + Monitorw = 818, + // `MONITOR` + // + // `a32 NP 0F 01 C8` + // + // `MONITOR` + // + // `16/32/64-bit` + Monitord = 819, + // `MONITOR` + // + // `a64 NP 0F 01 C8` + // + // `MONITOR` + // + // `64-bit` + Monitorq = 820, + // `MWAIT` + // + // `NP 0F 01 C9` + // + // `MONITOR` + // + // `16/32/64-bit` + Mwait = 821, + // `CLAC` + // + // `NP 0F 01 CA` + // + // `SMAP` + // + // `16/32/64-bit` + Clac = 822, + // `STAC` + // + // `NP 0F 01 CB` + // + // `SMAP` + // + // `16/32/64-bit` + Stac = 823, + // `ENCLS` + // + // `NP 0F 01 CF` + // + // `SGX1` + // + // `16/32/64-bit` + Encls = 824, + // `XGETBV` + // + // `NP 0F 01 D0` + // + // `XSAVE` + // + // `16/32/64-bit` + Xgetbv = 825, + // `XSETBV` + // + // `NP 0F 01 D1` + // + // `XSAVE` + // + // `16/32/64-bit` + Xsetbv = 826, + // `VMFUNC` + // + // `NP 0F 01 D4` + // + // `VMX` + // + // `16/32/64-bit` + Vmfunc = 827, + // `XEND` + // + // `NP 0F 01 D5` + // + // `RTM` + // + // `16/32/64-bit` + Xend = 828, + // `XTEST` + // + // `NP 0F 01 D6` + // + // `HLE or RTM` + // + // `16/32/64-bit` + Xtest = 829, + // `ENCLU` + // + // `NP 0F 01 D7` + // + // `SGX1` + // + // `16/32/64-bit` + Enclu = 830, + // `VMRUN` + // + // `a16 0F 01 D8` + // + // `SVM` + // + // `16/32-bit` + Vmrunw = 831, + // `VMRUN` + // + // `a32 0F 01 D8` + // + // `SVM` + // + // `16/32/64-bit` + Vmrund = 832, + // `VMRUN` + // + // `a64 0F 01 D8` + // + // `SVM` + // + // `64-bit` + Vmrunq = 833, + // `VMMCALL` + // + // `0F 01 D9` + // + // `SVM` + // + // `16/32/64-bit` + Vmmcall = 834, + // `VMLOAD` + // + // `a16 0F 01 DA` + // + // `SVM` + // + // `16/32-bit` + Vmloadw = 835, + // `VMLOAD` + // + // `a32 0F 01 DA` + // + // `SVM` + // + // `16/32/64-bit` + Vmloadd = 836, + // `VMLOAD` + // + // `a64 0F 01 DA` + // + // `SVM` + // + // `64-bit` + Vmloadq = 837, + // `VMSAVE` + // + // `a16 0F 01 DB` + // + // `SVM` + // + // `16/32-bit` + Vmsavew = 838, + // `VMSAVE` + // + // `a32 0F 01 DB` + // + // `SVM` + // + // `16/32/64-bit` + Vmsaved = 839, + // `VMSAVE` + // + // `a64 0F 01 DB` + // + // `SVM` + // + // `64-bit` + Vmsaveq = 840, + // `STGI` + // + // `0F 01 DC` + // + // `SKINIT or SVM` + // + // `16/32/64-bit` + Stgi = 841, + // `CLGI` + // + // `0F 01 DD` + // + // `SVM` + // + // `16/32/64-bit` + Clgi = 842, + // `SKINIT` + // + // `0F 01 DE` + // + // `SKINIT or SVM` + // + // `16/32/64-bit` + Skinit = 843, + // `INVLPGA` + // + // `a16 0F 01 DF` + // + // `SVM` + // + // `16/32-bit` + Invlpgaw = 844, + // `INVLPGA` + // + // `a32 0F 01 DF` + // + // `SVM` + // + // `16/32/64-bit` + Invlpgad = 845, + // `INVLPGA` + // + // `a64 0F 01 DF` + // + // `SVM` + // + // `64-bit` + Invlpgaq = 846, + // `SETSSBSY` + // + // `F3 0F 01 E8` + // + // `CET_SS` + // + // `16/32/64-bit` + Setssbsy = 847, + // `SAVEPREVSSP` + // + // `F3 0F 01 EA` + // + // `CET_SS` + // + // `16/32/64-bit` + Saveprevssp = 848, + // `RDPKRU` + // + // `NP 0F 01 EE` + // + // `PKU` + // + // `16/32/64-bit` + Rdpkru = 849, + // `WRPKRU` + // + // `NP 0F 01 EF` + // + // `PKU` + // + // `16/32/64-bit` + Wrpkru = 850, + // `SWAPGS` + // + // `0F 01 F8` + // + // `X64` + // + // `64-bit` + Swapgs = 851, + // `RDTSCP` + // + // `0F 01 F9` + // + // `RDTSCP` + // + // `16/32/64-bit` + Rdtscp = 852, + // `MONITORX` + // + // `a16 NP 0F 01 FA` + // + // `MONITORX` + // + // `16/32-bit` + Monitorxw = 853, + // `MONITORX` + // + // `a32 NP 0F 01 FA` + // + // `MONITORX` + // + // `16/32/64-bit` + Monitorxd = 854, + // `MONITORX` + // + // `a64 NP 0F 01 FA` + // + // `MONITORX` + // + // `64-bit` + Monitorxq = 855, + // `MCOMMIT` + // + // `F3 0F 01 FA` + // + // `MCOMMIT` + // + // `16/32/64-bit` + Mcommit = 856, + // `MWAITX` + // + // `NP 0F 01 FB` + // + // `MONITORX` + // + // `16/32/64-bit` + Mwaitx = 857, + // `CLZERO` + // + // `a16 0F 01 FC` + // + // `CLZERO` + // + // `16/32-bit` + Clzerow = 858, + // `CLZERO` + // + // `a32 0F 01 FC` + // + // `CLZERO` + // + // `16/32/64-bit` + Clzerod = 859, + // `CLZERO` + // + // `a64 0F 01 FC` + // + // `CLZERO` + // + // `64-bit` + Clzeroq = 860, + // `RDPRU` + // + // `0F 01 FD` + // + // `RDPRU` + // + // `16/32/64-bit` + Rdpru = 861, + // `LAR r16, r/m16` + // + // `o16 0F 02 /r` + // + // `286+` + // + // `16/32/64-bit` + Lar_r16_rm16 = 862, + // `LAR r32, r32/m16` + // + // `o32 0F 02 /r` + // + // `386+` + // + // `16/32/64-bit` + Lar_r32_r32m16 = 863, + // `LAR r64, r64/m16` + // + // `o64 0F 02 /r` + // + // `X64` + // + // `64-bit` + Lar_r64_r64m16 = 864, + // `LSL r16, r/m16` + // + // `o16 0F 03 /r` + // + // `286+` + // + // `16/32/64-bit` + Lsl_r16_rm16 = 865, + // `LSL r32, r32/m16` + // + // `o32 0F 03 /r` + // + // `386+` + // + // `16/32/64-bit` + Lsl_r32_r32m16 = 866, + // `LSL r64, r64/m16` + // + // `o64 0F 03 /r` + // + // `X64` + // + // `64-bit` + Lsl_r64_r64m16 = 867, + // `STOREALL` + // + // `0F 04` + // + // `286` + // + // `16/32-bit` + Storeall = 868, + // `LOADALL` + // + // `0F 05` + // + // `286` + // + // `16/32-bit` + Loadall286 = 869, + // `SYSCALL` + // + // `0F 05` + // + // `SYSCALL` + // + // `16/32/64-bit` + Syscall = 870, + // `CLTS` + // + // `0F 06` + // + // `286+` + // + // `16/32/64-bit` + Clts = 871, + // `LOADALL` + // + // `0F 07` + // + // `386` + // + // `16/32-bit` + Loadall386 = 872, + // `SYSRET` + // + // `0F 07` + // + // `SYSCALL` + // + // `16/32/64-bit` + Sysretd = 873, + // `SYSRETQ` + // + // `o64 0F 07` + // + // `SYSCALL` + // + // `64-bit` + Sysretq = 874, + // `INVD` + // + // `0F 08` + // + // `486+` + // + // `16/32/64-bit` + Invd = 875, + // `WBINVD` + // + // `0F 09` + // + // `486+` + // + // `16/32/64-bit` + Wbinvd = 876, + // `WBNOINVD` + // + // `F3 0F 09` + // + // `WBNOINVD` + // + // `16/32/64-bit` + Wbnoinvd = 877, + // `CL1INVMB` + // + // `0F 0A` + // + // `CL1INVMB` + // + // `16/32-bit` + Cl1invmb = 878, + // `UD2` + // + // `0F 0B` + // + // `286+` + // + // `16/32/64-bit` + Ud2 = 879, + // `RESERVEDNOP r/m16, r16` + // + // `o16 0F 0D /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm16_r16_0F0D = 880, + // `RESERVEDNOP r/m32, r32` + // + // `o32 0F 0D /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm32_r32_0F0D = 881, + // `RESERVEDNOP r/m64, r64` + // + // `o64 0F 0D /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `64-bit` + Reservednop_rm64_r64_0F0D = 882, + // `PREFETCH m8` + // + // `0F 0D /0` + // + // `PREFETCHW` + // + // `16/32/64-bit` + Prefetch_m8 = 883, + // `PREFETCHW m8` + // + // `0F 0D /1` + // + // `PREFETCHW` + // + // `16/32/64-bit` + Prefetchw_m8 = 884, + // `PREFETCHWT1 m8` + // + // `0F 0D /2` + // + // `PREFETCHWT1` + // + // `16/32/64-bit` + Prefetchwt1_m8 = 885, + // `FEMMS` + // + // `0F 0E` + // + // `3DNOW` + // + // `16/32/64-bit` + Femms = 886, + // `UMOV r/m8, r8` + // + // `0F 10 /r` + // + // `386/486` + // + // `16/32-bit` + Umov_rm8_r8 = 887, + // `UMOV r/m16, r16` + // + // `o16 0F 11 /r` + // + // `386/486` + // + // `16/32-bit` + Umov_rm16_r16 = 888, + // `UMOV r/m32, r32` + // + // `o32 0F 11 /r` + // + // `386/486` + // + // `16/32-bit` + Umov_rm32_r32 = 889, + // `UMOV r8, r/m8` + // + // `0F 12 /r` + // + // `386/486` + // + // `16/32-bit` + Umov_r8_rm8 = 890, + // `UMOV r16, r/m16` + // + // `o16 0F 13 /r` + // + // `386/486` + // + // `16/32-bit` + Umov_r16_rm16 = 891, + // `UMOV r32, r/m32` + // + // `o32 0F 13 /r` + // + // `386/486` + // + // `16/32-bit` + Umov_r32_rm32 = 892, + // `MOVUPS xmm1, xmm2/m128` + // + // `NP 0F 10 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movups_xmm_xmmm128 = 893, + // `VMOVUPS xmm1, xmm2/m128` + // + // `VEX.128.0F.WIG 10 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovups_xmm_xmmm128 = 894, + // `VMOVUPS ymm1, ymm2/m256` + // + // `VEX.256.0F.WIG 10 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovups_ymm_ymmm256 = 895, + // `VMOVUPS xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.0F.W0 10 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovups_xmm_k1z_xmmm128 = 896, + // `VMOVUPS ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.0F.W0 10 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovups_ymm_k1z_ymmm256 = 897, + // `VMOVUPS zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.0F.W0 10 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovups_zmm_k1z_zmmm512 = 898, + // `MOVUPD xmm1, xmm2/m128` + // + // `66 0F 10 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movupd_xmm_xmmm128 = 899, + // `VMOVUPD xmm1, xmm2/m128` + // + // `VEX.128.66.0F.WIG 10 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovupd_xmm_xmmm128 = 900, + // `VMOVUPD ymm1, ymm2/m256` + // + // `VEX.256.66.0F.WIG 10 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovupd_ymm_ymmm256 = 901, + // `VMOVUPD xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F.W1 10 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovupd_xmm_k1z_xmmm128 = 902, + // `VMOVUPD ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F.W1 10 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovupd_ymm_k1z_ymmm256 = 903, + // `VMOVUPD zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F.W1 10 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovupd_zmm_k1z_zmmm512 = 904, + // `MOVSS xmm1, xmm2/m32` + // + // `F3 0F 10 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movss_xmm_xmmm32 = 905, + // `VMOVSS xmm1, xmm2, xmm3` + // + // `VEX.LIG.F3.0F.WIG 10 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovss_xmm_xmm_xmm = 906, + // `VMOVSS xmm1, m32` + // + // `VEX.LIG.F3.0F.WIG 10 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovss_xmm_m32 = 907, + // `VMOVSS xmm1 {k1}{z}, xmm2, xmm3` + // + // `EVEX.LIG.F3.0F.W0 10 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovss_xmm_k1z_xmm_xmm = 908, + // `VMOVSS xmm1 {k1}{z}, m32` + // + // `EVEX.LIG.F3.0F.W0 10 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovss_xmm_k1z_m32 = 909, + // `MOVSD xmm1, xmm2/m64` + // + // `F2 0F 10 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movsd_xmm_xmmm64 = 910, + // `VMOVSD xmm1, xmm2, xmm3` + // + // `VEX.LIG.F2.0F.WIG 10 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovsd_xmm_xmm_xmm = 911, + // `VMOVSD xmm1, m64` + // + // `VEX.LIG.F2.0F.WIG 10 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovsd_xmm_m64 = 912, + // `VMOVSD xmm1 {k1}{z}, xmm2, xmm3` + // + // `EVEX.LIG.F2.0F.W1 10 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovsd_xmm_k1z_xmm_xmm = 913, + // `VMOVSD xmm1 {k1}{z}, m64` + // + // `EVEX.LIG.F2.0F.W1 10 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovsd_xmm_k1z_m64 = 914, + // `MOVUPS xmm2/m128, xmm1` + // + // `NP 0F 11 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movups_xmmm128_xmm = 915, + // `VMOVUPS xmm2/m128, xmm1` + // + // `VEX.128.0F.WIG 11 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovups_xmmm128_xmm = 916, + // `VMOVUPS ymm2/m256, ymm1` + // + // `VEX.256.0F.WIG 11 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovups_ymmm256_ymm = 917, + // `VMOVUPS xmm2/m128 {k1}{z}, xmm1` + // + // `EVEX.128.0F.W0 11 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovups_xmmm128_k1z_xmm = 918, + // `VMOVUPS ymm2/m256 {k1}{z}, ymm1` + // + // `EVEX.256.0F.W0 11 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovups_ymmm256_k1z_ymm = 919, + // `VMOVUPS zmm2/m512 {k1}{z}, zmm1` + // + // `EVEX.512.0F.W0 11 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovups_zmmm512_k1z_zmm = 920, + // `MOVUPD xmm2/m128, xmm1` + // + // `66 0F 11 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movupd_xmmm128_xmm = 921, + // `VMOVUPD xmm2/m128, xmm1` + // + // `VEX.128.66.0F.WIG 11 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovupd_xmmm128_xmm = 922, + // `VMOVUPD ymm2/m256, ymm1` + // + // `VEX.256.66.0F.WIG 11 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovupd_ymmm256_ymm = 923, + // `VMOVUPD xmm2/m128 {k1}{z}, xmm1` + // + // `EVEX.128.66.0F.W1 11 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovupd_xmmm128_k1z_xmm = 924, + // `VMOVUPD ymm2/m256 {k1}{z}, ymm1` + // + // `EVEX.256.66.0F.W1 11 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovupd_ymmm256_k1z_ymm = 925, + // `VMOVUPD zmm2/m512 {k1}{z}, zmm1` + // + // `EVEX.512.66.0F.W1 11 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovupd_zmmm512_k1z_zmm = 926, + // `MOVSS xmm2/m32, xmm1` + // + // `F3 0F 11 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movss_xmmm32_xmm = 927, + // `VMOVSS xmm1, xmm2, xmm3` + // + // `VEX.LIG.F3.0F.WIG 11 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovss_xmm_xmm_xmm_0F11 = 928, + // `VMOVSS m32, xmm1` + // + // `VEX.LIG.F3.0F.WIG 11 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovss_m32_xmm = 929, + // `VMOVSS xmm1 {k1}{z}, xmm2, xmm3` + // + // `EVEX.LIG.F3.0F.W0 11 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovss_xmm_k1z_xmm_xmm_0F11 = 930, + // `VMOVSS m32 {k1}, xmm1` + // + // `EVEX.LIG.F3.0F.W0 11 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovss_m32_k1_xmm = 931, + // `MOVSD xmm1/m64, xmm2` + // + // `F2 0F 11 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movsd_xmmm64_xmm = 932, + // `VMOVSD xmm1, xmm2, xmm3` + // + // `VEX.LIG.F2.0F.WIG 11 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovsd_xmm_xmm_xmm_0F11 = 933, + // `VMOVSD m64, xmm1` + // + // `VEX.LIG.F2.0F.WIG 11 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovsd_m64_xmm = 934, + // `VMOVSD xmm1 {k1}{z}, xmm2, xmm3` + // + // `EVEX.LIG.F2.0F.W1 11 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovsd_xmm_k1z_xmm_xmm_0F11 = 935, + // `VMOVSD m64 {k1}, xmm1` + // + // `EVEX.LIG.F2.0F.W1 11 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovsd_m64_k1_xmm = 936, + // `MOVHLPS xmm1, xmm2` + // + // `NP 0F 12 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movhlps_xmm_xmm = 937, + // `MOVLPS xmm1, m64` + // + // `NP 0F 12 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movlps_xmm_m64 = 938, + // `VMOVHLPS xmm1, xmm2, xmm3` + // + // `VEX.128.0F.WIG 12 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovhlps_xmm_xmm_xmm = 939, + // `VMOVLPS xmm2, xmm1, m64` + // + // `VEX.128.0F.WIG 12 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovlps_xmm_xmm_m64 = 940, + // `VMOVHLPS xmm1, xmm2, xmm3` + // + // `EVEX.128.0F.W0 12 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovhlps_xmm_xmm_xmm = 941, + // `VMOVLPS xmm2, xmm1, m64` + // + // `EVEX.128.0F.W0 12 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovlps_xmm_xmm_m64 = 942, + // `MOVLPD xmm1, m64` + // + // `66 0F 12 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movlpd_xmm_m64 = 943, + // `VMOVLPD xmm2, xmm1, m64` + // + // `VEX.128.66.0F.WIG 12 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovlpd_xmm_xmm_m64 = 944, + // `VMOVLPD xmm2, xmm1, m64` + // + // `EVEX.128.66.0F.W1 12 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovlpd_xmm_xmm_m64 = 945, + // `MOVSLDUP xmm1, xmm2/m128` + // + // `F3 0F 12 /r` + // + // `SSE3` + // + // `16/32/64-bit` + Movsldup_xmm_xmmm128 = 946, + // `VMOVSLDUP xmm1, xmm2/m128` + // + // `VEX.128.F3.0F.WIG 12 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovsldup_xmm_xmmm128 = 947, + // `VMOVSLDUP ymm1, ymm2/m256` + // + // `VEX.256.F3.0F.WIG 12 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovsldup_ymm_ymmm256 = 948, + // `VMOVSLDUP xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.F3.0F.W0 12 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovsldup_xmm_k1z_xmmm128 = 949, + // `VMOVSLDUP ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.F3.0F.W0 12 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovsldup_ymm_k1z_ymmm256 = 950, + // `VMOVSLDUP zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.F3.0F.W0 12 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovsldup_zmm_k1z_zmmm512 = 951, + // `MOVDDUP xmm1, xmm2/m64` + // + // `F2 0F 12 /r` + // + // `SSE3` + // + // `16/32/64-bit` + Movddup_xmm_xmmm64 = 952, + // `VMOVDDUP xmm1, xmm2/m64` + // + // `VEX.128.F2.0F.WIG 12 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovddup_xmm_xmmm64 = 953, + // `VMOVDDUP ymm1, ymm2/m256` + // + // `VEX.256.F2.0F.WIG 12 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovddup_ymm_ymmm256 = 954, + // `VMOVDDUP xmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.128.F2.0F.W1 12 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovddup_xmm_k1z_xmmm64 = 955, + // `VMOVDDUP ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.F2.0F.W1 12 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovddup_ymm_k1z_ymmm256 = 956, + // `VMOVDDUP zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.F2.0F.W1 12 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovddup_zmm_k1z_zmmm512 = 957, + // `MOVLPS m64, xmm1` + // + // `NP 0F 13 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movlps_m64_xmm = 958, + // `VMOVLPS m64, xmm1` + // + // `VEX.128.0F.WIG 13 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovlps_m64_xmm = 959, + // `VMOVLPS m64, xmm1` + // + // `EVEX.128.0F.W0 13 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovlps_m64_xmm = 960, + // `MOVLPD m64, xmm1` + // + // `66 0F 13 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movlpd_m64_xmm = 961, + // `VMOVLPD m64, xmm1` + // + // `VEX.128.66.0F.WIG 13 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovlpd_m64_xmm = 962, + // `VMOVLPD m64, xmm1` + // + // `EVEX.128.66.0F.W1 13 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovlpd_m64_xmm = 963, + // `UNPCKLPS xmm1, xmm2/m128` + // + // `NP 0F 14 /r` + // + // `SSE` + // + // `16/32/64-bit` + Unpcklps_xmm_xmmm128 = 964, + // `VUNPCKLPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 14 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vunpcklps_xmm_xmm_xmmm128 = 965, + // `VUNPCKLPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 14 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vunpcklps_ymm_ymm_ymmm256 = 966, + // `VUNPCKLPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 14 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpcklps_xmm_k1z_xmm_xmmm128b32 = 967, + // `VUNPCKLPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 14 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpcklps_ymm_k1z_ymm_ymmm256b32 = 968, + // `VUNPCKLPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.0F.W0 14 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpcklps_zmm_k1z_zmm_zmmm512b32 = 969, + // `UNPCKLPD xmm1, xmm2/m128` + // + // `66 0F 14 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Unpcklpd_xmm_xmmm128 = 970, + // `VUNPCKLPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 14 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vunpcklpd_xmm_xmm_xmmm128 = 971, + // `VUNPCKLPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 14 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vunpcklpd_ymm_ymm_ymmm256 = 972, + // `VUNPCKLPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 14 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpcklpd_xmm_k1z_xmm_xmmm128b64 = 973, + // `VUNPCKLPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 14 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpcklpd_ymm_k1z_ymm_ymmm256b64 = 974, + // `VUNPCKLPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 14 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpcklpd_zmm_k1z_zmm_zmmm512b64 = 975, + // `UNPCKHPS xmm1, xmm2/m128` + // + // `NP 0F 15 /r` + // + // `SSE` + // + // `16/32/64-bit` + Unpckhps_xmm_xmmm128 = 976, + // `VUNPCKHPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 15 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vunpckhps_xmm_xmm_xmmm128 = 977, + // `VUNPCKHPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 15 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vunpckhps_ymm_ymm_ymmm256 = 978, + // `VUNPCKHPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 15 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpckhps_xmm_k1z_xmm_xmmm128b32 = 979, + // `VUNPCKHPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 15 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpckhps_ymm_k1z_ymm_ymmm256b32 = 980, + // `VUNPCKHPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.0F.W0 15 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpckhps_zmm_k1z_zmm_zmmm512b32 = 981, + // `UNPCKHPD xmm1, xmm2/m128` + // + // `66 0F 15 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Unpckhpd_xmm_xmmm128 = 982, + // `VUNPCKHPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 15 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vunpckhpd_xmm_xmm_xmmm128 = 983, + // `VUNPCKHPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 15 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vunpckhpd_ymm_ymm_ymmm256 = 984, + // `VUNPCKHPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 15 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpckhpd_xmm_k1z_xmm_xmmm128b64 = 985, + // `VUNPCKHPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 15 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpckhpd_ymm_k1z_ymm_ymmm256b64 = 986, + // `VUNPCKHPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 15 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vunpckhpd_zmm_k1z_zmm_zmmm512b64 = 987, + // `MOVLHPS xmm1, xmm2` + // + // `NP 0F 16 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movlhps_xmm_xmm = 988, + // `VMOVLHPS xmm1, xmm2, xmm3` + // + // `VEX.128.0F.WIG 16 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovlhps_xmm_xmm_xmm = 989, + // `VMOVLHPS xmm1, xmm2, xmm3` + // + // `EVEX.128.0F.W0 16 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovlhps_xmm_xmm_xmm = 990, + // `MOVHPS xmm1, m64` + // + // `NP 0F 16 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movhps_xmm_m64 = 991, + // `VMOVHPS xmm2, xmm1, m64` + // + // `VEX.128.0F.WIG 16 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovhps_xmm_xmm_m64 = 992, + // `VMOVHPS xmm2, xmm1, m64` + // + // `EVEX.128.0F.W0 16 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovhps_xmm_xmm_m64 = 993, + // `MOVHPD xmm1, m64` + // + // `66 0F 16 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movhpd_xmm_m64 = 994, + // `VMOVHPD xmm2, xmm1, m64` + // + // `VEX.128.66.0F.WIG 16 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovhpd_xmm_xmm_m64 = 995, + // `VMOVHPD xmm2, xmm1, m64` + // + // `EVEX.128.66.0F.W1 16 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovhpd_xmm_xmm_m64 = 996, + // `MOVSHDUP xmm1, xmm2/m128` + // + // `F3 0F 16 /r` + // + // `SSE3` + // + // `16/32/64-bit` + Movshdup_xmm_xmmm128 = 997, + // `VMOVSHDUP xmm1, xmm2/m128` + // + // `VEX.128.F3.0F.WIG 16 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovshdup_xmm_xmmm128 = 998, + // `VMOVSHDUP ymm1, ymm2/m256` + // + // `VEX.256.F3.0F.WIG 16 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovshdup_ymm_ymmm256 = 999, + // `VMOVSHDUP xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.F3.0F.W0 16 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovshdup_xmm_k1z_xmmm128 = 1000, + // `VMOVSHDUP ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.F3.0F.W0 16 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovshdup_ymm_k1z_ymmm256 = 1001, + // `VMOVSHDUP zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.F3.0F.W0 16 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovshdup_zmm_k1z_zmmm512 = 1002, + // `MOVHPS m64, xmm1` + // + // `NP 0F 17 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movhps_m64_xmm = 1003, + // `VMOVHPS m64, xmm1` + // + // `VEX.128.0F.WIG 17 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovhps_m64_xmm = 1004, + // `VMOVHPS m64, xmm1` + // + // `EVEX.128.0F.W0 17 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovhps_m64_xmm = 1005, + // `MOVHPD m64, xmm1` + // + // `66 0F 17 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movhpd_m64_xmm = 1006, + // `VMOVHPD m64, xmm1` + // + // `VEX.128.66.0F.WIG 17 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovhpd_m64_xmm = 1007, + // `VMOVHPD m64, xmm1` + // + // `EVEX.128.66.0F.W1 17 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovhpd_m64_xmm = 1008, + // `RESERVEDNOP r/m16, r16` + // + // `o16 0F 18 /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm16_r16_0F18 = 1009, + // `RESERVEDNOP r/m32, r32` + // + // `o32 0F 18 /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm32_r32_0F18 = 1010, + // `RESERVEDNOP r/m64, r64` + // + // `o64 0F 18 /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `64-bit` + Reservednop_rm64_r64_0F18 = 1011, + // `RESERVEDNOP r/m16, r16` + // + // `o16 0F 19 /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm16_r16_0F19 = 1012, + // `RESERVEDNOP r/m32, r32` + // + // `o32 0F 19 /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm32_r32_0F19 = 1013, + // `RESERVEDNOP r/m64, r64` + // + // `o64 0F 19 /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `64-bit` + Reservednop_rm64_r64_0F19 = 1014, + // `RESERVEDNOP r/m16, r16` + // + // `o16 0F 1A /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm16_r16_0F1A = 1015, + // `RESERVEDNOP r/m32, r32` + // + // `o32 0F 1A /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm32_r32_0F1A = 1016, + // `RESERVEDNOP r/m64, r64` + // + // `o64 0F 1A /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `64-bit` + Reservednop_rm64_r64_0F1A = 1017, + // `RESERVEDNOP r/m16, r16` + // + // `o16 0F 1B /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm16_r16_0F1B = 1018, + // `RESERVEDNOP r/m32, r32` + // + // `o32 0F 1B /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm32_r32_0F1B = 1019, + // `RESERVEDNOP r/m64, r64` + // + // `o64 0F 1B /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `64-bit` + Reservednop_rm64_r64_0F1B = 1020, + // `RESERVEDNOP r/m16, r16` + // + // `o16 0F 1C /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm16_r16_0F1C = 1021, + // `RESERVEDNOP r/m32, r32` + // + // `o32 0F 1C /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm32_r32_0F1C = 1022, + // `RESERVEDNOP r/m64, r64` + // + // `o64 0F 1C /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `64-bit` + Reservednop_rm64_r64_0F1C = 1023, + // `RESERVEDNOP r/m16, r16` + // + // `o16 0F 1D /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm16_r16_0F1D = 1024, + // `RESERVEDNOP r/m32, r32` + // + // `o32 0F 1D /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm32_r32_0F1D = 1025, + // `RESERVEDNOP r/m64, r64` + // + // `o64 0F 1D /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `64-bit` + Reservednop_rm64_r64_0F1D = 1026, + // `RESERVEDNOP r/m16, r16` + // + // `o16 0F 1E /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm16_r16_0F1E = 1027, + // `RESERVEDNOP r/m32, r32` + // + // `o32 0F 1E /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm32_r32_0F1E = 1028, + // `RESERVEDNOP r/m64, r64` + // + // `o64 0F 1E /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `64-bit` + Reservednop_rm64_r64_0F1E = 1029, + // `RESERVEDNOP r/m16, r16` + // + // `o16 0F 1F /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm16_r16_0F1F = 1030, + // `RESERVEDNOP r/m32, r32` + // + // `o32 0F 1F /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Reservednop_rm32_r32_0F1F = 1031, + // `RESERVEDNOP r/m64, r64` + // + // `o64 0F 1F /r` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `64-bit` + Reservednop_rm64_r64_0F1F = 1032, + // `PREFETCHNTA m8` + // + // `0F 18 /0` + // + // `SSE` + // + // `16/32/64-bit` + Prefetchnta_m8 = 1033, + // `PREFETCHT0 m8` + // + // `0F 18 /1` + // + // `SSE` + // + // `16/32/64-bit` + Prefetcht0_m8 = 1034, + // `PREFETCHT1 m8` + // + // `0F 18 /2` + // + // `SSE` + // + // `16/32/64-bit` + Prefetcht1_m8 = 1035, + // `PREFETCHT2 m8` + // + // `0F 18 /3` + // + // `SSE` + // + // `16/32/64-bit` + Prefetcht2_m8 = 1036, + // `BNDLDX bnd, mib` + // + // `NP 0F 1A /r` + // + // `MPX` + // + // `16/32/64-bit` + Bndldx_bnd_mib = 1037, + // `BNDMOV bnd1, bnd2/m64` + // + // `66 0F 1A /r` + // + // `MPX` + // + // `16/32-bit` + Bndmov_bnd_bndm64 = 1038, + // `BNDMOV bnd1, bnd2/m128` + // + // `66 0F 1A /r` + // + // `MPX` + // + // `64-bit` + Bndmov_bnd_bndm128 = 1039, + // `BNDCL bnd, r/m32` + // + // `F3 0F 1A /r` + // + // `MPX` + // + // `16/32-bit` + Bndcl_bnd_rm32 = 1040, + // `BNDCL bnd, r/m64` + // + // `F3 0F 1A /r` + // + // `MPX` + // + // `64-bit` + Bndcl_bnd_rm64 = 1041, + // `BNDCU bnd, r/m32` + // + // `F2 0F 1A /r` + // + // `MPX` + // + // `16/32-bit` + Bndcu_bnd_rm32 = 1042, + // `BNDCU bnd, r/m64` + // + // `F2 0F 1A /r` + // + // `MPX` + // + // `64-bit` + Bndcu_bnd_rm64 = 1043, + // `BNDSTX mib, bnd` + // + // `NP 0F 1B /r` + // + // `MPX` + // + // `16/32/64-bit` + Bndstx_mib_bnd = 1044, + // `BNDMOV bnd1/m64, bnd2` + // + // `66 0F 1B /r` + // + // `MPX` + // + // `16/32-bit` + Bndmov_bndm64_bnd = 1045, + // `BNDMOV bnd1/m128, bnd2` + // + // `66 0F 1B /r` + // + // `MPX` + // + // `64-bit` + Bndmov_bndm128_bnd = 1046, + // `BNDMK bnd, m32` + // + // `F3 0F 1B /r` + // + // `MPX` + // + // `16/32-bit` + Bndmk_bnd_m32 = 1047, + // `BNDMK bnd, m64` + // + // `F3 0F 1B /r` + // + // `MPX` + // + // `64-bit` + Bndmk_bnd_m64 = 1048, + // `BNDCN bnd, r/m32` + // + // `F2 0F 1B /r` + // + // `MPX` + // + // `16/32-bit` + Bndcn_bnd_rm32 = 1049, + // `BNDCN bnd, r/m64` + // + // `F2 0F 1B /r` + // + // `MPX` + // + // `64-bit` + Bndcn_bnd_rm64 = 1050, + // `CLDEMOTE m8` + // + // `NP 0F 1C /0` + // + // `CLDEMOTE` + // + // `16/32/64-bit` + Cldemote_m8 = 1051, + // `RDSSPD r32` + // + // `F3 0F 1E /1` + // + // `CET_SS` + // + // `16/32/64-bit` + Rdsspd_r32 = 1052, + // `RDSSPQ r64` + // + // `F3 o64 0F 1E /1` + // + // `CET_SS` + // + // `64-bit` + Rdsspq_r64 = 1053, + // `ENDBR64` + // + // `F3 0F 1E FA` + // + // `CET_IBT` + // + // `16/32/64-bit` + Endbr64 = 1054, + // `ENDBR32` + // + // `F3 0F 1E FB` + // + // `CET_IBT` + // + // `16/32/64-bit` + Endbr32 = 1055, + // `NOP r/m16` + // + // `o16 0F 1F /0` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Nop_rm16 = 1056, + // `NOP r/m32` + // + // `o32 0F 1F /0` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `16/32/64-bit` + Nop_rm32 = 1057, + // `NOP r/m64` + // + // `o64 0F 1F /0` + // + // `CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B` + // + // `64-bit` + Nop_rm64 = 1058, + // `MOV r32, cr` + // + // `0F 20 /r` + // + // `386+` + // + // `16/32-bit` + Mov_r32_cr = 1059, + // `MOV r64, cr` + // + // `0F 20 /r` + // + // `X64` + // + // `64-bit` + Mov_r64_cr = 1060, + // `MOV r32, dr` + // + // `0F 21 /r` + // + // `386+` + // + // `16/32-bit` + Mov_r32_dr = 1061, + // `MOV r64, dr` + // + // `0F 21 /r` + // + // `X64` + // + // `64-bit` + Mov_r64_dr = 1062, + // `MOV cr, r32` + // + // `0F 22 /r` + // + // `386+` + // + // `16/32-bit` + Mov_cr_r32 = 1063, + // `MOV cr, r64` + // + // `0F 22 /r` + // + // `X64` + // + // `64-bit` + Mov_cr_r64 = 1064, + // `MOV dr, r32` + // + // `0F 23 /r` + // + // `386+` + // + // `16/32-bit` + Mov_dr_r32 = 1065, + // `MOV dr, r64` + // + // `0F 23 /r` + // + // `X64` + // + // `64-bit` + Mov_dr_r64 = 1066, + // `MOV r32, tr` + // + // `0F 24 /r` + // + // `386/486/Cyrix/Geode` + // + // `16/32-bit` + Mov_r32_tr = 1067, + // `MOV tr, r32` + // + // `0F 26 /r` + // + // `386/486/Cyrix/Geode` + // + // `16/32-bit` + Mov_tr_r32 = 1068, + // `MOVAPS xmm1, xmm2/m128` + // + // `NP 0F 28 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movaps_xmm_xmmm128 = 1069, + // `VMOVAPS xmm1, xmm2/m128` + // + // `VEX.128.0F.WIG 28 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovaps_xmm_xmmm128 = 1070, + // `VMOVAPS ymm1, ymm2/m256` + // + // `VEX.256.0F.WIG 28 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovaps_ymm_ymmm256 = 1071, + // `VMOVAPS xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.0F.W0 28 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovaps_xmm_k1z_xmmm128 = 1072, + // `VMOVAPS ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.0F.W0 28 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovaps_ymm_k1z_ymmm256 = 1073, + // `VMOVAPS zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.0F.W0 28 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovaps_zmm_k1z_zmmm512 = 1074, + // `MOVAPD xmm1, xmm2/m128` + // + // `66 0F 28 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movapd_xmm_xmmm128 = 1075, + // `VMOVAPD xmm1, xmm2/m128` + // + // `VEX.128.66.0F.WIG 28 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovapd_xmm_xmmm128 = 1076, + // `VMOVAPD ymm1, ymm2/m256` + // + // `VEX.256.66.0F.WIG 28 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovapd_ymm_ymmm256 = 1077, + // `VMOVAPD xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F.W1 28 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovapd_xmm_k1z_xmmm128 = 1078, + // `VMOVAPD ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F.W1 28 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovapd_ymm_k1z_ymmm256 = 1079, + // `VMOVAPD zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F.W1 28 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovapd_zmm_k1z_zmmm512 = 1080, + // `MOVAPS xmm2/m128, xmm1` + // + // `NP 0F 29 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movaps_xmmm128_xmm = 1081, + // `VMOVAPS xmm2/m128, xmm1` + // + // `VEX.128.0F.WIG 29 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovaps_xmmm128_xmm = 1082, + // `VMOVAPS ymm2/m256, ymm1` + // + // `VEX.256.0F.WIG 29 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovaps_ymmm256_ymm = 1083, + // `VMOVAPS xmm2/m128 {k1}{z}, xmm1` + // + // `EVEX.128.0F.W0 29 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovaps_xmmm128_k1z_xmm = 1084, + // `VMOVAPS ymm2/m256 {k1}{z}, ymm1` + // + // `EVEX.256.0F.W0 29 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovaps_ymmm256_k1z_ymm = 1085, + // `VMOVAPS zmm2/m512 {k1}{z}, zmm1` + // + // `EVEX.512.0F.W0 29 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovaps_zmmm512_k1z_zmm = 1086, + // `MOVAPD xmm2/m128, xmm1` + // + // `66 0F 29 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movapd_xmmm128_xmm = 1087, + // `VMOVAPD xmm2/m128, xmm1` + // + // `VEX.128.66.0F.WIG 29 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovapd_xmmm128_xmm = 1088, + // `VMOVAPD ymm2/m256, ymm1` + // + // `VEX.256.66.0F.WIG 29 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovapd_ymmm256_ymm = 1089, + // `VMOVAPD xmm2/m128 {k1}{z}, xmm1` + // + // `EVEX.128.66.0F.W1 29 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovapd_xmmm128_k1z_xmm = 1090, + // `VMOVAPD ymm2/m256 {k1}{z}, ymm1` + // + // `EVEX.256.66.0F.W1 29 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovapd_ymmm256_k1z_ymm = 1091, + // `VMOVAPD zmm2/m512 {k1}{z}, zmm1` + // + // `EVEX.512.66.0F.W1 29 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovapd_zmmm512_k1z_zmm = 1092, + // `CVTPI2PS xmm, mm/m64` + // + // `NP 0F 2A /r` + // + // `SSE` + // + // `16/32/64-bit` + Cvtpi2ps_xmm_mmm64 = 1093, + // `CVTPI2PD xmm, mm/m64` + // + // `66 0F 2A /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtpi2pd_xmm_mmm64 = 1094, + // `CVTSI2SS xmm1, r/m32` + // + // `F3 0F 2A /r` + // + // `SSE` + // + // `16/32/64-bit` + Cvtsi2ss_xmm_rm32 = 1095, + // `CVTSI2SS xmm1, r/m64` + // + // `F3 o64 0F 2A /r` + // + // `SSE` + // + // `64-bit` + Cvtsi2ss_xmm_rm64 = 1096, + // `VCVTSI2SS xmm1, xmm2, r/m32` + // + // `VEX.LIG.F3.0F.W0 2A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtsi2ss_xmm_xmm_rm32 = 1097, + // `VCVTSI2SS xmm1, xmm2, r/m64` + // + // `VEX.LIG.F3.0F.W1 2A /r` + // + // `AVX` + // + // `64-bit` + VEX_Vcvtsi2ss_xmm_xmm_rm64 = 1098, + // `VCVTSI2SS xmm1, xmm2, r/m32{er}` + // + // `EVEX.LIG.F3.0F.W0 2A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtsi2ss_xmm_xmm_rm32_er = 1099, + // `VCVTSI2SS xmm1, xmm2, r/m64{er}` + // + // `EVEX.LIG.F3.0F.W1 2A /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvtsi2ss_xmm_xmm_rm64_er = 1100, + // `CVTSI2SD xmm1, r/m32` + // + // `F2 0F 2A /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtsi2sd_xmm_rm32 = 1101, + // `CVTSI2SD xmm1, r/m64` + // + // `F2 o64 0F 2A /r` + // + // `SSE2` + // + // `64-bit` + Cvtsi2sd_xmm_rm64 = 1102, + // `VCVTSI2SD xmm1, xmm2, r/m32` + // + // `VEX.LIG.F2.0F.W0 2A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtsi2sd_xmm_xmm_rm32 = 1103, + // `VCVTSI2SD xmm1, xmm2, r/m64` + // + // `VEX.LIG.F2.0F.W1 2A /r` + // + // `AVX` + // + // `64-bit` + VEX_Vcvtsi2sd_xmm_xmm_rm64 = 1104, + // `VCVTSI2SD xmm1, xmm2, r/m32{er}` + // + // `EVEX.LIG.F2.0F.W0 2A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtsi2sd_xmm_xmm_rm32_er = 1105, + // `VCVTSI2SD xmm1, xmm2, r/m64{er}` + // + // `EVEX.LIG.F2.0F.W1 2A /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvtsi2sd_xmm_xmm_rm64_er = 1106, + // `MOVNTPS m128, xmm1` + // + // `NP 0F 2B /r` + // + // `SSE` + // + // `16/32/64-bit` + Movntps_m128_xmm = 1107, + // `VMOVNTPS m128, xmm1` + // + // `VEX.128.0F.WIG 2B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovntps_m128_xmm = 1108, + // `VMOVNTPS m256, ymm1` + // + // `VEX.256.0F.WIG 2B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovntps_m256_ymm = 1109, + // `VMOVNTPS m128, xmm1` + // + // `EVEX.128.0F.W0 2B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntps_m128_xmm = 1110, + // `VMOVNTPS m256, ymm1` + // + // `EVEX.256.0F.W0 2B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntps_m256_ymm = 1111, + // `VMOVNTPS m512, zmm1` + // + // `EVEX.512.0F.W0 2B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntps_m512_zmm = 1112, + // `MOVNTPD m128, xmm1` + // + // `66 0F 2B /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movntpd_m128_xmm = 1113, + // `VMOVNTPD m128, xmm1` + // + // `VEX.128.66.0F.WIG 2B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovntpd_m128_xmm = 1114, + // `VMOVNTPD m256, ymm1` + // + // `VEX.256.66.0F.WIG 2B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovntpd_m256_ymm = 1115, + // `VMOVNTPD m128, xmm1` + // + // `EVEX.128.66.0F.W1 2B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntpd_m128_xmm = 1116, + // `VMOVNTPD m256, ymm1` + // + // `EVEX.256.66.0F.W1 2B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntpd_m256_ymm = 1117, + // `VMOVNTPD m512, zmm1` + // + // `EVEX.512.66.0F.W1 2B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntpd_m512_zmm = 1118, + // `MOVNTSS m32, xmm1` + // + // `F3 0F 2B /r` + // + // `SSE4A` + // + // `16/32/64-bit` + Movntss_m32_xmm = 1119, + // `MOVNTSD m64, xmm1` + // + // `F2 0F 2B /r` + // + // `SSE4A` + // + // `16/32/64-bit` + Movntsd_m64_xmm = 1120, + // `CVTTPS2PI mm, xmm/m64` + // + // `NP 0F 2C /r` + // + // `SSE` + // + // `16/32/64-bit` + Cvttps2pi_mm_xmmm64 = 1121, + // `CVTTPD2PI mm, xmm/m128` + // + // `66 0F 2C /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvttpd2pi_mm_xmmm128 = 1122, + // `CVTTSS2SI r32, xmm1/m32` + // + // `F3 0F 2C /r` + // + // `SSE` + // + // `16/32/64-bit` + Cvttss2si_r32_xmmm32 = 1123, + // `CVTTSS2SI r64, xmm1/m32` + // + // `F3 o64 0F 2C /r` + // + // `SSE` + // + // `64-bit` + Cvttss2si_r64_xmmm32 = 1124, + // `VCVTTSS2SI r32, xmm1/m32` + // + // `VEX.LIG.F3.0F.W0 2C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvttss2si_r32_xmmm32 = 1125, + // `VCVTTSS2SI r64, xmm1/m32` + // + // `VEX.LIG.F3.0F.W1 2C /r` + // + // `AVX` + // + // `64-bit` + VEX_Vcvttss2si_r64_xmmm32 = 1126, + // `VCVTTSS2SI r32, xmm1/m32{sae}` + // + // `EVEX.LIG.F3.0F.W0 2C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttss2si_r32_xmmm32_sae = 1127, + // `VCVTTSS2SI r64, xmm1/m32{sae}` + // + // `EVEX.LIG.F3.0F.W1 2C /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvttss2si_r64_xmmm32_sae = 1128, + // `CVTTSD2SI r32, xmm1/m64` + // + // `F2 0F 2C /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvttsd2si_r32_xmmm64 = 1129, + // `CVTTSD2SI r64, xmm1/m64` + // + // `F2 o64 0F 2C /r` + // + // `SSE2` + // + // `64-bit` + Cvttsd2si_r64_xmmm64 = 1130, + // `VCVTTSD2SI r32, xmm1/m64` + // + // `VEX.LIG.F2.0F.W0 2C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvttsd2si_r32_xmmm64 = 1131, + // `VCVTTSD2SI r64, xmm1/m64` + // + // `VEX.LIG.F2.0F.W1 2C /r` + // + // `AVX` + // + // `64-bit` + VEX_Vcvttsd2si_r64_xmmm64 = 1132, + // `VCVTTSD2SI r32, xmm1/m64{sae}` + // + // `EVEX.LIG.F2.0F.W0 2C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttsd2si_r32_xmmm64_sae = 1133, + // `VCVTTSD2SI r64, xmm1/m64{sae}` + // + // `EVEX.LIG.F2.0F.W1 2C /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvttsd2si_r64_xmmm64_sae = 1134, + // `CVTPS2PI mm, xmm/m64` + // + // `NP 0F 2D /r` + // + // `SSE` + // + // `16/32/64-bit` + Cvtps2pi_mm_xmmm64 = 1135, + // `CVTPD2PI mm, xmm/m128` + // + // `66 0F 2D /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtpd2pi_mm_xmmm128 = 1136, + // `CVTSS2SI r32, xmm1/m32` + // + // `F3 0F 2D /r` + // + // `SSE` + // + // `16/32/64-bit` + Cvtss2si_r32_xmmm32 = 1137, + // `CVTSS2SI r64, xmm1/m32` + // + // `F3 o64 0F 2D /r` + // + // `SSE` + // + // `64-bit` + Cvtss2si_r64_xmmm32 = 1138, + // `VCVTSS2SI r32, xmm1/m32` + // + // `VEX.LIG.F3.0F.W0 2D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtss2si_r32_xmmm32 = 1139, + // `VCVTSS2SI r64, xmm1/m32` + // + // `VEX.LIG.F3.0F.W1 2D /r` + // + // `AVX` + // + // `64-bit` + VEX_Vcvtss2si_r64_xmmm32 = 1140, + // `VCVTSS2SI r32, xmm1/m32{er}` + // + // `EVEX.LIG.F3.0F.W0 2D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtss2si_r32_xmmm32_er = 1141, + // `VCVTSS2SI r64, xmm1/m32{er}` + // + // `EVEX.LIG.F3.0F.W1 2D /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvtss2si_r64_xmmm32_er = 1142, + // `CVTSD2SI r32, xmm1/m64` + // + // `F2 0F 2D /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtsd2si_r32_xmmm64 = 1143, + // `CVTSD2SI r64, xmm1/m64` + // + // `F2 o64 0F 2D /r` + // + // `SSE2` + // + // `64-bit` + Cvtsd2si_r64_xmmm64 = 1144, + // `VCVTSD2SI r32, xmm1/m64` + // + // `VEX.LIG.F2.0F.W0 2D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtsd2si_r32_xmmm64 = 1145, + // `VCVTSD2SI r64, xmm1/m64` + // + // `VEX.LIG.F2.0F.W1 2D /r` + // + // `AVX` + // + // `64-bit` + VEX_Vcvtsd2si_r64_xmmm64 = 1146, + // `VCVTSD2SI r32, xmm1/m64{er}` + // + // `EVEX.LIG.F2.0F.W0 2D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtsd2si_r32_xmmm64_er = 1147, + // `VCVTSD2SI r64, xmm1/m64{er}` + // + // `EVEX.LIG.F2.0F.W1 2D /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvtsd2si_r64_xmmm64_er = 1148, + // `UCOMISS xmm1, xmm2/m32` + // + // `NP 0F 2E /r` + // + // `SSE` + // + // `16/32/64-bit` + Ucomiss_xmm_xmmm32 = 1149, + // `VUCOMISS xmm1, xmm2/m32` + // + // `VEX.LIG.0F.WIG 2E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vucomiss_xmm_xmmm32 = 1150, + // `VUCOMISS xmm1, xmm2/m32{sae}` + // + // `EVEX.LIG.0F.W0 2E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vucomiss_xmm_xmmm32_sae = 1151, + // `UCOMISD xmm1, xmm2/m64` + // + // `66 0F 2E /r` + // + // `SSE2` + // + // `16/32/64-bit` + Ucomisd_xmm_xmmm64 = 1152, + // `VUCOMISD xmm1, xmm2/m64` + // + // `VEX.LIG.66.0F.WIG 2E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vucomisd_xmm_xmmm64 = 1153, + // `VUCOMISD xmm1, xmm2/m64{sae}` + // + // `EVEX.LIG.66.0F.W1 2E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vucomisd_xmm_xmmm64_sae = 1154, + // `COMISS xmm1, xmm2/m32` + // + // `NP 0F 2F /r` + // + // `SSE` + // + // `16/32/64-bit` + Comiss_xmm_xmmm32 = 1155, + // `COMISD xmm1, xmm2/m64` + // + // `66 0F 2F /r` + // + // `SSE2` + // + // `16/32/64-bit` + Comisd_xmm_xmmm64 = 1156, + // `VCOMISS xmm1, xmm2/m32` + // + // `VEX.LIG.0F.WIG 2F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcomiss_xmm_xmmm32 = 1157, + // `VCOMISD xmm1, xmm2/m64` + // + // `VEX.LIG.66.0F.WIG 2F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcomisd_xmm_xmmm64 = 1158, + // `VCOMISS xmm1, xmm2/m32{sae}` + // + // `EVEX.LIG.0F.W0 2F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcomiss_xmm_xmmm32_sae = 1159, + // `VCOMISD xmm1, xmm2/m64{sae}` + // + // `EVEX.LIG.66.0F.W1 2F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcomisd_xmm_xmmm64_sae = 1160, + // `WRMSR` + // + // `0F 30` + // + // `MSR` + // + // `16/32/64-bit` + Wrmsr = 1161, + // `RDTSC` + // + // `0F 31` + // + // `TSC` + // + // `16/32/64-bit` + Rdtsc = 1162, + // `RDMSR` + // + // `0F 32` + // + // `MSR` + // + // `16/32/64-bit` + Rdmsr = 1163, + // `RDPMC` + // + // `0F 33` + // + // `Pentium MMX or later, or Pentium Pro or later` + // + // `16/32/64-bit` + Rdpmc = 1164, + // `SYSENTER` + // + // `0F 34` + // + // `SEP` + // + // `16/32/64-bit` + Sysenter = 1165, + // `SYSEXIT` + // + // `0F 35` + // + // `SEP` + // + // `16/32/64-bit` + Sysexitd = 1166, + // `SYSEXITQ` + // + // `o64 0F 35` + // + // `SEP` + // + // `64-bit` + Sysexitq = 1167, + // `GETSEC` + // + // `NP 0F 37` + // + // `SMX` + // + // `16/32/64-bit` + Getsecd = 1168, + // `CMOVO r16, r/m16` + // + // `o16 0F 40 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovo_r16_rm16 = 1169, + // `CMOVO r32, r/m32` + // + // `o32 0F 40 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovo_r32_rm32 = 1170, + // `CMOVO r64, r/m64` + // + // `o64 0F 40 /r` + // + // `CMOV` + // + // `64-bit` + Cmovo_r64_rm64 = 1171, + // `CMOVNO r16, r/m16` + // + // `o16 0F 41 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovno_r16_rm16 = 1172, + // `CMOVNO r32, r/m32` + // + // `o32 0F 41 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovno_r32_rm32 = 1173, + // `CMOVNO r64, r/m64` + // + // `o64 0F 41 /r` + // + // `CMOV` + // + // `64-bit` + Cmovno_r64_rm64 = 1174, + // `CMOVB r16, r/m16` + // + // `o16 0F 42 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovb_r16_rm16 = 1175, + // `CMOVB r32, r/m32` + // + // `o32 0F 42 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovb_r32_rm32 = 1176, + // `CMOVB r64, r/m64` + // + // `o64 0F 42 /r` + // + // `CMOV` + // + // `64-bit` + Cmovb_r64_rm64 = 1177, + // `CMOVAE r16, r/m16` + // + // `o16 0F 43 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovae_r16_rm16 = 1178, + // `CMOVAE r32, r/m32` + // + // `o32 0F 43 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovae_r32_rm32 = 1179, + // `CMOVAE r64, r/m64` + // + // `o64 0F 43 /r` + // + // `CMOV` + // + // `64-bit` + Cmovae_r64_rm64 = 1180, + // `CMOVE r16, r/m16` + // + // `o16 0F 44 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmove_r16_rm16 = 1181, + // `CMOVE r32, r/m32` + // + // `o32 0F 44 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmove_r32_rm32 = 1182, + // `CMOVE r64, r/m64` + // + // `o64 0F 44 /r` + // + // `CMOV` + // + // `64-bit` + Cmove_r64_rm64 = 1183, + // `CMOVNE r16, r/m16` + // + // `o16 0F 45 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovne_r16_rm16 = 1184, + // `CMOVNE r32, r/m32` + // + // `o32 0F 45 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovne_r32_rm32 = 1185, + // `CMOVNE r64, r/m64` + // + // `o64 0F 45 /r` + // + // `CMOV` + // + // `64-bit` + Cmovne_r64_rm64 = 1186, + // `CMOVBE r16, r/m16` + // + // `o16 0F 46 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovbe_r16_rm16 = 1187, + // `CMOVBE r32, r/m32` + // + // `o32 0F 46 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovbe_r32_rm32 = 1188, + // `CMOVBE r64, r/m64` + // + // `o64 0F 46 /r` + // + // `CMOV` + // + // `64-bit` + Cmovbe_r64_rm64 = 1189, + // `CMOVA r16, r/m16` + // + // `o16 0F 47 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmova_r16_rm16 = 1190, + // `CMOVA r32, r/m32` + // + // `o32 0F 47 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmova_r32_rm32 = 1191, + // `CMOVA r64, r/m64` + // + // `o64 0F 47 /r` + // + // `CMOV` + // + // `64-bit` + Cmova_r64_rm64 = 1192, + // `CMOVS r16, r/m16` + // + // `o16 0F 48 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovs_r16_rm16 = 1193, + // `CMOVS r32, r/m32` + // + // `o32 0F 48 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovs_r32_rm32 = 1194, + // `CMOVS r64, r/m64` + // + // `o64 0F 48 /r` + // + // `CMOV` + // + // `64-bit` + Cmovs_r64_rm64 = 1195, + // `CMOVNS r16, r/m16` + // + // `o16 0F 49 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovns_r16_rm16 = 1196, + // `CMOVNS r32, r/m32` + // + // `o32 0F 49 /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovns_r32_rm32 = 1197, + // `CMOVNS r64, r/m64` + // + // `o64 0F 49 /r` + // + // `CMOV` + // + // `64-bit` + Cmovns_r64_rm64 = 1198, + // `CMOVP r16, r/m16` + // + // `o16 0F 4A /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovp_r16_rm16 = 1199, + // `CMOVP r32, r/m32` + // + // `o32 0F 4A /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovp_r32_rm32 = 1200, + // `CMOVP r64, r/m64` + // + // `o64 0F 4A /r` + // + // `CMOV` + // + // `64-bit` + Cmovp_r64_rm64 = 1201, + // `CMOVNP r16, r/m16` + // + // `o16 0F 4B /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovnp_r16_rm16 = 1202, + // `CMOVNP r32, r/m32` + // + // `o32 0F 4B /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovnp_r32_rm32 = 1203, + // `CMOVNP r64, r/m64` + // + // `o64 0F 4B /r` + // + // `CMOV` + // + // `64-bit` + Cmovnp_r64_rm64 = 1204, + // `CMOVL r16, r/m16` + // + // `o16 0F 4C /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovl_r16_rm16 = 1205, + // `CMOVL r32, r/m32` + // + // `o32 0F 4C /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovl_r32_rm32 = 1206, + // `CMOVL r64, r/m64` + // + // `o64 0F 4C /r` + // + // `CMOV` + // + // `64-bit` + Cmovl_r64_rm64 = 1207, + // `CMOVGE r16, r/m16` + // + // `o16 0F 4D /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovge_r16_rm16 = 1208, + // `CMOVGE r32, r/m32` + // + // `o32 0F 4D /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovge_r32_rm32 = 1209, + // `CMOVGE r64, r/m64` + // + // `o64 0F 4D /r` + // + // `CMOV` + // + // `64-bit` + Cmovge_r64_rm64 = 1210, + // `CMOVLE r16, r/m16` + // + // `o16 0F 4E /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovle_r16_rm16 = 1211, + // `CMOVLE r32, r/m32` + // + // `o32 0F 4E /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovle_r32_rm32 = 1212, + // `CMOVLE r64, r/m64` + // + // `o64 0F 4E /r` + // + // `CMOV` + // + // `64-bit` + Cmovle_r64_rm64 = 1213, + // `CMOVG r16, r/m16` + // + // `o16 0F 4F /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovg_r16_rm16 = 1214, + // `CMOVG r32, r/m32` + // + // `o32 0F 4F /r` + // + // `CMOV` + // + // `16/32/64-bit` + Cmovg_r32_rm32 = 1215, + // `CMOVG r64, r/m64` + // + // `o64 0F 4F /r` + // + // `CMOV` + // + // `64-bit` + Cmovg_r64_rm64 = 1216, + // `KANDW k1, k2, k3` + // + // `VEX.L1.0F.W0 41 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kandw_kr_kr_kr = 1217, + // `KANDQ k1, k2, k3` + // + // `VEX.L1.0F.W1 41 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kandq_kr_kr_kr = 1218, + // `KANDB k1, k2, k3` + // + // `VEX.L1.66.0F.W0 41 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kandb_kr_kr_kr = 1219, + // `KANDD k1, k2, k3` + // + // `VEX.L1.66.0F.W1 41 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kandd_kr_kr_kr = 1220, + // `KANDNW k1, k2, k3` + // + // `VEX.L1.0F.W0 42 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kandnw_kr_kr_kr = 1221, + // `KANDNQ k1, k2, k3` + // + // `VEX.L1.0F.W1 42 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kandnq_kr_kr_kr = 1222, + // `KANDNB k1, k2, k3` + // + // `VEX.L1.66.0F.W0 42 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kandnb_kr_kr_kr = 1223, + // `KANDND k1, k2, k3` + // + // `VEX.L1.66.0F.W1 42 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kandnd_kr_kr_kr = 1224, + // `KNOTW k1, k2` + // + // `VEX.L0.0F.W0 44 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Knotw_kr_kr = 1225, + // `KNOTQ k1, k2` + // + // `VEX.L0.0F.W1 44 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Knotq_kr_kr = 1226, + // `KNOTB k1, k2` + // + // `VEX.L0.66.0F.W0 44 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Knotb_kr_kr = 1227, + // `KNOTD k1, k2` + // + // `VEX.L0.66.0F.W1 44 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Knotd_kr_kr = 1228, + // `KORW k1, k2, k3` + // + // `VEX.L1.0F.W0 45 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Korw_kr_kr_kr = 1229, + // `KORQ k1, k2, k3` + // + // `VEX.L1.0F.W1 45 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Korq_kr_kr_kr = 1230, + // `KORB k1, k2, k3` + // + // `VEX.L1.66.0F.W0 45 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Korb_kr_kr_kr = 1231, + // `KORD k1, k2, k3` + // + // `VEX.L1.66.0F.W1 45 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kord_kr_kr_kr = 1232, + // `KXNORW k1, k2, k3` + // + // `VEX.L1.0F.W0 46 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kxnorw_kr_kr_kr = 1233, + // `KXNORQ k1, k2, k3` + // + // `VEX.L1.0F.W1 46 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kxnorq_kr_kr_kr = 1234, + // `KXNORB k1, k2, k3` + // + // `VEX.L1.66.0F.W0 46 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kxnorb_kr_kr_kr = 1235, + // `KXNORD k1, k2, k3` + // + // `VEX.L1.66.0F.W1 46 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kxnord_kr_kr_kr = 1236, + // `KXORW k1, k2, k3` + // + // `VEX.L1.0F.W0 47 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kxorw_kr_kr_kr = 1237, + // `KXORQ k1, k2, k3` + // + // `VEX.L1.0F.W1 47 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kxorq_kr_kr_kr = 1238, + // `KXORB k1, k2, k3` + // + // `VEX.L1.66.0F.W0 47 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kxorb_kr_kr_kr = 1239, + // `KXORD k1, k2, k3` + // + // `VEX.L1.66.0F.W1 47 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kxord_kr_kr_kr = 1240, + // `KADDW k1, k2, k3` + // + // `VEX.L1.0F.W0 4A /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kaddw_kr_kr_kr = 1241, + // `KADDQ k1, k2, k3` + // + // `VEX.L1.0F.W1 4A /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kaddq_kr_kr_kr = 1242, + // `KADDB k1, k2, k3` + // + // `VEX.L1.66.0F.W0 4A /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kaddb_kr_kr_kr = 1243, + // `KADDD k1, k2, k3` + // + // `VEX.L1.66.0F.W1 4A /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kaddd_kr_kr_kr = 1244, + // `KUNPCKWD k1, k2, k3` + // + // `VEX.L1.0F.W0 4B /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kunpckwd_kr_kr_kr = 1245, + // `KUNPCKDQ k1, k2, k3` + // + // `VEX.L1.0F.W1 4B /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kunpckdq_kr_kr_kr = 1246, + // `KUNPCKBW k1, k2, k3` + // + // `VEX.L1.66.0F.W0 4B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kunpckbw_kr_kr_kr = 1247, + // `MOVMSKPS r32, xmm` + // + // `NP 0F 50 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movmskps_r32_xmm = 1248, + // `MOVMSKPS r64, xmm` + // + // `NP o64 0F 50 /r` + // + // `SSE` + // + // `64-bit` + Movmskps_r64_xmm = 1249, + // `VMOVMSKPS r32, xmm2` + // + // `VEX.128.0F.W0 50 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovmskps_r32_xmm = 1250, + // `VMOVMSKPS r64, xmm2` + // + // `VEX.128.0F.W1 50 /r` + // + // `AVX` + // + // `64-bit` + VEX_Vmovmskps_r64_xmm = 1251, + // `VMOVMSKPS r32, ymm2` + // + // `VEX.256.0F.W0 50 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovmskps_r32_ymm = 1252, + // `VMOVMSKPS r64, ymm2` + // + // `VEX.256.0F.W1 50 /r` + // + // `AVX` + // + // `64-bit` + VEX_Vmovmskps_r64_ymm = 1253, + // `MOVMSKPD r32, xmm` + // + // `66 0F 50 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movmskpd_r32_xmm = 1254, + // `MOVMSKPD r64, xmm` + // + // `66 o64 0F 50 /r` + // + // `SSE2` + // + // `64-bit` + Movmskpd_r64_xmm = 1255, + // `VMOVMSKPD r32, xmm2` + // + // `VEX.128.66.0F.W0 50 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovmskpd_r32_xmm = 1256, + // `VMOVMSKPD r64, xmm2` + // + // `VEX.128.66.0F.W1 50 /r` + // + // `AVX` + // + // `64-bit` + VEX_Vmovmskpd_r64_xmm = 1257, + // `VMOVMSKPD r32, ymm2` + // + // `VEX.256.66.0F.W0 50 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovmskpd_r32_ymm = 1258, + // `VMOVMSKPD r64, ymm2` + // + // `VEX.256.66.0F.W1 50 /r` + // + // `AVX` + // + // `64-bit` + VEX_Vmovmskpd_r64_ymm = 1259, + // `SQRTPS xmm1, xmm2/m128` + // + // `NP 0F 51 /r` + // + // `SSE` + // + // `16/32/64-bit` + Sqrtps_xmm_xmmm128 = 1260, + // `VSQRTPS xmm1, xmm2/m128` + // + // `VEX.128.0F.WIG 51 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsqrtps_xmm_xmmm128 = 1261, + // `VSQRTPS ymm1, ymm2/m256` + // + // `VEX.256.0F.WIG 51 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsqrtps_ymm_ymmm256 = 1262, + // `VSQRTPS xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.0F.W0 51 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vsqrtps_xmm_k1z_xmmm128b32 = 1263, + // `VSQRTPS ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.0F.W0 51 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vsqrtps_ymm_k1z_ymmm256b32 = 1264, + // `VSQRTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}` + // + // `EVEX.512.0F.W0 51 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vsqrtps_zmm_k1z_zmmm512b32_er = 1265, + // `SQRTPD xmm1, xmm2/m128` + // + // `66 0F 51 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Sqrtpd_xmm_xmmm128 = 1266, + // `VSQRTPD xmm1, xmm2/m128` + // + // `VEX.128.66.0F.WIG 51 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsqrtpd_xmm_xmmm128 = 1267, + // `VSQRTPD ymm1, ymm2/m256` + // + // `VEX.256.66.0F.WIG 51 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsqrtpd_ymm_ymmm256 = 1268, + // `VSQRTPD xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 51 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vsqrtpd_xmm_k1z_xmmm128b64 = 1269, + // `VSQRTPD ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 51 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vsqrtpd_ymm_k1z_ymmm256b64 = 1270, + // `VSQRTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.66.0F.W1 51 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vsqrtpd_zmm_k1z_zmmm512b64_er = 1271, + // `SQRTSS xmm1, xmm2/m32` + // + // `F3 0F 51 /r` + // + // `SSE` + // + // `16/32/64-bit` + Sqrtss_xmm_xmmm32 = 1272, + // `VSQRTSS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.F3.0F.WIG 51 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsqrtss_xmm_xmm_xmmm32 = 1273, + // `VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.F3.0F.W0 51 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vsqrtss_xmm_k1z_xmm_xmmm32_er = 1274, + // `SQRTSD xmm1, xmm2/m64` + // + // `F2 0F 51 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Sqrtsd_xmm_xmmm64 = 1275, + // `VSQRTSD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.F2.0F.WIG 51 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsqrtsd_xmm_xmm_xmmm64 = 1276, + // `VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.F2.0F.W1 51 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vsqrtsd_xmm_k1z_xmm_xmmm64_er = 1277, + // `RSQRTPS xmm1, xmm2/m128` + // + // `NP 0F 52 /r` + // + // `SSE` + // + // `16/32/64-bit` + Rsqrtps_xmm_xmmm128 = 1278, + // `VRSQRTPS xmm1, xmm2/m128` + // + // `VEX.128.0F.WIG 52 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vrsqrtps_xmm_xmmm128 = 1279, + // `VRSQRTPS ymm1, ymm2/m256` + // + // `VEX.256.0F.WIG 52 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vrsqrtps_ymm_ymmm256 = 1280, + // `RSQRTSS xmm1, xmm2/m32` + // + // `F3 0F 52 /r` + // + // `SSE` + // + // `16/32/64-bit` + Rsqrtss_xmm_xmmm32 = 1281, + // `VRSQRTSS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.F3.0F.WIG 52 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vrsqrtss_xmm_xmm_xmmm32 = 1282, + // `RCPPS xmm1, xmm2/m128` + // + // `NP 0F 53 /r` + // + // `SSE` + // + // `16/32/64-bit` + Rcpps_xmm_xmmm128 = 1283, + // `VRCPPS xmm1, xmm2/m128` + // + // `VEX.128.0F.WIG 53 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vrcpps_xmm_xmmm128 = 1284, + // `VRCPPS ymm1, ymm2/m256` + // + // `VEX.256.0F.WIG 53 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vrcpps_ymm_ymmm256 = 1285, + // `RCPSS xmm1, xmm2/m32` + // + // `F3 0F 53 /r` + // + // `SSE` + // + // `16/32/64-bit` + Rcpss_xmm_xmmm32 = 1286, + // `VRCPSS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.F3.0F.WIG 53 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vrcpss_xmm_xmm_xmmm32 = 1287, + // `ANDPS xmm1, xmm2/m128` + // + // `NP 0F 54 /r` + // + // `SSE` + // + // `16/32/64-bit` + Andps_xmm_xmmm128 = 1288, + // `VANDPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 54 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vandps_xmm_xmm_xmmm128 = 1289, + // `VANDPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 54 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vandps_ymm_ymm_ymmm256 = 1290, + // `VANDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 54 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandps_xmm_k1z_xmm_xmmm128b32 = 1291, + // `VANDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 54 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandps_ymm_k1z_ymm_ymmm256b32 = 1292, + // `VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.0F.W0 54 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandps_zmm_k1z_zmm_zmmm512b32 = 1293, + // `ANDPD xmm1, xmm2/m128` + // + // `66 0F 54 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Andpd_xmm_xmmm128 = 1294, + // `VANDPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 54 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vandpd_xmm_xmm_xmmm128 = 1295, + // `VANDPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 54 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vandpd_ymm_ymm_ymmm256 = 1296, + // `VANDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 54 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandpd_xmm_k1z_xmm_xmmm128b64 = 1297, + // `VANDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 54 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandpd_ymm_k1z_ymm_ymmm256b64 = 1298, + // `VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 54 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandpd_zmm_k1z_zmm_zmmm512b64 = 1299, + // `ANDNPS xmm1, xmm2/m128` + // + // `NP 0F 55 /r` + // + // `SSE` + // + // `16/32/64-bit` + Andnps_xmm_xmmm128 = 1300, + // `VANDNPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 55 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vandnps_xmm_xmm_xmmm128 = 1301, + // `VANDNPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 55 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vandnps_ymm_ymm_ymmm256 = 1302, + // `VANDNPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 55 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandnps_xmm_k1z_xmm_xmmm128b32 = 1303, + // `VANDNPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 55 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandnps_ymm_k1z_ymm_ymmm256b32 = 1304, + // `VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.0F.W0 55 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandnps_zmm_k1z_zmm_zmmm512b32 = 1305, + // `ANDNPD xmm1, xmm2/m128` + // + // `66 0F 55 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Andnpd_xmm_xmmm128 = 1306, + // `VANDNPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 55 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vandnpd_xmm_xmm_xmmm128 = 1307, + // `VANDNPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 55 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vandnpd_ymm_ymm_ymmm256 = 1308, + // `VANDNPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 55 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandnpd_xmm_k1z_xmm_xmmm128b64 = 1309, + // `VANDNPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 55 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandnpd_ymm_k1z_ymm_ymmm256b64 = 1310, + // `VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 55 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vandnpd_zmm_k1z_zmm_zmmm512b64 = 1311, + // `ORPS xmm1, xmm2/m128` + // + // `NP 0F 56 /r` + // + // `SSE` + // + // `16/32/64-bit` + Orps_xmm_xmmm128 = 1312, + // `VORPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 56 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vorps_xmm_xmm_xmmm128 = 1313, + // `VORPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 56 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vorps_ymm_ymm_ymmm256 = 1314, + // `VORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 56 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vorps_xmm_k1z_xmm_xmmm128b32 = 1315, + // `VORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 56 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vorps_ymm_k1z_ymm_ymmm256b32 = 1316, + // `VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.0F.W0 56 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vorps_zmm_k1z_zmm_zmmm512b32 = 1317, + // `ORPD xmm1, xmm2/m128` + // + // `66 0F 56 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Orpd_xmm_xmmm128 = 1318, + // `VORPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 56 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vorpd_xmm_xmm_xmmm128 = 1319, + // `VORPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 56 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vorpd_ymm_ymm_ymmm256 = 1320, + // `VORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 56 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vorpd_xmm_k1z_xmm_xmmm128b64 = 1321, + // `VORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 56 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vorpd_ymm_k1z_ymm_ymmm256b64 = 1322, + // `VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 56 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vorpd_zmm_k1z_zmm_zmmm512b64 = 1323, + // `XORPS xmm1, xmm2/m128` + // + // `NP 0F 57 /r` + // + // `SSE` + // + // `16/32/64-bit` + Xorps_xmm_xmmm128 = 1324, + // `VXORPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 57 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vxorps_xmm_xmm_xmmm128 = 1325, + // `VXORPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 57 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vxorps_ymm_ymm_ymmm256 = 1326, + // `VXORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 57 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vxorps_xmm_k1z_xmm_xmmm128b32 = 1327, + // `VXORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 57 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vxorps_ymm_k1z_ymm_ymmm256b32 = 1328, + // `VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.0F.W0 57 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vxorps_zmm_k1z_zmm_zmmm512b32 = 1329, + // `XORPD xmm1, xmm2/m128` + // + // `66 0F 57 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Xorpd_xmm_xmmm128 = 1330, + // `VXORPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 57 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vxorpd_xmm_xmm_xmmm128 = 1331, + // `VXORPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 57 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vxorpd_ymm_ymm_ymmm256 = 1332, + // `VXORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 57 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vxorpd_xmm_k1z_xmm_xmmm128b64 = 1333, + // `VXORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 57 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vxorpd_ymm_k1z_ymm_ymmm256b64 = 1334, + // `VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 57 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vxorpd_zmm_k1z_zmm_zmmm512b64 = 1335, + // `ADDPS xmm1, xmm2/m128` + // + // `NP 0F 58 /r` + // + // `SSE` + // + // `16/32/64-bit` + Addps_xmm_xmmm128 = 1336, + // `VADDPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 58 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vaddps_xmm_xmm_xmmm128 = 1337, + // `VADDPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 58 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vaddps_ymm_ymm_ymmm256 = 1338, + // `VADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 58 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vaddps_xmm_k1z_xmm_xmmm128b32 = 1339, + // `VADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 58 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vaddps_ymm_k1z_ymm_ymmm256b32 = 1340, + // `VADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.0F.W0 58 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vaddps_zmm_k1z_zmm_zmmm512b32_er = 1341, + // `ADDPD xmm1, xmm2/m128` + // + // `66 0F 58 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Addpd_xmm_xmmm128 = 1342, + // `VADDPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 58 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vaddpd_xmm_xmm_xmmm128 = 1343, + // `VADDPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 58 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vaddpd_ymm_ymm_ymmm256 = 1344, + // `VADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 58 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vaddpd_xmm_k1z_xmm_xmmm128b64 = 1345, + // `VADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 58 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vaddpd_ymm_k1z_ymm_ymmm256b64 = 1346, + // `VADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F.W1 58 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vaddpd_zmm_k1z_zmm_zmmm512b64_er = 1347, + // `ADDSS xmm1, xmm2/m32` + // + // `F3 0F 58 /r` + // + // `SSE` + // + // `16/32/64-bit` + Addss_xmm_xmmm32 = 1348, + // `VADDSS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.F3.0F.WIG 58 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vaddss_xmm_xmm_xmmm32 = 1349, + // `VADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.F3.0F.W0 58 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vaddss_xmm_k1z_xmm_xmmm32_er = 1350, + // `ADDSD xmm1, xmm2/m64` + // + // `F2 0F 58 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Addsd_xmm_xmmm64 = 1351, + // `VADDSD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.F2.0F.WIG 58 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vaddsd_xmm_xmm_xmmm64 = 1352, + // `VADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.F2.0F.W1 58 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vaddsd_xmm_k1z_xmm_xmmm64_er = 1353, + // `MULPS xmm1, xmm2/m128` + // + // `NP 0F 59 /r` + // + // `SSE` + // + // `16/32/64-bit` + Mulps_xmm_xmmm128 = 1354, + // `VMULPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 59 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmulps_xmm_xmm_xmmm128 = 1355, + // `VMULPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 59 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmulps_ymm_ymm_ymmm256 = 1356, + // `VMULPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 59 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmulps_xmm_k1z_xmm_xmmm128b32 = 1357, + // `VMULPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 59 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmulps_ymm_k1z_ymm_ymmm256b32 = 1358, + // `VMULPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.0F.W0 59 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmulps_zmm_k1z_zmm_zmmm512b32_er = 1359, + // `MULPD xmm1, xmm2/m128` + // + // `66 0F 59 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Mulpd_xmm_xmmm128 = 1360, + // `VMULPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 59 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmulpd_xmm_xmm_xmmm128 = 1361, + // `VMULPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 59 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmulpd_ymm_ymm_ymmm256 = 1362, + // `VMULPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 59 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmulpd_xmm_k1z_xmm_xmmm128b64 = 1363, + // `VMULPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 59 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmulpd_ymm_k1z_ymm_ymmm256b64 = 1364, + // `VMULPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F.W1 59 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmulpd_zmm_k1z_zmm_zmmm512b64_er = 1365, + // `MULSS xmm1, xmm2/m32` + // + // `F3 0F 59 /r` + // + // `SSE` + // + // `16/32/64-bit` + Mulss_xmm_xmmm32 = 1366, + // `VMULSS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.F3.0F.WIG 59 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmulss_xmm_xmm_xmmm32 = 1367, + // `VMULSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.F3.0F.W0 59 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmulss_xmm_k1z_xmm_xmmm32_er = 1368, + // `MULSD xmm1, xmm2/m64` + // + // `F2 0F 59 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Mulsd_xmm_xmmm64 = 1369, + // `VMULSD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.F2.0F.WIG 59 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmulsd_xmm_xmm_xmmm64 = 1370, + // `VMULSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.F2.0F.W1 59 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmulsd_xmm_k1z_xmm_xmmm64_er = 1371, + // `CVTPS2PD xmm1, xmm2/m64` + // + // `NP 0F 5A /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtps2pd_xmm_xmmm64 = 1372, + // `VCVTPS2PD xmm1, xmm2/m64` + // + // `VEX.128.0F.WIG 5A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtps2pd_xmm_xmmm64 = 1373, + // `VCVTPS2PD ymm1, xmm2/m128` + // + // `VEX.256.0F.WIG 5A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtps2pd_ymm_xmmm128 = 1374, + // `VCVTPS2PD xmm1 {k1}{z}, xmm2/m64/m32bcst` + // + // `EVEX.128.0F.W0 5A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2pd_xmm_k1z_xmmm64b32 = 1375, + // `VCVTPS2PD ymm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.256.0F.W0 5A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2pd_ymm_k1z_xmmm128b32 = 1376, + // `VCVTPS2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}` + // + // `EVEX.512.0F.W0 5A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2pd_zmm_k1z_ymmm256b32_sae = 1377, + // `CVTPD2PS xmm1, xmm2/m128` + // + // `66 0F 5A /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtpd2ps_xmm_xmmm128 = 1378, + // `VCVTPD2PS xmm1, xmm2/m128` + // + // `VEX.128.66.0F.WIG 5A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtpd2ps_xmm_xmmm128 = 1379, + // `VCVTPD2PS xmm1, ymm2/m256` + // + // `VEX.256.66.0F.WIG 5A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtpd2ps_xmm_ymmm256 = 1380, + // `VCVTPD2PS xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 5A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtpd2ps_xmm_k1z_xmmm128b64 = 1381, + // `VCVTPD2PS xmm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 5A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtpd2ps_xmm_k1z_ymmm256b64 = 1382, + // `VCVTPD2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.66.0F.W1 5A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtpd2ps_ymm_k1z_zmmm512b64_er = 1383, + // `CVTSS2SD xmm1, xmm2/m32` + // + // `F3 0F 5A /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtss2sd_xmm_xmmm32 = 1384, + // `VCVTSS2SD xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.F3.0F.WIG 5A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtss2sd_xmm_xmm_xmmm32 = 1385, + // `VCVTSS2SD xmm1 {k1}{z}, xmm2, xmm3/m32{sae}` + // + // `EVEX.LIG.F3.0F.W0 5A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtss2sd_xmm_k1z_xmm_xmmm32_sae = 1386, + // `CVTSD2SS xmm1, xmm2/m64` + // + // `F2 0F 5A /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtsd2ss_xmm_xmmm64 = 1387, + // `VCVTSD2SS xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.F2.0F.WIG 5A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtsd2ss_xmm_xmm_xmmm64 = 1388, + // `VCVTSD2SS xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.F2.0F.W1 5A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtsd2ss_xmm_k1z_xmm_xmmm64_er = 1389, + // `CVTDQ2PS xmm1, xmm2/m128` + // + // `NP 0F 5B /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtdq2ps_xmm_xmmm128 = 1390, + // `VCVTDQ2PS xmm1, xmm2/m128` + // + // `VEX.128.0F.WIG 5B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtdq2ps_xmm_xmmm128 = 1391, + // `VCVTDQ2PS ymm1, ymm2/m256` + // + // `VEX.256.0F.WIG 5B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtdq2ps_ymm_ymmm256 = 1392, + // `VCVTDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.0F.W0 5B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtdq2ps_xmm_k1z_xmmm128b32 = 1393, + // `VCVTDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.0F.W0 5B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtdq2ps_ymm_k1z_ymmm256b32 = 1394, + // `VCVTDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}` + // + // `EVEX.512.0F.W0 5B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtdq2ps_zmm_k1z_zmmm512b32_er = 1395, + // `VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.0F.W1 5B /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtqq2ps_xmm_k1z_xmmm128b64 = 1396, + // `VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.0F.W1 5B /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtqq2ps_xmm_k1z_ymmm256b64 = 1397, + // `VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.0F.W1 5B /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtqq2ps_ymm_k1z_zmmm512b64_er = 1398, + // `CVTPS2DQ xmm1, xmm2/m128` + // + // `66 0F 5B /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtps2dq_xmm_xmmm128 = 1399, + // `VCVTPS2DQ xmm1, xmm2/m128` + // + // `VEX.128.66.0F.WIG 5B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtps2dq_xmm_xmmm128 = 1400, + // `VCVTPS2DQ ymm1, ymm2/m256` + // + // `VEX.256.66.0F.WIG 5B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtps2dq_ymm_ymmm256 = 1401, + // `VCVTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 5B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2dq_xmm_k1z_xmmm128b32 = 1402, + // `VCVTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 5B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2dq_ymm_k1z_ymmm256b32 = 1403, + // `VCVTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er}` + // + // `EVEX.512.66.0F.W0 5B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2dq_zmm_k1z_zmmm512b32_er = 1404, + // `CVTTPS2DQ xmm1, xmm2/m128` + // + // `F3 0F 5B /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvttps2dq_xmm_xmmm128 = 1405, + // `VCVTTPS2DQ xmm1, xmm2/m128` + // + // `VEX.128.F3.0F.WIG 5B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvttps2dq_xmm_xmmm128 = 1406, + // `VCVTTPS2DQ ymm1, ymm2/m256` + // + // `VEX.256.F3.0F.WIG 5B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvttps2dq_ymm_ymmm256 = 1407, + // `VCVTTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.F3.0F.W0 5B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttps2dq_xmm_k1z_xmmm128b32 = 1408, + // `VCVTTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.F3.0F.W0 5B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttps2dq_ymm_k1z_ymmm256b32 = 1409, + // `VCVTTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}` + // + // `EVEX.512.F3.0F.W0 5B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttps2dq_zmm_k1z_zmmm512b32_sae = 1410, + // `SUBPS xmm1, xmm2/m128` + // + // `NP 0F 5C /r` + // + // `SSE` + // + // `16/32/64-bit` + Subps_xmm_xmmm128 = 1411, + // `VSUBPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 5C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsubps_xmm_xmm_xmmm128 = 1412, + // `VSUBPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 5C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsubps_ymm_ymm_ymmm256 = 1413, + // `VSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 5C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vsubps_xmm_k1z_xmm_xmmm128b32 = 1414, + // `VSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 5C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vsubps_ymm_k1z_ymm_ymmm256b32 = 1415, + // `VSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.0F.W0 5C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vsubps_zmm_k1z_zmm_zmmm512b32_er = 1416, + // `SUBPD xmm1, xmm2/m128` + // + // `66 0F 5C /r` + // + // `SSE2` + // + // `16/32/64-bit` + Subpd_xmm_xmmm128 = 1417, + // `VSUBPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 5C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsubpd_xmm_xmm_xmmm128 = 1418, + // `VSUBPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 5C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsubpd_ymm_ymm_ymmm256 = 1419, + // `VSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 5C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vsubpd_xmm_k1z_xmm_xmmm128b64 = 1420, + // `VSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 5C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vsubpd_ymm_k1z_ymm_ymmm256b64 = 1421, + // `VSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F.W1 5C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vsubpd_zmm_k1z_zmm_zmmm512b64_er = 1422, + // `SUBSS xmm1, xmm2/m32` + // + // `F3 0F 5C /r` + // + // `SSE` + // + // `16/32/64-bit` + Subss_xmm_xmmm32 = 1423, + // `VSUBSS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.F3.0F.WIG 5C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsubss_xmm_xmm_xmmm32 = 1424, + // `VSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.F3.0F.W0 5C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vsubss_xmm_k1z_xmm_xmmm32_er = 1425, + // `SUBSD xmm1, xmm2/m64` + // + // `F2 0F 5C /r` + // + // `SSE2` + // + // `16/32/64-bit` + Subsd_xmm_xmmm64 = 1426, + // `VSUBSD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.F2.0F.WIG 5C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vsubsd_xmm_xmm_xmmm64 = 1427, + // `VSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.F2.0F.W1 5C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vsubsd_xmm_k1z_xmm_xmmm64_er = 1428, + // `MINPS xmm1, xmm2/m128` + // + // `NP 0F 5D /r` + // + // `SSE` + // + // `16/32/64-bit` + Minps_xmm_xmmm128 = 1429, + // `VMINPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 5D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vminps_xmm_xmm_xmmm128 = 1430, + // `VMINPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 5D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vminps_ymm_ymm_ymmm256 = 1431, + // `VMINPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 5D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vminps_xmm_k1z_xmm_xmmm128b32 = 1432, + // `VMINPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 5D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vminps_ymm_k1z_ymm_ymmm256b32 = 1433, + // `VMINPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}` + // + // `EVEX.512.0F.W0 5D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vminps_zmm_k1z_zmm_zmmm512b32_sae = 1434, + // `MINPD xmm1, xmm2/m128` + // + // `66 0F 5D /r` + // + // `SSE2` + // + // `16/32/64-bit` + Minpd_xmm_xmmm128 = 1435, + // `VMINPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 5D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vminpd_xmm_xmm_xmmm128 = 1436, + // `VMINPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 5D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vminpd_ymm_ymm_ymmm256 = 1437, + // `VMINPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 5D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vminpd_xmm_k1z_xmm_xmmm128b64 = 1438, + // `VMINPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 5D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vminpd_ymm_k1z_ymm_ymmm256b64 = 1439, + // `VMINPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}` + // + // `EVEX.512.66.0F.W1 5D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vminpd_zmm_k1z_zmm_zmmm512b64_sae = 1440, + // `MINSS xmm1, xmm2/m32` + // + // `F3 0F 5D /r` + // + // `SSE` + // + // `16/32/64-bit` + Minss_xmm_xmmm32 = 1441, + // `VMINSS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.F3.0F.WIG 5D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vminss_xmm_xmm_xmmm32 = 1442, + // `VMINSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}` + // + // `EVEX.LIG.F3.0F.W0 5D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vminss_xmm_k1z_xmm_xmmm32_sae = 1443, + // `MINSD xmm1, xmm2/m64` + // + // `F2 0F 5D /r` + // + // `SSE2` + // + // `16/32/64-bit` + Minsd_xmm_xmmm64 = 1444, + // `VMINSD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.F2.0F.WIG 5D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vminsd_xmm_xmm_xmmm64 = 1445, + // `VMINSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}` + // + // `EVEX.LIG.F2.0F.W1 5D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vminsd_xmm_k1z_xmm_xmmm64_sae = 1446, + // `DIVPS xmm1, xmm2/m128` + // + // `NP 0F 5E /r` + // + // `SSE` + // + // `16/32/64-bit` + Divps_xmm_xmmm128 = 1447, + // `VDIVPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 5E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vdivps_xmm_xmm_xmmm128 = 1448, + // `VDIVPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 5E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vdivps_ymm_ymm_ymmm256 = 1449, + // `VDIVPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 5E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vdivps_xmm_k1z_xmm_xmmm128b32 = 1450, + // `VDIVPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 5E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vdivps_ymm_k1z_ymm_ymmm256b32 = 1451, + // `VDIVPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.0F.W0 5E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vdivps_zmm_k1z_zmm_zmmm512b32_er = 1452, + // `DIVPD xmm1, xmm2/m128` + // + // `66 0F 5E /r` + // + // `SSE2` + // + // `16/32/64-bit` + Divpd_xmm_xmmm128 = 1453, + // `VDIVPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 5E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vdivpd_xmm_xmm_xmmm128 = 1454, + // `VDIVPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 5E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vdivpd_ymm_ymm_ymmm256 = 1455, + // `VDIVPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 5E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vdivpd_xmm_k1z_xmm_xmmm128b64 = 1456, + // `VDIVPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 5E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vdivpd_ymm_k1z_ymm_ymmm256b64 = 1457, + // `VDIVPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F.W1 5E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vdivpd_zmm_k1z_zmm_zmmm512b64_er = 1458, + // `DIVSS xmm1, xmm2/m32` + // + // `F3 0F 5E /r` + // + // `SSE` + // + // `16/32/64-bit` + Divss_xmm_xmmm32 = 1459, + // `VDIVSS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.F3.0F.WIG 5E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vdivss_xmm_xmm_xmmm32 = 1460, + // `VDIVSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.F3.0F.W0 5E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vdivss_xmm_k1z_xmm_xmmm32_er = 1461, + // `DIVSD xmm1, xmm2/m64` + // + // `F2 0F 5E /r` + // + // `SSE2` + // + // `16/32/64-bit` + Divsd_xmm_xmmm64 = 1462, + // `VDIVSD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.F2.0F.WIG 5E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vdivsd_xmm_xmm_xmmm64 = 1463, + // `VDIVSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.F2.0F.W1 5E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vdivsd_xmm_k1z_xmm_xmmm64_er = 1464, + // `MAXPS xmm1, xmm2/m128` + // + // `NP 0F 5F /r` + // + // `SSE` + // + // `16/32/64-bit` + Maxps_xmm_xmmm128 = 1465, + // `VMAXPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F.WIG 5F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaxps_xmm_xmm_xmmm128 = 1466, + // `VMAXPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F.WIG 5F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaxps_ymm_ymm_ymmm256 = 1467, + // `VMAXPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.0F.W0 5F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmaxps_xmm_k1z_xmm_xmmm128b32 = 1468, + // `VMAXPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.0F.W0 5F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmaxps_ymm_k1z_ymm_ymmm256b32 = 1469, + // `VMAXPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}` + // + // `EVEX.512.0F.W0 5F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmaxps_zmm_k1z_zmm_zmmm512b32_sae = 1470, + // `MAXPD xmm1, xmm2/m128` + // + // `66 0F 5F /r` + // + // `SSE2` + // + // `16/32/64-bit` + Maxpd_xmm_xmmm128 = 1471, + // `VMAXPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 5F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaxpd_xmm_xmm_xmmm128 = 1472, + // `VMAXPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 5F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaxpd_ymm_ymm_ymmm256 = 1473, + // `VMAXPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 5F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmaxpd_xmm_k1z_xmm_xmmm128b64 = 1474, + // `VMAXPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 5F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmaxpd_ymm_k1z_ymm_ymmm256b64 = 1475, + // `VMAXPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}` + // + // `EVEX.512.66.0F.W1 5F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmaxpd_zmm_k1z_zmm_zmmm512b64_sae = 1476, + // `MAXSS xmm1, xmm2/m32` + // + // `F3 0F 5F /r` + // + // `SSE` + // + // `16/32/64-bit` + Maxss_xmm_xmmm32 = 1477, + // `VMAXSS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.F3.0F.WIG 5F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaxss_xmm_xmm_xmmm32 = 1478, + // `VMAXSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}` + // + // `EVEX.LIG.F3.0F.W0 5F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmaxss_xmm_k1z_xmm_xmmm32_sae = 1479, + // `MAXSD xmm1, xmm2/m64` + // + // `F2 0F 5F /r` + // + // `SSE2` + // + // `16/32/64-bit` + Maxsd_xmm_xmmm64 = 1480, + // `VMAXSD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.F2.0F.WIG 5F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaxsd_xmm_xmm_xmmm64 = 1481, + // `VMAXSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}` + // + // `EVEX.LIG.F2.0F.W1 5F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmaxsd_xmm_k1z_xmm_xmmm64_sae = 1482, + // `PUNPCKLBW mm, mm/m32` + // + // `NP 0F 60 /r` + // + // `MMX` + // + // `16/32/64-bit` + Punpcklbw_mm_mmm32 = 1483, + // `PUNPCKLBW xmm1, xmm2/m128` + // + // `66 0F 60 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Punpcklbw_xmm_xmmm128 = 1484, + // `VPUNPCKLBW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 60 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpunpcklbw_xmm_xmm_xmmm128 = 1485, + // `VPUNPCKLBW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 60 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpunpcklbw_ymm_ymm_ymmm256 = 1486, + // `VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG 60 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpcklbw_xmm_k1z_xmm_xmmm128 = 1487, + // `VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG 60 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpcklbw_ymm_k1z_ymm_ymmm256 = 1488, + // `VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG 60 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpcklbw_zmm_k1z_zmm_zmmm512 = 1489, + // `PUNPCKLWD mm, mm/m32` + // + // `NP 0F 61 /r` + // + // `MMX` + // + // `16/32/64-bit` + Punpcklwd_mm_mmm32 = 1490, + // `PUNPCKLWD xmm1, xmm2/m128` + // + // `66 0F 61 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Punpcklwd_xmm_xmmm128 = 1491, + // `VPUNPCKLWD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 61 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpunpcklwd_xmm_xmm_xmmm128 = 1492, + // `VPUNPCKLWD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 61 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpunpcklwd_ymm_ymm_ymmm256 = 1493, + // `VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG 61 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpcklwd_xmm_k1z_xmm_xmmm128 = 1494, + // `VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG 61 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpcklwd_ymm_k1z_ymm_ymmm256 = 1495, + // `VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG 61 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpcklwd_zmm_k1z_zmm_zmmm512 = 1496, + // `PUNPCKLDQ mm, mm/m32` + // + // `NP 0F 62 /r` + // + // `MMX` + // + // `16/32/64-bit` + Punpckldq_mm_mmm32 = 1497, + // `PUNPCKLDQ xmm1, xmm2/m128` + // + // `66 0F 62 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Punpckldq_xmm_xmmm128 = 1498, + // `VPUNPCKLDQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 62 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpunpckldq_xmm_xmm_xmmm128 = 1499, + // `VPUNPCKLDQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 62 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpunpckldq_ymm_ymm_ymmm256 = 1500, + // `VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 62 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpckldq_xmm_k1z_xmm_xmmm128b32 = 1501, + // `VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 62 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpckldq_ymm_k1z_ymm_ymmm256b32 = 1502, + // `VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F.W0 62 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpckldq_zmm_k1z_zmm_zmmm512b32 = 1503, + // `PACKSSWB mm1, mm2/m64` + // + // `NP 0F 63 /r` + // + // `MMX` + // + // `16/32/64-bit` + Packsswb_mm_mmm64 = 1504, + // `PACKSSWB xmm1, xmm2/m128` + // + // `66 0F 63 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Packsswb_xmm_xmmm128 = 1505, + // `VPACKSSWB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 63 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpacksswb_xmm_xmm_xmmm128 = 1506, + // `VPACKSSWB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 63 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpacksswb_ymm_ymm_ymmm256 = 1507, + // `VPACKSSWB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG 63 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpacksswb_xmm_k1z_xmm_xmmm128 = 1508, + // `VPACKSSWB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG 63 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpacksswb_ymm_k1z_ymm_ymmm256 = 1509, + // `VPACKSSWB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG 63 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpacksswb_zmm_k1z_zmm_zmmm512 = 1510, + // `PCMPGTB mm, mm/m64` + // + // `NP 0F 64 /r` + // + // `MMX` + // + // `16/32/64-bit` + Pcmpgtb_mm_mmm64 = 1511, + // `PCMPGTB xmm1, xmm2/m128` + // + // `66 0F 64 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pcmpgtb_xmm_xmmm128 = 1512, + // `VPCMPGTB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 64 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpgtb_xmm_xmm_xmmm128 = 1513, + // `VPCMPGTB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 64 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpcmpgtb_ymm_ymm_ymmm256 = 1514, + // `VPCMPGTB k1 {k2}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG 64 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpgtb_kr_k1_xmm_xmmm128 = 1515, + // `VPCMPGTB k1 {k2}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG 64 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpgtb_kr_k1_ymm_ymmm256 = 1516, + // `VPCMPGTB k1 {k2}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG 64 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpgtb_kr_k1_zmm_zmmm512 = 1517, + // `PCMPGTW mm, mm/m64` + // + // `NP 0F 65 /r` + // + // `MMX` + // + // `16/32/64-bit` + Pcmpgtw_mm_mmm64 = 1518, + // `PCMPGTW xmm1, xmm2/m128` + // + // `66 0F 65 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pcmpgtw_xmm_xmmm128 = 1519, + // `VPCMPGTW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 65 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpgtw_xmm_xmm_xmmm128 = 1520, + // `VPCMPGTW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 65 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpcmpgtw_ymm_ymm_ymmm256 = 1521, + // `VPCMPGTW k1 {k2}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG 65 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpgtw_kr_k1_xmm_xmmm128 = 1522, + // `VPCMPGTW k1 {k2}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG 65 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpgtw_kr_k1_ymm_ymmm256 = 1523, + // `VPCMPGTW k1 {k2}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG 65 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpgtw_kr_k1_zmm_zmmm512 = 1524, + // `PCMPGTD mm, mm/m64` + // + // `NP 0F 66 /r` + // + // `MMX` + // + // `16/32/64-bit` + Pcmpgtd_mm_mmm64 = 1525, + // `PCMPGTD xmm1, xmm2/m128` + // + // `66 0F 66 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pcmpgtd_xmm_xmmm128 = 1526, + // `VPCMPGTD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 66 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpgtd_xmm_xmm_xmmm128 = 1527, + // `VPCMPGTD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 66 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpcmpgtd_ymm_ymm_ymmm256 = 1528, + // `VPCMPGTD k1 {k2}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 66 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpgtd_kr_k1_xmm_xmmm128b32 = 1529, + // `VPCMPGTD k1 {k2}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 66 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpgtd_kr_k1_ymm_ymmm256b32 = 1530, + // `VPCMPGTD k1 {k2}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F.W0 66 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpgtd_kr_k1_zmm_zmmm512b32 = 1531, + // `PACKUSWB mm, mm/m64` + // + // `NP 0F 67 /r` + // + // `MMX` + // + // `16/32/64-bit` + Packuswb_mm_mmm64 = 1532, + // `PACKUSWB xmm1, xmm2/m128` + // + // `66 0F 67 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Packuswb_xmm_xmmm128 = 1533, + // `VPACKUSWB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 67 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpackuswb_xmm_xmm_xmmm128 = 1534, + // `VPACKUSWB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 67 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpackuswb_ymm_ymm_ymmm256 = 1535, + // `VPACKUSWB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG 67 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpackuswb_xmm_k1z_xmm_xmmm128 = 1536, + // `VPACKUSWB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG 67 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpackuswb_ymm_k1z_ymm_ymmm256 = 1537, + // `VPACKUSWB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG 67 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpackuswb_zmm_k1z_zmm_zmmm512 = 1538, + // `PUNPCKHBW mm, mm/m64` + // + // `NP 0F 68 /r` + // + // `MMX` + // + // `16/32/64-bit` + Punpckhbw_mm_mmm64 = 1539, + // `PUNPCKHBW xmm1, xmm2/m128` + // + // `66 0F 68 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Punpckhbw_xmm_xmmm128 = 1540, + // `VPUNPCKHBW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 68 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpunpckhbw_xmm_xmm_xmmm128 = 1541, + // `VPUNPCKHBW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 68 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpunpckhbw_ymm_ymm_ymmm256 = 1542, + // `VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG 68 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpckhbw_xmm_k1z_xmm_xmmm128 = 1543, + // `VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG 68 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpckhbw_ymm_k1z_ymm_ymmm256 = 1544, + // `VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG 68 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpckhbw_zmm_k1z_zmm_zmmm512 = 1545, + // `PUNPCKHWD mm, mm/m64` + // + // `NP 0F 69 /r` + // + // `MMX` + // + // `16/32/64-bit` + Punpckhwd_mm_mmm64 = 1546, + // `PUNPCKHWD xmm1, xmm2/m128` + // + // `66 0F 69 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Punpckhwd_xmm_xmmm128 = 1547, + // `VPUNPCKHWD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 69 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpunpckhwd_xmm_xmm_xmmm128 = 1548, + // `VPUNPCKHWD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 69 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpunpckhwd_ymm_ymm_ymmm256 = 1549, + // `VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG 69 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpckhwd_xmm_k1z_xmm_xmmm128 = 1550, + // `VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG 69 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpckhwd_ymm_k1z_ymm_ymmm256 = 1551, + // `VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG 69 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpunpckhwd_zmm_k1z_zmm_zmmm512 = 1552, + // `PUNPCKHDQ mm, mm/m64` + // + // `NP 0F 6A /r` + // + // `MMX` + // + // `16/32/64-bit` + Punpckhdq_mm_mmm64 = 1553, + // `PUNPCKHDQ xmm1, xmm2/m128` + // + // `66 0F 6A /r` + // + // `SSE2` + // + // `16/32/64-bit` + Punpckhdq_xmm_xmmm128 = 1554, + // `VPUNPCKHDQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 6A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpunpckhdq_xmm_xmm_xmmm128 = 1555, + // `VPUNPCKHDQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 6A /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpunpckhdq_ymm_ymm_ymmm256 = 1556, + // `VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 6A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpckhdq_xmm_k1z_xmm_xmmm128b32 = 1557, + // `VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 6A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpckhdq_ymm_k1z_ymm_ymmm256b32 = 1558, + // `VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F.W0 6A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpckhdq_zmm_k1z_zmm_zmmm512b32 = 1559, + // `PACKSSDW mm1, mm2/m64` + // + // `NP 0F 6B /r` + // + // `MMX` + // + // `16/32/64-bit` + Packssdw_mm_mmm64 = 1560, + // `PACKSSDW xmm1, xmm2/m128` + // + // `66 0F 6B /r` + // + // `SSE2` + // + // `16/32/64-bit` + Packssdw_xmm_xmmm128 = 1561, + // `VPACKSSDW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 6B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpackssdw_xmm_xmm_xmmm128 = 1562, + // `VPACKSSDW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 6B /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpackssdw_ymm_ymm_ymmm256 = 1563, + // `VPACKSSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 6B /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpackssdw_xmm_k1z_xmm_xmmm128b32 = 1564, + // `VPACKSSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 6B /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpackssdw_ymm_k1z_ymm_ymmm256b32 = 1565, + // `VPACKSSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F.W0 6B /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpackssdw_zmm_k1z_zmm_zmmm512b32 = 1566, + // `PUNPCKLQDQ xmm1, xmm2/m128` + // + // `66 0F 6C /r` + // + // `SSE2` + // + // `16/32/64-bit` + Punpcklqdq_xmm_xmmm128 = 1567, + // `VPUNPCKLQDQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 6C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpunpcklqdq_xmm_xmm_xmmm128 = 1568, + // `VPUNPCKLQDQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 6C /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpunpcklqdq_ymm_ymm_ymmm256 = 1569, + // `VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 6C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpcklqdq_xmm_k1z_xmm_xmmm128b64 = 1570, + // `VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 6C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpcklqdq_ymm_k1z_ymm_ymmm256b64 = 1571, + // `VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 6C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpcklqdq_zmm_k1z_zmm_zmmm512b64 = 1572, + // `PUNPCKHQDQ xmm1, xmm2/m128` + // + // `66 0F 6D /r` + // + // `SSE2` + // + // `16/32/64-bit` + Punpckhqdq_xmm_xmmm128 = 1573, + // `VPUNPCKHQDQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 6D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpunpckhqdq_xmm_xmm_xmmm128 = 1574, + // `VPUNPCKHQDQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 6D /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpunpckhqdq_ymm_ymm_ymmm256 = 1575, + // `VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 6D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpckhqdq_xmm_k1z_xmm_xmmm128b64 = 1576, + // `VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 6D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpckhqdq_ymm_k1z_ymm_ymmm256b64 = 1577, + // `VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 6D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpunpckhqdq_zmm_k1z_zmm_zmmm512b64 = 1578, + // `MOVD mm, r/m32` + // + // `NP 0F 6E /r` + // + // `MMX` + // + // `16/32/64-bit` + Movd_mm_rm32 = 1579, + // `MOVQ mm, r/m64` + // + // `NP o64 0F 6E /r` + // + // `MMX` + // + // `64-bit` + Movq_mm_rm64 = 1580, + // `MOVD xmm, r/m32` + // + // `66 0F 6E /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movd_xmm_rm32 = 1581, + // `MOVQ xmm, r/m64` + // + // `66 o64 0F 6E /r` + // + // `SSE2` + // + // `64-bit` + Movq_xmm_rm64 = 1582, + // `VMOVD xmm1, r/m32` + // + // `VEX.128.66.0F.W0 6E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovd_xmm_rm32 = 1583, + // `VMOVQ xmm1, r/m64` + // + // `VEX.128.66.0F.W1 6E /r` + // + // `AVX` + // + // `64-bit` + VEX_Vmovq_xmm_rm64 = 1584, + // `VMOVD xmm1, r/m32` + // + // `EVEX.128.66.0F.W0 6E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovd_xmm_rm32 = 1585, + // `VMOVQ xmm1, r/m64` + // + // `EVEX.128.66.0F.W1 6E /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vmovq_xmm_rm64 = 1586, + // `MOVQ mm, mm/m64` + // + // `NP 0F 6F /r` + // + // `MMX` + // + // `16/32/64-bit` + Movq_mm_mmm64 = 1587, + // `MOVDQA xmm1, xmm2/m128` + // + // `66 0F 6F /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movdqa_xmm_xmmm128 = 1588, + // `VMOVDQA xmm1, xmm2/m128` + // + // `VEX.128.66.0F.WIG 6F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovdqa_xmm_xmmm128 = 1589, + // `VMOVDQA ymm1, ymm2/m256` + // + // `VEX.256.66.0F.WIG 6F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovdqa_ymm_ymmm256 = 1590, + // `VMOVDQA32 xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F.W0 6F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa32_xmm_k1z_xmmm128 = 1591, + // `VMOVDQA32 ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F.W0 6F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa32_ymm_k1z_ymmm256 = 1592, + // `VMOVDQA32 zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F.W0 6F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa32_zmm_k1z_zmmm512 = 1593, + // `VMOVDQA64 xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F.W1 6F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa64_xmm_k1z_xmmm128 = 1594, + // `VMOVDQA64 ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F.W1 6F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa64_ymm_k1z_ymmm256 = 1595, + // `VMOVDQA64 zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F.W1 6F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa64_zmm_k1z_zmmm512 = 1596, + // `MOVDQU xmm1, xmm2/m128` + // + // `F3 0F 6F /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movdqu_xmm_xmmm128 = 1597, + // `VMOVDQU xmm1, xmm2/m128` + // + // `VEX.128.F3.0F.WIG 6F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovdqu_xmm_xmmm128 = 1598, + // `VMOVDQU ymm1, ymm2/m256` + // + // `VEX.256.F3.0F.WIG 6F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovdqu_ymm_ymmm256 = 1599, + // `VMOVDQU32 xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.F3.0F.W0 6F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu32_xmm_k1z_xmmm128 = 1600, + // `VMOVDQU32 ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.F3.0F.W0 6F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu32_ymm_k1z_ymmm256 = 1601, + // `VMOVDQU32 zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.F3.0F.W0 6F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu32_zmm_k1z_zmmm512 = 1602, + // `VMOVDQU64 xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.F3.0F.W1 6F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu64_xmm_k1z_xmmm128 = 1603, + // `VMOVDQU64 ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.F3.0F.W1 6F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu64_ymm_k1z_ymmm256 = 1604, + // `VMOVDQU64 zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.F3.0F.W1 6F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu64_zmm_k1z_zmmm512 = 1605, + // `VMOVDQU8 xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.F2.0F.W0 6F /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu8_xmm_k1z_xmmm128 = 1606, + // `VMOVDQU8 ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.F2.0F.W0 6F /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu8_ymm_k1z_ymmm256 = 1607, + // `VMOVDQU8 zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.F2.0F.W0 6F /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu8_zmm_k1z_zmmm512 = 1608, + // `VMOVDQU16 xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.F2.0F.W1 6F /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu16_xmm_k1z_xmmm128 = 1609, + // `VMOVDQU16 ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.F2.0F.W1 6F /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu16_ymm_k1z_ymmm256 = 1610, + // `VMOVDQU16 zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.F2.0F.W1 6F /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu16_zmm_k1z_zmmm512 = 1611, + // `PSHUFW mm1, mm2/m64, imm8` + // + // `NP 0F 70 /r ib` + // + // `SSE` + // + // `16/32/64-bit` + Pshufw_mm_mmm64_imm8 = 1612, + // `PSHUFD xmm1, xmm2/m128, imm8` + // + // `66 0F 70 /r ib` + // + // `SSE2` + // + // `16/32/64-bit` + Pshufd_xmm_xmmm128_imm8 = 1613, + // `VPSHUFD xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F.WIG 70 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpshufd_xmm_xmmm128_imm8 = 1614, + // `VPSHUFD ymm1, ymm2/m256, imm8` + // + // `VEX.256.66.0F.WIG 70 /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpshufd_ymm_ymmm256_imm8 = 1615, + // `VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F.W0 70 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpshufd_xmm_k1z_xmmm128b32_imm8 = 1616, + // `VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F.W0 70 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpshufd_ymm_k1z_ymmm256b32_imm8 = 1617, + // `VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F.W0 70 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpshufd_zmm_k1z_zmmm512b32_imm8 = 1618, + // `PSHUFHW xmm1, xmm2/m128, imm8` + // + // `F3 0F 70 /r ib` + // + // `SSE2` + // + // `16/32/64-bit` + Pshufhw_xmm_xmmm128_imm8 = 1619, + // `VPSHUFHW xmm1, xmm2/m128, imm8` + // + // `VEX.128.F3.0F.WIG 70 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpshufhw_xmm_xmmm128_imm8 = 1620, + // `VPSHUFHW ymm1, ymm2/m256, imm8` + // + // `VEX.256.F3.0F.WIG 70 /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpshufhw_ymm_ymmm256_imm8 = 1621, + // `VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8` + // + // `EVEX.128.F3.0F.WIG 70 /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpshufhw_xmm_k1z_xmmm128_imm8 = 1622, + // `VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8` + // + // `EVEX.256.F3.0F.WIG 70 /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpshufhw_ymm_k1z_ymmm256_imm8 = 1623, + // `VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8` + // + // `EVEX.512.F3.0F.WIG 70 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpshufhw_zmm_k1z_zmmm512_imm8 = 1624, + // `PSHUFLW xmm1, xmm2/m128, imm8` + // + // `F2 0F 70 /r ib` + // + // `SSE2` + // + // `16/32/64-bit` + Pshuflw_xmm_xmmm128_imm8 = 1625, + // `VPSHUFLW xmm1, xmm2/m128, imm8` + // + // `VEX.128.F2.0F.WIG 70 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpshuflw_xmm_xmmm128_imm8 = 1626, + // `VPSHUFLW ymm1, ymm2/m256, imm8` + // + // `VEX.256.F2.0F.WIG 70 /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpshuflw_ymm_ymmm256_imm8 = 1627, + // `VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8` + // + // `EVEX.128.F2.0F.WIG 70 /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpshuflw_xmm_k1z_xmmm128_imm8 = 1628, + // `VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8` + // + // `EVEX.256.F2.0F.WIG 70 /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpshuflw_ymm_k1z_ymmm256_imm8 = 1629, + // `VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8` + // + // `EVEX.512.F2.0F.WIG 70 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpshuflw_zmm_k1z_zmmm512_imm8 = 1630, + // `PSRLW mm, imm8` + // + // `NP 0F 71 /2 ib` + // + // `MMX` + // + // `16/32/64-bit` + Psrlw_mm_imm8 = 1631, + // `PSRLW xmm1, imm8` + // + // `66 0F 71 /2 ib` + // + // `SSE2` + // + // `16/32/64-bit` + Psrlw_xmm_imm8 = 1632, + // `VPSRLW xmm1, xmm2, imm8` + // + // `VEX.128.66.0F.WIG 71 /2 ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsrlw_xmm_xmm_imm8 = 1633, + // `VPSRLW ymm1, ymm2, imm8` + // + // `VEX.256.66.0F.WIG 71 /2 ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrlw_ymm_ymm_imm8 = 1634, + // `VPSRLW xmm1 {k1}{z}, xmm2/m128, imm8` + // + // `EVEX.128.66.0F.WIG 71 /2 ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrlw_xmm_k1z_xmmm128_imm8 = 1635, + // `VPSRLW ymm1 {k1}{z}, ymm2/m256, imm8` + // + // `EVEX.256.66.0F.WIG 71 /2 ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrlw_ymm_k1z_ymmm256_imm8 = 1636, + // `VPSRLW zmm1 {k1}{z}, zmm2/m512, imm8` + // + // `EVEX.512.66.0F.WIG 71 /2 ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrlw_zmm_k1z_zmmm512_imm8 = 1637, + // `PSRAW mm, imm8` + // + // `NP 0F 71 /4 ib` + // + // `MMX` + // + // `16/32/64-bit` + Psraw_mm_imm8 = 1638, + // `PSRAW xmm1, imm8` + // + // `66 0F 71 /4 ib` + // + // `SSE2` + // + // `16/32/64-bit` + Psraw_xmm_imm8 = 1639, + // `VPSRAW xmm1, xmm2, imm8` + // + // `VEX.128.66.0F.WIG 71 /4 ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsraw_xmm_xmm_imm8 = 1640, + // `VPSRAW ymm1, ymm2, imm8` + // + // `VEX.256.66.0F.WIG 71 /4 ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsraw_ymm_ymm_imm8 = 1641, + // `VPSRAW xmm1 {k1}{z}, xmm2/m128, imm8` + // + // `EVEX.128.66.0F.WIG 71 /4 ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsraw_xmm_k1z_xmmm128_imm8 = 1642, + // `VPSRAW ymm1 {k1}{z}, ymm2/m256, imm8` + // + // `EVEX.256.66.0F.WIG 71 /4 ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsraw_ymm_k1z_ymmm256_imm8 = 1643, + // `VPSRAW zmm1 {k1}{z}, zmm2/m512, imm8` + // + // `EVEX.512.66.0F.WIG 71 /4 ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsraw_zmm_k1z_zmmm512_imm8 = 1644, + // `PSLLW mm1, imm8` + // + // `NP 0F 71 /6 ib` + // + // `MMX` + // + // `16/32/64-bit` + Psllw_mm_imm8 = 1645, + // `PSLLW xmm1, imm8` + // + // `66 0F 71 /6 ib` + // + // `SSE2` + // + // `16/32/64-bit` + Psllw_xmm_imm8 = 1646, + // `VPSLLW xmm1, xmm2, imm8` + // + // `VEX.128.66.0F.WIG 71 /6 ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsllw_xmm_xmm_imm8 = 1647, + // `VPSLLW ymm1, ymm2, imm8` + // + // `VEX.256.66.0F.WIG 71 /6 ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsllw_ymm_ymm_imm8 = 1648, + // `VPSLLW xmm1 {k1}{z}, xmm2/m128, imm8` + // + // `EVEX.128.66.0F.WIG 71 /6 ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsllw_xmm_k1z_xmmm128_imm8 = 1649, + // `VPSLLW ymm1 {k1}{z}, ymm2/m256, imm8` + // + // `EVEX.256.66.0F.WIG 71 /6 ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsllw_ymm_k1z_ymmm256_imm8 = 1650, + // `VPSLLW zmm1 {k1}{z}, zmm2/m512, imm8` + // + // `EVEX.512.66.0F.WIG 71 /6 ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsllw_zmm_k1z_zmmm512_imm8 = 1651, + // `VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F.W0 72 /0 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprord_xmm_k1z_xmmm128b32_imm8 = 1652, + // `VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F.W0 72 /0 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprord_ymm_k1z_ymmm256b32_imm8 = 1653, + // `VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F.W0 72 /0 ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vprord_zmm_k1z_zmmm512b32_imm8 = 1654, + // `VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F.W1 72 /0 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprorq_xmm_k1z_xmmm128b64_imm8 = 1655, + // `VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F.W1 72 /0 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprorq_ymm_k1z_ymmm256b64_imm8 = 1656, + // `VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F.W1 72 /0 ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vprorq_zmm_k1z_zmmm512b64_imm8 = 1657, + // `VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F.W0 72 /1 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprold_xmm_k1z_xmmm128b32_imm8 = 1658, + // `VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F.W0 72 /1 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprold_ymm_k1z_ymmm256b32_imm8 = 1659, + // `VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F.W0 72 /1 ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vprold_zmm_k1z_zmmm512b32_imm8 = 1660, + // `VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F.W1 72 /1 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprolq_xmm_k1z_xmmm128b64_imm8 = 1661, + // `VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F.W1 72 /1 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprolq_ymm_k1z_ymmm256b64_imm8 = 1662, + // `VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F.W1 72 /1 ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vprolq_zmm_k1z_zmmm512b64_imm8 = 1663, + // `PSRLD mm, imm8` + // + // `NP 0F 72 /2 ib` + // + // `MMX` + // + // `16/32/64-bit` + Psrld_mm_imm8 = 1664, + // `PSRLD xmm1, imm8` + // + // `66 0F 72 /2 ib` + // + // `SSE2` + // + // `16/32/64-bit` + Psrld_xmm_imm8 = 1665, + // `VPSRLD xmm1, xmm2, imm8` + // + // `VEX.128.66.0F.WIG 72 /2 ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsrld_xmm_xmm_imm8 = 1666, + // `VPSRLD ymm1, ymm2, imm8` + // + // `VEX.256.66.0F.WIG 72 /2 ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrld_ymm_ymm_imm8 = 1667, + // `VPSRLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F.W0 72 /2 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrld_xmm_k1z_xmmm128b32_imm8 = 1668, + // `VPSRLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F.W0 72 /2 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrld_ymm_k1z_ymmm256b32_imm8 = 1669, + // `VPSRLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F.W0 72 /2 ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrld_zmm_k1z_zmmm512b32_imm8 = 1670, + // `PSRAD mm, imm8` + // + // `NP 0F 72 /4 ib` + // + // `MMX` + // + // `16/32/64-bit` + Psrad_mm_imm8 = 1671, + // `PSRAD xmm1, imm8` + // + // `66 0F 72 /4 ib` + // + // `SSE2` + // + // `16/32/64-bit` + Psrad_xmm_imm8 = 1672, + // `VPSRAD xmm1, xmm2, imm8` + // + // `VEX.128.66.0F.WIG 72 /4 ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsrad_xmm_xmm_imm8 = 1673, + // `VPSRAD ymm1, ymm2, imm8` + // + // `VEX.256.66.0F.WIG 72 /4 ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrad_ymm_ymm_imm8 = 1674, + // `VPSRAD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F.W0 72 /4 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrad_xmm_k1z_xmmm128b32_imm8 = 1675, + // `VPSRAD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F.W0 72 /4 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrad_ymm_k1z_ymmm256b32_imm8 = 1676, + // `VPSRAD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F.W0 72 /4 ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrad_zmm_k1z_zmmm512b32_imm8 = 1677, + // `VPSRAQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F.W1 72 /4 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsraq_xmm_k1z_xmmm128b64_imm8 = 1678, + // `VPSRAQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F.W1 72 /4 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsraq_ymm_k1z_ymmm256b64_imm8 = 1679, + // `VPSRAQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F.W1 72 /4 ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsraq_zmm_k1z_zmmm512b64_imm8 = 1680, + // `PSLLD mm, imm8` + // + // `NP 0F 72 /6 ib` + // + // `MMX` + // + // `16/32/64-bit` + Pslld_mm_imm8 = 1681, + // `PSLLD xmm1, imm8` + // + // `66 0F 72 /6 ib` + // + // `SSE2` + // + // `16/32/64-bit` + Pslld_xmm_imm8 = 1682, + // `VPSLLD xmm1, xmm2, imm8` + // + // `VEX.128.66.0F.WIG 72 /6 ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpslld_xmm_xmm_imm8 = 1683, + // `VPSLLD ymm1, ymm2, imm8` + // + // `VEX.256.66.0F.WIG 72 /6 ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpslld_ymm_ymm_imm8 = 1684, + // `VPSLLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F.W0 72 /6 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpslld_xmm_k1z_xmmm128b32_imm8 = 1685, + // `VPSLLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F.W0 72 /6 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpslld_ymm_k1z_ymmm256b32_imm8 = 1686, + // `VPSLLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F.W0 72 /6 ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpslld_zmm_k1z_zmmm512b32_imm8 = 1687, + // `PSRLQ mm, imm8` + // + // `NP 0F 73 /2 ib` + // + // `MMX` + // + // `16/32/64-bit` + Psrlq_mm_imm8 = 1688, + // `PSRLQ xmm1, imm8` + // + // `66 0F 73 /2 ib` + // + // `SSE2` + // + // `16/32/64-bit` + Psrlq_xmm_imm8 = 1689, + // `VPSRLQ xmm1, xmm2, imm8` + // + // `VEX.128.66.0F.WIG 73 /2 ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsrlq_xmm_xmm_imm8 = 1690, + // `VPSRLQ ymm1, ymm2, imm8` + // + // `VEX.256.66.0F.WIG 73 /2 ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrlq_ymm_ymm_imm8 = 1691, + // `VPSRLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F.W1 73 /2 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlq_xmm_k1z_xmmm128b64_imm8 = 1692, + // `VPSRLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F.W1 73 /2 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlq_ymm_k1z_ymmm256b64_imm8 = 1693, + // `VPSRLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F.W1 73 /2 ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlq_zmm_k1z_zmmm512b64_imm8 = 1694, + // `PSRLDQ xmm1, imm8` + // + // `66 0F 73 /3 ib` + // + // `SSE2` + // + // `16/32/64-bit` + Psrldq_xmm_imm8 = 1695, + // `VPSRLDQ xmm1, xmm2, imm8` + // + // `VEX.128.66.0F.WIG 73 /3 ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsrldq_xmm_xmm_imm8 = 1696, + // `VPSRLDQ ymm1, ymm2, imm8` + // + // `VEX.256.66.0F.WIG 73 /3 ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrldq_ymm_ymm_imm8 = 1697, + // `VPSRLDQ xmm1, xmm2/m128, imm8` + // + // `EVEX.128.66.0F.WIG 73 /3 ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrldq_xmm_xmmm128_imm8 = 1698, + // `VPSRLDQ ymm1, ymm2/m256, imm8` + // + // `EVEX.256.66.0F.WIG 73 /3 ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrldq_ymm_ymmm256_imm8 = 1699, + // `VPSRLDQ zmm1, zmm2/m512, imm8` + // + // `EVEX.512.66.0F.WIG 73 /3 ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrldq_zmm_zmmm512_imm8 = 1700, + // `PSLLQ mm, imm8` + // + // `NP 0F 73 /6 ib` + // + // `MMX` + // + // `16/32/64-bit` + Psllq_mm_imm8 = 1701, + // `PSLLQ xmm1, imm8` + // + // `66 0F 73 /6 ib` + // + // `SSE2` + // + // `16/32/64-bit` + Psllq_xmm_imm8 = 1702, + // `VPSLLQ xmm1, xmm2, imm8` + // + // `VEX.128.66.0F.WIG 73 /6 ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsllq_xmm_xmm_imm8 = 1703, + // `VPSLLQ ymm1, ymm2, imm8` + // + // `VEX.256.66.0F.WIG 73 /6 ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsllq_ymm_ymm_imm8 = 1704, + // `VPSLLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F.W1 73 /6 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllq_xmm_k1z_xmmm128b64_imm8 = 1705, + // `VPSLLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F.W1 73 /6 ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllq_ymm_k1z_ymmm256b64_imm8 = 1706, + // `VPSLLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F.W1 73 /6 ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllq_zmm_k1z_zmmm512b64_imm8 = 1707, + // `PSLLDQ xmm1, imm8` + // + // `66 0F 73 /7 ib` + // + // `SSE2` + // + // `16/32/64-bit` + Pslldq_xmm_imm8 = 1708, + // `VPSLLDQ xmm1, xmm2, imm8` + // + // `VEX.128.66.0F.WIG 73 /7 ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpslldq_xmm_xmm_imm8 = 1709, + // `VPSLLDQ ymm1, ymm2, imm8` + // + // `VEX.256.66.0F.WIG 73 /7 ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpslldq_ymm_ymm_imm8 = 1710, + // `VPSLLDQ xmm1, xmm2/m128, imm8` + // + // `EVEX.128.66.0F.WIG 73 /7 ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpslldq_xmm_xmmm128_imm8 = 1711, + // `VPSLLDQ ymm1, ymm2/m256, imm8` + // + // `EVEX.256.66.0F.WIG 73 /7 ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpslldq_ymm_ymmm256_imm8 = 1712, + // `VPSLLDQ zmm1, zmm2/m512, imm8` + // + // `EVEX.512.66.0F.WIG 73 /7 ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpslldq_zmm_zmmm512_imm8 = 1713, + // `PCMPEQB mm, mm/m64` + // + // `NP 0F 74 /r` + // + // `MMX` + // + // `16/32/64-bit` + Pcmpeqb_mm_mmm64 = 1714, + // `PCMPEQB xmm1, xmm2/m128` + // + // `66 0F 74 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pcmpeqb_xmm_xmmm128 = 1715, + // `VPCMPEQB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 74 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpeqb_xmm_xmm_xmmm128 = 1716, + // `VPCMPEQB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 74 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpcmpeqb_ymm_ymm_ymmm256 = 1717, + // `VPCMPEQB k1 {k2}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG 74 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpeqb_kr_k1_xmm_xmmm128 = 1718, + // `VPCMPEQB k1 {k2}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG 74 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpeqb_kr_k1_ymm_ymmm256 = 1719, + // `VPCMPEQB k1 {k2}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG 74 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpeqb_kr_k1_zmm_zmmm512 = 1720, + // `PCMPEQW mm, mm/m64` + // + // `NP 0F 75 /r` + // + // `MMX` + // + // `16/32/64-bit` + Pcmpeqw_mm_mmm64 = 1721, + // `PCMPEQW xmm1, xmm2/m128` + // + // `66 0F 75 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pcmpeqw_xmm_xmmm128 = 1722, + // `VPCMPEQW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 75 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpeqw_xmm_xmm_xmmm128 = 1723, + // `VPCMPEQW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 75 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpcmpeqw_ymm_ymm_ymmm256 = 1724, + // `VPCMPEQW k1 {k2}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG 75 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpeqw_kr_k1_xmm_xmmm128 = 1725, + // `VPCMPEQW k1 {k2}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG 75 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpeqw_kr_k1_ymm_ymmm256 = 1726, + // `VPCMPEQW k1 {k2}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG 75 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpeqw_kr_k1_zmm_zmmm512 = 1727, + // `PCMPEQD mm, mm/m64` + // + // `NP 0F 76 /r` + // + // `MMX` + // + // `16/32/64-bit` + Pcmpeqd_mm_mmm64 = 1728, + // `PCMPEQD xmm1, xmm2/m128` + // + // `66 0F 76 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pcmpeqd_xmm_xmmm128 = 1729, + // `VPCMPEQD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 76 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpeqd_xmm_xmm_xmmm128 = 1730, + // `VPCMPEQD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 76 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpcmpeqd_ymm_ymm_ymmm256 = 1731, + // `VPCMPEQD k1 {k2}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 76 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpeqd_kr_k1_xmm_xmmm128b32 = 1732, + // `VPCMPEQD k1 {k2}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 76 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpeqd_kr_k1_ymm_ymmm256b32 = 1733, + // `VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F.W0 76 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpeqd_kr_k1_zmm_zmmm512b32 = 1734, + // `EMMS` + // + // `NP 0F 77` + // + // `MMX` + // + // `16/32/64-bit` + Emms = 1735, + // `VZEROUPPER` + // + // `VEX.128.0F.WIG 77` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vzeroupper = 1736, + // `VZEROALL` + // + // `VEX.256.0F.WIG 77` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vzeroall = 1737, + // `VMREAD r/m32, r32` + // + // `NP 0F 78 /r` + // + // `VMX` + // + // `16/32-bit` + Vmread_rm32_r32 = 1738, + // `VMREAD r/m64, r64` + // + // `NP 0F 78 /r` + // + // `VMX` + // + // `64-bit` + Vmread_rm64_r64 = 1739, + // `VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.0F.W0 78 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttps2udq_xmm_k1z_xmmm128b32 = 1740, + // `VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.0F.W0 78 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttps2udq_ymm_k1z_ymmm256b32 = 1741, + // `VCVTTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}` + // + // `EVEX.512.0F.W0 78 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttps2udq_zmm_k1z_zmmm512b32_sae = 1742, + // `VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.0F.W1 78 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttpd2udq_xmm_k1z_xmmm128b64 = 1743, + // `VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.0F.W1 78 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttpd2udq_xmm_k1z_ymmm256b64 = 1744, + // `VCVTTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae}` + // + // `EVEX.512.0F.W1 78 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttpd2udq_ymm_k1z_zmmm512b64_sae = 1745, + // `EXTRQ xmm1, imm8, imm8` + // + // `66 0F 78 /0 ib ib` + // + // `SSE4A` + // + // `16/32/64-bit` + Extrq_xmm_imm8_imm8 = 1746, + // `VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst` + // + // `EVEX.128.66.0F.W0 78 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttps2uqq_xmm_k1z_xmmm64b32 = 1747, + // `VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.256.66.0F.W0 78 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttps2uqq_ymm_k1z_xmmm128b32 = 1748, + // `VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}` + // + // `EVEX.512.66.0F.W0 78 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttps2uqq_zmm_k1z_ymmm256b32_sae = 1749, + // `VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 78 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttpd2uqq_xmm_k1z_xmmm128b64 = 1750, + // `VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 78 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttpd2uqq_ymm_k1z_ymmm256b64 = 1751, + // `VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}` + // + // `EVEX.512.66.0F.W1 78 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttpd2uqq_zmm_k1z_zmmm512b64_sae = 1752, + // `VCVTTSS2USI r32, xmm1/m32{sae}` + // + // `EVEX.LIG.F3.0F.W0 78 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttss2usi_r32_xmmm32_sae = 1753, + // `VCVTTSS2USI r64, xmm1/m32{sae}` + // + // `EVEX.LIG.F3.0F.W1 78 /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvttss2usi_r64_xmmm32_sae = 1754, + // `INSERTQ xmm1, xmm2, imm8, imm8` + // + // `F2 0F 78 /r ib ib` + // + // `SSE4A` + // + // `16/32/64-bit` + Insertq_xmm_xmm_imm8_imm8 = 1755, + // `VCVTTSD2USI r32, xmm1/m64{sae}` + // + // `EVEX.LIG.F2.0F.W0 78 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttsd2usi_r32_xmmm64_sae = 1756, + // `VCVTTSD2USI r64, xmm1/m64{sae}` + // + // `EVEX.LIG.F2.0F.W1 78 /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvttsd2usi_r64_xmmm64_sae = 1757, + // `VMWRITE r32, r/m32` + // + // `NP 0F 79 /r` + // + // `VMX` + // + // `16/32-bit` + Vmwrite_r32_rm32 = 1758, + // `VMWRITE r64, r/m64` + // + // `NP 0F 79 /r` + // + // `VMX` + // + // `64-bit` + Vmwrite_r64_rm64 = 1759, + // `VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.0F.W0 79 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2udq_xmm_k1z_xmmm128b32 = 1760, + // `VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.0F.W0 79 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2udq_ymm_k1z_ymmm256b32 = 1761, + // `VCVTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er}` + // + // `EVEX.512.0F.W0 79 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2udq_zmm_k1z_zmmm512b32_er = 1762, + // `VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.0F.W1 79 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtpd2udq_xmm_k1z_xmmm128b64 = 1763, + // `VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.0F.W1 79 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtpd2udq_xmm_k1z_ymmm256b64 = 1764, + // `VCVTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.0F.W1 79 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtpd2udq_ymm_k1z_zmmm512b64_er = 1765, + // `EXTRQ xmm1, xmm2` + // + // `66 0F 79 /r` + // + // `SSE4A` + // + // `16/32/64-bit` + Extrq_xmm_xmm = 1766, + // `VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst` + // + // `EVEX.128.66.0F.W0 79 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtps2uqq_xmm_k1z_xmmm64b32 = 1767, + // `VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.256.66.0F.W0 79 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtps2uqq_ymm_k1z_xmmm128b32 = 1768, + // `VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er}` + // + // `EVEX.512.66.0F.W0 79 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtps2uqq_zmm_k1z_ymmm256b32_er = 1769, + // `VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 79 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtpd2uqq_xmm_k1z_xmmm128b64 = 1770, + // `VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 79 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtpd2uqq_ymm_k1z_ymmm256b64 = 1771, + // `VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.66.0F.W1 79 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtpd2uqq_zmm_k1z_zmmm512b64_er = 1772, + // `VCVTSS2USI r32, xmm1/m32{er}` + // + // `EVEX.LIG.F3.0F.W0 79 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtss2usi_r32_xmmm32_er = 1773, + // `VCVTSS2USI r64, xmm1/m32{er}` + // + // `EVEX.LIG.F3.0F.W1 79 /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvtss2usi_r64_xmmm32_er = 1774, + // `INSERTQ xmm1, xmm2` + // + // `F2 0F 79 /r` + // + // `SSE4A` + // + // `16/32/64-bit` + Insertq_xmm_xmm = 1775, + // `VCVTSD2USI r32, xmm1/m64{er}` + // + // `EVEX.LIG.F2.0F.W0 79 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtsd2usi_r32_xmmm64_er = 1776, + // `VCVTSD2USI r64, xmm1/m64{er}` + // + // `EVEX.LIG.F2.0F.W1 79 /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvtsd2usi_r64_xmmm64_er = 1777, + // `VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst` + // + // `EVEX.128.66.0F.W0 7A /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttps2qq_xmm_k1z_xmmm64b32 = 1778, + // `VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.256.66.0F.W0 7A /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttps2qq_ymm_k1z_xmmm128b32 = 1779, + // `VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}` + // + // `EVEX.512.66.0F.W0 7A /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttps2qq_zmm_k1z_ymmm256b32_sae = 1780, + // `VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 7A /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttpd2qq_xmm_k1z_xmmm128b64 = 1781, + // `VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 7A /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttpd2qq_ymm_k1z_ymmm256b64 = 1782, + // `VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}` + // + // `EVEX.512.66.0F.W1 7A /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvttpd2qq_zmm_k1z_zmmm512b64_sae = 1783, + // `VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst` + // + // `EVEX.128.F3.0F.W0 7A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtudq2pd_xmm_k1z_xmmm64b32 = 1784, + // `VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.256.F3.0F.W0 7A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtudq2pd_ymm_k1z_xmmm128b32 = 1785, + // `VCVTUDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{er}` + // + // `EVEX.512.F3.0F.W0 7A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtudq2pd_zmm_k1z_ymmm256b32_er = 1786, + // `VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.F3.0F.W1 7A /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtuqq2pd_xmm_k1z_xmmm128b64 = 1787, + // `VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.F3.0F.W1 7A /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtuqq2pd_ymm_k1z_ymmm256b64 = 1788, + // `VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.F3.0F.W1 7A /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtuqq2pd_zmm_k1z_zmmm512b64_er = 1789, + // `VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.F2.0F.W0 7A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtudq2ps_xmm_k1z_xmmm128b32 = 1790, + // `VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.F2.0F.W0 7A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtudq2ps_ymm_k1z_ymmm256b32 = 1791, + // `VCVTUDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}` + // + // `EVEX.512.F2.0F.W0 7A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtudq2ps_zmm_k1z_zmmm512b32_er = 1792, + // `VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.F2.0F.W1 7A /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtuqq2ps_xmm_k1z_xmmm128b64 = 1793, + // `VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.F2.0F.W1 7A /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtuqq2ps_xmm_k1z_ymmm256b64 = 1794, + // `VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.F2.0F.W1 7A /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtuqq2ps_ymm_k1z_zmmm512b64_er = 1795, + // `VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst` + // + // `EVEX.128.66.0F.W0 7B /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtps2qq_xmm_k1z_xmmm64b32 = 1796, + // `VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.256.66.0F.W0 7B /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtps2qq_ymm_k1z_xmmm128b32 = 1797, + // `VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er}` + // + // `EVEX.512.66.0F.W0 7B /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtps2qq_zmm_k1z_ymmm256b32_er = 1798, + // `VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 7B /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtpd2qq_xmm_k1z_xmmm128b64 = 1799, + // `VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 7B /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtpd2qq_ymm_k1z_ymmm256b64 = 1800, + // `VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.66.0F.W1 7B /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtpd2qq_zmm_k1z_zmmm512b64_er = 1801, + // `VCVTUSI2SS xmm1, xmm2, r/m32{er}` + // + // `EVEX.LIG.F3.0F.W0 7B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtusi2ss_xmm_xmm_rm32_er = 1802, + // `VCVTUSI2SS xmm1, xmm2, r/m64{er}` + // + // `EVEX.LIG.F3.0F.W1 7B /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvtusi2ss_xmm_xmm_rm64_er = 1803, + // `VCVTUSI2SD xmm1, xmm2, r/m32{er}` + // + // `EVEX.LIG.F2.0F.W0 7B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtusi2sd_xmm_xmm_rm32_er = 1804, + // `VCVTUSI2SD xmm1, xmm2, r/m64{er}` + // + // `EVEX.LIG.F2.0F.W1 7B /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vcvtusi2sd_xmm_xmm_rm64_er = 1805, + // `HADDPD xmm1, xmm2/m128` + // + // `66 0F 7C /r` + // + // `SSE3` + // + // `16/32/64-bit` + Haddpd_xmm_xmmm128 = 1806, + // `VHADDPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 7C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vhaddpd_xmm_xmm_xmmm128 = 1807, + // `VHADDPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 7C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vhaddpd_ymm_ymm_ymmm256 = 1808, + // `HADDPS xmm1, xmm2/m128` + // + // `F2 0F 7C /r` + // + // `SSE3` + // + // `16/32/64-bit` + Haddps_xmm_xmmm128 = 1809, + // `VHADDPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.F2.0F.WIG 7C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vhaddps_xmm_xmm_xmmm128 = 1810, + // `VHADDPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.F2.0F.WIG 7C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vhaddps_ymm_ymm_ymmm256 = 1811, + // `HSUBPD xmm1, xmm2/m128` + // + // `66 0F 7D /r` + // + // `SSE3` + // + // `16/32/64-bit` + Hsubpd_xmm_xmmm128 = 1812, + // `VHSUBPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG 7D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vhsubpd_xmm_xmm_xmmm128 = 1813, + // `VHSUBPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG 7D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vhsubpd_ymm_ymm_ymmm256 = 1814, + // `HSUBPS xmm1, xmm2/m128` + // + // `F2 0F 7D /r` + // + // `SSE3` + // + // `16/32/64-bit` + Hsubps_xmm_xmmm128 = 1815, + // `VHSUBPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.F2.0F.WIG 7D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vhsubps_xmm_xmm_xmmm128 = 1816, + // `VHSUBPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.F2.0F.WIG 7D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vhsubps_ymm_ymm_ymmm256 = 1817, + // `MOVD r/m32, mm` + // + // `NP 0F 7E /r` + // + // `MMX` + // + // `16/32/64-bit` + Movd_rm32_mm = 1818, + // `MOVQ r/m64, mm` + // + // `NP o64 0F 7E /r` + // + // `MMX` + // + // `64-bit` + Movq_rm64_mm = 1819, + // `MOVD r/m32, xmm` + // + // `66 0F 7E /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movd_rm32_xmm = 1820, + // `MOVQ r/m64, xmm` + // + // `66 o64 0F 7E /r` + // + // `SSE2` + // + // `64-bit` + Movq_rm64_xmm = 1821, + // `VMOVD r/m32, xmm1` + // + // `VEX.128.66.0F.W0 7E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovd_rm32_xmm = 1822, + // `VMOVQ r/m64, xmm1` + // + // `VEX.128.66.0F.W1 7E /r` + // + // `AVX` + // + // `64-bit` + VEX_Vmovq_rm64_xmm = 1823, + // `VMOVD r/m32, xmm1` + // + // `EVEX.128.66.0F.W0 7E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovd_rm32_xmm = 1824, + // `VMOVQ r/m64, xmm1` + // + // `EVEX.128.66.0F.W1 7E /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vmovq_rm64_xmm = 1825, + // `MOVQ xmm1, xmm2/m64` + // + // `F3 0F 7E /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movq_xmm_xmmm64 = 1826, + // `VMOVQ xmm1, xmm2/m64` + // + // `VEX.128.F3.0F.WIG 7E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovq_xmm_xmmm64 = 1827, + // `VMOVQ xmm1, xmm2/m64` + // + // `EVEX.128.F3.0F.W1 7E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovq_xmm_xmmm64 = 1828, + // `MOVQ mm/m64, mm` + // + // `NP 0F 7F /r` + // + // `MMX` + // + // `16/32/64-bit` + Movq_mmm64_mm = 1829, + // `MOVDQA xmm2/m128, xmm1` + // + // `66 0F 7F /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movdqa_xmmm128_xmm = 1830, + // `VMOVDQA xmm2/m128, xmm1` + // + // `VEX.128.66.0F.WIG 7F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovdqa_xmmm128_xmm = 1831, + // `VMOVDQA ymm2/m256, ymm1` + // + // `VEX.256.66.0F.WIG 7F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovdqa_ymmm256_ymm = 1832, + // `VMOVDQA32 xmm2/m128 {k1}{z}, xmm1` + // + // `EVEX.128.66.0F.W0 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa32_xmmm128_k1z_xmm = 1833, + // `VMOVDQA32 ymm2/m256 {k1}{z}, ymm1` + // + // `EVEX.256.66.0F.W0 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa32_ymmm256_k1z_ymm = 1834, + // `VMOVDQA32 zmm2/m512 {k1}{z}, zmm1` + // + // `EVEX.512.66.0F.W0 7F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa32_zmmm512_k1z_zmm = 1835, + // `VMOVDQA64 xmm2/m128 {k1}{z}, xmm1` + // + // `EVEX.128.66.0F.W1 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa64_xmmm128_k1z_xmm = 1836, + // `VMOVDQA64 ymm2/m256 {k1}{z}, ymm1` + // + // `EVEX.256.66.0F.W1 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa64_ymmm256_k1z_ymm = 1837, + // `VMOVDQA64 zmm2/m512 {k1}{z}, zmm1` + // + // `EVEX.512.66.0F.W1 7F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqa64_zmmm512_k1z_zmm = 1838, + // `MOVDQU xmm2/m128, xmm1` + // + // `F3 0F 7F /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movdqu_xmmm128_xmm = 1839, + // `VMOVDQU xmm2/m128, xmm1` + // + // `VEX.128.F3.0F.WIG 7F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovdqu_xmmm128_xmm = 1840, + // `VMOVDQU ymm2/m256, ymm1` + // + // `VEX.256.F3.0F.WIG 7F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovdqu_ymmm256_ymm = 1841, + // `VMOVDQU32 xmm2/m128 {k1}{z}, xmm1` + // + // `EVEX.128.F3.0F.W0 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu32_xmmm128_k1z_xmm = 1842, + // `VMOVDQU32 ymm2/m256 {k1}{z}, ymm1` + // + // `EVEX.256.F3.0F.W0 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu32_ymmm256_k1z_ymm = 1843, + // `VMOVDQU32 zmm2/m512 {k1}{z}, zmm1` + // + // `EVEX.512.F3.0F.W0 7F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu32_zmmm512_k1z_zmm = 1844, + // `VMOVDQU64 xmm2/m128 {k1}{z}, xmm1` + // + // `EVEX.128.F3.0F.W1 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu64_xmmm128_k1z_xmm = 1845, + // `VMOVDQU64 ymm2/m256 {k1}{z}, ymm1` + // + // `EVEX.256.F3.0F.W1 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu64_ymmm256_k1z_ymm = 1846, + // `VMOVDQU64 zmm2/m512 {k1}{z}, zmm1` + // + // `EVEX.512.F3.0F.W1 7F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovdqu64_zmmm512_k1z_zmm = 1847, + // `VMOVDQU8 xmm2/m128 {k1}{z}, xmm1` + // + // `EVEX.128.F2.0F.W0 7F /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu8_xmmm128_k1z_xmm = 1848, + // `VMOVDQU8 ymm2/m256 {k1}{z}, ymm1` + // + // `EVEX.256.F2.0F.W0 7F /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu8_ymmm256_k1z_ymm = 1849, + // `VMOVDQU8 zmm2/m512 {k1}{z}, zmm1` + // + // `EVEX.512.F2.0F.W0 7F /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu8_zmmm512_k1z_zmm = 1850, + // `VMOVDQU16 xmm2/m128 {k1}{z}, xmm1` + // + // `EVEX.128.F2.0F.W1 7F /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu16_xmmm128_k1z_xmm = 1851, + // `VMOVDQU16 ymm2/m256 {k1}{z}, ymm1` + // + // `EVEX.256.F2.0F.W1 7F /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu16_ymmm256_k1z_ymm = 1852, + // `VMOVDQU16 zmm2/m512 {k1}{z}, zmm1` + // + // `EVEX.512.F2.0F.W1 7F /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vmovdqu16_zmmm512_k1z_zmm = 1853, + // `JO rel16` + // + // `o16 0F 80 cw` + // + // `386+` + // + // `16/32/64-bit` + Jo_rel16 = 1854, + // `JO rel32` + // + // `o32 0F 80 cd` + // + // `386+` + // + // `16/32-bit` + Jo_rel32_32 = 1855, + // `JO rel32` + // + // `o64 0F 80 cd` + // + // `X64` + // + // `64-bit` + Jo_rel32_64 = 1856, + // `JNO rel16` + // + // `o16 0F 81 cw` + // + // `386+` + // + // `16/32/64-bit` + Jno_rel16 = 1857, + // `JNO rel32` + // + // `o32 0F 81 cd` + // + // `386+` + // + // `16/32-bit` + Jno_rel32_32 = 1858, + // `JNO rel32` + // + // `o64 0F 81 cd` + // + // `X64` + // + // `64-bit` + Jno_rel32_64 = 1859, + // `JB rel16` + // + // `o16 0F 82 cw` + // + // `386+` + // + // `16/32/64-bit` + Jb_rel16 = 1860, + // `JB rel32` + // + // `o32 0F 82 cd` + // + // `386+` + // + // `16/32-bit` + Jb_rel32_32 = 1861, + // `JB rel32` + // + // `o64 0F 82 cd` + // + // `X64` + // + // `64-bit` + Jb_rel32_64 = 1862, + // `JAE rel16` + // + // `o16 0F 83 cw` + // + // `386+` + // + // `16/32/64-bit` + Jae_rel16 = 1863, + // `JAE rel32` + // + // `o32 0F 83 cd` + // + // `386+` + // + // `16/32-bit` + Jae_rel32_32 = 1864, + // `JAE rel32` + // + // `o64 0F 83 cd` + // + // `X64` + // + // `64-bit` + Jae_rel32_64 = 1865, + // `JE rel16` + // + // `o16 0F 84 cw` + // + // `386+` + // + // `16/32/64-bit` + Je_rel16 = 1866, + // `JE rel32` + // + // `o32 0F 84 cd` + // + // `386+` + // + // `16/32-bit` + Je_rel32_32 = 1867, + // `JE rel32` + // + // `o64 0F 84 cd` + // + // `X64` + // + // `64-bit` + Je_rel32_64 = 1868, + // `JNE rel16` + // + // `o16 0F 85 cw` + // + // `386+` + // + // `16/32/64-bit` + Jne_rel16 = 1869, + // `JNE rel32` + // + // `o32 0F 85 cd` + // + // `386+` + // + // `16/32-bit` + Jne_rel32_32 = 1870, + // `JNE rel32` + // + // `o64 0F 85 cd` + // + // `X64` + // + // `64-bit` + Jne_rel32_64 = 1871, + // `JBE rel16` + // + // `o16 0F 86 cw` + // + // `386+` + // + // `16/32/64-bit` + Jbe_rel16 = 1872, + // `JBE rel32` + // + // `o32 0F 86 cd` + // + // `386+` + // + // `16/32-bit` + Jbe_rel32_32 = 1873, + // `JBE rel32` + // + // `o64 0F 86 cd` + // + // `X64` + // + // `64-bit` + Jbe_rel32_64 = 1874, + // `JA rel16` + // + // `o16 0F 87 cw` + // + // `386+` + // + // `16/32/64-bit` + Ja_rel16 = 1875, + // `JA rel32` + // + // `o32 0F 87 cd` + // + // `386+` + // + // `16/32-bit` + Ja_rel32_32 = 1876, + // `JA rel32` + // + // `o64 0F 87 cd` + // + // `X64` + // + // `64-bit` + Ja_rel32_64 = 1877, + // `JS rel16` + // + // `o16 0F 88 cw` + // + // `386+` + // + // `16/32/64-bit` + Js_rel16 = 1878, + // `JS rel32` + // + // `o32 0F 88 cd` + // + // `386+` + // + // `16/32-bit` + Js_rel32_32 = 1879, + // `JS rel32` + // + // `o64 0F 88 cd` + // + // `X64` + // + // `64-bit` + Js_rel32_64 = 1880, + // `JNS rel16` + // + // `o16 0F 89 cw` + // + // `386+` + // + // `16/32/64-bit` + Jns_rel16 = 1881, + // `JNS rel32` + // + // `o32 0F 89 cd` + // + // `386+` + // + // `16/32-bit` + Jns_rel32_32 = 1882, + // `JNS rel32` + // + // `o64 0F 89 cd` + // + // `X64` + // + // `64-bit` + Jns_rel32_64 = 1883, + // `JP rel16` + // + // `o16 0F 8A cw` + // + // `386+` + // + // `16/32/64-bit` + Jp_rel16 = 1884, + // `JP rel32` + // + // `o32 0F 8A cd` + // + // `386+` + // + // `16/32-bit` + Jp_rel32_32 = 1885, + // `JP rel32` + // + // `o64 0F 8A cd` + // + // `X64` + // + // `64-bit` + Jp_rel32_64 = 1886, + // `JNP rel16` + // + // `o16 0F 8B cw` + // + // `386+` + // + // `16/32/64-bit` + Jnp_rel16 = 1887, + // `JNP rel32` + // + // `o32 0F 8B cd` + // + // `386+` + // + // `16/32-bit` + Jnp_rel32_32 = 1888, + // `JNP rel32` + // + // `o64 0F 8B cd` + // + // `X64` + // + // `64-bit` + Jnp_rel32_64 = 1889, + // `JL rel16` + // + // `o16 0F 8C cw` + // + // `386+` + // + // `16/32/64-bit` + Jl_rel16 = 1890, + // `JL rel32` + // + // `o32 0F 8C cd` + // + // `386+` + // + // `16/32-bit` + Jl_rel32_32 = 1891, + // `JL rel32` + // + // `o64 0F 8C cd` + // + // `X64` + // + // `64-bit` + Jl_rel32_64 = 1892, + // `JGE rel16` + // + // `o16 0F 8D cw` + // + // `386+` + // + // `16/32/64-bit` + Jge_rel16 = 1893, + // `JGE rel32` + // + // `o32 0F 8D cd` + // + // `386+` + // + // `16/32-bit` + Jge_rel32_32 = 1894, + // `JGE rel32` + // + // `o64 0F 8D cd` + // + // `X64` + // + // `64-bit` + Jge_rel32_64 = 1895, + // `JLE rel16` + // + // `o16 0F 8E cw` + // + // `386+` + // + // `16/32/64-bit` + Jle_rel16 = 1896, + // `JLE rel32` + // + // `o32 0F 8E cd` + // + // `386+` + // + // `16/32-bit` + Jle_rel32_32 = 1897, + // `JLE rel32` + // + // `o64 0F 8E cd` + // + // `X64` + // + // `64-bit` + Jle_rel32_64 = 1898, + // `JG rel16` + // + // `o16 0F 8F cw` + // + // `386+` + // + // `16/32/64-bit` + Jg_rel16 = 1899, + // `JG rel32` + // + // `o32 0F 8F cd` + // + // `386+` + // + // `16/32-bit` + Jg_rel32_32 = 1900, + // `JG rel32` + // + // `o64 0F 8F cd` + // + // `X64` + // + // `64-bit` + Jg_rel32_64 = 1901, + // `SETO r/m8` + // + // `0F 90 /r` + // + // `386+` + // + // `16/32/64-bit` + Seto_rm8 = 1902, + // `SETNO r/m8` + // + // `0F 91 /r` + // + // `386+` + // + // `16/32/64-bit` + Setno_rm8 = 1903, + // `SETB r/m8` + // + // `0F 92 /r` + // + // `386+` + // + // `16/32/64-bit` + Setb_rm8 = 1904, + // `SETAE r/m8` + // + // `0F 93 /r` + // + // `386+` + // + // `16/32/64-bit` + Setae_rm8 = 1905, + // `SETE r/m8` + // + // `0F 94 /r` + // + // `386+` + // + // `16/32/64-bit` + Sete_rm8 = 1906, + // `SETNE r/m8` + // + // `0F 95 /r` + // + // `386+` + // + // `16/32/64-bit` + Setne_rm8 = 1907, + // `SETBE r/m8` + // + // `0F 96 /r` + // + // `386+` + // + // `16/32/64-bit` + Setbe_rm8 = 1908, + // `SETA r/m8` + // + // `0F 97 /r` + // + // `386+` + // + // `16/32/64-bit` + Seta_rm8 = 1909, + // `SETS r/m8` + // + // `0F 98 /r` + // + // `386+` + // + // `16/32/64-bit` + Sets_rm8 = 1910, + // `SETNS r/m8` + // + // `0F 99 /r` + // + // `386+` + // + // `16/32/64-bit` + Setns_rm8 = 1911, + // `SETP r/m8` + // + // `0F 9A /r` + // + // `386+` + // + // `16/32/64-bit` + Setp_rm8 = 1912, + // `SETNP r/m8` + // + // `0F 9B /r` + // + // `386+` + // + // `16/32/64-bit` + Setnp_rm8 = 1913, + // `SETL r/m8` + // + // `0F 9C /r` + // + // `386+` + // + // `16/32/64-bit` + Setl_rm8 = 1914, + // `SETGE r/m8` + // + // `0F 9D /r` + // + // `386+` + // + // `16/32/64-bit` + Setge_rm8 = 1915, + // `SETLE r/m8` + // + // `0F 9E /r` + // + // `386+` + // + // `16/32/64-bit` + Setle_rm8 = 1916, + // `SETG r/m8` + // + // `0F 9F /r` + // + // `386+` + // + // `16/32/64-bit` + Setg_rm8 = 1917, + // `KMOVW k1, k2/m16` + // + // `VEX.L0.0F.W0 90 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kmovw_kr_km16 = 1918, + // `KMOVQ k1, k2/m64` + // + // `VEX.L0.0F.W1 90 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kmovq_kr_km64 = 1919, + // `KMOVB k1, k2/m8` + // + // `VEX.L0.66.0F.W0 90 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kmovb_kr_km8 = 1920, + // `KMOVD k1, k2/m32` + // + // `VEX.L0.66.0F.W1 90 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kmovd_kr_km32 = 1921, + // `KMOVW m16, k1` + // + // `VEX.L0.0F.W0 91 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kmovw_m16_kr = 1922, + // `KMOVQ m64, k1` + // + // `VEX.L0.0F.W1 91 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kmovq_m64_kr = 1923, + // `KMOVB m8, k1` + // + // `VEX.L0.66.0F.W0 91 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kmovb_m8_kr = 1924, + // `KMOVD m32, k1` + // + // `VEX.L0.66.0F.W1 91 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kmovd_m32_kr = 1925, + // `KMOVW k1, r32` + // + // `VEX.L0.0F.W0 92 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kmovw_kr_r32 = 1926, + // `KMOVB k1, r32` + // + // `VEX.L0.66.0F.W0 92 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kmovb_kr_r32 = 1927, + // `KMOVD k1, r32` + // + // `VEX.L0.F2.0F.W0 92 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kmovd_kr_r32 = 1928, + // `KMOVQ k1, r64` + // + // `VEX.L0.F2.0F.W1 92 /r` + // + // `AVX512BW` + // + // `64-bit` + VEX_Kmovq_kr_r64 = 1929, + // `KMOVW r32, k1` + // + // `VEX.L0.0F.W0 93 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kmovw_r32_kr = 1930, + // `KMOVB r32, k1` + // + // `VEX.L0.66.0F.W0 93 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kmovb_r32_kr = 1931, + // `KMOVD r32, k1` + // + // `VEX.L0.F2.0F.W0 93 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kmovd_r32_kr = 1932, + // `KMOVQ r64, k1` + // + // `VEX.L0.F2.0F.W1 93 /r` + // + // `AVX512BW` + // + // `64-bit` + VEX_Kmovq_r64_kr = 1933, + // `KORTESTW k1, k2` + // + // `VEX.L0.0F.W0 98 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kortestw_kr_kr = 1934, + // `KORTESTQ k1, k2` + // + // `VEX.L0.0F.W1 98 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kortestq_kr_kr = 1935, + // `KORTESTB k1, k2` + // + // `VEX.L0.66.0F.W0 98 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kortestb_kr_kr = 1936, + // `KORTESTD k1, k2` + // + // `VEX.L0.66.0F.W1 98 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kortestd_kr_kr = 1937, + // `KTESTW k1, k2` + // + // `VEX.L0.0F.W0 99 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Ktestw_kr_kr = 1938, + // `KTESTQ k1, k2` + // + // `VEX.L0.0F.W1 99 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Ktestq_kr_kr = 1939, + // `KTESTB k1, k2` + // + // `VEX.L0.66.0F.W0 99 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Ktestb_kr_kr = 1940, + // `KTESTD k1, k2` + // + // `VEX.L0.66.0F.W1 99 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Ktestd_kr_kr = 1941, + // `PUSH FS` + // + // `o16 0F A0` + // + // `386+` + // + // `16/32/64-bit` + Pushw_FS = 1942, + // `PUSH FS` + // + // `o32 0F A0` + // + // `386+` + // + // `16/32-bit` + Pushd_FS = 1943, + // `PUSH FS` + // + // `o64 0F A0` + // + // `X64` + // + // `64-bit` + Pushq_FS = 1944, + // `POP FS` + // + // `o16 0F A1` + // + // `386+` + // + // `16/32/64-bit` + Popw_FS = 1945, + // `POP FS` + // + // `o32 0F A1` + // + // `386+` + // + // `16/32-bit` + Popd_FS = 1946, + // `POP FS` + // + // `o64 0F A1` + // + // `X64` + // + // `64-bit` + Popq_FS = 1947, + // `CPUID` + // + // `0F A2` + // + // `CPUID` + // + // `16/32/64-bit` + Cpuid = 1948, + // `BT r/m16, r16` + // + // `o16 0F A3 /r` + // + // `386+` + // + // `16/32/64-bit` + Bt_rm16_r16 = 1949, + // `BT r/m32, r32` + // + // `o32 0F A3 /r` + // + // `386+` + // + // `16/32/64-bit` + Bt_rm32_r32 = 1950, + // `BT r/m64, r64` + // + // `o64 0F A3 /r` + // + // `X64` + // + // `64-bit` + Bt_rm64_r64 = 1951, + // `SHLD r/m16, r16, imm8` + // + // `o16 0F A4 /r ib` + // + // `386+` + // + // `16/32/64-bit` + Shld_rm16_r16_imm8 = 1952, + // `SHLD r/m32, r32, imm8` + // + // `o32 0F A4 /r ib` + // + // `386+` + // + // `16/32/64-bit` + Shld_rm32_r32_imm8 = 1953, + // `SHLD r/m64, r64, imm8` + // + // `o64 0F A4 /r ib` + // + // `X64` + // + // `64-bit` + Shld_rm64_r64_imm8 = 1954, + // `SHLD r/m16, r16, CL` + // + // `o16 0F A5 /r` + // + // `386+` + // + // `16/32/64-bit` + Shld_rm16_r16_CL = 1955, + // `SHLD r/m32, r32, CL` + // + // `o32 0F A5 /r` + // + // `386+` + // + // `16/32/64-bit` + Shld_rm32_r32_CL = 1956, + // `SHLD r/m64, r64, CL` + // + // `o64 0F A5 /r` + // + // `X64` + // + // `64-bit` + Shld_rm64_r64_CL = 1957, + // `MONTMUL` + // + // `a16 F3 0F A6 C0` + // + // `PADLOCK_PMM` + // + // `16/32-bit` + Montmul_16 = 1958, + // `MONTMUL` + // + // `a32 F3 0F A6 C0` + // + // `PADLOCK_PMM` + // + // `16/32/64-bit` + Montmul_32 = 1959, + // `MONTMUL` + // + // `a64 F3 0F A6 C0` + // + // `PADLOCK_PMM` + // + // `64-bit` + Montmul_64 = 1960, + // `XSHA1` + // + // `a16 F3 0F A6 C8` + // + // `PADLOCK_PHE` + // + // `16/32-bit` + Xsha1_16 = 1961, + // `XSHA1` + // + // `a32 F3 0F A6 C8` + // + // `PADLOCK_PHE` + // + // `16/32/64-bit` + Xsha1_32 = 1962, + // `XSHA1` + // + // `a64 F3 0F A6 C8` + // + // `PADLOCK_PHE` + // + // `64-bit` + Xsha1_64 = 1963, + // `XSHA256` + // + // `a16 F3 0F A6 D0` + // + // `PADLOCK_PHE` + // + // `16/32-bit` + Xsha256_16 = 1964, + // `XSHA256` + // + // `a32 F3 0F A6 D0` + // + // `PADLOCK_PHE` + // + // `16/32/64-bit` + Xsha256_32 = 1965, + // `XSHA256` + // + // `a64 F3 0F A6 D0` + // + // `PADLOCK_PHE` + // + // `64-bit` + Xsha256_64 = 1966, + // `XBTS r16, r/m16` + // + // `o16 0F A6 /r` + // + // `386 A0` + // + // `16/32-bit` + Xbts_r16_rm16 = 1967, + // `XBTS r32, r/m32` + // + // `o32 0F A6 /r` + // + // `386 A0` + // + // `16/32-bit` + Xbts_r32_rm32 = 1968, + // `XSTORE` + // + // `a16 0F A7 C0` + // + // `PADLOCK_RNG` + // + // `16/32-bit` + Xstore_16 = 1969, + // `XSTORE` + // + // `a32 0F A7 C0` + // + // `PADLOCK_RNG` + // + // `16/32/64-bit` + Xstore_32 = 1970, + // `XSTORE` + // + // `a64 0F A7 C0` + // + // `PADLOCK_RNG` + // + // `64-bit` + Xstore_64 = 1971, + // `XCRYPTECB` + // + // `a16 F3 0F A7 C8` + // + // `PADLOCK_ACE` + // + // `16/32-bit` + Xcryptecb_16 = 1972, + // `XCRYPTECB` + // + // `a32 F3 0F A7 C8` + // + // `PADLOCK_ACE` + // + // `16/32/64-bit` + Xcryptecb_32 = 1973, + // `XCRYPTECB` + // + // `a64 F3 0F A7 C8` + // + // `PADLOCK_ACE` + // + // `64-bit` + Xcryptecb_64 = 1974, + // `XCRYPTCBC` + // + // `a16 F3 0F A7 D0` + // + // `PADLOCK_ACE` + // + // `16/32-bit` + Xcryptcbc_16 = 1975, + // `XCRYPTCBC` + // + // `a32 F3 0F A7 D0` + // + // `PADLOCK_ACE` + // + // `16/32/64-bit` + Xcryptcbc_32 = 1976, + // `XCRYPTCBC` + // + // `a64 F3 0F A7 D0` + // + // `PADLOCK_ACE` + // + // `64-bit` + Xcryptcbc_64 = 1977, + // `XCRYPTCTR` + // + // `a16 F3 0F A7 D8` + // + // `PADLOCK_ACE` + // + // `16/32-bit` + Xcryptctr_16 = 1978, + // `XCRYPTCTR` + // + // `a32 F3 0F A7 D8` + // + // `PADLOCK_ACE` + // + // `16/32/64-bit` + Xcryptctr_32 = 1979, + // `XCRYPTCTR` + // + // `a64 F3 0F A7 D8` + // + // `PADLOCK_ACE` + // + // `64-bit` + Xcryptctr_64 = 1980, + // `XCRYPTCFB` + // + // `a16 F3 0F A7 E0` + // + // `PADLOCK_ACE` + // + // `16/32-bit` + Xcryptcfb_16 = 1981, + // `XCRYPTCFB` + // + // `a32 F3 0F A7 E0` + // + // `PADLOCK_ACE` + // + // `16/32/64-bit` + Xcryptcfb_32 = 1982, + // `XCRYPTCFB` + // + // `a64 F3 0F A7 E0` + // + // `PADLOCK_ACE` + // + // `64-bit` + Xcryptcfb_64 = 1983, + // `XCRYPTOFB` + // + // `a16 F3 0F A7 E8` + // + // `PADLOCK_ACE` + // + // `16/32-bit` + Xcryptofb_16 = 1984, + // `XCRYPTOFB` + // + // `a32 F3 0F A7 E8` + // + // `PADLOCK_ACE` + // + // `16/32/64-bit` + Xcryptofb_32 = 1985, + // `XCRYPTOFB` + // + // `a64 F3 0F A7 E8` + // + // `PADLOCK_ACE` + // + // `64-bit` + Xcryptofb_64 = 1986, + // `IBTS r/m16, r16` + // + // `o16 0F A7 /r` + // + // `386 A0` + // + // `16/32-bit` + Ibts_rm16_r16 = 1987, + // `IBTS r/m32, r32` + // + // `o32 0F A7 /r` + // + // `386 A0` + // + // `16/32-bit` + Ibts_rm32_r32 = 1988, + // `CMPXCHG r/m8, r8` + // + // `0F A6 /r` + // + // `486 A` + // + // `16/32-bit` + Cmpxchg486_rm8_r8 = 1989, + // `CMPXCHG r/m16, r16` + // + // `o16 0F A7 /r` + // + // `486 A` + // + // `16/32-bit` + Cmpxchg486_rm16_r16 = 1990, + // `CMPXCHG r/m32, r32` + // + // `o32 0F A7 /r` + // + // `486 A` + // + // `16/32-bit` + Cmpxchg486_rm32_r32 = 1991, + // `PUSH GS` + // + // `o16 0F A8` + // + // `386+` + // + // `16/32/64-bit` + Pushw_GS = 1992, + // `PUSH GS` + // + // `o32 0F A8` + // + // `386+` + // + // `16/32-bit` + Pushd_GS = 1993, + // `PUSH GS` + // + // `o64 0F A8` + // + // `X64` + // + // `64-bit` + Pushq_GS = 1994, + // `POP GS` + // + // `o16 0F A9` + // + // `386+` + // + // `16/32/64-bit` + Popw_GS = 1995, + // `POP GS` + // + // `o32 0F A9` + // + // `386+` + // + // `16/32-bit` + Popd_GS = 1996, + // `POP GS` + // + // `o64 0F A9` + // + // `X64` + // + // `64-bit` + Popq_GS = 1997, + // `RSM` + // + // `0F AA` + // + // `386+` + // + // `16/32/64-bit` + Rsm = 1998, + // `BTS r/m16, r16` + // + // `o16 0F AB /r` + // + // `386+` + // + // `16/32/64-bit` + Bts_rm16_r16 = 1999, + // `BTS r/m32, r32` + // + // `o32 0F AB /r` + // + // `386+` + // + // `16/32/64-bit` + Bts_rm32_r32 = 2000, + // `BTS r/m64, r64` + // + // `o64 0F AB /r` + // + // `X64` + // + // `64-bit` + Bts_rm64_r64 = 2001, + // `SHRD r/m16, r16, imm8` + // + // `o16 0F AC /r ib` + // + // `386+` + // + // `16/32/64-bit` + Shrd_rm16_r16_imm8 = 2002, + // `SHRD r/m32, r32, imm8` + // + // `o32 0F AC /r ib` + // + // `386+` + // + // `16/32/64-bit` + Shrd_rm32_r32_imm8 = 2003, + // `SHRD r/m64, r64, imm8` + // + // `o64 0F AC /r ib` + // + // `X64` + // + // `64-bit` + Shrd_rm64_r64_imm8 = 2004, + // `SHRD r/m16, r16, CL` + // + // `o16 0F AD /r` + // + // `386+` + // + // `16/32/64-bit` + Shrd_rm16_r16_CL = 2005, + // `SHRD r/m32, r32, CL` + // + // `o32 0F AD /r` + // + // `386+` + // + // `16/32/64-bit` + Shrd_rm32_r32_CL = 2006, + // `SHRD r/m64, r64, CL` + // + // `o64 0F AD /r` + // + // `X64` + // + // `64-bit` + Shrd_rm64_r64_CL = 2007, + // `FXSAVE m512byte` + // + // `NP 0F AE /0` + // + // `FXSR` + // + // `16/32/64-bit` + Fxsave_m512byte = 2008, + // `FXSAVE64 m512byte` + // + // `NP o64 0F AE /0` + // + // `FXSR` + // + // `64-bit` + Fxsave64_m512byte = 2009, + // `RDFSBASE r32` + // + // `F3 0F AE /0` + // + // `FSGSBASE` + // + // `64-bit` + Rdfsbase_r32 = 2010, + // `RDFSBASE r64` + // + // `F3 o64 0F AE /0` + // + // `FSGSBASE` + // + // `64-bit` + Rdfsbase_r64 = 2011, + // `FXRSTOR m512byte` + // + // `NP 0F AE /1` + // + // `FXSR` + // + // `16/32/64-bit` + Fxrstor_m512byte = 2012, + // `FXRSTOR64 m512byte` + // + // `NP o64 0F AE /1` + // + // `FXSR` + // + // `64-bit` + Fxrstor64_m512byte = 2013, + // `RDGSBASE r32` + // + // `F3 0F AE /1` + // + // `FSGSBASE` + // + // `64-bit` + Rdgsbase_r32 = 2014, + // `RDGSBASE r64` + // + // `F3 o64 0F AE /1` + // + // `FSGSBASE` + // + // `64-bit` + Rdgsbase_r64 = 2015, + // `LDMXCSR m32` + // + // `NP 0F AE /2` + // + // `SSE` + // + // `16/32/64-bit` + Ldmxcsr_m32 = 2016, + // `WRFSBASE r32` + // + // `F3 0F AE /2` + // + // `FSGSBASE` + // + // `64-bit` + Wrfsbase_r32 = 2017, + // `WRFSBASE r64` + // + // `F3 o64 0F AE /2` + // + // `FSGSBASE` + // + // `64-bit` + Wrfsbase_r64 = 2018, + // `VLDMXCSR m32` + // + // `VEX.LZ.0F.WIG AE /2` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vldmxcsr_m32 = 2019, + // `STMXCSR m32` + // + // `NP 0F AE /3` + // + // `SSE` + // + // `16/32/64-bit` + Stmxcsr_m32 = 2020, + // `WRGSBASE r32` + // + // `F3 0F AE /3` + // + // `FSGSBASE` + // + // `64-bit` + Wrgsbase_r32 = 2021, + // `WRGSBASE r64` + // + // `F3 o64 0F AE /3` + // + // `FSGSBASE` + // + // `64-bit` + Wrgsbase_r64 = 2022, + // `VSTMXCSR m32` + // + // `VEX.LZ.0F.WIG AE /3` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vstmxcsr_m32 = 2023, + // `XSAVE mem` + // + // `NP 0F AE /4` + // + // `XSAVE` + // + // `16/32/64-bit` + Xsave_mem = 2024, + // `XSAVE64 mem` + // + // `NP o64 0F AE /4` + // + // `XSAVE` + // + // `64-bit` + Xsave64_mem = 2025, + // `PTWRITE r/m32` + // + // `F3 0F AE /4` + // + // `PTWRITE` + // + // `16/32/64-bit` + Ptwrite_rm32 = 2026, + // `PTWRITE r/m64` + // + // `F3 o64 0F AE /4` + // + // `PTWRITE` + // + // `64-bit` + Ptwrite_rm64 = 2027, + // `XRSTOR mem` + // + // `NP 0F AE /5` + // + // `XSAVE` + // + // `16/32/64-bit` + Xrstor_mem = 2028, + // `XRSTOR64 mem` + // + // `NP o64 0F AE /5` + // + // `XSAVE` + // + // `64-bit` + Xrstor64_mem = 2029, + // `INCSSPD r32` + // + // `F3 0F AE /5` + // + // `CET_SS` + // + // `16/32/64-bit` + Incsspd_r32 = 2030, + // `INCSSPQ r64` + // + // `F3 o64 0F AE /5` + // + // `CET_SS` + // + // `64-bit` + Incsspq_r64 = 2031, + // `XSAVEOPT mem` + // + // `NP 0F AE /6` + // + // `XSAVEOPT` + // + // `16/32/64-bit` + Xsaveopt_mem = 2032, + // `XSAVEOPT64 mem` + // + // `NP o64 0F AE /6` + // + // `XSAVEOPT` + // + // `64-bit` + Xsaveopt64_mem = 2033, + // `CLWB m8` + // + // `66 0F AE /6` + // + // `CLWB` + // + // `16/32/64-bit` + Clwb_m8 = 2034, + // `TPAUSE r32, , ` + // + // `66 0F AE /6` + // + // `WAITPKG` + // + // `16/32/64-bit` + Tpause_r32 = 2035, + // `TPAUSE r64, , ` + // + // `66 o64 0F AE /6` + // + // `WAITPKG` + // + // `64-bit` + Tpause_r64 = 2036, + // `CLRSSBSY m64` + // + // `F3 0F AE /6` + // + // `CET_SS` + // + // `16/32/64-bit` + Clrssbsy_m64 = 2037, + // `UMONITOR r16` + // + // `a16 F3 0F AE /6` + // + // `WAITPKG` + // + // `16/32-bit` + Umonitor_r16 = 2038, + // `UMONITOR r32` + // + // `a32 F3 0F AE /6` + // + // `WAITPKG` + // + // `16/32/64-bit` + Umonitor_r32 = 2039, + // `UMONITOR r64` + // + // `a64 F3 0F AE /6` + // + // `WAITPKG` + // + // `64-bit` + Umonitor_r64 = 2040, + // `UMWAIT r32, , ` + // + // `F2 0F AE /6` + // + // `WAITPKG` + // + // `16/32/64-bit` + Umwait_r32 = 2041, + // `UMWAIT r64, , ` + // + // `F2 o64 0F AE /6` + // + // `WAITPKG` + // + // `64-bit` + Umwait_r64 = 2042, + // `CLFLUSH m8` + // + // `NP 0F AE /7` + // + // `CLFSH` + // + // `16/32/64-bit` + Clflush_m8 = 2043, + // `CLFLUSHOPT m8` + // + // `66 0F AE /7` + // + // `CLFLUSHOPT` + // + // `16/32/64-bit` + Clflushopt_m8 = 2044, + // `LFENCE` + // + // `NP 0F AE E8` + // + // `SSE2` + // + // `16/32/64-bit` + Lfence = 2045, + // `LFENCE` + // + // `NP 0F AE E9` + // + // `SSE2` + // + // `16/32/64-bit` + Lfence_E9 = 2046, + // `LFENCE` + // + // `NP 0F AE EA` + // + // `SSE2` + // + // `16/32/64-bit` + Lfence_EA = 2047, + // `LFENCE` + // + // `NP 0F AE EB` + // + // `SSE2` + // + // `16/32/64-bit` + Lfence_EB = 2048, + // `LFENCE` + // + // `NP 0F AE EC` + // + // `SSE2` + // + // `16/32/64-bit` + Lfence_EC = 2049, + // `LFENCE` + // + // `NP 0F AE ED` + // + // `SSE2` + // + // `16/32/64-bit` + Lfence_ED = 2050, + // `LFENCE` + // + // `NP 0F AE EE` + // + // `SSE2` + // + // `16/32/64-bit` + Lfence_EE = 2051, + // `LFENCE` + // + // `NP 0F AE EF` + // + // `SSE2` + // + // `16/32/64-bit` + Lfence_EF = 2052, + // `MFENCE` + // + // `NP 0F AE F0` + // + // `SSE2` + // + // `16/32/64-bit` + Mfence = 2053, + // `MFENCE` + // + // `NP 0F AE F1` + // + // `SSE2` + // + // `16/32/64-bit` + Mfence_F1 = 2054, + // `MFENCE` + // + // `NP 0F AE F2` + // + // `SSE2` + // + // `16/32/64-bit` + Mfence_F2 = 2055, + // `MFENCE` + // + // `NP 0F AE F3` + // + // `SSE2` + // + // `16/32/64-bit` + Mfence_F3 = 2056, + // `MFENCE` + // + // `NP 0F AE F4` + // + // `SSE2` + // + // `16/32/64-bit` + Mfence_F4 = 2057, + // `MFENCE` + // + // `NP 0F AE F5` + // + // `SSE2` + // + // `16/32/64-bit` + Mfence_F5 = 2058, + // `MFENCE` + // + // `NP 0F AE F6` + // + // `SSE2` + // + // `16/32/64-bit` + Mfence_F6 = 2059, + // `MFENCE` + // + // `NP 0F AE F7` + // + // `SSE2` + // + // `16/32/64-bit` + Mfence_F7 = 2060, + // `SFENCE` + // + // `NP 0F AE F8` + // + // `SSE` + // + // `16/32/64-bit` + Sfence = 2061, + // `SFENCE` + // + // `NP 0F AE F9` + // + // `SSE` + // + // `16/32/64-bit` + Sfence_F9 = 2062, + // `SFENCE` + // + // `NP 0F AE FA` + // + // `SSE` + // + // `16/32/64-bit` + Sfence_FA = 2063, + // `SFENCE` + // + // `NP 0F AE FB` + // + // `SSE` + // + // `16/32/64-bit` + Sfence_FB = 2064, + // `SFENCE` + // + // `NP 0F AE FC` + // + // `SSE` + // + // `16/32/64-bit` + Sfence_FC = 2065, + // `SFENCE` + // + // `NP 0F AE FD` + // + // `SSE` + // + // `16/32/64-bit` + Sfence_FD = 2066, + // `SFENCE` + // + // `NP 0F AE FE` + // + // `SSE` + // + // `16/32/64-bit` + Sfence_FE = 2067, + // `SFENCE` + // + // `NP 0F AE FF` + // + // `SSE` + // + // `16/32/64-bit` + Sfence_FF = 2068, + // `PCOMMIT` + // + // `66 0F AE F8` + // + // `PCOMMIT` + // + // `16/32/64-bit` + Pcommit = 2069, + // `IMUL r16, r/m16` + // + // `o16 0F AF /r` + // + // `386+` + // + // `16/32/64-bit` + Imul_r16_rm16 = 2070, + // `IMUL r32, r/m32` + // + // `o32 0F AF /r` + // + // `386+` + // + // `16/32/64-bit` + Imul_r32_rm32 = 2071, + // `IMUL r64, r/m64` + // + // `o64 0F AF /r` + // + // `X64` + // + // `64-bit` + Imul_r64_rm64 = 2072, + // `CMPXCHG r/m8, r8` + // + // `0F B0 /r` + // + // `486+` + // + // `16/32/64-bit` + Cmpxchg_rm8_r8 = 2073, + // `CMPXCHG r/m16, r16` + // + // `o16 0F B1 /r` + // + // `486+` + // + // `16/32/64-bit` + Cmpxchg_rm16_r16 = 2074, + // `CMPXCHG r/m32, r32` + // + // `o32 0F B1 /r` + // + // `486+` + // + // `16/32/64-bit` + Cmpxchg_rm32_r32 = 2075, + // `CMPXCHG r/m64, r64` + // + // `o64 0F B1 /r` + // + // `X64` + // + // `64-bit` + Cmpxchg_rm64_r64 = 2076, + // `LSS r16, m16:16` + // + // `o16 0F B2 /r` + // + // `386+` + // + // `16/32/64-bit` + Lss_r16_m1616 = 2077, + // `LSS r32, m16:32` + // + // `o32 0F B2 /r` + // + // `386+` + // + // `16/32/64-bit` + Lss_r32_m1632 = 2078, + // `LSS r64, m16:64` + // + // `o64 0F B2 /r` + // + // `X64` + // + // `64-bit` + Lss_r64_m1664 = 2079, + // `BTR r/m16, r16` + // + // `o16 0F B3 /r` + // + // `386+` + // + // `16/32/64-bit` + Btr_rm16_r16 = 2080, + // `BTR r/m32, r32` + // + // `o32 0F B3 /r` + // + // `386+` + // + // `16/32/64-bit` + Btr_rm32_r32 = 2081, + // `BTR r/m64, r64` + // + // `o64 0F B3 /r` + // + // `X64` + // + // `64-bit` + Btr_rm64_r64 = 2082, + // `LFS r16, m16:16` + // + // `o16 0F B4 /r` + // + // `386+` + // + // `16/32/64-bit` + Lfs_r16_m1616 = 2083, + // `LFS r32, m16:32` + // + // `o32 0F B4 /r` + // + // `386+` + // + // `16/32/64-bit` + Lfs_r32_m1632 = 2084, + // `LFS r64, m16:64` + // + // `o64 0F B4 /r` + // + // `X64` + // + // `64-bit` + Lfs_r64_m1664 = 2085, + // `LGS r16, m16:16` + // + // `o16 0F B5 /r` + // + // `386+` + // + // `16/32/64-bit` + Lgs_r16_m1616 = 2086, + // `LGS r32, m16:32` + // + // `o32 0F B5 /r` + // + // `386+` + // + // `16/32/64-bit` + Lgs_r32_m1632 = 2087, + // `LGS r64, m16:64` + // + // `o64 0F B5 /r` + // + // `X64` + // + // `64-bit` + Lgs_r64_m1664 = 2088, + // `MOVZX r16, r/m8` + // + // `o16 0F B6 /r` + // + // `386+` + // + // `16/32/64-bit` + Movzx_r16_rm8 = 2089, + // `MOVZX r32, r/m8` + // + // `o32 0F B6 /r` + // + // `386+` + // + // `16/32/64-bit` + Movzx_r32_rm8 = 2090, + // `MOVZX r64, r/m8` + // + // `o64 0F B6 /r` + // + // `X64` + // + // `64-bit` + Movzx_r64_rm8 = 2091, + // `MOVZX r16, r/m16` + // + // `o16 0F B7 /r` + // + // `386+` + // + // `16/32/64-bit` + Movzx_r16_rm16 = 2092, + // `MOVZX r32, r/m16` + // + // `o32 0F B7 /r` + // + // `386+` + // + // `16/32/64-bit` + Movzx_r32_rm16 = 2093, + // `MOVZX r64, r/m16` + // + // `o64 0F B7 /r` + // + // `X64` + // + // `64-bit` + Movzx_r64_rm16 = 2094, + // `JMPE disp16` + // + // `o16 0F B8 cw` + // + // `IA-64` + // + // `16/32-bit` + Jmpe_disp16 = 2095, + // `JMPE disp32` + // + // `o32 0F B8 cd` + // + // `IA-64` + // + // `16/32-bit` + Jmpe_disp32 = 2096, + // `POPCNT r16, r/m16` + // + // `o16 F3 0F B8 /r` + // + // `POPCNT` + // + // `16/32/64-bit` + Popcnt_r16_rm16 = 2097, + // `POPCNT r32, r/m32` + // + // `o32 F3 0F B8 /r` + // + // `POPCNT` + // + // `16/32/64-bit` + Popcnt_r32_rm32 = 2098, + // `POPCNT r64, r/m64` + // + // `F3 o64 0F B8 /r` + // + // `POPCNT` + // + // `64-bit` + Popcnt_r64_rm64 = 2099, + // `UD1 r16, r/m16` + // + // `o16 0F B9 /r` + // + // `286+` + // + // `16/32/64-bit` + Ud1_r16_rm16 = 2100, + // `UD1 r32, r/m32` + // + // `o32 0F B9 /r` + // + // `386+` + // + // `16/32/64-bit` + Ud1_r32_rm32 = 2101, + // `UD1 r64, r/m64` + // + // `o64 0F B9 /r` + // + // `X64` + // + // `64-bit` + Ud1_r64_rm64 = 2102, + // `BT r/m16, imm8` + // + // `o16 0F BA /4 ib` + // + // `386+` + // + // `16/32/64-bit` + Bt_rm16_imm8 = 2103, + // `BT r/m32, imm8` + // + // `o32 0F BA /4 ib` + // + // `386+` + // + // `16/32/64-bit` + Bt_rm32_imm8 = 2104, + // `BT r/m64, imm8` + // + // `o64 0F BA /4 ib` + // + // `X64` + // + // `64-bit` + Bt_rm64_imm8 = 2105, + // `BTS r/m16, imm8` + // + // `o16 0F BA /5 ib` + // + // `386+` + // + // `16/32/64-bit` + Bts_rm16_imm8 = 2106, + // `BTS r/m32, imm8` + // + // `o32 0F BA /5 ib` + // + // `386+` + // + // `16/32/64-bit` + Bts_rm32_imm8 = 2107, + // `BTS r/m64, imm8` + // + // `o64 0F BA /5 ib` + // + // `X64` + // + // `64-bit` + Bts_rm64_imm8 = 2108, + // `BTR r/m16, imm8` + // + // `o16 0F BA /6 ib` + // + // `386+` + // + // `16/32/64-bit` + Btr_rm16_imm8 = 2109, + // `BTR r/m32, imm8` + // + // `o32 0F BA /6 ib` + // + // `386+` + // + // `16/32/64-bit` + Btr_rm32_imm8 = 2110, + // `BTR r/m64, imm8` + // + // `o64 0F BA /6 ib` + // + // `X64` + // + // `64-bit` + Btr_rm64_imm8 = 2111, + // `BTC r/m16, imm8` + // + // `o16 0F BA /7 ib` + // + // `386+` + // + // `16/32/64-bit` + Btc_rm16_imm8 = 2112, + // `BTC r/m32, imm8` + // + // `o32 0F BA /7 ib` + // + // `386+` + // + // `16/32/64-bit` + Btc_rm32_imm8 = 2113, + // `BTC r/m64, imm8` + // + // `o64 0F BA /7 ib` + // + // `X64` + // + // `64-bit` + Btc_rm64_imm8 = 2114, + // `BTC r/m16, r16` + // + // `o16 0F BB /r` + // + // `386+` + // + // `16/32/64-bit` + Btc_rm16_r16 = 2115, + // `BTC r/m32, r32` + // + // `o32 0F BB /r` + // + // `386+` + // + // `16/32/64-bit` + Btc_rm32_r32 = 2116, + // `BTC r/m64, r64` + // + // `o64 0F BB /r` + // + // `X64` + // + // `64-bit` + Btc_rm64_r64 = 2117, + // `BSF r16, r/m16` + // + // `o16 0F BC /r` + // + // `386+` + // + // `16/32/64-bit` + Bsf_r16_rm16 = 2118, + // `BSF r32, r/m32` + // + // `o32 0F BC /r` + // + // `386+` + // + // `16/32/64-bit` + Bsf_r32_rm32 = 2119, + // `BSF r64, r/m64` + // + // `o64 0F BC /r` + // + // `X64` + // + // `64-bit` + Bsf_r64_rm64 = 2120, + // `TZCNT r16, r/m16` + // + // `o16 F3 0F BC /r` + // + // `BMI1` + // + // `16/32/64-bit` + Tzcnt_r16_rm16 = 2121, + // `TZCNT r32, r/m32` + // + // `o32 F3 0F BC /r` + // + // `BMI1` + // + // `16/32/64-bit` + Tzcnt_r32_rm32 = 2122, + // `TZCNT r64, r/m64` + // + // `F3 o64 0F BC /r` + // + // `BMI1` + // + // `64-bit` + Tzcnt_r64_rm64 = 2123, + // `BSR r16, r/m16` + // + // `o16 0F BD /r` + // + // `386+` + // + // `16/32/64-bit` + Bsr_r16_rm16 = 2124, + // `BSR r32, r/m32` + // + // `o32 0F BD /r` + // + // `386+` + // + // `16/32/64-bit` + Bsr_r32_rm32 = 2125, + // `BSR r64, r/m64` + // + // `o64 0F BD /r` + // + // `X64` + // + // `64-bit` + Bsr_r64_rm64 = 2126, + // `LZCNT r16, r/m16` + // + // `o16 F3 0F BD /r` + // + // `LZCNT` + // + // `16/32/64-bit` + Lzcnt_r16_rm16 = 2127, + // `LZCNT r32, r/m32` + // + // `o32 F3 0F BD /r` + // + // `LZCNT` + // + // `16/32/64-bit` + Lzcnt_r32_rm32 = 2128, + // `LZCNT r64, r/m64` + // + // `F3 o64 0F BD /r` + // + // `LZCNT` + // + // `64-bit` + Lzcnt_r64_rm64 = 2129, + // `MOVSX r16, r/m8` + // + // `o16 0F BE /r` + // + // `386+` + // + // `16/32/64-bit` + Movsx_r16_rm8 = 2130, + // `MOVSX r32, r/m8` + // + // `o32 0F BE /r` + // + // `386+` + // + // `16/32/64-bit` + Movsx_r32_rm8 = 2131, + // `MOVSX r64, r/m8` + // + // `o64 0F BE /r` + // + // `X64` + // + // `64-bit` + Movsx_r64_rm8 = 2132, + // `MOVSX r16, r/m16` + // + // `o16 0F BF /r` + // + // `386+` + // + // `16/32/64-bit` + Movsx_r16_rm16 = 2133, + // `MOVSX r32, r/m16` + // + // `o32 0F BF /r` + // + // `386+` + // + // `16/32/64-bit` + Movsx_r32_rm16 = 2134, + // `MOVSX r64, r/m16` + // + // `o64 0F BF /r` + // + // `X64` + // + // `64-bit` + Movsx_r64_rm16 = 2135, + // `XADD r/m8, r8` + // + // `0F C0 /r` + // + // `486+` + // + // `16/32/64-bit` + Xadd_rm8_r8 = 2136, + // `XADD r/m16, r16` + // + // `o16 0F C1 /r` + // + // `486+` + // + // `16/32/64-bit` + Xadd_rm16_r16 = 2137, + // `XADD r/m32, r32` + // + // `o32 0F C1 /r` + // + // `486+` + // + // `16/32/64-bit` + Xadd_rm32_r32 = 2138, + // `XADD r/m64, r64` + // + // `o64 0F C1 /r` + // + // `X64` + // + // `64-bit` + Xadd_rm64_r64 = 2139, + // `CMPPS xmm1, xmm2/m128, imm8` + // + // `NP 0F C2 /r ib` + // + // `SSE` + // + // `16/32/64-bit` + Cmpps_xmm_xmmm128_imm8 = 2140, + // `VCMPPS xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.0F.WIG C2 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcmpps_xmm_xmm_xmmm128_imm8 = 2141, + // `VCMPPS ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.0F.WIG C2 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcmpps_ymm_ymm_ymmm256_imm8 = 2142, + // `VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8` + // + // `EVEX.128.0F.W0 C2 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcmpps_kr_k1_xmm_xmmm128b32_imm8 = 2143, + // `VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.0F.W0 C2 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcmpps_kr_k1_ymm_ymmm256b32_imm8 = 2144, + // `VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8` + // + // `EVEX.512.0F.W0 C2 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcmpps_kr_k1_zmm_zmmm512b32_imm8_sae = 2145, + // `CMPPD xmm1, xmm2/m128, imm8` + // + // `66 0F C2 /r ib` + // + // `SSE2` + // + // `16/32/64-bit` + Cmppd_xmm_xmmm128_imm8 = 2146, + // `VCMPPD xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F.WIG C2 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcmppd_xmm_xmm_xmmm128_imm8 = 2147, + // `VCMPPD ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F.WIG C2 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcmppd_ymm_ymm_ymmm256_imm8 = 2148, + // `VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F.W1 C2 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcmppd_kr_k1_xmm_xmmm128b64_imm8 = 2149, + // `VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F.W1 C2 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcmppd_kr_k1_ymm_ymmm256b64_imm8 = 2150, + // `VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8` + // + // `EVEX.512.66.0F.W1 C2 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcmppd_kr_k1_zmm_zmmm512b64_imm8_sae = 2151, + // `CMPSS xmm1, xmm2/m32, imm8` + // + // `F3 0F C2 /r ib` + // + // `SSE` + // + // `16/32/64-bit` + Cmpss_xmm_xmmm32_imm8 = 2152, + // `VCMPSS xmm1, xmm2, xmm3/m32, imm8` + // + // `VEX.LIG.F3.0F.WIG C2 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcmpss_xmm_xmm_xmmm32_imm8 = 2153, + // `VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8` + // + // `EVEX.LIG.F3.0F.W0 C2 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcmpss_kr_k1_xmm_xmmm32_imm8_sae = 2154, + // `CMPSD xmm1, xmm2/m64, imm8` + // + // `F2 0F C2 /r ib` + // + // `SSE2` + // + // `16/32/64-bit` + Cmpsd_xmm_xmmm64_imm8 = 2155, + // `VCMPSD xmm1, xmm2, xmm3/m64, imm8` + // + // `VEX.LIG.F2.0F.WIG C2 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcmpsd_xmm_xmm_xmmm64_imm8 = 2156, + // `VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8` + // + // `EVEX.LIG.F2.0F.W1 C2 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcmpsd_kr_k1_xmm_xmmm64_imm8_sae = 2157, + // `MOVNTI m32, r32` + // + // `NP 0F C3 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movnti_m32_r32 = 2158, + // `MOVNTI m64, r64` + // + // `NP o64 0F C3 /r` + // + // `SSE2` + // + // `64-bit` + Movnti_m64_r64 = 2159, + // `PINSRW mm, r32/m16, imm8` + // + // `NP 0F C4 /r ib` + // + // `SSE` + // + // `16/32/64-bit` + Pinsrw_mm_r32m16_imm8 = 2160, + // `PINSRW mm, r64/m16, imm8` + // + // `NP o64 0F C4 /r ib` + // + // `SSE` + // + // `64-bit` + Pinsrw_mm_r64m16_imm8 = 2161, + // `PINSRW xmm, r32/m16, imm8` + // + // `66 0F C4 /r ib` + // + // `SSE2` + // + // `16/32/64-bit` + Pinsrw_xmm_r32m16_imm8 = 2162, + // `PINSRW xmm, r64/m16, imm8` + // + // `66 o64 0F C4 /r ib` + // + // `SSE2` + // + // `64-bit` + Pinsrw_xmm_r64m16_imm8 = 2163, + // `VPINSRW xmm1, xmm2, r32/m16, imm8` + // + // `VEX.128.66.0F.W0 C4 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpinsrw_xmm_xmm_r32m16_imm8 = 2164, + // `VPINSRW xmm1, xmm2, r64/m16, imm8` + // + // `VEX.128.66.0F.W1 C4 /r ib` + // + // `AVX` + // + // `64-bit` + VEX_Vpinsrw_xmm_xmm_r64m16_imm8 = 2165, + // `VPINSRW xmm1, xmm2, r32/m16, imm8` + // + // `EVEX.128.66.0F.W0 C4 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpinsrw_xmm_xmm_r32m16_imm8 = 2166, + // `VPINSRW xmm1, xmm2, r64/m16, imm8` + // + // `EVEX.128.66.0F.W1 C4 /r ib` + // + // `AVX512BW` + // + // `64-bit` + EVEX_Vpinsrw_xmm_xmm_r64m16_imm8 = 2167, + // `PEXTRW r32, mm, imm8` + // + // `NP 0F C5 /r ib` + // + // `SSE` + // + // `16/32/64-bit` + Pextrw_r32_mm_imm8 = 2168, + // `PEXTRW r64, mm, imm8` + // + // `NP o64 0F C5 /r ib` + // + // `SSE` + // + // `64-bit` + Pextrw_r64_mm_imm8 = 2169, + // `PEXTRW r32, xmm, imm8` + // + // `66 0F C5 /r ib` + // + // `SSE2` + // + // `16/32/64-bit` + Pextrw_r32_xmm_imm8 = 2170, + // `PEXTRW r64, xmm, imm8` + // + // `66 o64 0F C5 /r ib` + // + // `SSE2` + // + // `64-bit` + Pextrw_r64_xmm_imm8 = 2171, + // `VPEXTRW r32, xmm1, imm8` + // + // `VEX.128.66.0F.W0 C5 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpextrw_r32_xmm_imm8 = 2172, + // `VPEXTRW r64, xmm1, imm8` + // + // `VEX.128.66.0F.W1 C5 /r ib` + // + // `AVX` + // + // `64-bit` + VEX_Vpextrw_r64_xmm_imm8 = 2173, + // `VPEXTRW r32, xmm1, imm8` + // + // `EVEX.128.66.0F.W0 C5 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpextrw_r32_xmm_imm8 = 2174, + // `VPEXTRW r64, xmm1, imm8` + // + // `EVEX.128.66.0F.W1 C5 /r ib` + // + // `AVX512BW` + // + // `64-bit` + EVEX_Vpextrw_r64_xmm_imm8 = 2175, + // `SHUFPS xmm1, xmm2/m128, imm8` + // + // `NP 0F C6 /r ib` + // + // `SSE` + // + // `16/32/64-bit` + Shufps_xmm_xmmm128_imm8 = 2176, + // `VSHUFPS xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.0F.WIG C6 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vshufps_xmm_xmm_xmmm128_imm8 = 2177, + // `VSHUFPS ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.0F.WIG C6 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vshufps_ymm_ymm_ymmm256_imm8 = 2178, + // `VSHUFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8` + // + // `EVEX.128.0F.W0 C6 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vshufps_xmm_k1z_xmm_xmmm128b32_imm8 = 2179, + // `VSHUFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.0F.W0 C6 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vshufps_ymm_k1z_ymm_ymmm256b32_imm8 = 2180, + // `VSHUFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8` + // + // `EVEX.512.0F.W0 C6 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vshufps_zmm_k1z_zmm_zmmm512b32_imm8 = 2181, + // `SHUFPD xmm1, xmm2/m128, imm8` + // + // `66 0F C6 /r ib` + // + // `SSE2` + // + // `16/32/64-bit` + Shufpd_xmm_xmmm128_imm8 = 2182, + // `VSHUFPD xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F.WIG C6 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vshufpd_xmm_xmm_xmmm128_imm8 = 2183, + // `VSHUFPD ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F.WIG C6 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vshufpd_ymm_ymm_ymmm256_imm8 = 2184, + // `VSHUFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F.W1 C6 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vshufpd_xmm_k1z_xmm_xmmm128b64_imm8 = 2185, + // `VSHUFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F.W1 C6 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vshufpd_ymm_k1z_ymm_ymmm256b64_imm8 = 2186, + // `VSHUFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F.W1 C6 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vshufpd_zmm_k1z_zmm_zmmm512b64_imm8 = 2187, + // `CMPXCHG8B m64` + // + // `0F C7 /1` + // + // `CX8` + // + // `16/32/64-bit` + Cmpxchg8b_m64 = 2188, + // `CMPXCHG16B m128` + // + // `o64 0F C7 /1` + // + // `CMPXCHG16B` + // + // `64-bit` + Cmpxchg16b_m128 = 2189, + // `XRSTORS mem` + // + // `NP 0F C7 /3` + // + // `XSAVES` + // + // `16/32/64-bit` + Xrstors_mem = 2190, + // `XRSTORS64 mem` + // + // `NP o64 0F C7 /3` + // + // `XSAVES` + // + // `64-bit` + Xrstors64_mem = 2191, + // `XSAVEC mem` + // + // `NP 0F C7 /4` + // + // `XSAVEC` + // + // `16/32/64-bit` + Xsavec_mem = 2192, + // `XSAVEC64 mem` + // + // `NP o64 0F C7 /4` + // + // `XSAVEC` + // + // `64-bit` + Xsavec64_mem = 2193, + // `XSAVES mem` + // + // `NP 0F C7 /5` + // + // `XSAVES` + // + // `16/32/64-bit` + Xsaves_mem = 2194, + // `XSAVES64 mem` + // + // `NP o64 0F C7 /5` + // + // `XSAVES` + // + // `64-bit` + Xsaves64_mem = 2195, + // `VMPTRLD m64` + // + // `NP 0F C7 /6` + // + // `VMX` + // + // `16/32/64-bit` + Vmptrld_m64 = 2196, + // `VMCLEAR m64` + // + // `66 0F C7 /6` + // + // `VMX` + // + // `16/32/64-bit` + Vmclear_m64 = 2197, + // `VMXON m64` + // + // `F3 0F C7 /6` + // + // `VMX` + // + // `16/32/64-bit` + Vmxon_m64 = 2198, + // `RDRAND r16` + // + // `o16 0F C7 /6` + // + // `RDRAND` + // + // `16/32/64-bit` + Rdrand_r16 = 2199, + // `RDRAND r32` + // + // `o32 0F C7 /6` + // + // `RDRAND` + // + // `16/32/64-bit` + Rdrand_r32 = 2200, + // `RDRAND r64` + // + // `o64 0F C7 /6` + // + // `RDRAND` + // + // `64-bit` + Rdrand_r64 = 2201, + // `VMPTRST m64` + // + // `NP 0F C7 /7` + // + // `VMX` + // + // `16/32/64-bit` + Vmptrst_m64 = 2202, + // `RDSEED r16` + // + // `o16 0F C7 /7` + // + // `RDSEED` + // + // `16/32/64-bit` + Rdseed_r16 = 2203, + // `RDSEED r32` + // + // `o32 0F C7 /7` + // + // `RDSEED` + // + // `16/32/64-bit` + Rdseed_r32 = 2204, + // `RDSEED r64` + // + // `o64 0F C7 /7` + // + // `RDSEED` + // + // `64-bit` + Rdseed_r64 = 2205, + // `RDPID r32` + // + // `F3 0F C7 /7` + // + // `RDPID` + // + // `16/32-bit` + Rdpid_r32 = 2206, + // `RDPID r64` + // + // `F3 0F C7 /7` + // + // `RDPID` + // + // `64-bit` + Rdpid_r64 = 2207, + // `BSWAP r16` + // + // `o16 0F C8+rw` + // + // `486+` + // + // `16/32/64-bit` + Bswap_r16 = 2208, + // `BSWAP r32` + // + // `o32 0F C8+rd` + // + // `486+` + // + // `16/32/64-bit` + Bswap_r32 = 2209, + // `BSWAP r64` + // + // `o64 0F C8+ro` + // + // `X64` + // + // `64-bit` + Bswap_r64 = 2210, + // `ADDSUBPD xmm1, xmm2/m128` + // + // `66 0F D0 /r` + // + // `SSE3` + // + // `16/32/64-bit` + Addsubpd_xmm_xmmm128 = 2211, + // `VADDSUBPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG D0 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vaddsubpd_xmm_xmm_xmmm128 = 2212, + // `VADDSUBPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG D0 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vaddsubpd_ymm_ymm_ymmm256 = 2213, + // `ADDSUBPS xmm1, xmm2/m128` + // + // `F2 0F D0 /r` + // + // `SSE3` + // + // `16/32/64-bit` + Addsubps_xmm_xmmm128 = 2214, + // `VADDSUBPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.F2.0F.WIG D0 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vaddsubps_xmm_xmm_xmmm128 = 2215, + // `VADDSUBPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.F2.0F.WIG D0 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vaddsubps_ymm_ymm_ymmm256 = 2216, + // `PSRLW mm, mm/m64` + // + // `NP 0F D1 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psrlw_mm_mmm64 = 2217, + // `PSRLW xmm1, xmm2/m128` + // + // `66 0F D1 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psrlw_xmm_xmmm128 = 2218, + // `VPSRLW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG D1 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsrlw_xmm_xmm_xmmm128 = 2219, + // `VPSRLW ymm1, ymm2, xmm3/m128` + // + // `VEX.256.66.0F.WIG D1 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrlw_ymm_ymm_xmmm128 = 2220, + // `VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG D1 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrlw_xmm_k1z_xmm_xmmm128 = 2221, + // `VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128` + // + // `EVEX.256.66.0F.WIG D1 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrlw_ymm_k1z_ymm_xmmm128 = 2222, + // `VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128` + // + // `EVEX.512.66.0F.WIG D1 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrlw_zmm_k1z_zmm_xmmm128 = 2223, + // `PSRLD mm, mm/m64` + // + // `NP 0F D2 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psrld_mm_mmm64 = 2224, + // `PSRLD xmm1, xmm2/m128` + // + // `66 0F D2 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psrld_xmm_xmmm128 = 2225, + // `VPSRLD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG D2 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsrld_xmm_xmm_xmmm128 = 2226, + // `VPSRLD ymm1, ymm2, xmm3/m128` + // + // `VEX.256.66.0F.WIG D2 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrld_ymm_ymm_xmmm128 = 2227, + // `VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.W0 D2 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrld_xmm_k1z_xmm_xmmm128 = 2228, + // `VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128` + // + // `EVEX.256.66.0F.W0 D2 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrld_ymm_k1z_ymm_xmmm128 = 2229, + // `VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128` + // + // `EVEX.512.66.0F.W0 D2 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrld_zmm_k1z_zmm_xmmm128 = 2230, + // `PSRLQ mm, mm/m64` + // + // `NP 0F D3 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psrlq_mm_mmm64 = 2231, + // `PSRLQ xmm1, xmm2/m128` + // + // `66 0F D3 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psrlq_xmm_xmmm128 = 2232, + // `VPSRLQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG D3 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsrlq_xmm_xmm_xmmm128 = 2233, + // `VPSRLQ ymm1, ymm2, xmm3/m128` + // + // `VEX.256.66.0F.WIG D3 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrlq_ymm_ymm_xmmm128 = 2234, + // `VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.W1 D3 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlq_xmm_k1z_xmm_xmmm128 = 2235, + // `VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128` + // + // `EVEX.256.66.0F.W1 D3 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlq_ymm_k1z_ymm_xmmm128 = 2236, + // `VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128` + // + // `EVEX.512.66.0F.W1 D3 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlq_zmm_k1z_zmm_xmmm128 = 2237, + // `PADDQ mm, mm/m64` + // + // `NP 0F D4 /r` + // + // `MMX` + // + // `16/32/64-bit` + Paddq_mm_mmm64 = 2238, + // `PADDQ xmm1, xmm2/m128` + // + // `66 0F D4 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Paddq_xmm_xmmm128 = 2239, + // `VPADDQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG D4 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpaddq_xmm_xmm_xmmm128 = 2240, + // `VPADDQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG D4 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpaddq_ymm_ymm_ymmm256 = 2241, + // `VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 D4 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpaddq_xmm_k1z_xmm_xmmm128b64 = 2242, + // `VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 D4 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpaddq_ymm_k1z_ymm_ymmm256b64 = 2243, + // `VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 D4 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpaddq_zmm_k1z_zmm_zmmm512b64 = 2244, + // `PMULLW mm, mm/m64` + // + // `NP 0F D5 /r` + // + // `MMX` + // + // `16/32/64-bit` + Pmullw_mm_mmm64 = 2245, + // `PMULLW xmm1, xmm2/m128` + // + // `66 0F D5 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pmullw_xmm_xmmm128 = 2246, + // `VPMULLW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG D5 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmullw_xmm_xmm_xmmm128 = 2247, + // `VPMULLW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG D5 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmullw_ymm_ymm_ymmm256 = 2248, + // `VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG D5 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmullw_xmm_k1z_xmm_xmmm128 = 2249, + // `VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG D5 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmullw_ymm_k1z_ymm_ymmm256 = 2250, + // `VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG D5 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmullw_zmm_k1z_zmm_zmmm512 = 2251, + // `MOVQ xmm2/m64, xmm1` + // + // `66 0F D6 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movq_xmmm64_xmm = 2252, + // `VMOVQ xmm1/m64, xmm2` + // + // `VEX.128.66.0F.WIG D6 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovq_xmmm64_xmm = 2253, + // `VMOVQ xmm1/m64, xmm2` + // + // `EVEX.128.66.0F.W1 D6 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovq_xmmm64_xmm = 2254, + // `MOVQ2DQ xmm, mm` + // + // `F3 0F D6 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movq2dq_xmm_mm = 2255, + // `MOVDQ2Q mm, xmm` + // + // `F2 0F D6 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movdq2q_mm_xmm = 2256, + // `PMOVMSKB r32, mm` + // + // `NP 0F D7 /r` + // + // `SSE` + // + // `16/32/64-bit` + Pmovmskb_r32_mm = 2257, + // `PMOVMSKB r64, mm` + // + // `NP o64 0F D7 /r` + // + // `SSE` + // + // `64-bit` + Pmovmskb_r64_mm = 2258, + // `PMOVMSKB r32, xmm` + // + // `66 0F D7 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pmovmskb_r32_xmm = 2259, + // `PMOVMSKB r64, xmm` + // + // `66 o64 0F D7 /r` + // + // `SSE2` + // + // `64-bit` + Pmovmskb_r64_xmm = 2260, + // `VPMOVMSKB r32, xmm1` + // + // `VEX.128.66.0F.W0 D7 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovmskb_r32_xmm = 2261, + // `VPMOVMSKB r64, xmm1` + // + // `VEX.128.66.0F.W1 D7 /r` + // + // `AVX` + // + // `64-bit` + VEX_Vpmovmskb_r64_xmm = 2262, + // `VPMOVMSKB r32, ymm1` + // + // `VEX.256.66.0F.W0 D7 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovmskb_r32_ymm = 2263, + // `VPMOVMSKB r64, ymm1` + // + // `VEX.256.66.0F.W1 D7 /r` + // + // `AVX2` + // + // `64-bit` + VEX_Vpmovmskb_r64_ymm = 2264, + // `PSUBUSB mm, mm/m64` + // + // `NP 0F D8 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psubusb_mm_mmm64 = 2265, + // `PSUBUSB xmm1, xmm2/m128` + // + // `66 0F D8 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psubusb_xmm_xmmm128 = 2266, + // `VPSUBUSB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG D8 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsubusb_xmm_xmm_xmmm128 = 2267, + // `VPSUBUSB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG D8 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsubusb_ymm_ymm_ymmm256 = 2268, + // `VPSUBUSB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG D8 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubusb_xmm_k1z_xmm_xmmm128 = 2269, + // `VPSUBUSB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG D8 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubusb_ymm_k1z_ymm_ymmm256 = 2270, + // `VPSUBUSB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG D8 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubusb_zmm_k1z_zmm_zmmm512 = 2271, + // `PSUBUSW mm, mm/m64` + // + // `NP 0F D9 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psubusw_mm_mmm64 = 2272, + // `PSUBUSW xmm1, xmm2/m128` + // + // `66 0F D9 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psubusw_xmm_xmmm128 = 2273, + // `VPSUBUSW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG D9 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsubusw_xmm_xmm_xmmm128 = 2274, + // `VPSUBUSW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG D9 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsubusw_ymm_ymm_ymmm256 = 2275, + // `VPSUBUSW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG D9 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubusw_xmm_k1z_xmm_xmmm128 = 2276, + // `VPSUBUSW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG D9 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubusw_ymm_k1z_ymm_ymmm256 = 2277, + // `VPSUBUSW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG D9 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubusw_zmm_k1z_zmm_zmmm512 = 2278, + // `PMINUB mm1, mm2/m64` + // + // `NP 0F DA /r` + // + // `SSE` + // + // `16/32/64-bit` + Pminub_mm_mmm64 = 2279, + // `PMINUB xmm1, xmm2/m128` + // + // `66 0F DA /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pminub_xmm_xmmm128 = 2280, + // `VPMINUB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG DA /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpminub_xmm_xmm_xmmm128 = 2281, + // `VPMINUB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG DA /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpminub_ymm_ymm_ymmm256 = 2282, + // `VPMINUB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG DA /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminub_xmm_k1z_xmm_xmmm128 = 2283, + // `VPMINUB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG DA /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminub_ymm_k1z_ymm_ymmm256 = 2284, + // `VPMINUB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG DA /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminub_zmm_k1z_zmm_zmmm512 = 2285, + // `PAND mm, mm/m64` + // + // `NP 0F DB /r` + // + // `MMX` + // + // `16/32/64-bit` + Pand_mm_mmm64 = 2286, + // `PAND xmm1, xmm2/m128` + // + // `66 0F DB /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pand_xmm_xmmm128 = 2287, + // `VPAND xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG DB /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpand_xmm_xmm_xmmm128 = 2288, + // `VPAND ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG DB /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpand_ymm_ymm_ymmm256 = 2289, + // `VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 DB /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandd_xmm_k1z_xmm_xmmm128b32 = 2290, + // `VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 DB /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandd_ymm_k1z_ymm_ymmm256b32 = 2291, + // `VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F.W0 DB /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandd_zmm_k1z_zmm_zmmm512b32 = 2292, + // `VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 DB /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandq_xmm_k1z_xmm_xmmm128b64 = 2293, + // `VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 DB /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandq_ymm_k1z_ymm_ymmm256b64 = 2294, + // `VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 DB /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandq_zmm_k1z_zmm_zmmm512b64 = 2295, + // `PADDUSB mm, mm/m64` + // + // `NP 0F DC /r` + // + // `MMX` + // + // `16/32/64-bit` + Paddusb_mm_mmm64 = 2296, + // `PADDUSB xmm1, xmm2/m128` + // + // `66 0F DC /r` + // + // `SSE2` + // + // `16/32/64-bit` + Paddusb_xmm_xmmm128 = 2297, + // `VPADDUSB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG DC /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpaddusb_xmm_xmm_xmmm128 = 2298, + // `VPADDUSB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG DC /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpaddusb_ymm_ymm_ymmm256 = 2299, + // `VPADDUSB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG DC /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddusb_xmm_k1z_xmm_xmmm128 = 2300, + // `VPADDUSB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG DC /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddusb_ymm_k1z_ymm_ymmm256 = 2301, + // `VPADDUSB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG DC /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddusb_zmm_k1z_zmm_zmmm512 = 2302, + // `PADDUSW mm, mm/m64` + // + // `NP 0F DD /r` + // + // `MMX` + // + // `16/32/64-bit` + Paddusw_mm_mmm64 = 2303, + // `PADDUSW xmm1, xmm2/m128` + // + // `66 0F DD /r` + // + // `SSE2` + // + // `16/32/64-bit` + Paddusw_xmm_xmmm128 = 2304, + // `VPADDUSW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG DD /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpaddusw_xmm_xmm_xmmm128 = 2305, + // `VPADDUSW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG DD /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpaddusw_ymm_ymm_ymmm256 = 2306, + // `VPADDUSW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG DD /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddusw_xmm_k1z_xmm_xmmm128 = 2307, + // `VPADDUSW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG DD /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddusw_ymm_k1z_ymm_ymmm256 = 2308, + // `VPADDUSW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG DD /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddusw_zmm_k1z_zmm_zmmm512 = 2309, + // `PMAXUB mm1, mm2/m64` + // + // `NP 0F DE /r` + // + // `SSE` + // + // `16/32/64-bit` + Pmaxub_mm_mmm64 = 2310, + // `PMAXUB xmm1, xmm2/m128` + // + // `66 0F DE /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pmaxub_xmm_xmmm128 = 2311, + // `VPMAXUB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG DE /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmaxub_xmm_xmm_xmmm128 = 2312, + // `VPMAXUB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG DE /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaxub_ymm_ymm_ymmm256 = 2313, + // `VPMAXUB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG DE /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxub_xmm_k1z_xmm_xmmm128 = 2314, + // `VPMAXUB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG DE /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxub_ymm_k1z_ymm_ymmm256 = 2315, + // `VPMAXUB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG DE /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxub_zmm_k1z_zmm_zmmm512 = 2316, + // `PANDN mm, mm/m64` + // + // `NP 0F DF /r` + // + // `MMX` + // + // `16/32/64-bit` + Pandn_mm_mmm64 = 2317, + // `PANDN xmm1, xmm2/m128` + // + // `66 0F DF /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pandn_xmm_xmmm128 = 2318, + // `VPANDN xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG DF /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpandn_xmm_xmm_xmmm128 = 2319, + // `VPANDN ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG DF /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpandn_ymm_ymm_ymmm256 = 2320, + // `VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 DF /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandnd_xmm_k1z_xmm_xmmm128b32 = 2321, + // `VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 DF /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandnd_ymm_k1z_ymm_ymmm256b32 = 2322, + // `VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F.W0 DF /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandnd_zmm_k1z_zmm_zmmm512b32 = 2323, + // `VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 DF /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandnq_xmm_k1z_xmm_xmmm128b64 = 2324, + // `VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 DF /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandnq_ymm_k1z_ymm_ymmm256b64 = 2325, + // `VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 DF /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpandnq_zmm_k1z_zmm_zmmm512b64 = 2326, + // `PAVGB mm1, mm2/m64` + // + // `NP 0F E0 /r` + // + // `SSE` + // + // `16/32/64-bit` + Pavgb_mm_mmm64 = 2327, + // `PAVGB xmm1, xmm2/m128` + // + // `66 0F E0 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pavgb_xmm_xmmm128 = 2328, + // `VPAVGB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG E0 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpavgb_xmm_xmm_xmmm128 = 2329, + // `VPAVGB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG E0 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpavgb_ymm_ymm_ymmm256 = 2330, + // `VPAVGB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG E0 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpavgb_xmm_k1z_xmm_xmmm128 = 2331, + // `VPAVGB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG E0 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpavgb_ymm_k1z_ymm_ymmm256 = 2332, + // `VPAVGB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG E0 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpavgb_zmm_k1z_zmm_zmmm512 = 2333, + // `PSRAW mm, mm/m64` + // + // `NP 0F E1 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psraw_mm_mmm64 = 2334, + // `PSRAW xmm1, xmm2/m128` + // + // `66 0F E1 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psraw_xmm_xmmm128 = 2335, + // `VPSRAW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG E1 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsraw_xmm_xmm_xmmm128 = 2336, + // `VPSRAW ymm1, ymm2, xmm3/m128` + // + // `VEX.256.66.0F.WIG E1 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsraw_ymm_ymm_xmmm128 = 2337, + // `VPSRAW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG E1 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsraw_xmm_k1z_xmm_xmmm128 = 2338, + // `VPSRAW ymm1 {k1}{z}, ymm2, xmm3/m128` + // + // `EVEX.256.66.0F.WIG E1 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsraw_ymm_k1z_ymm_xmmm128 = 2339, + // `VPSRAW zmm1 {k1}{z}, zmm2, xmm3/m128` + // + // `EVEX.512.66.0F.WIG E1 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsraw_zmm_k1z_zmm_xmmm128 = 2340, + // `PSRAD mm, mm/m64` + // + // `NP 0F E2 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psrad_mm_mmm64 = 2341, + // `PSRAD xmm1, xmm2/m128` + // + // `66 0F E2 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psrad_xmm_xmmm128 = 2342, + // `VPSRAD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG E2 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsrad_xmm_xmm_xmmm128 = 2343, + // `VPSRAD ymm1, ymm2, xmm3/m128` + // + // `VEX.256.66.0F.WIG E2 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrad_ymm_ymm_xmmm128 = 2344, + // `VPSRAD xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.W0 E2 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrad_xmm_k1z_xmm_xmmm128 = 2345, + // `VPSRAD ymm1 {k1}{z}, ymm2, xmm3/m128` + // + // `EVEX.256.66.0F.W0 E2 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrad_ymm_k1z_ymm_xmmm128 = 2346, + // `VPSRAD zmm1 {k1}{z}, zmm2, xmm3/m128` + // + // `EVEX.512.66.0F.W0 E2 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrad_zmm_k1z_zmm_xmmm128 = 2347, + // `VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.W1 E2 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsraq_xmm_k1z_xmm_xmmm128 = 2348, + // `VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128` + // + // `EVEX.256.66.0F.W1 E2 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsraq_ymm_k1z_ymm_xmmm128 = 2349, + // `VPSRAQ zmm1 {k1}{z}, zmm2, xmm3/m128` + // + // `EVEX.512.66.0F.W1 E2 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsraq_zmm_k1z_zmm_xmmm128 = 2350, + // `PAVGW mm1, mm2/m64` + // + // `NP 0F E3 /r` + // + // `SSE` + // + // `16/32/64-bit` + Pavgw_mm_mmm64 = 2351, + // `PAVGW xmm1, xmm2/m128` + // + // `66 0F E3 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pavgw_xmm_xmmm128 = 2352, + // `VPAVGW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG E3 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpavgw_xmm_xmm_xmmm128 = 2353, + // `VPAVGW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG E3 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpavgw_ymm_ymm_ymmm256 = 2354, + // `VPAVGW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG E3 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpavgw_xmm_k1z_xmm_xmmm128 = 2355, + // `VPAVGW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG E3 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpavgw_ymm_k1z_ymm_ymmm256 = 2356, + // `VPAVGW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG E3 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpavgw_zmm_k1z_zmm_zmmm512 = 2357, + // `PMULHUW mm1, mm2/m64` + // + // `NP 0F E4 /r` + // + // `SSE` + // + // `16/32/64-bit` + Pmulhuw_mm_mmm64 = 2358, + // `PMULHUW xmm1, xmm2/m128` + // + // `66 0F E4 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pmulhuw_xmm_xmmm128 = 2359, + // `VPMULHUW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG E4 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmulhuw_xmm_xmm_xmmm128 = 2360, + // `VPMULHUW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG E4 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmulhuw_ymm_ymm_ymmm256 = 2361, + // `VPMULHUW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG E4 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmulhuw_xmm_k1z_xmm_xmmm128 = 2362, + // `VPMULHUW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG E4 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmulhuw_ymm_k1z_ymm_ymmm256 = 2363, + // `VPMULHUW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG E4 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmulhuw_zmm_k1z_zmm_zmmm512 = 2364, + // `PMULHW mm, mm/m64` + // + // `NP 0F E5 /r` + // + // `MMX` + // + // `16/32/64-bit` + Pmulhw_mm_mmm64 = 2365, + // `PMULHW xmm1, xmm2/m128` + // + // `66 0F E5 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pmulhw_xmm_xmmm128 = 2366, + // `VPMULHW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG E5 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmulhw_xmm_xmm_xmmm128 = 2367, + // `VPMULHW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG E5 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmulhw_ymm_ymm_ymmm256 = 2368, + // `VPMULHW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG E5 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmulhw_xmm_k1z_xmm_xmmm128 = 2369, + // `VPMULHW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG E5 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmulhw_ymm_k1z_ymm_ymmm256 = 2370, + // `VPMULHW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG E5 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmulhw_zmm_k1z_zmm_zmmm512 = 2371, + // `CVTTPD2DQ xmm1, xmm2/m128` + // + // `66 0F E6 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvttpd2dq_xmm_xmmm128 = 2372, + // `VCVTTPD2DQ xmm1, xmm2/m128` + // + // `VEX.128.66.0F.WIG E6 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvttpd2dq_xmm_xmmm128 = 2373, + // `VCVTTPD2DQ xmm1, ymm2/m256` + // + // `VEX.256.66.0F.WIG E6 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvttpd2dq_xmm_ymmm256 = 2374, + // `VCVTTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 E6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttpd2dq_xmm_k1z_xmmm128b64 = 2375, + // `VCVTTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 E6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttpd2dq_xmm_k1z_ymmm256b64 = 2376, + // `VCVTTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae}` + // + // `EVEX.512.66.0F.W1 E6 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvttpd2dq_ymm_k1z_zmmm512b64_sae = 2377, + // `CVTDQ2PD xmm1, xmm2/m64` + // + // `F3 0F E6 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtdq2pd_xmm_xmmm64 = 2378, + // `VCVTDQ2PD xmm1, xmm2/m64` + // + // `VEX.128.F3.0F.WIG E6 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtdq2pd_xmm_xmmm64 = 2379, + // `VCVTDQ2PD ymm1, xmm2/m128` + // + // `VEX.256.F3.0F.WIG E6 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtdq2pd_ymm_xmmm128 = 2380, + // `VCVTDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst` + // + // `EVEX.128.F3.0F.W0 E6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtdq2pd_xmm_k1z_xmmm64b32 = 2381, + // `VCVTDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.256.F3.0F.W0 E6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtdq2pd_ymm_k1z_xmmm128b32 = 2382, + // `VCVTDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{er}` + // + // `EVEX.512.F3.0F.W0 E6 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtdq2pd_zmm_k1z_ymmm256b32_er = 2383, + // `VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.F3.0F.W1 E6 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtqq2pd_xmm_k1z_xmmm128b64 = 2384, + // `VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.F3.0F.W1 E6 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtqq2pd_ymm_k1z_ymmm256b64 = 2385, + // `VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.F3.0F.W1 E6 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vcvtqq2pd_zmm_k1z_zmmm512b64_er = 2386, + // `CVTPD2DQ xmm1, xmm2/m128` + // + // `F2 0F E6 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Cvtpd2dq_xmm_xmmm128 = 2387, + // `VCVTPD2DQ xmm1, xmm2/m128` + // + // `VEX.128.F2.0F.WIG E6 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtpd2dq_xmm_xmmm128 = 2388, + // `VCVTPD2DQ xmm1, ymm2/m256` + // + // `VEX.256.F2.0F.WIG E6 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vcvtpd2dq_xmm_ymmm256 = 2389, + // `VCVTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.F2.0F.W1 E6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtpd2dq_xmm_k1z_xmmm128b64 = 2390, + // `VCVTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.F2.0F.W1 E6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtpd2dq_xmm_k1z_ymmm256b64 = 2391, + // `VCVTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.F2.0F.W1 E6 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtpd2dq_ymm_k1z_zmmm512b64_er = 2392, + // `MOVNTQ m64, mm` + // + // `NP 0F E7 /r` + // + // `SSE` + // + // `16/32/64-bit` + Movntq_m64_mm = 2393, + // `MOVNTDQ m128, xmm1` + // + // `66 0F E7 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Movntdq_m128_xmm = 2394, + // `VMOVNTDQ m128, xmm1` + // + // `VEX.128.66.0F.WIG E7 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovntdq_m128_xmm = 2395, + // `VMOVNTDQ m256, ymm1` + // + // `VEX.256.66.0F.WIG E7 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovntdq_m256_ymm = 2396, + // `VMOVNTDQ m128, xmm1` + // + // `EVEX.128.66.0F.W0 E7 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntdq_m128_xmm = 2397, + // `VMOVNTDQ m256, ymm1` + // + // `EVEX.256.66.0F.W0 E7 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntdq_m256_ymm = 2398, + // `VMOVNTDQ m512, zmm1` + // + // `EVEX.512.66.0F.W0 E7 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntdq_m512_zmm = 2399, + // `PSUBSB mm, mm/m64` + // + // `NP 0F E8 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psubsb_mm_mmm64 = 2400, + // `PSUBSB xmm1, xmm2/m128` + // + // `66 0F E8 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psubsb_xmm_xmmm128 = 2401, + // `VPSUBSB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG E8 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsubsb_xmm_xmm_xmmm128 = 2402, + // `VPSUBSB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG E8 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsubsb_ymm_ymm_ymmm256 = 2403, + // `VPSUBSB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG E8 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubsb_xmm_k1z_xmm_xmmm128 = 2404, + // `VPSUBSB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG E8 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubsb_ymm_k1z_ymm_ymmm256 = 2405, + // `VPSUBSB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG E8 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubsb_zmm_k1z_zmm_zmmm512 = 2406, + // `PSUBSW mm, mm/m64` + // + // `NP 0F E9 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psubsw_mm_mmm64 = 2407, + // `PSUBSW xmm1, xmm2/m128` + // + // `66 0F E9 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psubsw_xmm_xmmm128 = 2408, + // `VPSUBSW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG E9 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsubsw_xmm_xmm_xmmm128 = 2409, + // `VPSUBSW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG E9 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsubsw_ymm_ymm_ymmm256 = 2410, + // `VPSUBSW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG E9 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubsw_xmm_k1z_xmm_xmmm128 = 2411, + // `VPSUBSW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG E9 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubsw_ymm_k1z_ymm_ymmm256 = 2412, + // `VPSUBSW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG E9 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubsw_zmm_k1z_zmm_zmmm512 = 2413, + // `PMINSW mm1, mm2/m64` + // + // `NP 0F EA /r` + // + // `SSE` + // + // `16/32/64-bit` + Pminsw_mm_mmm64 = 2414, + // `PMINSW xmm1, xmm2/m128` + // + // `66 0F EA /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pminsw_xmm_xmmm128 = 2415, + // `VPMINSW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG EA /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpminsw_xmm_xmm_xmmm128 = 2416, + // `VPMINSW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG EA /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpminsw_ymm_ymm_ymmm256 = 2417, + // `VPMINSW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG EA /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminsw_xmm_k1z_xmm_xmmm128 = 2418, + // `VPMINSW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG EA /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminsw_ymm_k1z_ymm_ymmm256 = 2419, + // `VPMINSW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG EA /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminsw_zmm_k1z_zmm_zmmm512 = 2420, + // `POR mm, mm/m64` + // + // `NP 0F EB /r` + // + // `MMX` + // + // `16/32/64-bit` + Por_mm_mmm64 = 2421, + // `POR xmm1, xmm2/m128` + // + // `66 0F EB /r` + // + // `SSE2` + // + // `16/32/64-bit` + Por_xmm_xmmm128 = 2422, + // `VPOR xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG EB /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpor_xmm_xmm_xmmm128 = 2423, + // `VPOR ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG EB /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpor_ymm_ymm_ymmm256 = 2424, + // `VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 EB /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpord_xmm_k1z_xmm_xmmm128b32 = 2425, + // `VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 EB /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpord_ymm_k1z_ymm_ymmm256b32 = 2426, + // `VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F.W0 EB /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpord_zmm_k1z_zmm_zmmm512b32 = 2427, + // `VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 EB /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vporq_xmm_k1z_xmm_xmmm128b64 = 2428, + // `VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 EB /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vporq_ymm_k1z_ymm_ymmm256b64 = 2429, + // `VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 EB /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vporq_zmm_k1z_zmm_zmmm512b64 = 2430, + // `PADDSB mm, mm/m64` + // + // `NP 0F EC /r` + // + // `MMX` + // + // `16/32/64-bit` + Paddsb_mm_mmm64 = 2431, + // `PADDSB xmm1, xmm2/m128` + // + // `66 0F EC /r` + // + // `SSE2` + // + // `16/32/64-bit` + Paddsb_xmm_xmmm128 = 2432, + // `VPADDSB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG EC /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpaddsb_xmm_xmm_xmmm128 = 2433, + // `VPADDSB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG EC /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpaddsb_ymm_ymm_ymmm256 = 2434, + // `VPADDSB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG EC /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddsb_xmm_k1z_xmm_xmmm128 = 2435, + // `VPADDSB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG EC /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddsb_ymm_k1z_ymm_ymmm256 = 2436, + // `VPADDSB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG EC /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddsb_zmm_k1z_zmm_zmmm512 = 2437, + // `PADDSW mm, mm/m64` + // + // `NP 0F ED /r` + // + // `MMX` + // + // `16/32/64-bit` + Paddsw_mm_mmm64 = 2438, + // `PADDSW xmm1, xmm2/m128` + // + // `66 0F ED /r` + // + // `SSE2` + // + // `16/32/64-bit` + Paddsw_xmm_xmmm128 = 2439, + // `VPADDSW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG ED /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpaddsw_xmm_xmm_xmmm128 = 2440, + // `VPADDSW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG ED /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpaddsw_ymm_ymm_ymmm256 = 2441, + // `VPADDSW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG ED /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddsw_xmm_k1z_xmm_xmmm128 = 2442, + // `VPADDSW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG ED /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddsw_ymm_k1z_ymm_ymmm256 = 2443, + // `VPADDSW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG ED /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddsw_zmm_k1z_zmm_zmmm512 = 2444, + // `PMAXSW mm1, mm2/m64` + // + // `NP 0F EE /r` + // + // `SSE` + // + // `16/32/64-bit` + Pmaxsw_mm_mmm64 = 2445, + // `PMAXSW xmm1, xmm2/m128` + // + // `66 0F EE /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pmaxsw_xmm_xmmm128 = 2446, + // `VPMAXSW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG EE /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmaxsw_xmm_xmm_xmmm128 = 2447, + // `VPMAXSW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG EE /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaxsw_ymm_ymm_ymmm256 = 2448, + // `VPMAXSW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG EE /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxsw_xmm_k1z_xmm_xmmm128 = 2449, + // `VPMAXSW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG EE /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxsw_ymm_k1z_ymm_ymmm256 = 2450, + // `VPMAXSW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG EE /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxsw_zmm_k1z_zmm_zmmm512 = 2451, + // `PXOR mm, mm/m64` + // + // `NP 0F EF /r` + // + // `MMX` + // + // `16/32/64-bit` + Pxor_mm_mmm64 = 2452, + // `PXOR xmm1, xmm2/m128` + // + // `66 0F EF /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pxor_xmm_xmmm128 = 2453, + // `VPXOR xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG EF /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpxor_xmm_xmm_xmmm128 = 2454, + // `VPXOR ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG EF /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpxor_ymm_ymm_ymmm256 = 2455, + // `VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 EF /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpxord_xmm_k1z_xmm_xmmm128b32 = 2456, + // `VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 EF /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpxord_ymm_k1z_ymm_ymmm256b32 = 2457, + // `VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F.W0 EF /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpxord_zmm_k1z_zmm_zmmm512b32 = 2458, + // `VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 EF /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpxorq_xmm_k1z_xmm_xmmm128b64 = 2459, + // `VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 EF /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpxorq_ymm_k1z_ymm_ymmm256b64 = 2460, + // `VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 EF /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpxorq_zmm_k1z_zmm_zmmm512b64 = 2461, + // `LDDQU xmm1, m128` + // + // `F2 0F F0 /r` + // + // `SSE3` + // + // `16/32/64-bit` + Lddqu_xmm_m128 = 2462, + // `VLDDQU xmm1, m128` + // + // `VEX.128.F2.0F.WIG F0 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vlddqu_xmm_m128 = 2463, + // `VLDDQU ymm1, m256` + // + // `VEX.256.F2.0F.WIG F0 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vlddqu_ymm_m256 = 2464, + // `PSLLW mm, mm/m64` + // + // `NP 0F F1 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psllw_mm_mmm64 = 2465, + // `PSLLW xmm1, xmm2/m128` + // + // `66 0F F1 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psllw_xmm_xmmm128 = 2466, + // `VPSLLW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG F1 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsllw_xmm_xmm_xmmm128 = 2467, + // `VPSLLW ymm1, ymm2, xmm3/m128` + // + // `VEX.256.66.0F.WIG F1 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsllw_ymm_ymm_xmmm128 = 2468, + // `VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG F1 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsllw_xmm_k1z_xmm_xmmm128 = 2469, + // `VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128` + // + // `EVEX.256.66.0F.WIG F1 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsllw_ymm_k1z_ymm_xmmm128 = 2470, + // `VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128` + // + // `EVEX.512.66.0F.WIG F1 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsllw_zmm_k1z_zmm_xmmm128 = 2471, + // `PSLLD mm, mm/m64` + // + // `NP 0F F2 /r` + // + // `MMX` + // + // `16/32/64-bit` + Pslld_mm_mmm64 = 2472, + // `PSLLD xmm1, xmm2/m128` + // + // `66 0F F2 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pslld_xmm_xmmm128 = 2473, + // `VPSLLD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG F2 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpslld_xmm_xmm_xmmm128 = 2474, + // `VPSLLD ymm1, ymm2, xmm3/m128` + // + // `VEX.256.66.0F.WIG F2 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpslld_ymm_ymm_xmmm128 = 2475, + // `VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.W0 F2 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpslld_xmm_k1z_xmm_xmmm128 = 2476, + // `VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128` + // + // `EVEX.256.66.0F.W0 F2 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpslld_ymm_k1z_ymm_xmmm128 = 2477, + // `VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128` + // + // `EVEX.512.66.0F.W0 F2 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpslld_zmm_k1z_zmm_xmmm128 = 2478, + // `PSLLQ mm, mm/m64` + // + // `NP 0F F3 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psllq_mm_mmm64 = 2479, + // `PSLLQ xmm1, xmm2/m128` + // + // `66 0F F3 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psllq_xmm_xmmm128 = 2480, + // `VPSLLQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG F3 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsllq_xmm_xmm_xmmm128 = 2481, + // `VPSLLQ ymm1, ymm2, xmm3/m128` + // + // `VEX.256.66.0F.WIG F3 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsllq_ymm_ymm_xmmm128 = 2482, + // `VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.W1 F3 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllq_xmm_k1z_xmm_xmmm128 = 2483, + // `VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128` + // + // `EVEX.256.66.0F.W1 F3 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllq_ymm_k1z_ymm_xmmm128 = 2484, + // `VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128` + // + // `EVEX.512.66.0F.W1 F3 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllq_zmm_k1z_zmm_xmmm128 = 2485, + // `PMULUDQ mm1, mm2/m64` + // + // `NP 0F F4 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pmuludq_mm_mmm64 = 2486, + // `PMULUDQ xmm1, xmm2/m128` + // + // `66 0F F4 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pmuludq_xmm_xmmm128 = 2487, + // `VPMULUDQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG F4 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmuludq_xmm_xmm_xmmm128 = 2488, + // `VPMULUDQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG F4 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmuludq_ymm_ymm_ymmm256 = 2489, + // `VPMULUDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 F4 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmuludq_xmm_k1z_xmm_xmmm128b64 = 2490, + // `VPMULUDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 F4 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmuludq_ymm_k1z_ymm_ymmm256b64 = 2491, + // `VPMULUDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 F4 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmuludq_zmm_k1z_zmm_zmmm512b64 = 2492, + // `PMADDWD mm, mm/m64` + // + // `NP 0F F5 /r` + // + // `MMX` + // + // `16/32/64-bit` + Pmaddwd_mm_mmm64 = 2493, + // `PMADDWD xmm1, xmm2/m128` + // + // `66 0F F5 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Pmaddwd_xmm_xmmm128 = 2494, + // `VPMADDWD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG F5 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmaddwd_xmm_xmm_xmmm128 = 2495, + // `VPMADDWD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG F5 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaddwd_ymm_ymm_ymmm256 = 2496, + // `VPMADDWD xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG F5 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaddwd_xmm_k1z_xmm_xmmm128 = 2497, + // `VPMADDWD ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG F5 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaddwd_ymm_k1z_ymm_ymmm256 = 2498, + // `VPMADDWD zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG F5 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaddwd_zmm_k1z_zmm_zmmm512 = 2499, + // `PSADBW mm1, mm2/m64` + // + // `NP 0F F6 /r` + // + // `SSE` + // + // `16/32/64-bit` + Psadbw_mm_mmm64 = 2500, + // `PSADBW xmm1, xmm2/m128` + // + // `66 0F F6 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psadbw_xmm_xmmm128 = 2501, + // `VPSADBW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG F6 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsadbw_xmm_xmm_xmmm128 = 2502, + // `VPSADBW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG F6 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsadbw_ymm_ymm_ymmm256 = 2503, + // `VPSADBW xmm1, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG F6 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsadbw_xmm_xmm_xmmm128 = 2504, + // `VPSADBW ymm1, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG F6 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsadbw_ymm_ymm_ymmm256 = 2505, + // `VPSADBW zmm1, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG F6 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsadbw_zmm_zmm_zmmm512 = 2506, + // `MASKMOVQ mm1, mm2` + // + // `NP 0F F7 /r` + // + // `SSE` + // + // `16/32/64-bit` + Maskmovq_rDI_mm_mm = 2507, + // `MASKMOVDQU xmm1, xmm2` + // + // `66 0F F7 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Maskmovdqu_rDI_xmm_xmm = 2508, + // `VMASKMOVDQU xmm1, xmm2` + // + // `VEX.128.66.0F.WIG F7 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaskmovdqu_rDI_xmm_xmm = 2509, + // `PSUBB mm, mm/m64` + // + // `NP 0F F8 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psubb_mm_mmm64 = 2510, + // `PSUBB xmm1, xmm2/m128` + // + // `66 0F F8 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psubb_xmm_xmmm128 = 2511, + // `VPSUBB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG F8 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsubb_xmm_xmm_xmmm128 = 2512, + // `VPSUBB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG F8 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsubb_ymm_ymm_ymmm256 = 2513, + // `VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG F8 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubb_xmm_k1z_xmm_xmmm128 = 2514, + // `VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG F8 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubb_ymm_k1z_ymm_ymmm256 = 2515, + // `VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG F8 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubb_zmm_k1z_zmm_zmmm512 = 2516, + // `PSUBW mm, mm/m64` + // + // `NP 0F F9 /r` + // + // `MMX` + // + // `16/32/64-bit` + Psubw_mm_mmm64 = 2517, + // `PSUBW xmm1, xmm2/m128` + // + // `66 0F F9 /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psubw_xmm_xmmm128 = 2518, + // `VPSUBW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG F9 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsubw_xmm_xmm_xmmm128 = 2519, + // `VPSUBW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG F9 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsubw_ymm_ymm_ymmm256 = 2520, + // `VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG F9 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubw_xmm_k1z_xmm_xmmm128 = 2521, + // `VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG F9 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubw_ymm_k1z_ymm_ymmm256 = 2522, + // `VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG F9 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsubw_zmm_k1z_zmm_zmmm512 = 2523, + // `PSUBD mm, mm/m64` + // + // `NP 0F FA /r` + // + // `MMX` + // + // `16/32/64-bit` + Psubd_mm_mmm64 = 2524, + // `PSUBD xmm1, xmm2/m128` + // + // `66 0F FA /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psubd_xmm_xmmm128 = 2525, + // `VPSUBD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG FA /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsubd_xmm_xmm_xmmm128 = 2526, + // `VPSUBD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG FA /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsubd_ymm_ymm_ymmm256 = 2527, + // `VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 FA /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsubd_xmm_k1z_xmm_xmmm128b32 = 2528, + // `VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 FA /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsubd_ymm_k1z_ymm_ymmm256b32 = 2529, + // `VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F.W0 FA /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsubd_zmm_k1z_zmm_zmmm512b32 = 2530, + // `PSUBQ mm1, mm2/m64` + // + // `NP 0F FB /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psubq_mm_mmm64 = 2531, + // `PSUBQ xmm1, xmm2/m128` + // + // `66 0F FB /r` + // + // `SSE2` + // + // `16/32/64-bit` + Psubq_xmm_xmmm128 = 2532, + // `VPSUBQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG FB /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsubq_xmm_xmm_xmmm128 = 2533, + // `VPSUBQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG FB /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsubq_ymm_ymm_ymmm256 = 2534, + // `VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F.W1 FB /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsubq_xmm_k1z_xmm_xmmm128b64 = 2535, + // `VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F.W1 FB /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsubq_ymm_k1z_ymm_ymmm256b64 = 2536, + // `VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F.W1 FB /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsubq_zmm_k1z_zmm_zmmm512b64 = 2537, + // `PADDB mm, mm/m64` + // + // `NP 0F FC /r` + // + // `MMX` + // + // `16/32/64-bit` + Paddb_mm_mmm64 = 2538, + // `PADDB xmm1, xmm2/m128` + // + // `66 0F FC /r` + // + // `SSE2` + // + // `16/32/64-bit` + Paddb_xmm_xmmm128 = 2539, + // `VPADDB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG FC /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpaddb_xmm_xmm_xmmm128 = 2540, + // `VPADDB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG FC /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpaddb_ymm_ymm_ymmm256 = 2541, + // `VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG FC /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddb_xmm_k1z_xmm_xmmm128 = 2542, + // `VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG FC /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddb_ymm_k1z_ymm_ymmm256 = 2543, + // `VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG FC /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddb_zmm_k1z_zmm_zmmm512 = 2544, + // `PADDW mm, mm/m64` + // + // `NP 0F FD /r` + // + // `MMX` + // + // `16/32/64-bit` + Paddw_mm_mmm64 = 2545, + // `PADDW xmm1, xmm2/m128` + // + // `66 0F FD /r` + // + // `SSE2` + // + // `16/32/64-bit` + Paddw_xmm_xmmm128 = 2546, + // `VPADDW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG FD /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpaddw_xmm_xmm_xmmm128 = 2547, + // `VPADDW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG FD /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpaddw_ymm_ymm_ymmm256 = 2548, + // `VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F.WIG FD /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddw_xmm_k1z_xmm_xmmm128 = 2549, + // `VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F.WIG FD /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddw_ymm_k1z_ymm_ymmm256 = 2550, + // `VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F.WIG FD /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpaddw_zmm_k1z_zmm_zmmm512 = 2551, + // `PADDD mm, mm/m64` + // + // `NP 0F FE /r` + // + // `MMX` + // + // `16/32/64-bit` + Paddd_mm_mmm64 = 2552, + // `PADDD xmm1, xmm2/m128` + // + // `66 0F FE /r` + // + // `SSE2` + // + // `16/32/64-bit` + Paddd_xmm_xmmm128 = 2553, + // `VPADDD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F.WIG FE /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpaddd_xmm_xmm_xmmm128 = 2554, + // `VPADDD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F.WIG FE /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpaddd_ymm_ymm_ymmm256 = 2555, + // `VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F.W0 FE /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpaddd_xmm_k1z_xmm_xmmm128b32 = 2556, + // `VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F.W0 FE /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpaddd_ymm_k1z_ymm_ymmm256b32 = 2557, + // `VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F.W0 FE /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpaddd_zmm_k1z_zmm_zmmm512b32 = 2558, + // `UD0 r16, r/m16` + // + // `o16 0F FF /r` + // + // `286+` + // + // `16/32/64-bit` + Ud0_r16_rm16 = 2559, + // `UD0 r32, r/m32` + // + // `o32 0F FF /r` + // + // `386+` + // + // `16/32/64-bit` + Ud0_r32_rm32 = 2560, + // `UD0 r64, r/m64` + // + // `o64 0F FF /r` + // + // `X64` + // + // `64-bit` + Ud0_r64_rm64 = 2561, + // `PSHUFB mm1, mm2/m64` + // + // `NP 0F 38 00 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pshufb_mm_mmm64 = 2562, + // `PSHUFB xmm1, xmm2/m128` + // + // `66 0F 38 00 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pshufb_xmm_xmmm128 = 2563, + // `VPSHUFB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 00 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpshufb_xmm_xmm_xmmm128 = 2564, + // `VPSHUFB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 00 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpshufb_ymm_ymm_ymmm256 = 2565, + // `VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.WIG 00 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpshufb_xmm_k1z_xmm_xmmm128 = 2566, + // `VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.WIG 00 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpshufb_ymm_k1z_ymm_ymmm256 = 2567, + // `VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.WIG 00 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpshufb_zmm_k1z_zmm_zmmm512 = 2568, + // `PHADDW mm1, mm2/m64` + // + // `NP 0F 38 01 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phaddw_mm_mmm64 = 2569, + // `PHADDW xmm1, xmm2/m128` + // + // `66 0F 38 01 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phaddw_xmm_xmmm128 = 2570, + // `VPHADDW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 01 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vphaddw_xmm_xmm_xmmm128 = 2571, + // `VPHADDW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 01 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vphaddw_ymm_ymm_ymmm256 = 2572, + // `PHADDD mm1, mm2/m64` + // + // `NP 0F 38 02 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phaddd_mm_mmm64 = 2573, + // `PHADDD xmm1, xmm2/m128` + // + // `66 0F 38 02 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phaddd_xmm_xmmm128 = 2574, + // `VPHADDD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 02 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vphaddd_xmm_xmm_xmmm128 = 2575, + // `VPHADDD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 02 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vphaddd_ymm_ymm_ymmm256 = 2576, + // `PHADDSW mm1, mm2/m64` + // + // `NP 0F 38 03 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phaddsw_mm_mmm64 = 2577, + // `PHADDSW xmm1, xmm2/m128` + // + // `66 0F 38 03 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phaddsw_xmm_xmmm128 = 2578, + // `VPHADDSW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 03 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vphaddsw_xmm_xmm_xmmm128 = 2579, + // `VPHADDSW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 03 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vphaddsw_ymm_ymm_ymmm256 = 2580, + // `PMADDUBSW mm1, mm2/m64` + // + // `NP 0F 38 04 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pmaddubsw_mm_mmm64 = 2581, + // `PMADDUBSW xmm1, xmm2/m128` + // + // `66 0F 38 04 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pmaddubsw_xmm_xmmm128 = 2582, + // `VPMADDUBSW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 04 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmaddubsw_xmm_xmm_xmmm128 = 2583, + // `VPMADDUBSW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 04 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaddubsw_ymm_ymm_ymmm256 = 2584, + // `VPMADDUBSW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.WIG 04 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaddubsw_xmm_k1z_xmm_xmmm128 = 2585, + // `VPMADDUBSW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.WIG 04 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaddubsw_ymm_k1z_ymm_ymmm256 = 2586, + // `VPMADDUBSW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.WIG 04 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaddubsw_zmm_k1z_zmm_zmmm512 = 2587, + // `PHSUBW mm1, mm2/m64` + // + // `NP 0F 38 05 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phsubw_mm_mmm64 = 2588, + // `PHSUBW xmm1, xmm2/m128` + // + // `66 0F 38 05 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phsubw_xmm_xmmm128 = 2589, + // `VPHSUBW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 05 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vphsubw_xmm_xmm_xmmm128 = 2590, + // `VPHSUBW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 05 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vphsubw_ymm_ymm_ymmm256 = 2591, + // `PHSUBD mm1, mm2/m64` + // + // `NP 0F 38 06 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phsubd_mm_mmm64 = 2592, + // `PHSUBD xmm1, xmm2/m128` + // + // `66 0F 38 06 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phsubd_xmm_xmmm128 = 2593, + // `VPHSUBD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 06 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vphsubd_xmm_xmm_xmmm128 = 2594, + // `VPHSUBD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 06 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vphsubd_ymm_ymm_ymmm256 = 2595, + // `PHSUBSW mm1, mm2/m64` + // + // `NP 0F 38 07 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phsubsw_mm_mmm64 = 2596, + // `PHSUBSW xmm1, xmm2/m128` + // + // `66 0F 38 07 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Phsubsw_xmm_xmmm128 = 2597, + // `VPHSUBSW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 07 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vphsubsw_xmm_xmm_xmmm128 = 2598, + // `VPHSUBSW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 07 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vphsubsw_ymm_ymm_ymmm256 = 2599, + // `PSIGNB mm1, mm2/m64` + // + // `NP 0F 38 08 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Psignb_mm_mmm64 = 2600, + // `PSIGNB xmm1, xmm2/m128` + // + // `66 0F 38 08 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Psignb_xmm_xmmm128 = 2601, + // `VPSIGNB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 08 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsignb_xmm_xmm_xmmm128 = 2602, + // `VPSIGNB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 08 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsignb_ymm_ymm_ymmm256 = 2603, + // `PSIGNW mm1, mm2/m64` + // + // `NP 0F 38 09 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Psignw_mm_mmm64 = 2604, + // `PSIGNW xmm1, xmm2/m128` + // + // `66 0F 38 09 /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Psignw_xmm_xmmm128 = 2605, + // `VPSIGNW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 09 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsignw_xmm_xmm_xmmm128 = 2606, + // `VPSIGNW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 09 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsignw_ymm_ymm_ymmm256 = 2607, + // `PSIGND mm1, mm2/m64` + // + // `NP 0F 38 0A /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Psignd_mm_mmm64 = 2608, + // `PSIGND xmm1, xmm2/m128` + // + // `66 0F 38 0A /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Psignd_xmm_xmmm128 = 2609, + // `VPSIGND xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 0A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpsignd_xmm_xmm_xmmm128 = 2610, + // `VPSIGND ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 0A /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsignd_ymm_ymm_ymmm256 = 2611, + // `PMULHRSW mm1, mm2/m64` + // + // `NP 0F 38 0B /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pmulhrsw_mm_mmm64 = 2612, + // `PMULHRSW xmm1, xmm2/m128` + // + // `66 0F 38 0B /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pmulhrsw_xmm_xmmm128 = 2613, + // `VPMULHRSW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 0B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmulhrsw_xmm_xmm_xmmm128 = 2614, + // `VPMULHRSW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 0B /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmulhrsw_ymm_ymm_ymmm256 = 2615, + // `VPMULHRSW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.WIG 0B /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmulhrsw_xmm_k1z_xmm_xmmm128 = 2616, + // `VPMULHRSW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.WIG 0B /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmulhrsw_ymm_k1z_ymm_ymmm256 = 2617, + // `VPMULHRSW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.WIG 0B /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmulhrsw_zmm_k1z_zmm_zmmm512 = 2618, + // `VPERMILPS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 0C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpermilps_xmm_xmm_xmmm128 = 2619, + // `VPERMILPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 0C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpermilps_ymm_ymm_ymmm256 = 2620, + // `VPERMILPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 0C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilps_xmm_k1z_xmm_xmmm128b32 = 2621, + // `VPERMILPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 0C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilps_ymm_k1z_ymm_ymmm256b32 = 2622, + // `VPERMILPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 0C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilps_zmm_k1z_zmm_zmmm512b32 = 2623, + // `VPERMILPD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 0D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpermilpd_xmm_xmm_xmmm128 = 2624, + // `VPERMILPD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 0D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpermilpd_ymm_ymm_ymmm256 = 2625, + // `VPERMILPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 0D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilpd_xmm_k1z_xmm_xmmm128b64 = 2626, + // `VPERMILPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 0D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilpd_ymm_k1z_ymm_ymmm256b64 = 2627, + // `VPERMILPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 0D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilpd_zmm_k1z_zmm_zmmm512b64 = 2628, + // `VTESTPS xmm1, xmm2/m128` + // + // `VEX.128.66.0F38.W0 0E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vtestps_xmm_xmmm128 = 2629, + // `VTESTPS ymm1, ymm2/m256` + // + // `VEX.256.66.0F38.W0 0E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vtestps_ymm_ymmm256 = 2630, + // `VTESTPD xmm1, xmm2/m128` + // + // `VEX.128.66.0F38.W0 0F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vtestpd_xmm_xmmm128 = 2631, + // `VTESTPD ymm1, ymm2/m256` + // + // `VEX.256.66.0F38.W0 0F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vtestpd_ymm_ymmm256 = 2632, + // `PBLENDVB xmm1, xmm2/m128, ` + // + // `66 0F 38 10 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pblendvb_xmm_xmmm128 = 2633, + // `VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W1 10 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrlvw_xmm_k1z_xmm_xmmm128 = 2634, + // `VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W1 10 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrlvw_ymm_k1z_ymm_ymmm256 = 2635, + // `VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W1 10 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsrlvw_zmm_k1z_zmm_zmmm512 = 2636, + // `VPMOVUSWB xmm1/m64 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 10 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovuswb_xmmm64_k1z_xmm = 2637, + // `VPMOVUSWB xmm1/m128 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 10 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovuswb_xmmm128_k1z_ymm = 2638, + // `VPMOVUSWB ymm1/m256 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 10 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovuswb_ymmm256_k1z_zmm = 2639, + // `VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W1 11 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsravw_xmm_k1z_xmm_xmmm128 = 2640, + // `VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W1 11 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsravw_ymm_k1z_ymm_ymmm256 = 2641, + // `VPSRAVW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W1 11 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsravw_zmm_k1z_zmm_zmmm512 = 2642, + // `VPMOVUSDB xmm1/m32 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 11 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusdb_xmmm32_k1z_xmm = 2643, + // `VPMOVUSDB xmm1/m64 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 11 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusdb_xmmm64_k1z_ymm = 2644, + // `VPMOVUSDB xmm1/m128 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 11 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusdb_xmmm128_k1z_zmm = 2645, + // `VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W1 12 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsllvw_xmm_k1z_xmm_xmmm128 = 2646, + // `VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W1 12 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsllvw_ymm_k1z_ymm_ymmm256 = 2647, + // `VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W1 12 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpsllvw_zmm_k1z_zmm_zmmm512 = 2648, + // `VPMOVUSQB xmm1/m16 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 12 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusqb_xmmm16_k1z_xmm = 2649, + // `VPMOVUSQB xmm1/m32 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 12 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusqb_xmmm32_k1z_ymm = 2650, + // `VPMOVUSQB xmm1/m64 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 12 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusqb_xmmm64_k1z_zmm = 2651, + // `VCVTPH2PS xmm1, xmm2/m64` + // + // `VEX.128.66.0F38.W0 13 /r` + // + // `F16C` + // + // `16/32/64-bit` + VEX_Vcvtph2ps_xmm_xmmm64 = 2652, + // `VCVTPH2PS ymm1, xmm2/m128` + // + // `VEX.256.66.0F38.W0 13 /r` + // + // `F16C` + // + // `16/32/64-bit` + VEX_Vcvtph2ps_ymm_xmmm128 = 2653, + // `VCVTPH2PS xmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.128.66.0F38.W0 13 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtph2ps_xmm_k1z_xmmm64 = 2654, + // `VCVTPH2PS ymm1 {k1}{z}, xmm2/m128` + // + // `EVEX.256.66.0F38.W0 13 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtph2ps_ymm_k1z_xmmm128 = 2655, + // `VCVTPH2PS zmm1 {k1}{z}, ymm2/m256{sae}` + // + // `EVEX.512.66.0F38.W0 13 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtph2ps_zmm_k1z_ymmm256_sae = 2656, + // `VPMOVUSDW xmm1/m64 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 13 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusdw_xmmm64_k1z_xmm = 2657, + // `VPMOVUSDW xmm1/m128 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 13 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusdw_xmmm128_k1z_ymm = 2658, + // `VPMOVUSDW ymm1/m256 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 13 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusdw_ymmm256_k1z_zmm = 2659, + // `BLENDVPS xmm1, xmm2/m128, ` + // + // `66 0F 38 14 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Blendvps_xmm_xmmm128 = 2660, + // `VPRORVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 14 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprorvd_xmm_k1z_xmm_xmmm128b32 = 2661, + // `VPRORVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 14 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprorvd_ymm_k1z_ymm_ymmm256b32 = 2662, + // `VPRORVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 14 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vprorvd_zmm_k1z_zmm_zmmm512b32 = 2663, + // `VPRORVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 14 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprorvq_xmm_k1z_xmm_xmmm128b64 = 2664, + // `VPRORVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 14 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprorvq_ymm_k1z_ymm_ymmm256b64 = 2665, + // `VPRORVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 14 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vprorvq_zmm_k1z_zmm_zmmm512b64 = 2666, + // `VPMOVUSQW xmm1/m32 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 14 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusqw_xmmm32_k1z_xmm = 2667, + // `VPMOVUSQW xmm1/m64 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 14 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusqw_xmmm64_k1z_ymm = 2668, + // `VPMOVUSQW xmm1/m128 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 14 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusqw_xmmm128_k1z_zmm = 2669, + // `BLENDVPD xmm1, xmm2/m128, ` + // + // `66 0F 38 15 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Blendvpd_xmm_xmmm128 = 2670, + // `VPROLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 15 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprolvd_xmm_k1z_xmm_xmmm128b32 = 2671, + // `VPROLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 15 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprolvd_ymm_k1z_ymm_ymmm256b32 = 2672, + // `VPROLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 15 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vprolvd_zmm_k1z_zmm_zmmm512b32 = 2673, + // `VPROLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 15 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprolvq_xmm_k1z_xmm_xmmm128b64 = 2674, + // `VPROLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 15 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vprolvq_ymm_k1z_ymm_ymmm256b64 = 2675, + // `VPROLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 15 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vprolvq_zmm_k1z_zmm_zmmm512b64 = 2676, + // `VPMOVUSQD xmm1/m64 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 15 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusqd_xmmm64_k1z_xmm = 2677, + // `VPMOVUSQD xmm1/m128 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 15 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusqd_xmmm128_k1z_ymm = 2678, + // `VPMOVUSQD ymm1/m256 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 15 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovusqd_ymmm256_k1z_zmm = 2679, + // `VPERMPS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 16 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpermps_ymm_ymm_ymmm256 = 2680, + // `VPERMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 16 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermps_ymm_k1z_ymm_ymmm256b32 = 2681, + // `VPERMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 16 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermps_zmm_k1z_zmm_zmmm512b32 = 2682, + // `VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 16 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermpd_ymm_k1z_ymm_ymmm256b64 = 2683, + // `VPERMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 16 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermpd_zmm_k1z_zmm_zmmm512b64 = 2684, + // `PTEST xmm1, xmm2/m128` + // + // `66 0F 38 17 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Ptest_xmm_xmmm128 = 2685, + // `VPTEST xmm1, xmm2/m128` + // + // `VEX.128.66.0F38.WIG 17 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vptest_xmm_xmmm128 = 2686, + // `VPTEST ymm1, ymm2/m256` + // + // `VEX.256.66.0F38.WIG 17 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vptest_ymm_ymmm256 = 2687, + // `VBROADCASTSS xmm1, m32` + // + // `VEX.128.66.0F38.W0 18 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vbroadcastss_xmm_m32 = 2688, + // `VBROADCASTSS ymm1, m32` + // + // `VEX.256.66.0F38.W0 18 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vbroadcastss_ymm_m32 = 2689, + // `VBROADCASTSS xmm1 {k1}{z}, xmm2/m32` + // + // `EVEX.128.66.0F38.W0 18 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vbroadcastss_xmm_k1z_xmmm32 = 2690, + // `VBROADCASTSS ymm1 {k1}{z}, xmm2/m32` + // + // `EVEX.256.66.0F38.W0 18 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vbroadcastss_ymm_k1z_xmmm32 = 2691, + // `VBROADCASTSS zmm1 {k1}{z}, xmm2/m32` + // + // `EVEX.512.66.0F38.W0 18 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vbroadcastss_zmm_k1z_xmmm32 = 2692, + // `VBROADCASTSD ymm1, m64` + // + // `VEX.256.66.0F38.W0 19 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vbroadcastsd_ymm_m64 = 2693, + // `VBROADCASTF32X2 ymm1 {k1}{z}, xmm2/m64` + // + // `EVEX.256.66.0F38.W0 19 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vbroadcastf32x2_ymm_k1z_xmmm64 = 2694, + // `VBROADCASTF32X2 zmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.512.66.0F38.W0 19 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vbroadcastf32x2_zmm_k1z_xmmm64 = 2695, + // `VBROADCASTSD ymm1 {k1}{z}, xmm2/m64` + // + // `EVEX.256.66.0F38.W1 19 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vbroadcastsd_ymm_k1z_xmmm64 = 2696, + // `VBROADCASTSD zmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.512.66.0F38.W1 19 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vbroadcastsd_zmm_k1z_xmmm64 = 2697, + // `VBROADCASTF128 ymm1, m128` + // + // `VEX.256.66.0F38.W0 1A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vbroadcastf128_ymm_m128 = 2698, + // `VBROADCASTF32X4 ymm1 {k1}{z}, m128` + // + // `EVEX.256.66.0F38.W0 1A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vbroadcastf32x4_ymm_k1z_m128 = 2699, + // `VBROADCASTF32X4 zmm1 {k1}{z}, m128` + // + // `EVEX.512.66.0F38.W0 1A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vbroadcastf32x4_zmm_k1z_m128 = 2700, + // `VBROADCASTF64X2 ymm1 {k1}{z}, m128` + // + // `EVEX.256.66.0F38.W1 1A /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vbroadcastf64x2_ymm_k1z_m128 = 2701, + // `VBROADCASTF64X2 zmm1 {k1}{z}, m128` + // + // `EVEX.512.66.0F38.W1 1A /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vbroadcastf64x2_zmm_k1z_m128 = 2702, + // `VBROADCASTF32X8 zmm1 {k1}{z}, m256` + // + // `EVEX.512.66.0F38.W0 1B /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vbroadcastf32x8_zmm_k1z_m256 = 2703, + // `VBROADCASTF64X4 zmm1 {k1}{z}, m256` + // + // `EVEX.512.66.0F38.W1 1B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vbroadcastf64x4_zmm_k1z_m256 = 2704, + // `PABSB mm1, mm2/m64` + // + // `NP 0F 38 1C /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pabsb_mm_mmm64 = 2705, + // `PABSB xmm1, xmm2/m128` + // + // `66 0F 38 1C /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pabsb_xmm_xmmm128 = 2706, + // `VPABSB xmm1, xmm2/m128` + // + // `VEX.128.66.0F38.WIG 1C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpabsb_xmm_xmmm128 = 2707, + // `VPABSB ymm1, ymm2/m256` + // + // `VEX.256.66.0F38.WIG 1C /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpabsb_ymm_ymmm256 = 2708, + // `VPABSB xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F38.WIG 1C /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpabsb_xmm_k1z_xmmm128 = 2709, + // `VPABSB ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F38.WIG 1C /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpabsb_ymm_k1z_ymmm256 = 2710, + // `VPABSB zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F38.WIG 1C /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpabsb_zmm_k1z_zmmm512 = 2711, + // `PABSW mm1, mm2/m64` + // + // `NP 0F 38 1D /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pabsw_mm_mmm64 = 2712, + // `PABSW xmm1, xmm2/m128` + // + // `66 0F 38 1D /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pabsw_xmm_xmmm128 = 2713, + // `VPABSW xmm1, xmm2/m128` + // + // `VEX.128.66.0F38.WIG 1D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpabsw_xmm_xmmm128 = 2714, + // `VPABSW ymm1, ymm2/m256` + // + // `VEX.256.66.0F38.WIG 1D /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpabsw_ymm_ymmm256 = 2715, + // `VPABSW xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F38.WIG 1D /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpabsw_xmm_k1z_xmmm128 = 2716, + // `VPABSW ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F38.WIG 1D /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpabsw_ymm_k1z_ymmm256 = 2717, + // `VPABSW zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F38.WIG 1D /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpabsw_zmm_k1z_zmmm512 = 2718, + // `PABSD mm1, mm2/m64` + // + // `NP 0F 38 1E /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pabsd_mm_mmm64 = 2719, + // `PABSD xmm1, xmm2/m128` + // + // `66 0F 38 1E /r` + // + // `SSSE3` + // + // `16/32/64-bit` + Pabsd_xmm_xmmm128 = 2720, + // `VPABSD xmm1, xmm2/m128` + // + // `VEX.128.66.0F38.WIG 1E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpabsd_xmm_xmmm128 = 2721, + // `VPABSD ymm1, ymm2/m256` + // + // `VEX.256.66.0F38.WIG 1E /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpabsd_ymm_ymmm256 = 2722, + // `VPABSD xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 1E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpabsd_xmm_k1z_xmmm128b32 = 2723, + // `VPABSD ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 1E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpabsd_ymm_k1z_ymmm256b32 = 2724, + // `VPABSD zmm1 {k1}{z}, zmm2/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 1E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpabsd_zmm_k1z_zmmm512b32 = 2725, + // `VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 1F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpabsq_xmm_k1z_xmmm128b64 = 2726, + // `VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 1F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpabsq_ymm_k1z_ymmm256b64 = 2727, + // `VPABSQ zmm1 {k1}{z}, zmm2/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 1F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpabsq_zmm_k1z_zmmm512b64 = 2728, + // `PMOVSXBW xmm1, xmm2/m64` + // + // `66 0F 38 20 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovsxbw_xmm_xmmm64 = 2729, + // `VPMOVSXBW xmm1, xmm2/m64` + // + // `VEX.128.66.0F38.WIG 20 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovsxbw_xmm_xmmm64 = 2730, + // `VPMOVSXBW ymm1, xmm2/m128` + // + // `VEX.256.66.0F38.WIG 20 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovsxbw_ymm_xmmm128 = 2731, + // `VPMOVSXBW xmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.128.66.0F38.WIG 20 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovsxbw_xmm_k1z_xmmm64 = 2732, + // `VPMOVSXBW ymm1 {k1}{z}, xmm2/m128` + // + // `EVEX.256.66.0F38.WIG 20 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovsxbw_ymm_k1z_xmmm128 = 2733, + // `VPMOVSXBW zmm1 {k1}{z}, ymm2/m256` + // + // `EVEX.512.66.0F38.WIG 20 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovsxbw_zmm_k1z_ymmm256 = 2734, + // `VPMOVSWB xmm1/m64 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 20 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovswb_xmmm64_k1z_xmm = 2735, + // `VPMOVSWB xmm1/m128 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 20 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovswb_xmmm128_k1z_ymm = 2736, + // `VPMOVSWB ymm1/m256 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 20 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovswb_ymmm256_k1z_zmm = 2737, + // `PMOVSXBD xmm1, xmm2/m32` + // + // `66 0F 38 21 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovsxbd_xmm_xmmm32 = 2738, + // `VPMOVSXBD xmm1, xmm2/m32` + // + // `VEX.128.66.0F38.WIG 21 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovsxbd_xmm_xmmm32 = 2739, + // `VPMOVSXBD ymm1, xmm2/m64` + // + // `VEX.256.66.0F38.WIG 21 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovsxbd_ymm_xmmm64 = 2740, + // `VPMOVSXBD xmm1 {k1}{z}, xmm2/m32` + // + // `EVEX.128.66.0F38.WIG 21 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxbd_xmm_k1z_xmmm32 = 2741, + // `VPMOVSXBD ymm1 {k1}{z}, xmm2/m64` + // + // `EVEX.256.66.0F38.WIG 21 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxbd_ymm_k1z_xmmm64 = 2742, + // `VPMOVSXBD zmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.512.66.0F38.WIG 21 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxbd_zmm_k1z_xmmm128 = 2743, + // `VPMOVSDB xmm1/m32 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 21 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsdb_xmmm32_k1z_xmm = 2744, + // `VPMOVSDB xmm1/m64 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 21 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsdb_xmmm64_k1z_ymm = 2745, + // `VPMOVSDB xmm1/m128 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 21 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsdb_xmmm128_k1z_zmm = 2746, + // `PMOVSXBQ xmm1, xmm2/m16` + // + // `66 0F 38 22 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovsxbq_xmm_xmmm16 = 2747, + // `VPMOVSXBQ xmm1, xmm2/m16` + // + // `VEX.128.66.0F38.WIG 22 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovsxbq_xmm_xmmm16 = 2748, + // `VPMOVSXBQ ymm1, xmm2/m32` + // + // `VEX.256.66.0F38.WIG 22 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovsxbq_ymm_xmmm32 = 2749, + // `VPMOVSXBQ xmm1 {k1}{z}, xmm2/m16` + // + // `EVEX.128.66.0F38.WIG 22 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxbq_xmm_k1z_xmmm16 = 2750, + // `VPMOVSXBQ ymm1 {k1}{z}, xmm2/m32` + // + // `EVEX.256.66.0F38.WIG 22 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxbq_ymm_k1z_xmmm32 = 2751, + // `VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.512.66.0F38.WIG 22 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxbq_zmm_k1z_xmmm64 = 2752, + // `VPMOVSQB xmm1/m16 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 22 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsqb_xmmm16_k1z_xmm = 2753, + // `VPMOVSQB xmm1/m32 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 22 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsqb_xmmm32_k1z_ymm = 2754, + // `VPMOVSQB xmm1/m64 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 22 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsqb_xmmm64_k1z_zmm = 2755, + // `PMOVSXWD xmm1, xmm2/m64` + // + // `66 0F 38 23 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovsxwd_xmm_xmmm64 = 2756, + // `VPMOVSXWD xmm1, xmm2/m64` + // + // `VEX.128.66.0F38.WIG 23 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovsxwd_xmm_xmmm64 = 2757, + // `VPMOVSXWD ymm1, xmm2/m128` + // + // `VEX.256.66.0F38.WIG 23 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovsxwd_ymm_xmmm128 = 2758, + // `VPMOVSXWD xmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.128.66.0F38.WIG 23 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxwd_xmm_k1z_xmmm64 = 2759, + // `VPMOVSXWD ymm1 {k1}{z}, xmm2/m128` + // + // `EVEX.256.66.0F38.WIG 23 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxwd_ymm_k1z_xmmm128 = 2760, + // `VPMOVSXWD zmm1 {k1}{z}, ymm2/m256` + // + // `EVEX.512.66.0F38.WIG 23 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxwd_zmm_k1z_ymmm256 = 2761, + // `VPMOVSDW xmm1/m64 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 23 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsdw_xmmm64_k1z_xmm = 2762, + // `VPMOVSDW xmm1/m128 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 23 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsdw_xmmm128_k1z_ymm = 2763, + // `VPMOVSDW ymm1/m256 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 23 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsdw_ymmm256_k1z_zmm = 2764, + // `PMOVSXWQ xmm1, xmm2/m32` + // + // `66 0F 38 24 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovsxwq_xmm_xmmm32 = 2765, + // `VPMOVSXWQ xmm1, xmm2/m32` + // + // `VEX.128.66.0F38.WIG 24 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovsxwq_xmm_xmmm32 = 2766, + // `VPMOVSXWQ ymm1, xmm2/m64` + // + // `VEX.256.66.0F38.WIG 24 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovsxwq_ymm_xmmm64 = 2767, + // `VPMOVSXWQ xmm1 {k1}{z}, xmm2/m32` + // + // `EVEX.128.66.0F38.WIG 24 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxwq_xmm_k1z_xmmm32 = 2768, + // `VPMOVSXWQ ymm1 {k1}{z}, xmm2/m64` + // + // `EVEX.256.66.0F38.WIG 24 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxwq_ymm_k1z_xmmm64 = 2769, + // `VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.512.66.0F38.WIG 24 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxwq_zmm_k1z_xmmm128 = 2770, + // `VPMOVSQW xmm1/m32 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 24 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsqw_xmmm32_k1z_xmm = 2771, + // `VPMOVSQW xmm1/m64 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 24 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsqw_xmmm64_k1z_ymm = 2772, + // `VPMOVSQW xmm1/m128 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 24 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsqw_xmmm128_k1z_zmm = 2773, + // `PMOVSXDQ xmm1, xmm2/m64` + // + // `66 0F 38 25 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovsxdq_xmm_xmmm64 = 2774, + // `VPMOVSXDQ xmm1, xmm2/m64` + // + // `VEX.128.66.0F38.WIG 25 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovsxdq_xmm_xmmm64 = 2775, + // `VPMOVSXDQ ymm1, xmm2/m128` + // + // `VEX.256.66.0F38.WIG 25 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovsxdq_ymm_xmmm128 = 2776, + // `VPMOVSXDQ xmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.128.66.0F38.W0 25 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxdq_xmm_k1z_xmmm64 = 2777, + // `VPMOVSXDQ ymm1 {k1}{z}, xmm2/m128` + // + // `EVEX.256.66.0F38.W0 25 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxdq_ymm_k1z_xmmm128 = 2778, + // `VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256` + // + // `EVEX.512.66.0F38.W0 25 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsxdq_zmm_k1z_ymmm256 = 2779, + // `VPMOVSQD xmm1/m64 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 25 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsqd_xmmm64_k1z_xmm = 2780, + // `VPMOVSQD xmm1/m128 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 25 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsqd_xmmm128_k1z_ymm = 2781, + // `VPMOVSQD ymm1/m256 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 25 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovsqd_ymmm256_k1z_zmm = 2782, + // `VPTESTMB k2 {k1}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W0 26 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestmb_kr_k1_xmm_xmmm128 = 2783, + // `VPTESTMB k2 {k1}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W0 26 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestmb_kr_k1_ymm_ymmm256 = 2784, + // `VPTESTMB k2 {k1}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W0 26 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestmb_kr_k1_zmm_zmmm512 = 2785, + // `VPTESTMW k2 {k1}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W1 26 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestmw_kr_k1_xmm_xmmm128 = 2786, + // `VPTESTMW k2 {k1}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W1 26 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestmw_kr_k1_ymm_ymmm256 = 2787, + // `VPTESTMW k2 {k1}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W1 26 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestmw_kr_k1_zmm_zmmm512 = 2788, + // `VPTESTNMB k2 {k1}, xmm2, xmm3/m128` + // + // `EVEX.128.F3.0F38.W0 26 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestnmb_kr_k1_xmm_xmmm128 = 2789, + // `VPTESTNMB k2 {k1}, ymm2, ymm3/m256` + // + // `EVEX.256.F3.0F38.W0 26 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestnmb_kr_k1_ymm_ymmm256 = 2790, + // `VPTESTNMB k2 {k1}, zmm2, zmm3/m512` + // + // `EVEX.512.F3.0F38.W0 26 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestnmb_kr_k1_zmm_zmmm512 = 2791, + // `VPTESTNMW k2 {k1}, xmm2, xmm3/m128` + // + // `EVEX.128.F3.0F38.W1 26 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestnmw_kr_k1_xmm_xmmm128 = 2792, + // `VPTESTNMW k2 {k1}, ymm2, ymm3/m256` + // + // `EVEX.256.F3.0F38.W1 26 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestnmw_kr_k1_ymm_ymmm256 = 2793, + // `VPTESTNMW k2 {k1}, zmm2, zmm3/m512` + // + // `EVEX.512.F3.0F38.W1 26 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vptestnmw_kr_k1_zmm_zmmm512 = 2794, + // `VPTESTMD k2 {k1}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 27 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestmd_kr_k1_xmm_xmmm128b32 = 2795, + // `VPTESTMD k2 {k1}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 27 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestmd_kr_k1_ymm_ymmm256b32 = 2796, + // `VPTESTMD k2 {k1}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 27 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestmd_kr_k1_zmm_zmmm512b32 = 2797, + // `VPTESTMQ k2 {k1}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 27 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestmq_kr_k1_xmm_xmmm128b64 = 2798, + // `VPTESTMQ k2 {k1}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 27 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestmq_kr_k1_ymm_ymmm256b64 = 2799, + // `VPTESTMQ k2 {k1}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 27 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestmq_kr_k1_zmm_zmmm512b64 = 2800, + // `VPTESTNMD k2 {k1}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.F3.0F38.W0 27 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestnmd_kr_k1_xmm_xmmm128b32 = 2801, + // `VPTESTNMD k2 {k1}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.F3.0F38.W0 27 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestnmd_kr_k1_ymm_ymmm256b32 = 2802, + // `VPTESTNMD k2 {k1}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.F3.0F38.W0 27 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestnmd_kr_k1_zmm_zmmm512b32 = 2803, + // `VPTESTNMQ k2 {k1}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.F3.0F38.W1 27 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestnmq_kr_k1_xmm_xmmm128b64 = 2804, + // `VPTESTNMQ k2 {k1}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.F3.0F38.W1 27 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestnmq_kr_k1_ymm_ymmm256b64 = 2805, + // `VPTESTNMQ k2 {k1}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.F3.0F38.W1 27 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vptestnmq_kr_k1_zmm_zmmm512b64 = 2806, + // `PMULDQ xmm1, xmm2/m128` + // + // `66 0F 38 28 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmuldq_xmm_xmmm128 = 2807, + // `VPMULDQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 28 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmuldq_xmm_xmm_xmmm128 = 2808, + // `VPMULDQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 28 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmuldq_ymm_ymm_ymmm256 = 2809, + // `VPMULDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 28 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmuldq_xmm_k1z_xmm_xmmm128b64 = 2810, + // `VPMULDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 28 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmuldq_ymm_k1z_ymm_ymmm256b64 = 2811, + // `VPMULDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 28 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmuldq_zmm_k1z_zmm_zmmm512b64 = 2812, + // `VPMOVM2B xmm1, k1` + // + // `EVEX.128.F3.0F38.W0 28 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovm2b_xmm_kr = 2813, + // `VPMOVM2B ymm1, k1` + // + // `EVEX.256.F3.0F38.W0 28 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovm2b_ymm_kr = 2814, + // `VPMOVM2B zmm1, k1` + // + // `EVEX.512.F3.0F38.W0 28 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovm2b_zmm_kr = 2815, + // `VPMOVM2W xmm1, k1` + // + // `EVEX.128.F3.0F38.W1 28 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovm2w_xmm_kr = 2816, + // `VPMOVM2W ymm1, k1` + // + // `EVEX.256.F3.0F38.W1 28 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovm2w_ymm_kr = 2817, + // `VPMOVM2W zmm1, k1` + // + // `EVEX.512.F3.0F38.W1 28 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovm2w_zmm_kr = 2818, + // `PCMPEQQ xmm1, xmm2/m128` + // + // `66 0F 38 29 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pcmpeqq_xmm_xmmm128 = 2819, + // `VPCMPEQQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 29 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpeqq_xmm_xmm_xmmm128 = 2820, + // `VPCMPEQQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 29 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpcmpeqq_ymm_ymm_ymmm256 = 2821, + // `VPCMPEQQ k1 {k2}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 29 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpeqq_kr_k1_xmm_xmmm128b64 = 2822, + // `VPCMPEQQ k1 {k2}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 29 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpeqq_kr_k1_ymm_ymmm256b64 = 2823, + // `VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 29 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpeqq_kr_k1_zmm_zmmm512b64 = 2824, + // `VPMOVB2M k1, xmm1` + // + // `EVEX.128.F3.0F38.W0 29 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovb2m_kr_xmm = 2825, + // `VPMOVB2M k1, ymm1` + // + // `EVEX.256.F3.0F38.W0 29 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovb2m_kr_ymm = 2826, + // `VPMOVB2M k1, zmm1` + // + // `EVEX.512.F3.0F38.W0 29 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovb2m_kr_zmm = 2827, + // `VPMOVW2M k1, xmm1` + // + // `EVEX.128.F3.0F38.W1 29 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovw2m_kr_xmm = 2828, + // `VPMOVW2M k1, ymm1` + // + // `EVEX.256.F3.0F38.W1 29 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovw2m_kr_ymm = 2829, + // `VPMOVW2M k1, zmm1` + // + // `EVEX.512.F3.0F38.W1 29 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovw2m_kr_zmm = 2830, + // `MOVNTDQA xmm1, m128` + // + // `66 0F 38 2A /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Movntdqa_xmm_m128 = 2831, + // `VMOVNTDQA xmm1, m128` + // + // `VEX.128.66.0F38.WIG 2A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmovntdqa_xmm_m128 = 2832, + // `VMOVNTDQA ymm1, m256` + // + // `VEX.256.66.0F38.WIG 2A /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vmovntdqa_ymm_m256 = 2833, + // `VMOVNTDQA xmm1, m128` + // + // `EVEX.128.66.0F38.W0 2A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntdqa_xmm_m128 = 2834, + // `VMOVNTDQA ymm1, m256` + // + // `EVEX.256.66.0F38.W0 2A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntdqa_ymm_m256 = 2835, + // `VMOVNTDQA zmm1, m512` + // + // `EVEX.512.66.0F38.W0 2A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vmovntdqa_zmm_m512 = 2836, + // `VPBROADCASTMB2Q xmm1, k1` + // + // `EVEX.128.F3.0F38.W1 2A /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpbroadcastmb2q_xmm_kr = 2837, + // `VPBROADCASTMB2Q ymm1, k1` + // + // `EVEX.256.F3.0F38.W1 2A /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpbroadcastmb2q_ymm_kr = 2838, + // `VPBROADCASTMB2Q zmm1, k1` + // + // `EVEX.512.F3.0F38.W1 2A /r` + // + // `AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpbroadcastmb2q_zmm_kr = 2839, + // `PACKUSDW xmm1, xmm2/m128` + // + // `66 0F 38 2B /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Packusdw_xmm_xmmm128 = 2840, + // `VPACKUSDW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 2B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpackusdw_xmm_xmm_xmmm128 = 2841, + // `VPACKUSDW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 2B /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpackusdw_ymm_ymm_ymmm256 = 2842, + // `VPACKUSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 2B /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpackusdw_xmm_k1z_xmm_xmmm128b32 = 2843, + // `VPACKUSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 2B /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpackusdw_ymm_k1z_ymm_ymmm256b32 = 2844, + // `VPACKUSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 2B /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpackusdw_zmm_k1z_zmm_zmmm512b32 = 2845, + // `VMASKMOVPS xmm1, xmm2, m128` + // + // `VEX.128.66.0F38.W0 2C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaskmovps_xmm_xmm_m128 = 2846, + // `VMASKMOVPS ymm1, ymm2, m256` + // + // `VEX.256.66.0F38.W0 2C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaskmovps_ymm_ymm_m256 = 2847, + // `VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 2C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscalefps_xmm_k1z_xmm_xmmm128b32 = 2848, + // `VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 2C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscalefps_ymm_k1z_ymm_ymmm256b32 = 2849, + // `VSCALEFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 2C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vscalefps_zmm_k1z_zmm_zmmm512b32_er = 2850, + // `VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 2C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscalefpd_xmm_k1z_xmm_xmmm128b64 = 2851, + // `VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 2C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscalefpd_ymm_k1z_ymm_ymmm256b64 = 2852, + // `VSCALEFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 2C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vscalefpd_zmm_k1z_zmm_zmmm512b64_er = 2853, + // `VMASKMOVPD xmm1, xmm2, m128` + // + // `VEX.128.66.0F38.W0 2D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaskmovpd_xmm_xmm_m128 = 2854, + // `VMASKMOVPD ymm1, ymm2, m256` + // + // `VEX.256.66.0F38.W0 2D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaskmovpd_ymm_ymm_m256 = 2855, + // `VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 2D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vscalefss_xmm_k1z_xmm_xmmm32_er = 2856, + // `VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 2D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vscalefsd_xmm_k1z_xmm_xmmm64_er = 2857, + // `VMASKMOVPS m128, xmm1, xmm2` + // + // `VEX.128.66.0F38.W0 2E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaskmovps_m128_xmm_xmm = 2858, + // `VMASKMOVPS m256, ymm1, ymm2` + // + // `VEX.256.66.0F38.W0 2E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaskmovps_m256_ymm_ymm = 2859, + // `VMASKMOVPD m128, xmm1, xmm2` + // + // `VEX.128.66.0F38.W0 2F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaskmovpd_m128_xmm_xmm = 2860, + // `VMASKMOVPD m256, ymm1, ymm2` + // + // `VEX.256.66.0F38.W0 2F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmaskmovpd_m256_ymm_ymm = 2861, + // `PMOVZXBW xmm1, xmm2/m64` + // + // `66 0F 38 30 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovzxbw_xmm_xmmm64 = 2862, + // `VPMOVZXBW xmm1, xmm2/m64` + // + // `VEX.128.66.0F38.WIG 30 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovzxbw_xmm_xmmm64 = 2863, + // `VPMOVZXBW ymm1, xmm2/m128` + // + // `VEX.256.66.0F38.WIG 30 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovzxbw_ymm_xmmm128 = 2864, + // `VPMOVZXBW xmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.128.66.0F38.WIG 30 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovzxbw_xmm_k1z_xmmm64 = 2865, + // `VPMOVZXBW ymm1 {k1}{z}, xmm2/m128` + // + // `EVEX.256.66.0F38.WIG 30 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovzxbw_ymm_k1z_xmmm128 = 2866, + // `VPMOVZXBW zmm1 {k1}{z}, ymm2/m256` + // + // `EVEX.512.66.0F38.WIG 30 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovzxbw_zmm_k1z_ymmm256 = 2867, + // `VPMOVWB xmm1/m64 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 30 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovwb_xmmm64_k1z_xmm = 2868, + // `VPMOVWB xmm1/m128 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 30 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovwb_xmmm128_k1z_ymm = 2869, + // `VPMOVWB ymm1/m256 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 30 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmovwb_ymmm256_k1z_zmm = 2870, + // `PMOVZXBD xmm1, xmm2/m32` + // + // `66 0F 38 31 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovzxbd_xmm_xmmm32 = 2871, + // `VPMOVZXBD xmm1, xmm2/m32` + // + // `VEX.128.66.0F38.WIG 31 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovzxbd_xmm_xmmm32 = 2872, + // `VPMOVZXBD ymm1, xmm2/m64` + // + // `VEX.256.66.0F38.WIG 31 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovzxbd_ymm_xmmm64 = 2873, + // `VPMOVZXBD xmm1 {k1}{z}, xmm2/m32` + // + // `EVEX.128.66.0F38.WIG 31 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxbd_xmm_k1z_xmmm32 = 2874, + // `VPMOVZXBD ymm1 {k1}{z}, xmm2/m64` + // + // `EVEX.256.66.0F38.WIG 31 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxbd_ymm_k1z_xmmm64 = 2875, + // `VPMOVZXBD zmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.512.66.0F38.WIG 31 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxbd_zmm_k1z_xmmm128 = 2876, + // `VPMOVDB xmm1/m32 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 31 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovdb_xmmm32_k1z_xmm = 2877, + // `VPMOVDB xmm1/m64 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 31 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovdb_xmmm64_k1z_ymm = 2878, + // `VPMOVDB xmm1/m128 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 31 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovdb_xmmm128_k1z_zmm = 2879, + // `PMOVZXBQ xmm1, xmm2/m16` + // + // `66 0F 38 32 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovzxbq_xmm_xmmm16 = 2880, + // `VPMOVZXBQ xmm1, xmm2/m16` + // + // `VEX.128.66.0F38.WIG 32 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovzxbq_xmm_xmmm16 = 2881, + // `VPMOVZXBQ ymm1, xmm2/m32` + // + // `VEX.256.66.0F38.WIG 32 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovzxbq_ymm_xmmm32 = 2882, + // `VPMOVZXBQ xmm1 {k1}{z}, xmm2/m16` + // + // `EVEX.128.66.0F38.WIG 32 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxbq_xmm_k1z_xmmm16 = 2883, + // `VPMOVZXBQ ymm1 {k1}{z}, xmm2/m32` + // + // `EVEX.256.66.0F38.WIG 32 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxbq_ymm_k1z_xmmm32 = 2884, + // `VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.512.66.0F38.WIG 32 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxbq_zmm_k1z_xmmm64 = 2885, + // `VPMOVQB xmm1/m16 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 32 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovqb_xmmm16_k1z_xmm = 2886, + // `VPMOVQB xmm1/m32 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 32 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovqb_xmmm32_k1z_ymm = 2887, + // `VPMOVQB xmm1/m64 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 32 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovqb_xmmm64_k1z_zmm = 2888, + // `PMOVZXWD xmm1, xmm2/m64` + // + // `66 0F 38 33 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovzxwd_xmm_xmmm64 = 2889, + // `VPMOVZXWD xmm1, xmm2/m64` + // + // `VEX.128.66.0F38.WIG 33 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovzxwd_xmm_xmmm64 = 2890, + // `VPMOVZXWD ymm1, xmm2/m128` + // + // `VEX.256.66.0F38.WIG 33 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovzxwd_ymm_xmmm128 = 2891, + // `VPMOVZXWD xmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.128.66.0F38.WIG 33 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxwd_xmm_k1z_xmmm64 = 2892, + // `VPMOVZXWD ymm1 {k1}{z}, xmm2/m128` + // + // `EVEX.256.66.0F38.WIG 33 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxwd_ymm_k1z_xmmm128 = 2893, + // `VPMOVZXWD zmm1 {k1}{z}, ymm2/m256` + // + // `EVEX.512.66.0F38.WIG 33 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxwd_zmm_k1z_ymmm256 = 2894, + // `VPMOVDW xmm1/m64 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 33 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovdw_xmmm64_k1z_xmm = 2895, + // `VPMOVDW xmm1/m128 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 33 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovdw_xmmm128_k1z_ymm = 2896, + // `VPMOVDW ymm1/m256 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 33 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovdw_ymmm256_k1z_zmm = 2897, + // `PMOVZXWQ xmm1, xmm2/m32` + // + // `66 0F 38 34 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovzxwq_xmm_xmmm32 = 2898, + // `VPMOVZXWQ xmm1, xmm2/m32` + // + // `VEX.128.66.0F38.WIG 34 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovzxwq_xmm_xmmm32 = 2899, + // `VPMOVZXWQ ymm1, xmm2/m64` + // + // `VEX.256.66.0F38.WIG 34 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovzxwq_ymm_xmmm64 = 2900, + // `VPMOVZXWQ xmm1 {k1}{z}, xmm2/m32` + // + // `EVEX.128.66.0F38.WIG 34 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxwq_xmm_k1z_xmmm32 = 2901, + // `VPMOVZXWQ ymm1 {k1}{z}, xmm2/m64` + // + // `EVEX.256.66.0F38.WIG 34 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxwq_ymm_k1z_xmmm64 = 2902, + // `VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.512.66.0F38.WIG 34 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxwq_zmm_k1z_xmmm128 = 2903, + // `VPMOVQW xmm1/m32 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 34 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovqw_xmmm32_k1z_xmm = 2904, + // `VPMOVQW xmm1/m64 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 34 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovqw_xmmm64_k1z_ymm = 2905, + // `VPMOVQW xmm1/m128 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 34 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovqw_xmmm128_k1z_zmm = 2906, + // `PMOVZXDQ xmm1, xmm2/m64` + // + // `66 0F 38 35 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmovzxdq_xmm_xmmm64 = 2907, + // `VPMOVZXDQ xmm1, xmm2/m64` + // + // `VEX.128.66.0F38.WIG 35 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmovzxdq_xmm_xmmm64 = 2908, + // `VPMOVZXDQ ymm1, xmm2/m128` + // + // `VEX.256.66.0F38.WIG 35 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmovzxdq_ymm_xmmm128 = 2909, + // `VPMOVZXDQ xmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.128.66.0F38.W0 35 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxdq_xmm_k1z_xmmm64 = 2910, + // `VPMOVZXDQ ymm1 {k1}{z}, xmm2/m128` + // + // `EVEX.256.66.0F38.W0 35 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxdq_ymm_k1z_xmmm128 = 2911, + // `VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256` + // + // `EVEX.512.66.0F38.W0 35 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovzxdq_zmm_k1z_ymmm256 = 2912, + // `VPMOVQD xmm1/m64 {k1}{z}, xmm2` + // + // `EVEX.128.F3.0F38.W0 35 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovqd_xmmm64_k1z_xmm = 2913, + // `VPMOVQD xmm1/m128 {k1}{z}, ymm2` + // + // `EVEX.256.F3.0F38.W0 35 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovqd_xmmm128_k1z_ymm = 2914, + // `VPMOVQD ymm1/m256 {k1}{z}, zmm2` + // + // `EVEX.512.F3.0F38.W0 35 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmovqd_ymmm256_k1z_zmm = 2915, + // `VPERMD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 36 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpermd_ymm_ymm_ymmm256 = 2916, + // `VPERMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 36 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermd_ymm_k1z_ymm_ymmm256b32 = 2917, + // `VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 36 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermd_zmm_k1z_zmm_zmmm512b32 = 2918, + // `VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 36 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermq_ymm_k1z_ymm_ymmm256b64 = 2919, + // `VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 36 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermq_zmm_k1z_zmm_zmmm512b64 = 2920, + // `PCMPGTQ xmm1, xmm2/m128` + // + // `66 0F 38 37 /r` + // + // `SSE4.2` + // + // `16/32/64-bit` + Pcmpgtq_xmm_xmmm128 = 2921, + // `VPCMPGTQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 37 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpgtq_xmm_xmm_xmmm128 = 2922, + // `VPCMPGTQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 37 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpcmpgtq_ymm_ymm_ymmm256 = 2923, + // `VPCMPGTQ k1 {k2}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 37 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpgtq_kr_k1_xmm_xmmm128b64 = 2924, + // `VPCMPGTQ k1 {k2}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 37 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpgtq_kr_k1_ymm_ymmm256b64 = 2925, + // `VPCMPGTQ k1 {k2}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 37 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpgtq_kr_k1_zmm_zmmm512b64 = 2926, + // `PMINSB xmm1, xmm2/m128` + // + // `66 0F 38 38 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pminsb_xmm_xmmm128 = 2927, + // `VPMINSB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 38 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpminsb_xmm_xmm_xmmm128 = 2928, + // `VPMINSB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 38 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpminsb_ymm_ymm_ymmm256 = 2929, + // `VPMINSB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.WIG 38 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminsb_xmm_k1z_xmm_xmmm128 = 2930, + // `VPMINSB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.WIG 38 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminsb_ymm_k1z_ymm_ymmm256 = 2931, + // `VPMINSB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.WIG 38 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminsb_zmm_k1z_zmm_zmmm512 = 2932, + // `VPMOVM2D xmm1, k1` + // + // `EVEX.128.F3.0F38.W0 38 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovm2d_xmm_kr = 2933, + // `VPMOVM2D ymm1, k1` + // + // `EVEX.256.F3.0F38.W0 38 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovm2d_ymm_kr = 2934, + // `VPMOVM2D zmm1, k1` + // + // `EVEX.512.F3.0F38.W0 38 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovm2d_zmm_kr = 2935, + // `VPMOVM2Q xmm1, k1` + // + // `EVEX.128.F3.0F38.W1 38 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovm2q_xmm_kr = 2936, + // `VPMOVM2Q ymm1, k1` + // + // `EVEX.256.F3.0F38.W1 38 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovm2q_ymm_kr = 2937, + // `VPMOVM2Q zmm1, k1` + // + // `EVEX.512.F3.0F38.W1 38 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovm2q_zmm_kr = 2938, + // `PMINSD xmm1, xmm2/m128` + // + // `66 0F 38 39 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pminsd_xmm_xmmm128 = 2939, + // `VPMINSD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 39 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpminsd_xmm_xmm_xmmm128 = 2940, + // `VPMINSD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 39 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpminsd_ymm_ymm_ymmm256 = 2941, + // `VPMINSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 39 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminsd_xmm_k1z_xmm_xmmm128b32 = 2942, + // `VPMINSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 39 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminsd_ymm_k1z_ymm_ymmm256b32 = 2943, + // `VPMINSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 39 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminsd_zmm_k1z_zmm_zmmm512b32 = 2944, + // `VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 39 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminsq_xmm_k1z_xmm_xmmm128b64 = 2945, + // `VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 39 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminsq_ymm_k1z_ymm_ymmm256b64 = 2946, + // `VPMINSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 39 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminsq_zmm_k1z_zmm_zmmm512b64 = 2947, + // `VPMOVD2M k1, xmm1` + // + // `EVEX.128.F3.0F38.W0 39 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovd2m_kr_xmm = 2948, + // `VPMOVD2M k1, ymm1` + // + // `EVEX.256.F3.0F38.W0 39 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovd2m_kr_ymm = 2949, + // `VPMOVD2M k1, zmm1` + // + // `EVEX.512.F3.0F38.W0 39 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovd2m_kr_zmm = 2950, + // `VPMOVQ2M k1, xmm1` + // + // `EVEX.128.F3.0F38.W1 39 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovq2m_kr_xmm = 2951, + // `VPMOVQ2M k1, ymm1` + // + // `EVEX.256.F3.0F38.W1 39 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovq2m_kr_ymm = 2952, + // `VPMOVQ2M k1, zmm1` + // + // `EVEX.512.F3.0F38.W1 39 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmovq2m_kr_zmm = 2953, + // `PMINUW xmm1, xmm2/m128` + // + // `66 0F 38 3A /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pminuw_xmm_xmmm128 = 2954, + // `VPMINUW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 3A /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpminuw_xmm_xmm_xmmm128 = 2955, + // `VPMINUW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 3A /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpminuw_ymm_ymm_ymmm256 = 2956, + // `VPMINUW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.WIG 3A /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminuw_xmm_k1z_xmm_xmmm128 = 2957, + // `VPMINUW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.WIG 3A /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminuw_ymm_k1z_ymm_ymmm256 = 2958, + // `VPMINUW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.WIG 3A /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpminuw_zmm_k1z_zmm_zmmm512 = 2959, + // `VPBROADCASTMW2D xmm1, k1` + // + // `EVEX.128.F3.0F38.W0 3A /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpbroadcastmw2d_xmm_kr = 2960, + // `VPBROADCASTMW2D ymm1, k1` + // + // `EVEX.256.F3.0F38.W0 3A /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpbroadcastmw2d_ymm_kr = 2961, + // `VPBROADCASTMW2D zmm1, k1` + // + // `EVEX.512.F3.0F38.W0 3A /r` + // + // `AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpbroadcastmw2d_zmm_kr = 2962, + // `PMINUD xmm1, xmm2/m128` + // + // `66 0F 38 3B /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pminud_xmm_xmmm128 = 2963, + // `VPMINUD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 3B /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpminud_xmm_xmm_xmmm128 = 2964, + // `VPMINUD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 3B /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpminud_ymm_ymm_ymmm256 = 2965, + // `VPMINUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 3B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminud_xmm_k1z_xmm_xmmm128b32 = 2966, + // `VPMINUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 3B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminud_ymm_k1z_ymm_ymmm256b32 = 2967, + // `VPMINUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 3B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminud_zmm_k1z_zmm_zmmm512b32 = 2968, + // `VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 3B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminuq_xmm_k1z_xmm_xmmm128b64 = 2969, + // `VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 3B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminuq_ymm_k1z_ymm_ymmm256b64 = 2970, + // `VPMINUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 3B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpminuq_zmm_k1z_zmm_zmmm512b64 = 2971, + // `PMAXSB xmm1, xmm2/m128` + // + // `66 0F 38 3C /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmaxsb_xmm_xmmm128 = 2972, + // `VPMAXSB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 3C /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmaxsb_xmm_xmm_xmmm128 = 2973, + // `VPMAXSB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 3C /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaxsb_ymm_ymm_ymmm256 = 2974, + // `VPMAXSB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.WIG 3C /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxsb_xmm_k1z_xmm_xmmm128 = 2975, + // `VPMAXSB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.WIG 3C /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxsb_ymm_k1z_ymm_ymmm256 = 2976, + // `VPMAXSB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.WIG 3C /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxsb_zmm_k1z_zmm_zmmm512 = 2977, + // `PMAXSD xmm1, xmm2/m128` + // + // `66 0F 38 3D /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmaxsd_xmm_xmmm128 = 2978, + // `VPMAXSD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 3D /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmaxsd_xmm_xmm_xmmm128 = 2979, + // `VPMAXSD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 3D /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaxsd_ymm_ymm_ymmm256 = 2980, + // `VPMAXSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 3D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxsd_xmm_k1z_xmm_xmmm128b32 = 2981, + // `VPMAXSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 3D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxsd_ymm_k1z_ymm_ymmm256b32 = 2982, + // `VPMAXSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 3D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxsd_zmm_k1z_zmm_zmmm512b32 = 2983, + // `VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 3D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxsq_xmm_k1z_xmm_xmmm128b64 = 2984, + // `VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 3D /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxsq_ymm_k1z_ymm_ymmm256b64 = 2985, + // `VPMAXSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 3D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxsq_zmm_k1z_zmm_zmmm512b64 = 2986, + // `PMAXUW xmm1, xmm2/m128` + // + // `66 0F 38 3E /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmaxuw_xmm_xmmm128 = 2987, + // `VPMAXUW xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 3E /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmaxuw_xmm_xmm_xmmm128 = 2988, + // `VPMAXUW ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 3E /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaxuw_ymm_ymm_ymmm256 = 2989, + // `VPMAXUW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.WIG 3E /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxuw_xmm_k1z_xmm_xmmm128 = 2990, + // `VPMAXUW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.WIG 3E /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxuw_ymm_k1z_ymm_ymmm256 = 2991, + // `VPMAXUW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.WIG 3E /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpmaxuw_zmm_k1z_zmm_zmmm512 = 2992, + // `PMAXUD xmm1, xmm2/m128` + // + // `66 0F 38 3F /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmaxud_xmm_xmmm128 = 2993, + // `VPMAXUD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 3F /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmaxud_xmm_xmm_xmmm128 = 2994, + // `VPMAXUD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 3F /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaxud_ymm_ymm_ymmm256 = 2995, + // `VPMAXUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 3F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxud_xmm_k1z_xmm_xmmm128b32 = 2996, + // `VPMAXUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 3F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxud_ymm_k1z_ymm_ymmm256b32 = 2997, + // `VPMAXUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 3F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxud_zmm_k1z_zmm_zmmm512b32 = 2998, + // `VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 3F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxuq_xmm_k1z_xmm_xmmm128b64 = 2999, + // `VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 3F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxuq_ymm_k1z_ymm_ymmm256b64 = 3000, + // `VPMAXUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 3F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmaxuq_zmm_k1z_zmm_zmmm512b64 = 3001, + // `PMULLD xmm1, xmm2/m128` + // + // `66 0F 38 40 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pmulld_xmm_xmmm128 = 3002, + // `VPMULLD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG 40 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpmulld_xmm_xmm_xmmm128 = 3003, + // `VPMULLD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG 40 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmulld_ymm_ymm_ymmm256 = 3004, + // `VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 40 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmulld_xmm_k1z_xmm_xmmm128b32 = 3005, + // `VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 40 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmulld_ymm_k1z_ymm_ymmm256b32 = 3006, + // `VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 40 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpmulld_zmm_k1z_zmm_zmmm512b32 = 3007, + // `VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 40 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmullq_xmm_k1z_xmm_xmmm128b64 = 3008, + // `VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 40 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmullq_ymm_k1z_ymm_ymmm256b64 = 3009, + // `VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 40 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpmullq_zmm_k1z_zmm_zmmm512b64 = 3010, + // `PHMINPOSUW xmm1, xmm2/m128` + // + // `66 0F 38 41 /r` + // + // `SSE4.1` + // + // `16/32/64-bit` + Phminposuw_xmm_xmmm128 = 3011, + // `VPHMINPOSUW xmm1, xmm2/m128` + // + // `VEX.128.66.0F38.WIG 41 /r` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vphminposuw_xmm_xmmm128 = 3012, + // `VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 42 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetexpps_xmm_k1z_xmmm128b32 = 3013, + // `VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 42 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetexpps_ymm_k1z_ymmm256b32 = 3014, + // `VGETEXPPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}` + // + // `EVEX.512.66.0F38.W0 42 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetexpps_zmm_k1z_zmmm512b32_sae = 3015, + // `VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 42 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetexppd_xmm_k1z_xmmm128b64 = 3016, + // `VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 42 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetexppd_ymm_k1z_ymmm256b64 = 3017, + // `VGETEXPPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}` + // + // `EVEX.512.66.0F38.W1 42 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetexppd_zmm_k1z_zmmm512b64_sae = 3018, + // `VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}` + // + // `EVEX.LIG.66.0F38.W0 43 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetexpss_xmm_k1z_xmm_xmmm32_sae = 3019, + // `VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}` + // + // `EVEX.LIG.66.0F38.W1 43 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetexpsd_xmm_k1z_xmm_xmmm64_sae = 3020, + // `VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 44 /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vplzcntd_xmm_k1z_xmmm128b32 = 3021, + // `VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 44 /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vplzcntd_ymm_k1z_ymmm256b32 = 3022, + // `VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 44 /r` + // + // `AVX512CD` + // + // `16/32/64-bit` + EVEX_Vplzcntd_zmm_k1z_zmmm512b32 = 3023, + // `VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 44 /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vplzcntq_xmm_k1z_xmmm128b64 = 3024, + // `VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 44 /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vplzcntq_ymm_k1z_ymmm256b64 = 3025, + // `VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 44 /r` + // + // `AVX512CD` + // + // `16/32/64-bit` + EVEX_Vplzcntq_zmm_k1z_zmmm512b64 = 3026, + // `VPSRLVD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 45 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrlvd_xmm_xmm_xmmm128 = 3027, + // `VPSRLVD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 45 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrlvd_ymm_ymm_ymmm256 = 3028, + // `VPSRLVQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 45 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrlvq_xmm_xmm_xmmm128 = 3029, + // `VPSRLVQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 45 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsrlvq_ymm_ymm_ymmm256 = 3030, + // `VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 45 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlvd_xmm_k1z_xmm_xmmm128b32 = 3031, + // `VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 45 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlvd_ymm_k1z_ymm_ymmm256b32 = 3032, + // `VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 45 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlvd_zmm_k1z_zmm_zmmm512b32 = 3033, + // `VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 45 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlvq_xmm_k1z_xmm_xmmm128b64 = 3034, + // `VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 45 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlvq_ymm_k1z_ymm_ymmm256b64 = 3035, + // `VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 45 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsrlvq_zmm_k1z_zmm_zmmm512b64 = 3036, + // `VPSRAVD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 46 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsravd_xmm_xmm_xmmm128 = 3037, + // `VPSRAVD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 46 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsravd_ymm_ymm_ymmm256 = 3038, + // `VPSRAVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 46 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsravd_xmm_k1z_xmm_xmmm128b32 = 3039, + // `VPSRAVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 46 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsravd_ymm_k1z_ymm_ymmm256b32 = 3040, + // `VPSRAVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 46 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsravd_zmm_k1z_zmm_zmmm512b32 = 3041, + // `VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 46 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsravq_xmm_k1z_xmm_xmmm128b64 = 3042, + // `VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 46 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsravq_ymm_k1z_ymm_ymmm256b64 = 3043, + // `VPSRAVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 46 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsravq_zmm_k1z_zmm_zmmm512b64 = 3044, + // `VPSLLVD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 47 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsllvd_xmm_xmm_xmmm128 = 3045, + // `VPSLLVD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 47 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsllvd_ymm_ymm_ymmm256 = 3046, + // `VPSLLVQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 47 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsllvq_xmm_xmm_xmmm128 = 3047, + // `VPSLLVQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 47 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpsllvq_ymm_ymm_ymmm256 = 3048, + // `VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 47 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllvd_xmm_k1z_xmm_xmmm128b32 = 3049, + // `VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 47 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllvd_ymm_k1z_ymm_ymmm256b32 = 3050, + // `VPSLLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 47 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllvd_zmm_k1z_zmm_zmmm512b32 = 3051, + // `VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 47 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllvq_xmm_k1z_xmm_xmmm128b64 = 3052, + // `VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 47 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllvq_ymm_k1z_ymm_ymmm256b64 = 3053, + // `VPSLLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 47 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpsllvq_zmm_k1z_zmm_zmmm512b64 = 3054, + // `VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 4C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrcp14ps_xmm_k1z_xmmm128b32 = 3055, + // `VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 4C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrcp14ps_ymm_k1z_ymmm256b32 = 3056, + // `VRCP14PS zmm1 {k1}{z}, zmm2/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 4C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrcp14ps_zmm_k1z_zmmm512b32 = 3057, + // `VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 4C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrcp14pd_xmm_k1z_xmmm128b64 = 3058, + // `VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 4C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrcp14pd_ymm_k1z_ymmm256b64 = 3059, + // `VRCP14PD zmm1 {k1}{z}, zmm2/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 4C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrcp14pd_zmm_k1z_zmmm512b64 = 3060, + // `VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32` + // + // `EVEX.LIG.66.0F38.W0 4D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrcp14ss_xmm_k1z_xmm_xmmm32 = 3061, + // `VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64` + // + // `EVEX.LIG.66.0F38.W1 4D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrcp14sd_xmm_k1z_xmm_xmmm64 = 3062, + // `VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 4E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrsqrt14ps_xmm_k1z_xmmm128b32 = 3063, + // `VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 4E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrsqrt14ps_ymm_k1z_ymmm256b32 = 3064, + // `VRSQRT14PS zmm1 {k1}{z}, zmm2/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 4E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrsqrt14ps_zmm_k1z_zmmm512b32 = 3065, + // `VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 4E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrsqrt14pd_xmm_k1z_xmmm128b64 = 3066, + // `VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 4E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrsqrt14pd_ymm_k1z_ymmm256b64 = 3067, + // `VRSQRT14PD zmm1 {k1}{z}, zmm2/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 4E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrsqrt14pd_zmm_k1z_zmmm512b64 = 3068, + // `VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32` + // + // `EVEX.LIG.66.0F38.W0 4F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrsqrt14ss_xmm_k1z_xmm_xmmm32 = 3069, + // `VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64` + // + // `EVEX.LIG.66.0F38.W1 4F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrsqrt14sd_xmm_k1z_xmm_xmmm64 = 3070, + // `VPDPBUSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 50 /r` + // + // `AVX512VL and AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpbusd_xmm_k1z_xmm_xmmm128b32 = 3071, + // `VPDPBUSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 50 /r` + // + // `AVX512VL and AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpbusd_ymm_k1z_ymm_ymmm256b32 = 3072, + // `VPDPBUSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 50 /r` + // + // `AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpbusd_zmm_k1z_zmm_zmmm512b32 = 3073, + // `VPDPBUSDS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 51 /r` + // + // `AVX512VL and AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpbusds_xmm_k1z_xmm_xmmm128b32 = 3074, + // `VPDPBUSDS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 51 /r` + // + // `AVX512VL and AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpbusds_ymm_k1z_ymm_ymmm256b32 = 3075, + // `VPDPBUSDS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 51 /r` + // + // `AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpbusds_zmm_k1z_zmm_zmmm512b32 = 3076, + // `VPDPWSSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 52 /r` + // + // `AVX512VL and AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpwssd_xmm_k1z_xmm_xmmm128b32 = 3077, + // `VPDPWSSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 52 /r` + // + // `AVX512VL and AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpwssd_ymm_k1z_ymm_ymmm256b32 = 3078, + // `VPDPWSSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 52 /r` + // + // `AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpwssd_zmm_k1z_zmm_zmmm512b32 = 3079, + // `VDPBF16PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.F3.0F38.W0 52 /r` + // + // `AVX512VL and AVX512_BF16` + // + // `16/32/64-bit` + EVEX_Vdpbf16ps_xmm_k1z_xmm_xmmm128b32 = 3080, + // `VDPBF16PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.F3.0F38.W0 52 /r` + // + // `AVX512VL and AVX512_BF16` + // + // `16/32/64-bit` + EVEX_Vdpbf16ps_ymm_k1z_ymm_ymmm256b32 = 3081, + // `VDPBF16PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.F3.0F38.W0 52 /r` + // + // `AVX512F and AVX512_BF16` + // + // `16/32/64-bit` + EVEX_Vdpbf16ps_zmm_k1z_zmm_zmmm512b32 = 3082, + // `VP4DPWSSD zmm1 {k1}{z}, zmm2+3, m128` + // + // `EVEX.512.F2.0F38.W0 52 /r` + // + // `AVX512_4VNNIW` + // + // `16/32/64-bit` + EVEX_Vp4dpwssd_zmm_k1z_zmmp3_m128 = 3083, + // `VPDPWSSDS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 53 /r` + // + // `AVX512VL and AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpwssds_xmm_k1z_xmm_xmmm128b32 = 3084, + // `VPDPWSSDS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 53 /r` + // + // `AVX512VL and AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpwssds_ymm_k1z_ymm_ymmm256b32 = 3085, + // `VPDPWSSDS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 53 /r` + // + // `AVX512_VNNI` + // + // `16/32/64-bit` + EVEX_Vpdpwssds_zmm_k1z_zmm_zmmm512b32 = 3086, + // `VP4DPWSSDS zmm1 {k1}{z}, zmm2+3, m128` + // + // `EVEX.512.F2.0F38.W0 53 /r` + // + // `AVX512_4VNNIW` + // + // `16/32/64-bit` + EVEX_Vp4dpwssds_zmm_k1z_zmmp3_m128 = 3087, + // `VPOPCNTB xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F38.W0 54 /r` + // + // `AVX512VL and AVX512_BITALG` + // + // `16/32/64-bit` + EVEX_Vpopcntb_xmm_k1z_xmmm128 = 3088, + // `VPOPCNTB ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F38.W0 54 /r` + // + // `AVX512VL and AVX512_BITALG` + // + // `16/32/64-bit` + EVEX_Vpopcntb_ymm_k1z_ymmm256 = 3089, + // `VPOPCNTB zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F38.W0 54 /r` + // + // `AVX512_BITALG` + // + // `16/32/64-bit` + EVEX_Vpopcntb_zmm_k1z_zmmm512 = 3090, + // `VPOPCNTW xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F38.W1 54 /r` + // + // `AVX512VL and AVX512_BITALG` + // + // `16/32/64-bit` + EVEX_Vpopcntw_xmm_k1z_xmmm128 = 3091, + // `VPOPCNTW ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F38.W1 54 /r` + // + // `AVX512VL and AVX512_BITALG` + // + // `16/32/64-bit` + EVEX_Vpopcntw_ymm_k1z_ymmm256 = 3092, + // `VPOPCNTW zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F38.W1 54 /r` + // + // `AVX512_BITALG` + // + // `16/32/64-bit` + EVEX_Vpopcntw_zmm_k1z_zmmm512 = 3093, + // `VPOPCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 55 /r` + // + // `AVX512VL and AVX512_VPOPCNTDQ` + // + // `16/32/64-bit` + EVEX_Vpopcntd_xmm_k1z_xmmm128b32 = 3094, + // `VPOPCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 55 /r` + // + // `AVX512VL and AVX512_VPOPCNTDQ` + // + // `16/32/64-bit` + EVEX_Vpopcntd_ymm_k1z_ymmm256b32 = 3095, + // `VPOPCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 55 /r` + // + // `AVX512_VPOPCNTDQ` + // + // `16/32/64-bit` + EVEX_Vpopcntd_zmm_k1z_zmmm512b32 = 3096, + // `VPOPCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 55 /r` + // + // `AVX512VL and AVX512_VPOPCNTDQ` + // + // `16/32/64-bit` + EVEX_Vpopcntq_xmm_k1z_xmmm128b64 = 3097, + // `VPOPCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 55 /r` + // + // `AVX512VL and AVX512_VPOPCNTDQ` + // + // `16/32/64-bit` + EVEX_Vpopcntq_ymm_k1z_ymmm256b64 = 3098, + // `VPOPCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 55 /r` + // + // `AVX512_VPOPCNTDQ` + // + // `16/32/64-bit` + EVEX_Vpopcntq_zmm_k1z_zmmm512b64 = 3099, + // `VPBROADCASTD xmm1, xmm2/m32` + // + // `VEX.128.66.0F38.W0 58 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpbroadcastd_xmm_xmmm32 = 3100, + // `VPBROADCASTD ymm1, xmm2/m32` + // + // `VEX.256.66.0F38.W0 58 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpbroadcastd_ymm_xmmm32 = 3101, + // `VPBROADCASTD xmm1 {k1}{z}, xmm2/m32` + // + // `EVEX.128.66.0F38.W0 58 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpbroadcastd_xmm_k1z_xmmm32 = 3102, + // `VPBROADCASTD ymm1 {k1}{z}, xmm2/m32` + // + // `EVEX.256.66.0F38.W0 58 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpbroadcastd_ymm_k1z_xmmm32 = 3103, + // `VPBROADCASTD zmm1 {k1}{z}, xmm2/m32` + // + // `EVEX.512.66.0F38.W0 58 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpbroadcastd_zmm_k1z_xmmm32 = 3104, + // `VPBROADCASTQ xmm1, xmm2/m64` + // + // `VEX.128.66.0F38.W0 59 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpbroadcastq_xmm_xmmm64 = 3105, + // `VPBROADCASTQ ymm1, xmm2/m64` + // + // `VEX.256.66.0F38.W0 59 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpbroadcastq_ymm_xmmm64 = 3106, + // `VBROADCASTI32X2 xmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.128.66.0F38.W0 59 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vbroadcasti32x2_xmm_k1z_xmmm64 = 3107, + // `VBROADCASTI32X2 ymm1 {k1}{z}, xmm2/m64` + // + // `EVEX.256.66.0F38.W0 59 /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vbroadcasti32x2_ymm_k1z_xmmm64 = 3108, + // `VBROADCASTI32X2 zmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.512.66.0F38.W0 59 /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vbroadcasti32x2_zmm_k1z_xmmm64 = 3109, + // `VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.128.66.0F38.W1 59 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpbroadcastq_xmm_k1z_xmmm64 = 3110, + // `VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64` + // + // `EVEX.256.66.0F38.W1 59 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpbroadcastq_ymm_k1z_xmmm64 = 3111, + // `VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64` + // + // `EVEX.512.66.0F38.W1 59 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpbroadcastq_zmm_k1z_xmmm64 = 3112, + // `VBROADCASTI128 ymm1, m128` + // + // `VEX.256.66.0F38.W0 5A /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vbroadcasti128_ymm_m128 = 3113, + // `VBROADCASTI32X4 ymm1 {k1}{z}, m128` + // + // `EVEX.256.66.0F38.W0 5A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vbroadcasti32x4_ymm_k1z_m128 = 3114, + // `VBROADCASTI32X4 zmm1 {k1}{z}, m128` + // + // `EVEX.512.66.0F38.W0 5A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vbroadcasti32x4_zmm_k1z_m128 = 3115, + // `VBROADCASTI64X2 ymm1 {k1}{z}, m128` + // + // `EVEX.256.66.0F38.W1 5A /r` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vbroadcasti64x2_ymm_k1z_m128 = 3116, + // `VBROADCASTI64X2 zmm1 {k1}{z}, m128` + // + // `EVEX.512.66.0F38.W1 5A /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vbroadcasti64x2_zmm_k1z_m128 = 3117, + // `VBROADCASTI32X8 zmm1 {k1}{z}, m256` + // + // `EVEX.512.66.0F38.W0 5B /r` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vbroadcasti32x8_zmm_k1z_m256 = 3118, + // `VBROADCASTI64X4 zmm1 {k1}{z}, m256` + // + // `EVEX.512.66.0F38.W1 5B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vbroadcasti64x4_zmm_k1z_m256 = 3119, + // `VPEXPANDB xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F38.W0 62 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpexpandb_xmm_k1z_xmmm128 = 3120, + // `VPEXPANDB ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F38.W0 62 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpexpandb_ymm_k1z_ymmm256 = 3121, + // `VPEXPANDB zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F38.W0 62 /r` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpexpandb_zmm_k1z_zmmm512 = 3122, + // `VPEXPANDW xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F38.W1 62 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpexpandw_xmm_k1z_xmmm128 = 3123, + // `VPEXPANDW ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F38.W1 62 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpexpandw_ymm_k1z_ymmm256 = 3124, + // `VPEXPANDW zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F38.W1 62 /r` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpexpandw_zmm_k1z_zmmm512 = 3125, + // `VPCOMPRESSB xmm1/m128 {k1}{z}, xmm2` + // + // `EVEX.128.66.0F38.W0 63 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpcompressb_xmmm128_k1z_xmm = 3126, + // `VPCOMPRESSB ymm1/m256 {k1}{z}, ymm2` + // + // `EVEX.256.66.0F38.W0 63 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpcompressb_ymmm256_k1z_ymm = 3127, + // `VPCOMPRESSB zmm1/m512 {k1}{z}, zmm2` + // + // `EVEX.512.66.0F38.W0 63 /r` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpcompressb_zmmm512_k1z_zmm = 3128, + // `VPCOMPRESSW xmm1/m128 {k1}{z}, xmm2` + // + // `EVEX.128.66.0F38.W1 63 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpcompressw_xmmm128_k1z_xmm = 3129, + // `VPCOMPRESSW ymm1/m256 {k1}{z}, ymm2` + // + // `EVEX.256.66.0F38.W1 63 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpcompressw_ymmm256_k1z_ymm = 3130, + // `VPCOMPRESSW zmm1/m512 {k1}{z}, zmm2` + // + // `EVEX.512.66.0F38.W1 63 /r` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpcompressw_zmmm512_k1z_zmm = 3131, + // `VPBLENDMD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 64 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpblendmd_xmm_k1z_xmm_xmmm128b32 = 3132, + // `VPBLENDMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 64 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpblendmd_ymm_k1z_ymm_ymmm256b32 = 3133, + // `VPBLENDMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 64 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpblendmd_zmm_k1z_zmm_zmmm512b32 = 3134, + // `VPBLENDMQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 64 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpblendmq_xmm_k1z_xmm_xmmm128b64 = 3135, + // `VPBLENDMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 64 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpblendmq_ymm_k1z_ymm_ymmm256b64 = 3136, + // `VPBLENDMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 64 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpblendmq_zmm_k1z_zmm_zmmm512b64 = 3137, + // `VBLENDMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 65 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vblendmps_xmm_k1z_xmm_xmmm128b32 = 3138, + // `VBLENDMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 65 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vblendmps_ymm_k1z_ymm_ymmm256b32 = 3139, + // `VBLENDMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 65 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vblendmps_zmm_k1z_zmm_zmmm512b32 = 3140, + // `VBLENDMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 65 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vblendmpd_xmm_k1z_xmm_xmmm128b64 = 3141, + // `VBLENDMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 65 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vblendmpd_ymm_k1z_ymm_ymmm256b64 = 3142, + // `VBLENDMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 65 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vblendmpd_zmm_k1z_zmm_zmmm512b64 = 3143, + // `VPBLENDMB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W0 66 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpblendmb_xmm_k1z_xmm_xmmm128 = 3144, + // `VPBLENDMB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W0 66 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpblendmb_ymm_k1z_ymm_ymmm256 = 3145, + // `VPBLENDMB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W0 66 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpblendmb_zmm_k1z_zmm_zmmm512 = 3146, + // `VPBLENDMW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W1 66 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpblendmw_xmm_k1z_xmm_xmmm128 = 3147, + // `VPBLENDMW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W1 66 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpblendmw_ymm_k1z_ymm_ymmm256 = 3148, + // `VPBLENDMW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W1 66 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpblendmw_zmm_k1z_zmm_zmmm512 = 3149, + // `VP2INTERSECTD k1+1, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.F2.0F38.W0 68 /r` + // + // `AVX512VL and AVX512_VP2INTERSECT` + // + // `16/32/64-bit` + EVEX_Vp2intersectd_kp1_xmm_xmmm128b32 = 3150, + // `VP2INTERSECTD k1+1, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.F2.0F38.W0 68 /r` + // + // `AVX512VL and AVX512_VP2INTERSECT` + // + // `16/32/64-bit` + EVEX_Vp2intersectd_kp1_ymm_ymmm256b32 = 3151, + // `VP2INTERSECTD k1+1, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.F2.0F38.W0 68 /r` + // + // `AVX512F and AVX512_VP2INTERSECT` + // + // `16/32/64-bit` + EVEX_Vp2intersectd_kp1_zmm_zmmm512b32 = 3152, + // `VP2INTERSECTQ k1+1, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.F2.0F38.W1 68 /r` + // + // `AVX512VL and AVX512_VP2INTERSECT` + // + // `16/32/64-bit` + EVEX_Vp2intersectq_kp1_xmm_xmmm128b64 = 3153, + // `VP2INTERSECTQ k1+1, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.F2.0F38.W1 68 /r` + // + // `AVX512VL and AVX512_VP2INTERSECT` + // + // `16/32/64-bit` + EVEX_Vp2intersectq_kp1_ymm_ymmm256b64 = 3154, + // `VP2INTERSECTQ k1+1, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.F2.0F38.W1 68 /r` + // + // `AVX512F and AVX512_VP2INTERSECT` + // + // `16/32/64-bit` + EVEX_Vp2intersectq_kp1_zmm_zmmm512b64 = 3155, + // `VPSHLDVW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W1 70 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldvw_xmm_k1z_xmm_xmmm128 = 3156, + // `VPSHLDVW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W1 70 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldvw_ymm_k1z_ymm_ymmm256 = 3157, + // `VPSHLDVW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W1 70 /r` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldvw_zmm_k1z_zmm_zmmm512 = 3158, + // `VPSHLDVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 71 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldvd_xmm_k1z_xmm_xmmm128b32 = 3159, + // `VPSHLDVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 71 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldvd_ymm_k1z_ymm_ymmm256b32 = 3160, + // `VPSHLDVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 71 /r` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldvd_zmm_k1z_zmm_zmmm512b32 = 3161, + // `VPSHLDVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 71 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldvq_xmm_k1z_xmm_xmmm128b64 = 3162, + // `VPSHLDVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 71 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldvq_ymm_k1z_ymm_ymmm256b64 = 3163, + // `VPSHLDVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 71 /r` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldvq_zmm_k1z_zmm_zmmm512b64 = 3164, + // `VPSHRDVW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W1 72 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdvw_xmm_k1z_xmm_xmmm128 = 3165, + // `VPSHRDVW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W1 72 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdvw_ymm_k1z_ymm_ymmm256 = 3166, + // `VPSHRDVW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W1 72 /r` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdvw_zmm_k1z_zmm_zmmm512 = 3167, + // `VCVTNEPS2BF16 xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.F3.0F38.W0 72 /r` + // + // `AVX512VL and AVX512_BF16` + // + // `16/32/64-bit` + EVEX_Vcvtneps2bf16_xmm_k1z_xmmm128b32 = 3168, + // `VCVTNEPS2BF16 xmm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.F3.0F38.W0 72 /r` + // + // `AVX512VL and AVX512_BF16` + // + // `16/32/64-bit` + EVEX_Vcvtneps2bf16_xmm_k1z_ymmm256b32 = 3169, + // `VCVTNEPS2BF16 ymm1 {k1}{z}, zmm2/m512/m32bcst` + // + // `EVEX.512.F3.0F38.W0 72 /r` + // + // `AVX512F and AVX512_BF16` + // + // `16/32/64-bit` + EVEX_Vcvtneps2bf16_ymm_k1z_zmmm512b32 = 3170, + // `VCVTNE2PS2BF16 xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.F2.0F38.W0 72 /r` + // + // `AVX512VL and AVX512_BF16` + // + // `16/32/64-bit` + EVEX_Vcvtne2ps2bf16_xmm_k1z_xmm_xmmm128b32 = 3171, + // `VCVTNE2PS2BF16 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.F2.0F38.W0 72 /r` + // + // `AVX512VL and AVX512_BF16` + // + // `16/32/64-bit` + EVEX_Vcvtne2ps2bf16_ymm_k1z_ymm_ymmm256b32 = 3172, + // `VCVTNE2PS2BF16 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.F2.0F38.W0 72 /r` + // + // `AVX512F and AVX512_BF16` + // + // `16/32/64-bit` + EVEX_Vcvtne2ps2bf16_zmm_k1z_zmm_zmmm512b32 = 3173, + // `VPSHRDVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 73 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdvd_xmm_k1z_xmm_xmmm128b32 = 3174, + // `VPSHRDVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 73 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdvd_ymm_k1z_ymm_ymmm256b32 = 3175, + // `VPSHRDVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 73 /r` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdvd_zmm_k1z_zmm_zmmm512b32 = 3176, + // `VPSHRDVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 73 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdvq_xmm_k1z_xmm_xmmm128b64 = 3177, + // `VPSHRDVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 73 /r` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdvq_ymm_k1z_ymm_ymmm256b64 = 3178, + // `VPSHRDVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 73 /r` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdvq_zmm_k1z_zmm_zmmm512b64 = 3179, + // `VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W0 75 /r` + // + // `AVX512VL and AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpermi2b_xmm_k1z_xmm_xmmm128 = 3180, + // `VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W0 75 /r` + // + // `AVX512VL and AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpermi2b_ymm_k1z_ymm_ymmm256 = 3181, + // `VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W0 75 /r` + // + // `AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpermi2b_zmm_k1z_zmm_zmmm512 = 3182, + // `VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W1 75 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpermi2w_xmm_k1z_xmm_xmmm128 = 3183, + // `VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W1 75 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpermi2w_ymm_k1z_ymm_ymmm256 = 3184, + // `VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W1 75 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpermi2w_zmm_k1z_zmm_zmmm512 = 3185, + // `VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 76 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2d_xmm_k1z_xmm_xmmm128b32 = 3186, + // `VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 76 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2d_ymm_k1z_ymm_ymmm256b32 = 3187, + // `VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 76 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2d_zmm_k1z_zmm_zmmm512b32 = 3188, + // `VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 76 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2q_xmm_k1z_xmm_xmmm128b64 = 3189, + // `VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 76 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2q_ymm_k1z_ymm_ymmm256b64 = 3190, + // `VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 76 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2q_zmm_k1z_zmm_zmmm512b64 = 3191, + // `VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 77 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2ps_xmm_k1z_xmm_xmmm128b32 = 3192, + // `VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 77 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2ps_ymm_k1z_ymm_ymmm256b32 = 3193, + // `VPERMI2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 77 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2ps_zmm_k1z_zmm_zmmm512b32 = 3194, + // `VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 77 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2pd_xmm_k1z_xmm_xmmm128b64 = 3195, + // `VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 77 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2pd_ymm_k1z_ymm_ymmm256b64 = 3196, + // `VPERMI2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 77 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermi2pd_zmm_k1z_zmm_zmmm512b64 = 3197, + // `VPBROADCASTB xmm1, xmm2/m8` + // + // `VEX.128.66.0F38.W0 78 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpbroadcastb_xmm_xmmm8 = 3198, + // `VPBROADCASTB ymm1, xmm2/m8` + // + // `VEX.256.66.0F38.W0 78 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpbroadcastb_ymm_xmmm8 = 3199, + // `VPBROADCASTB xmm1 {k1}{z}, xmm2/m8` + // + // `EVEX.128.66.0F38.W0 78 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastb_xmm_k1z_xmmm8 = 3200, + // `VPBROADCASTB ymm1 {k1}{z}, xmm2/m8` + // + // `EVEX.256.66.0F38.W0 78 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastb_ymm_k1z_xmmm8 = 3201, + // `VPBROADCASTB zmm1 {k1}{z}, xmm2/m8` + // + // `EVEX.512.66.0F38.W0 78 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastb_zmm_k1z_xmmm8 = 3202, + // `VPBROADCASTW xmm1, xmm2/m16` + // + // `VEX.128.66.0F38.W0 79 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpbroadcastw_xmm_xmmm16 = 3203, + // `VPBROADCASTW ymm1, xmm2/m16` + // + // `VEX.256.66.0F38.W0 79 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpbroadcastw_ymm_xmmm16 = 3204, + // `VPBROADCASTW xmm1 {k1}{z}, xmm2/m16` + // + // `EVEX.128.66.0F38.W0 79 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastw_xmm_k1z_xmmm16 = 3205, + // `VPBROADCASTW ymm1 {k1}{z}, xmm2/m16` + // + // `EVEX.256.66.0F38.W0 79 /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastw_ymm_k1z_xmmm16 = 3206, + // `VPBROADCASTW zmm1 {k1}{z}, xmm2/m16` + // + // `EVEX.512.66.0F38.W0 79 /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastw_zmm_k1z_xmmm16 = 3207, + // `VPBROADCASTB xmm1 {k1}{z}, r32` + // + // `EVEX.128.66.0F38.W0 7A /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastb_xmm_k1z_r32 = 3208, + // `VPBROADCASTB ymm1 {k1}{z}, r32` + // + // `EVEX.256.66.0F38.W0 7A /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastb_ymm_k1z_r32 = 3209, + // `VPBROADCASTB zmm1 {k1}{z}, r32` + // + // `EVEX.512.66.0F38.W0 7A /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastb_zmm_k1z_r32 = 3210, + // `VPBROADCASTW xmm1 {k1}{z}, r32` + // + // `EVEX.128.66.0F38.W0 7B /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastw_xmm_k1z_r32 = 3211, + // `VPBROADCASTW ymm1 {k1}{z}, r32` + // + // `EVEX.256.66.0F38.W0 7B /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastw_ymm_k1z_r32 = 3212, + // `VPBROADCASTW zmm1 {k1}{z}, r32` + // + // `EVEX.512.66.0F38.W0 7B /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpbroadcastw_zmm_k1z_r32 = 3213, + // `VPBROADCASTD xmm1 {k1}{z}, r32` + // + // `EVEX.128.66.0F38.W0 7C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpbroadcastd_xmm_k1z_r32 = 3214, + // `VPBROADCASTD ymm1 {k1}{z}, r32` + // + // `EVEX.256.66.0F38.W0 7C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpbroadcastd_ymm_k1z_r32 = 3215, + // `VPBROADCASTD zmm1 {k1}{z}, r32` + // + // `EVEX.512.66.0F38.W0 7C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpbroadcastd_zmm_k1z_r32 = 3216, + // `VPBROADCASTQ xmm1 {k1}{z}, r64` + // + // `EVEX.128.66.0F38.W1 7C /r` + // + // `AVX512VL and AVX512F` + // + // `64-bit` + EVEX_Vpbroadcastq_xmm_k1z_r64 = 3217, + // `VPBROADCASTQ ymm1 {k1}{z}, r64` + // + // `EVEX.256.66.0F38.W1 7C /r` + // + // `AVX512VL and AVX512F` + // + // `64-bit` + EVEX_Vpbroadcastq_ymm_k1z_r64 = 3218, + // `VPBROADCASTQ zmm1 {k1}{z}, r64` + // + // `EVEX.512.66.0F38.W1 7C /r` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vpbroadcastq_zmm_k1z_r64 = 3219, + // `VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W0 7D /r` + // + // `AVX512VL and AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpermt2b_xmm_k1z_xmm_xmmm128 = 3220, + // `VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W0 7D /r` + // + // `AVX512VL and AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpermt2b_ymm_k1z_ymm_ymmm256 = 3221, + // `VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W0 7D /r` + // + // `AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpermt2b_zmm_k1z_zmm_zmmm512 = 3222, + // `VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W1 7D /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpermt2w_xmm_k1z_xmm_xmmm128 = 3223, + // `VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W1 7D /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpermt2w_ymm_k1z_ymm_ymmm256 = 3224, + // `VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W1 7D /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpermt2w_zmm_k1z_zmm_zmmm512 = 3225, + // `VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 7E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2d_xmm_k1z_xmm_xmmm128b32 = 3226, + // `VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 7E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2d_ymm_k1z_ymm_ymmm256b32 = 3227, + // `VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 7E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2d_zmm_k1z_zmm_zmmm512b32 = 3228, + // `VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 7E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2q_xmm_k1z_xmm_xmmm128b64 = 3229, + // `VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 7E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2q_ymm_k1z_ymm_ymmm256b64 = 3230, + // `VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 7E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2q_zmm_k1z_zmm_zmmm512b64 = 3231, + // `VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2ps_xmm_k1z_xmm_xmmm128b32 = 3232, + // `VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2ps_ymm_k1z_ymm_ymmm256b32 = 3233, + // `VPERMT2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 7F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2ps_zmm_k1z_zmm_zmmm512b32 = 3234, + // `VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2pd_xmm_k1z_xmm_xmmm128b64 = 3235, + // `VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 7F /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2pd_ymm_k1z_ymm_ymmm256b64 = 3236, + // `VPERMT2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 7F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermt2pd_zmm_k1z_zmm_zmmm512b64 = 3237, + // `INVEPT r32, m128` + // + // `66 0F 38 80 /r` + // + // `VMX and IA32_VMX_EPT_VPID_CAP[bit 20]` + // + // `16/32-bit` + Invept_r32_m128 = 3238, + // `INVEPT r64, m128` + // + // `66 0F 38 80 /r` + // + // `VMX and IA32_VMX_EPT_VPID_CAP[bit 20]` + // + // `64-bit` + Invept_r64_m128 = 3239, + // `INVVPID r32, m128` + // + // `66 0F 38 81 /r` + // + // `VMX and IA32_VMX_EPT_VPID_CAP[bit 32]` + // + // `16/32-bit` + Invvpid_r32_m128 = 3240, + // `INVVPID r64, m128` + // + // `66 0F 38 81 /r` + // + // `VMX and IA32_VMX_EPT_VPID_CAP[bit 32]` + // + // `64-bit` + Invvpid_r64_m128 = 3241, + // `INVPCID r32, m128` + // + // `66 0F 38 82 /r` + // + // `INVPCID` + // + // `16/32-bit` + Invpcid_r32_m128 = 3242, + // `INVPCID r64, m128` + // + // `66 0F 38 82 /r` + // + // `INVPCID` + // + // `64-bit` + Invpcid_r64_m128 = 3243, + // `VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 83 /r` + // + // `AVX512VL and AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpmultishiftqb_xmm_k1z_xmm_xmmm128b64 = 3244, + // `VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 83 /r` + // + // `AVX512VL and AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpmultishiftqb_ymm_k1z_ymm_ymmm256b64 = 3245, + // `VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 83 /r` + // + // `AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpmultishiftqb_zmm_k1z_zmm_zmmm512b64 = 3246, + // `VEXPANDPS xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F38.W0 88 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vexpandps_xmm_k1z_xmmm128 = 3247, + // `VEXPANDPS ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F38.W0 88 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vexpandps_ymm_k1z_ymmm256 = 3248, + // `VEXPANDPS zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F38.W0 88 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vexpandps_zmm_k1z_zmmm512 = 3249, + // `VEXPANDPD xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F38.W1 88 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vexpandpd_xmm_k1z_xmmm128 = 3250, + // `VEXPANDPD ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F38.W1 88 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vexpandpd_ymm_k1z_ymmm256 = 3251, + // `VEXPANDPD zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F38.W1 88 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vexpandpd_zmm_k1z_zmmm512 = 3252, + // `VPEXPANDD xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F38.W0 89 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpexpandd_xmm_k1z_xmmm128 = 3253, + // `VPEXPANDD ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F38.W0 89 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpexpandd_ymm_k1z_ymmm256 = 3254, + // `VPEXPANDD zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F38.W0 89 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpexpandd_zmm_k1z_zmmm512 = 3255, + // `VPEXPANDQ xmm1 {k1}{z}, xmm2/m128` + // + // `EVEX.128.66.0F38.W1 89 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpexpandq_xmm_k1z_xmmm128 = 3256, + // `VPEXPANDQ ymm1 {k1}{z}, ymm2/m256` + // + // `EVEX.256.66.0F38.W1 89 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpexpandq_ymm_k1z_ymmm256 = 3257, + // `VPEXPANDQ zmm1 {k1}{z}, zmm2/m512` + // + // `EVEX.512.66.0F38.W1 89 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpexpandq_zmm_k1z_zmmm512 = 3258, + // `VCOMPRESSPS xmm1/m128 {k1}{z}, xmm2` + // + // `EVEX.128.66.0F38.W0 8A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcompressps_xmmm128_k1z_xmm = 3259, + // `VCOMPRESSPS ymm1/m256 {k1}{z}, ymm2` + // + // `EVEX.256.66.0F38.W0 8A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcompressps_ymmm256_k1z_ymm = 3260, + // `VCOMPRESSPS zmm1/m512 {k1}{z}, zmm2` + // + // `EVEX.512.66.0F38.W0 8A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcompressps_zmmm512_k1z_zmm = 3261, + // `VCOMPRESSPD xmm1/m128 {k1}{z}, xmm2` + // + // `EVEX.128.66.0F38.W1 8A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcompresspd_xmmm128_k1z_xmm = 3262, + // `VCOMPRESSPD ymm1/m256 {k1}{z}, ymm2` + // + // `EVEX.256.66.0F38.W1 8A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcompresspd_ymmm256_k1z_ymm = 3263, + // `VCOMPRESSPD zmm1/m512 {k1}{z}, zmm2` + // + // `EVEX.512.66.0F38.W1 8A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcompresspd_zmmm512_k1z_zmm = 3264, + // `VPCOMPRESSD xmm1/m128 {k1}{z}, xmm2` + // + // `EVEX.128.66.0F38.W0 8B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcompressd_xmmm128_k1z_xmm = 3265, + // `VPCOMPRESSD ymm1/m256 {k1}{z}, ymm2` + // + // `EVEX.256.66.0F38.W0 8B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcompressd_ymmm256_k1z_ymm = 3266, + // `VPCOMPRESSD zmm1/m512 {k1}{z}, zmm2` + // + // `EVEX.512.66.0F38.W0 8B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcompressd_zmmm512_k1z_zmm = 3267, + // `VPCOMPRESSQ xmm1/m128 {k1}{z}, xmm2` + // + // `EVEX.128.66.0F38.W1 8B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcompressq_xmmm128_k1z_xmm = 3268, + // `VPCOMPRESSQ ymm1/m256 {k1}{z}, ymm2` + // + // `EVEX.256.66.0F38.W1 8B /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcompressq_ymmm256_k1z_ymm = 3269, + // `VPCOMPRESSQ zmm1/m512 {k1}{z}, zmm2` + // + // `EVEX.512.66.0F38.W1 8B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcompressq_zmmm512_k1z_zmm = 3270, + // `VPMASKMOVD xmm1, xmm2, m128` + // + // `VEX.128.66.0F38.W0 8C /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaskmovd_xmm_xmm_m128 = 3271, + // `VPMASKMOVD ymm1, ymm2, m256` + // + // `VEX.256.66.0F38.W0 8C /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaskmovd_ymm_ymm_m256 = 3272, + // `VPMASKMOVQ xmm1, xmm2, m128` + // + // `VEX.128.66.0F38.W1 8C /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaskmovq_xmm_xmm_m128 = 3273, + // `VPMASKMOVQ ymm1, ymm2, m256` + // + // `VEX.256.66.0F38.W1 8C /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaskmovq_ymm_ymm_m256 = 3274, + // `VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W0 8D /r` + // + // `AVX512VL and AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpermb_xmm_k1z_xmm_xmmm128 = 3275, + // `VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W0 8D /r` + // + // `AVX512VL and AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpermb_ymm_k1z_ymm_ymmm256 = 3276, + // `VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W0 8D /r` + // + // `AVX512_VBMI` + // + // `16/32/64-bit` + EVEX_Vpermb_zmm_k1z_zmm_zmmm512 = 3277, + // `VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W1 8D /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpermw_xmm_k1z_xmm_xmmm128 = 3278, + // `VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W1 8D /r` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpermw_ymm_k1z_ymm_ymmm256 = 3279, + // `VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W1 8D /r` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpermw_zmm_k1z_zmm_zmmm512 = 3280, + // `VPMASKMOVD m128, xmm1, xmm2` + // + // `VEX.128.66.0F38.W0 8E /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaskmovd_m128_xmm_xmm = 3281, + // `VPMASKMOVD m256, ymm1, ymm2` + // + // `VEX.256.66.0F38.W0 8E /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaskmovd_m256_ymm_ymm = 3282, + // `VPMASKMOVQ m128, xmm1, xmm2` + // + // `VEX.128.66.0F38.W1 8E /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaskmovq_m128_xmm_xmm = 3283, + // `VPMASKMOVQ m256, ymm1, ymm2` + // + // `VEX.256.66.0F38.W1 8E /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpmaskmovq_m256_ymm_ymm = 3284, + // `VPSHUFBITQMB k1 {k2}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W0 8F /r` + // + // `AVX512VL and AVX512_BITALG` + // + // `16/32/64-bit` + EVEX_Vpshufbitqmb_kr_k1_xmm_xmmm128 = 3285, + // `VPSHUFBITQMB k1 {k2}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W0 8F /r` + // + // `AVX512VL and AVX512_BITALG` + // + // `16/32/64-bit` + EVEX_Vpshufbitqmb_kr_k1_ymm_ymmm256 = 3286, + // `VPSHUFBITQMB k1 {k2}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W0 8F /r` + // + // `AVX512_BITALG` + // + // `16/32/64-bit` + EVEX_Vpshufbitqmb_kr_k1_zmm_zmmm512 = 3287, + // `VPGATHERDD xmm1, vm32x, xmm2` + // + // `VEX.128.66.0F38.W0 90 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpgatherdd_xmm_vm32x_xmm = 3288, + // `VPGATHERDD ymm1, vm32y, ymm2` + // + // `VEX.256.66.0F38.W0 90 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpgatherdd_ymm_vm32y_ymm = 3289, + // `VPGATHERDQ xmm1, vm32x, xmm2` + // + // `VEX.128.66.0F38.W1 90 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpgatherdq_xmm_vm32x_xmm = 3290, + // `VPGATHERDQ ymm1, vm32x, ymm2` + // + // `VEX.256.66.0F38.W1 90 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpgatherdq_ymm_vm32x_ymm = 3291, + // `VPGATHERDD xmm1 {k1}, vm32x` + // + // `EVEX.128.66.0F38.W0 90 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherdd_xmm_k1_vm32x = 3292, + // `VPGATHERDD ymm1 {k1}, vm32y` + // + // `EVEX.256.66.0F38.W0 90 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherdd_ymm_k1_vm32y = 3293, + // `VPGATHERDD zmm1 {k1}, vm32z` + // + // `EVEX.512.66.0F38.W0 90 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherdd_zmm_k1_vm32z = 3294, + // `VPGATHERDQ xmm1 {k1}, vm32x` + // + // `EVEX.128.66.0F38.W1 90 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherdq_xmm_k1_vm32x = 3295, + // `VPGATHERDQ ymm1 {k1}, vm32x` + // + // `EVEX.256.66.0F38.W1 90 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherdq_ymm_k1_vm32x = 3296, + // `VPGATHERDQ zmm1 {k1}, vm32y` + // + // `EVEX.512.66.0F38.W1 90 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherdq_zmm_k1_vm32y = 3297, + // `VPGATHERQD xmm1, vm64x, xmm2` + // + // `VEX.128.66.0F38.W0 91 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpgatherqd_xmm_vm64x_xmm = 3298, + // `VPGATHERQD xmm1, vm64y, xmm2` + // + // `VEX.256.66.0F38.W0 91 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpgatherqd_xmm_vm64y_xmm = 3299, + // `VPGATHERQQ xmm1, vm64x, xmm2` + // + // `VEX.128.66.0F38.W1 91 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpgatherqq_xmm_vm64x_xmm = 3300, + // `VPGATHERQQ ymm1, vm64y, ymm2` + // + // `VEX.256.66.0F38.W1 91 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpgatherqq_ymm_vm64y_ymm = 3301, + // `VPGATHERQD xmm1 {k1}, vm64x` + // + // `EVEX.128.66.0F38.W0 91 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherqd_xmm_k1_vm64x = 3302, + // `VPGATHERQD xmm1 {k1}, vm64y` + // + // `EVEX.256.66.0F38.W0 91 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherqd_xmm_k1_vm64y = 3303, + // `VPGATHERQD ymm1 {k1}, vm64z` + // + // `EVEX.512.66.0F38.W0 91 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherqd_ymm_k1_vm64z = 3304, + // `VPGATHERQQ xmm1 {k1}, vm64x` + // + // `EVEX.128.66.0F38.W1 91 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherqq_xmm_k1_vm64x = 3305, + // `VPGATHERQQ ymm1 {k1}, vm64y` + // + // `EVEX.256.66.0F38.W1 91 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherqq_ymm_k1_vm64y = 3306, + // `VPGATHERQQ zmm1 {k1}, vm64z` + // + // `EVEX.512.66.0F38.W1 91 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpgatherqq_zmm_k1_vm64z = 3307, + // `VGATHERDPS xmm1, vm32x, xmm2` + // + // `VEX.128.66.0F38.W0 92 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vgatherdps_xmm_vm32x_xmm = 3308, + // `VGATHERDPS ymm1, vm32y, ymm2` + // + // `VEX.256.66.0F38.W0 92 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vgatherdps_ymm_vm32y_ymm = 3309, + // `VGATHERDPD xmm1, vm32x, xmm2` + // + // `VEX.128.66.0F38.W1 92 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vgatherdpd_xmm_vm32x_xmm = 3310, + // `VGATHERDPD ymm1, vm32x, ymm2` + // + // `VEX.256.66.0F38.W1 92 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vgatherdpd_ymm_vm32x_ymm = 3311, + // `VGATHERDPS xmm1 {k1}, vm32x` + // + // `EVEX.128.66.0F38.W0 92 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherdps_xmm_k1_vm32x = 3312, + // `VGATHERDPS ymm1 {k1}, vm32y` + // + // `EVEX.256.66.0F38.W0 92 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherdps_ymm_k1_vm32y = 3313, + // `VGATHERDPS zmm1 {k1}, vm32z` + // + // `EVEX.512.66.0F38.W0 92 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherdps_zmm_k1_vm32z = 3314, + // `VGATHERDPD xmm1 {k1}, vm32x` + // + // `EVEX.128.66.0F38.W1 92 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherdpd_xmm_k1_vm32x = 3315, + // `VGATHERDPD ymm1 {k1}, vm32x` + // + // `EVEX.256.66.0F38.W1 92 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherdpd_ymm_k1_vm32x = 3316, + // `VGATHERDPD zmm1 {k1}, vm32y` + // + // `EVEX.512.66.0F38.W1 92 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherdpd_zmm_k1_vm32y = 3317, + // `VGATHERQPS xmm1, vm64x, xmm2` + // + // `VEX.128.66.0F38.W0 93 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vgatherqps_xmm_vm64x_xmm = 3318, + // `VGATHERQPS xmm1, vm64y, xmm2` + // + // `VEX.256.66.0F38.W0 93 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vgatherqps_xmm_vm64y_xmm = 3319, + // `VGATHERQPD xmm1, vm64x, xmm2` + // + // `VEX.128.66.0F38.W1 93 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vgatherqpd_xmm_vm64x_xmm = 3320, + // `VGATHERQPD ymm1, vm64y, ymm2` + // + // `VEX.256.66.0F38.W1 93 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vgatherqpd_ymm_vm64y_ymm = 3321, + // `VGATHERQPS xmm1 {k1}, vm64x` + // + // `EVEX.128.66.0F38.W0 93 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherqps_xmm_k1_vm64x = 3322, + // `VGATHERQPS xmm1 {k1}, vm64y` + // + // `EVEX.256.66.0F38.W0 93 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherqps_xmm_k1_vm64y = 3323, + // `VGATHERQPS ymm1 {k1}, vm64z` + // + // `EVEX.512.66.0F38.W0 93 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherqps_ymm_k1_vm64z = 3324, + // `VGATHERQPD xmm1 {k1}, vm64x` + // + // `EVEX.128.66.0F38.W1 93 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherqpd_xmm_k1_vm64x = 3325, + // `VGATHERQPD ymm1 {k1}, vm64y` + // + // `EVEX.256.66.0F38.W1 93 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherqpd_ymm_k1_vm64y = 3326, + // `VGATHERQPD zmm1 {k1}, vm64z` + // + // `EVEX.512.66.0F38.W1 93 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgatherqpd_zmm_k1_vm64z = 3327, + // `VFMADDSUB132PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 96 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub132ps_xmm_xmm_xmmm128 = 3328, + // `VFMADDSUB132PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 96 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub132ps_ymm_ymm_ymmm256 = 3329, + // `VFMADDSUB132PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 96 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub132pd_xmm_xmm_xmmm128 = 3330, + // `VFMADDSUB132PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 96 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub132pd_ymm_ymm_ymmm256 = 3331, + // `VFMADDSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 96 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub132ps_xmm_k1z_xmm_xmmm128b32 = 3332, + // `VFMADDSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 96 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub132ps_ymm_k1z_ymm_ymmm256b32 = 3333, + // `VFMADDSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 96 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub132ps_zmm_k1z_zmm_zmmm512b32_er = 3334, + // `VFMADDSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 96 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub132pd_xmm_k1z_xmm_xmmm128b64 = 3335, + // `VFMADDSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 96 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub132pd_ymm_k1z_ymm_ymmm256b64 = 3336, + // `VFMADDSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 96 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub132pd_zmm_k1z_zmm_zmmm512b64_er = 3337, + // `VFMSUBADD132PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 97 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd132ps_xmm_xmm_xmmm128 = 3338, + // `VFMSUBADD132PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 97 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd132ps_ymm_ymm_ymmm256 = 3339, + // `VFMSUBADD132PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 97 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd132pd_xmm_xmm_xmmm128 = 3340, + // `VFMSUBADD132PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 97 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd132pd_ymm_ymm_ymmm256 = 3341, + // `VFMSUBADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 97 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd132ps_xmm_k1z_xmm_xmmm128b32 = 3342, + // `VFMSUBADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 97 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd132ps_ymm_k1z_ymm_ymmm256b32 = 3343, + // `VFMSUBADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 97 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd132ps_zmm_k1z_zmm_zmmm512b32_er = 3344, + // `VFMSUBADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 97 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd132pd_xmm_k1z_xmm_xmmm128b64 = 3345, + // `VFMSUBADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 97 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd132pd_ymm_k1z_ymm_ymmm256b64 = 3346, + // `VFMSUBADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 97 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd132pd_zmm_k1z_zmm_zmmm512b64_er = 3347, + // `VFMADD132PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 98 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd132ps_xmm_xmm_xmmm128 = 3348, + // `VFMADD132PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 98 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd132ps_ymm_ymm_ymmm256 = 3349, + // `VFMADD132PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 98 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd132pd_xmm_xmm_xmmm128 = 3350, + // `VFMADD132PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 98 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd132pd_ymm_ymm_ymmm256 = 3351, + // `VFMADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 98 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd132ps_xmm_k1z_xmm_xmmm128b32 = 3352, + // `VFMADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 98 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd132ps_ymm_k1z_ymm_ymmm256b32 = 3353, + // `VFMADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 98 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd132ps_zmm_k1z_zmm_zmmm512b32_er = 3354, + // `VFMADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 98 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd132pd_xmm_k1z_xmm_xmmm128b64 = 3355, + // `VFMADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 98 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd132pd_ymm_k1z_ymm_ymmm256b64 = 3356, + // `VFMADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 98 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd132pd_zmm_k1z_zmm_zmmm512b64_er = 3357, + // `VFMADD132SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 99 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd132ss_xmm_xmm_xmmm32 = 3358, + // `VFMADD132SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 99 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd132sd_xmm_xmm_xmmm64 = 3359, + // `VFMADD132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 99 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd132ss_xmm_k1z_xmm_xmmm32_er = 3360, + // `VFMADD132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 99 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd132sd_xmm_k1z_xmm_xmmm64_er = 3361, + // `VFMSUB132PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 9A /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub132ps_xmm_xmm_xmmm128 = 3362, + // `VFMSUB132PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 9A /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub132ps_ymm_ymm_ymmm256 = 3363, + // `VFMSUB132PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 9A /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub132pd_xmm_xmm_xmmm128 = 3364, + // `VFMSUB132PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 9A /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub132pd_ymm_ymm_ymmm256 = 3365, + // `VFMSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 9A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub132ps_xmm_k1z_xmm_xmmm128b32 = 3366, + // `VFMSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 9A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub132ps_ymm_k1z_ymm_ymmm256b32 = 3367, + // `VFMSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 9A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub132ps_zmm_k1z_zmm_zmmm512b32_er = 3368, + // `VFMSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 9A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub132pd_xmm_k1z_xmm_xmmm128b64 = 3369, + // `VFMSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 9A /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub132pd_ymm_k1z_ymm_ymmm256b64 = 3370, + // `VFMSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 9A /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub132pd_zmm_k1z_zmm_zmmm512b64_er = 3371, + // `V4FMADDPS zmm1 {k1}{z}, zmm2+3, m128` + // + // `EVEX.512.F2.0F38.W0 9A /r` + // + // `AVX512_4FMAPS` + // + // `16/32/64-bit` + EVEX_V4fmaddps_zmm_k1z_zmmp3_m128 = 3372, + // `VFMSUB132SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 9B /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub132ss_xmm_xmm_xmmm32 = 3373, + // `VFMSUB132SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 9B /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub132sd_xmm_xmm_xmmm64 = 3374, + // `VFMSUB132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 9B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub132ss_xmm_k1z_xmm_xmmm32_er = 3375, + // `VFMSUB132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 9B /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub132sd_xmm_k1z_xmm_xmmm64_er = 3376, + // `V4FMADDSS xmm1 {k1}{z}, xmm2+3, m128` + // + // `EVEX.LIG.F2.0F38.W0 9B /r` + // + // `AVX512_4FMAPS` + // + // `16/32/64-bit` + EVEX_V4fmaddss_xmm_k1z_xmmp3_m128 = 3377, + // `VFNMADD132PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 9C /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd132ps_xmm_xmm_xmmm128 = 3378, + // `VFNMADD132PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 9C /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd132ps_ymm_ymm_ymmm256 = 3379, + // `VFNMADD132PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 9C /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd132pd_xmm_xmm_xmmm128 = 3380, + // `VFNMADD132PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 9C /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd132pd_ymm_ymm_ymmm256 = 3381, + // `VFNMADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 9C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd132ps_xmm_k1z_xmm_xmmm128b32 = 3382, + // `VFNMADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 9C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd132ps_ymm_k1z_ymm_ymmm256b32 = 3383, + // `VFNMADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 9C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd132ps_zmm_k1z_zmm_zmmm512b32_er = 3384, + // `VFNMADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 9C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd132pd_xmm_k1z_xmm_xmmm128b64 = 3385, + // `VFNMADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 9C /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd132pd_ymm_k1z_ymm_ymmm256b64 = 3386, + // `VFNMADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 9C /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd132pd_zmm_k1z_zmm_zmmm512b64_er = 3387, + // `VFNMADD132SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 9D /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd132ss_xmm_xmm_xmmm32 = 3388, + // `VFNMADD132SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 9D /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd132sd_xmm_xmm_xmmm64 = 3389, + // `VFNMADD132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 9D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd132ss_xmm_k1z_xmm_xmmm32_er = 3390, + // `VFNMADD132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 9D /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd132sd_xmm_k1z_xmm_xmmm64_er = 3391, + // `VFNMSUB132PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 9E /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub132ps_xmm_xmm_xmmm128 = 3392, + // `VFNMSUB132PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 9E /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub132ps_ymm_ymm_ymmm256 = 3393, + // `VFNMSUB132PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 9E /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub132pd_xmm_xmm_xmmm128 = 3394, + // `VFNMSUB132PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 9E /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub132pd_ymm_ymm_ymmm256 = 3395, + // `VFNMSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 9E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub132ps_xmm_k1z_xmm_xmmm128b32 = 3396, + // `VFNMSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 9E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub132ps_ymm_k1z_ymm_ymmm256b32 = 3397, + // `VFNMSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 9E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub132ps_zmm_k1z_zmm_zmmm512b32_er = 3398, + // `VFNMSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 9E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub132pd_xmm_k1z_xmm_xmmm128b64 = 3399, + // `VFNMSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 9E /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub132pd_ymm_k1z_ymm_ymmm256b64 = 3400, + // `VFNMSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 9E /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub132pd_zmm_k1z_zmm_zmmm512b64_er = 3401, + // `VFNMSUB132SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 9F /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub132ss_xmm_xmm_xmmm32 = 3402, + // `VFNMSUB132SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 9F /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub132sd_xmm_xmm_xmmm64 = 3403, + // `VFNMSUB132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 9F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub132ss_xmm_k1z_xmm_xmmm32_er = 3404, + // `VFNMSUB132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 9F /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub132sd_xmm_k1z_xmm_xmmm64_er = 3405, + // `VPSCATTERDD vm32x {k1}, xmm1` + // + // `EVEX.128.66.0F38.W0 A0 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterdd_vm32x_k1_xmm = 3406, + // `VPSCATTERDD vm32y {k1}, ymm1` + // + // `EVEX.256.66.0F38.W0 A0 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterdd_vm32y_k1_ymm = 3407, + // `VPSCATTERDD vm32z {k1}, zmm1` + // + // `EVEX.512.66.0F38.W0 A0 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterdd_vm32z_k1_zmm = 3408, + // `VPSCATTERDQ vm32x {k1}, xmm1` + // + // `EVEX.128.66.0F38.W1 A0 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterdq_vm32x_k1_xmm = 3409, + // `VPSCATTERDQ vm32x {k1}, ymm1` + // + // `EVEX.256.66.0F38.W1 A0 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterdq_vm32x_k1_ymm = 3410, + // `VPSCATTERDQ vm32y {k1}, zmm1` + // + // `EVEX.512.66.0F38.W1 A0 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterdq_vm32y_k1_zmm = 3411, + // `VPSCATTERQD vm64x {k1}, xmm1` + // + // `EVEX.128.66.0F38.W0 A1 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterqd_vm64x_k1_xmm = 3412, + // `VPSCATTERQD vm64y {k1}, xmm1` + // + // `EVEX.256.66.0F38.W0 A1 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterqd_vm64y_k1_xmm = 3413, + // `VPSCATTERQD vm64z {k1}, ymm1` + // + // `EVEX.512.66.0F38.W0 A1 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterqd_vm64z_k1_ymm = 3414, + // `VPSCATTERQQ vm64x {k1}, xmm1` + // + // `EVEX.128.66.0F38.W1 A1 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterqq_vm64x_k1_xmm = 3415, + // `VPSCATTERQQ vm64y {k1}, ymm1` + // + // `EVEX.256.66.0F38.W1 A1 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterqq_vm64y_k1_ymm = 3416, + // `VPSCATTERQQ vm64z {k1}, zmm1` + // + // `EVEX.512.66.0F38.W1 A1 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpscatterqq_vm64z_k1_zmm = 3417, + // `VSCATTERDPS vm32x {k1}, xmm1` + // + // `EVEX.128.66.0F38.W0 A2 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterdps_vm32x_k1_xmm = 3418, + // `VSCATTERDPS vm32y {k1}, ymm1` + // + // `EVEX.256.66.0F38.W0 A2 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterdps_vm32y_k1_ymm = 3419, + // `VSCATTERDPS vm32z {k1}, zmm1` + // + // `EVEX.512.66.0F38.W0 A2 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterdps_vm32z_k1_zmm = 3420, + // `VSCATTERDPD vm32x {k1}, xmm1` + // + // `EVEX.128.66.0F38.W1 A2 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterdpd_vm32x_k1_xmm = 3421, + // `VSCATTERDPD vm32x {k1}, ymm1` + // + // `EVEX.256.66.0F38.W1 A2 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterdpd_vm32x_k1_ymm = 3422, + // `VSCATTERDPD vm32y {k1}, zmm1` + // + // `EVEX.512.66.0F38.W1 A2 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterdpd_vm32y_k1_zmm = 3423, + // `VSCATTERQPS vm64x {k1}, xmm1` + // + // `EVEX.128.66.0F38.W0 A3 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterqps_vm64x_k1_xmm = 3424, + // `VSCATTERQPS vm64y {k1}, xmm1` + // + // `EVEX.256.66.0F38.W0 A3 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterqps_vm64y_k1_xmm = 3425, + // `VSCATTERQPS vm64z {k1}, ymm1` + // + // `EVEX.512.66.0F38.W0 A3 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterqps_vm64z_k1_ymm = 3426, + // `VSCATTERQPD vm64x {k1}, xmm1` + // + // `EVEX.128.66.0F38.W1 A3 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterqpd_vm64x_k1_xmm = 3427, + // `VSCATTERQPD vm64y {k1}, ymm1` + // + // `EVEX.256.66.0F38.W1 A3 /vsib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterqpd_vm64y_k1_ymm = 3428, + // `VSCATTERQPD vm64z {k1}, zmm1` + // + // `EVEX.512.66.0F38.W1 A3 /vsib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vscatterqpd_vm64z_k1_zmm = 3429, + // `VFMADDSUB213PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 A6 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub213ps_xmm_xmm_xmmm128 = 3430, + // `VFMADDSUB213PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 A6 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub213ps_ymm_ymm_ymmm256 = 3431, + // `VFMADDSUB213PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 A6 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub213pd_xmm_xmm_xmmm128 = 3432, + // `VFMADDSUB213PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 A6 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub213pd_ymm_ymm_ymmm256 = 3433, + // `VFMADDSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 A6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub213ps_xmm_k1z_xmm_xmmm128b32 = 3434, + // `VFMADDSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 A6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub213ps_ymm_k1z_ymm_ymmm256b32 = 3435, + // `VFMADDSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 A6 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub213ps_zmm_k1z_zmm_zmmm512b32_er = 3436, + // `VFMADDSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 A6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub213pd_xmm_k1z_xmm_xmmm128b64 = 3437, + // `VFMADDSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 A6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub213pd_ymm_k1z_ymm_ymmm256b64 = 3438, + // `VFMADDSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 A6 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub213pd_zmm_k1z_zmm_zmmm512b64_er = 3439, + // `VFMSUBADD213PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 A7 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd213ps_xmm_xmm_xmmm128 = 3440, + // `VFMSUBADD213PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 A7 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd213ps_ymm_ymm_ymmm256 = 3441, + // `VFMSUBADD213PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 A7 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd213pd_xmm_xmm_xmmm128 = 3442, + // `VFMSUBADD213PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 A7 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd213pd_ymm_ymm_ymmm256 = 3443, + // `VFMSUBADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 A7 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd213ps_xmm_k1z_xmm_xmmm128b32 = 3444, + // `VFMSUBADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 A7 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd213ps_ymm_k1z_ymm_ymmm256b32 = 3445, + // `VFMSUBADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 A7 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd213ps_zmm_k1z_zmm_zmmm512b32_er = 3446, + // `VFMSUBADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 A7 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd213pd_xmm_k1z_xmm_xmmm128b64 = 3447, + // `VFMSUBADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 A7 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd213pd_ymm_k1z_ymm_ymmm256b64 = 3448, + // `VFMSUBADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 A7 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd213pd_zmm_k1z_zmm_zmmm512b64_er = 3449, + // `VFMADD213PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 A8 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd213ps_xmm_xmm_xmmm128 = 3450, + // `VFMADD213PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 A8 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd213ps_ymm_ymm_ymmm256 = 3451, + // `VFMADD213PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 A8 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd213pd_xmm_xmm_xmmm128 = 3452, + // `VFMADD213PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 A8 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd213pd_ymm_ymm_ymmm256 = 3453, + // `VFMADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 A8 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd213ps_xmm_k1z_xmm_xmmm128b32 = 3454, + // `VFMADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 A8 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd213ps_ymm_k1z_ymm_ymmm256b32 = 3455, + // `VFMADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 A8 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd213ps_zmm_k1z_zmm_zmmm512b32_er = 3456, + // `VFMADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 A8 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd213pd_xmm_k1z_xmm_xmmm128b64 = 3457, + // `VFMADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 A8 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd213pd_ymm_k1z_ymm_ymmm256b64 = 3458, + // `VFMADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 A8 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd213pd_zmm_k1z_zmm_zmmm512b64_er = 3459, + // `VFMADD213SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 A9 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd213ss_xmm_xmm_xmmm32 = 3460, + // `VFMADD213SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 A9 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd213sd_xmm_xmm_xmmm64 = 3461, + // `VFMADD213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 A9 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd213ss_xmm_k1z_xmm_xmmm32_er = 3462, + // `VFMADD213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 A9 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd213sd_xmm_k1z_xmm_xmmm64_er = 3463, + // `VFMSUB213PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 AA /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub213ps_xmm_xmm_xmmm128 = 3464, + // `VFMSUB213PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 AA /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub213ps_ymm_ymm_ymmm256 = 3465, + // `VFMSUB213PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 AA /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub213pd_xmm_xmm_xmmm128 = 3466, + // `VFMSUB213PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 AA /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub213pd_ymm_ymm_ymmm256 = 3467, + // `VFMSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 AA /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub213ps_xmm_k1z_xmm_xmmm128b32 = 3468, + // `VFMSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 AA /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub213ps_ymm_k1z_ymm_ymmm256b32 = 3469, + // `VFMSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 AA /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub213ps_zmm_k1z_zmm_zmmm512b32_er = 3470, + // `VFMSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 AA /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub213pd_xmm_k1z_xmm_xmmm128b64 = 3471, + // `VFMSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 AA /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub213pd_ymm_k1z_ymm_ymmm256b64 = 3472, + // `VFMSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 AA /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub213pd_zmm_k1z_zmm_zmmm512b64_er = 3473, + // `V4FNMADDPS zmm1 {k1}{z}, zmm2+3, m128` + // + // `EVEX.512.F2.0F38.W0 AA /r` + // + // `AVX512_4FMAPS` + // + // `16/32/64-bit` + EVEX_V4fnmaddps_zmm_k1z_zmmp3_m128 = 3474, + // `VFMSUB213SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 AB /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub213ss_xmm_xmm_xmmm32 = 3475, + // `VFMSUB213SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 AB /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub213sd_xmm_xmm_xmmm64 = 3476, + // `VFMSUB213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 AB /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub213ss_xmm_k1z_xmm_xmmm32_er = 3477, + // `VFMSUB213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 AB /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub213sd_xmm_k1z_xmm_xmmm64_er = 3478, + // `V4FNMADDSS xmm1 {k1}{z}, xmm2+3, m128` + // + // `EVEX.LIG.F2.0F38.W0 AB /r` + // + // `AVX512_4FMAPS` + // + // `16/32/64-bit` + EVEX_V4fnmaddss_xmm_k1z_xmmp3_m128 = 3479, + // `VFNMADD213PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 AC /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd213ps_xmm_xmm_xmmm128 = 3480, + // `VFNMADD213PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 AC /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd213ps_ymm_ymm_ymmm256 = 3481, + // `VFNMADD213PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 AC /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd213pd_xmm_xmm_xmmm128 = 3482, + // `VFNMADD213PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 AC /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd213pd_ymm_ymm_ymmm256 = 3483, + // `VFNMADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 AC /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd213ps_xmm_k1z_xmm_xmmm128b32 = 3484, + // `VFNMADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 AC /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd213ps_ymm_k1z_ymm_ymmm256b32 = 3485, + // `VFNMADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 AC /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd213ps_zmm_k1z_zmm_zmmm512b32_er = 3486, + // `VFNMADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 AC /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd213pd_xmm_k1z_xmm_xmmm128b64 = 3487, + // `VFNMADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 AC /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd213pd_ymm_k1z_ymm_ymmm256b64 = 3488, + // `VFNMADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 AC /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd213pd_zmm_k1z_zmm_zmmm512b64_er = 3489, + // `VFNMADD213SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 AD /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd213ss_xmm_xmm_xmmm32 = 3490, + // `VFNMADD213SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 AD /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd213sd_xmm_xmm_xmmm64 = 3491, + // `VFNMADD213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 AD /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd213ss_xmm_k1z_xmm_xmmm32_er = 3492, + // `VFNMADD213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 AD /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd213sd_xmm_k1z_xmm_xmmm64_er = 3493, + // `VFNMSUB213PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 AE /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub213ps_xmm_xmm_xmmm128 = 3494, + // `VFNMSUB213PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 AE /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub213ps_ymm_ymm_ymmm256 = 3495, + // `VFNMSUB213PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 AE /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub213pd_xmm_xmm_xmmm128 = 3496, + // `VFNMSUB213PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 AE /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub213pd_ymm_ymm_ymmm256 = 3497, + // `VFNMSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 AE /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub213ps_xmm_k1z_xmm_xmmm128b32 = 3498, + // `VFNMSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 AE /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub213ps_ymm_k1z_ymm_ymmm256b32 = 3499, + // `VFNMSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 AE /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub213ps_zmm_k1z_zmm_zmmm512b32_er = 3500, + // `VFNMSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 AE /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub213pd_xmm_k1z_xmm_xmmm128b64 = 3501, + // `VFNMSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 AE /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub213pd_ymm_k1z_ymm_ymmm256b64 = 3502, + // `VFNMSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 AE /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub213pd_zmm_k1z_zmm_zmmm512b64_er = 3503, + // `VFNMSUB213SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 AF /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub213ss_xmm_xmm_xmmm32 = 3504, + // `VFNMSUB213SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 AF /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub213sd_xmm_xmm_xmmm64 = 3505, + // `VFNMSUB213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 AF /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub213ss_xmm_k1z_xmm_xmmm32_er = 3506, + // `VFNMSUB213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 AF /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub213sd_xmm_k1z_xmm_xmmm64_er = 3507, + // `VPMADD52LUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 B4 /r` + // + // `AVX512VL and AVX512_IFMA` + // + // `16/32/64-bit` + EVEX_Vpmadd52luq_xmm_k1z_xmm_xmmm128b64 = 3508, + // `VPMADD52LUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 B4 /r` + // + // `AVX512VL and AVX512_IFMA` + // + // `16/32/64-bit` + EVEX_Vpmadd52luq_ymm_k1z_ymm_ymmm256b64 = 3509, + // `VPMADD52LUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 B4 /r` + // + // `AVX512_IFMA` + // + // `16/32/64-bit` + EVEX_Vpmadd52luq_zmm_k1z_zmm_zmmm512b64 = 3510, + // `VPMADD52HUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 B5 /r` + // + // `AVX512VL and AVX512_IFMA` + // + // `16/32/64-bit` + EVEX_Vpmadd52huq_xmm_k1z_xmm_xmmm128b64 = 3511, + // `VPMADD52HUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 B5 /r` + // + // `AVX512VL and AVX512_IFMA` + // + // `16/32/64-bit` + EVEX_Vpmadd52huq_ymm_k1z_ymm_ymmm256b64 = 3512, + // `VPMADD52HUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 B5 /r` + // + // `AVX512_IFMA` + // + // `16/32/64-bit` + EVEX_Vpmadd52huq_zmm_k1z_zmm_zmmm512b64 = 3513, + // `VFMADDSUB231PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 B6 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub231ps_xmm_xmm_xmmm128 = 3514, + // `VFMADDSUB231PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 B6 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub231ps_ymm_ymm_ymmm256 = 3515, + // `VFMADDSUB231PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 B6 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub231pd_xmm_xmm_xmmm128 = 3516, + // `VFMADDSUB231PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 B6 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmaddsub231pd_ymm_ymm_ymmm256 = 3517, + // `VFMADDSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 B6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub231ps_xmm_k1z_xmm_xmmm128b32 = 3518, + // `VFMADDSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 B6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub231ps_ymm_k1z_ymm_ymmm256b32 = 3519, + // `VFMADDSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 B6 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub231ps_zmm_k1z_zmm_zmmm512b32_er = 3520, + // `VFMADDSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 B6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub231pd_xmm_k1z_xmm_xmmm128b64 = 3521, + // `VFMADDSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 B6 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub231pd_ymm_k1z_ymm_ymmm256b64 = 3522, + // `VFMADDSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 B6 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmaddsub231pd_zmm_k1z_zmm_zmmm512b64_er = 3523, + // `VFMSUBADD231PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 B7 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd231ps_xmm_xmm_xmmm128 = 3524, + // `VFMSUBADD231PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 B7 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd231ps_ymm_ymm_ymmm256 = 3525, + // `VFMSUBADD231PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 B7 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd231pd_xmm_xmm_xmmm128 = 3526, + // `VFMSUBADD231PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 B7 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsubadd231pd_ymm_ymm_ymmm256 = 3527, + // `VFMSUBADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 B7 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd231ps_xmm_k1z_xmm_xmmm128b32 = 3528, + // `VFMSUBADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 B7 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd231ps_ymm_k1z_ymm_ymmm256b32 = 3529, + // `VFMSUBADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 B7 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd231ps_zmm_k1z_zmm_zmmm512b32_er = 3530, + // `VFMSUBADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 B7 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd231pd_xmm_k1z_xmm_xmmm128b64 = 3531, + // `VFMSUBADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 B7 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd231pd_ymm_k1z_ymm_ymmm256b64 = 3532, + // `VFMSUBADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 B7 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsubadd231pd_zmm_k1z_zmm_zmmm512b64_er = 3533, + // `VFMADD231PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 B8 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd231ps_xmm_xmm_xmmm128 = 3534, + // `VFMADD231PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 B8 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd231ps_ymm_ymm_ymmm256 = 3535, + // `VFMADD231PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 B8 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd231pd_xmm_xmm_xmmm128 = 3536, + // `VFMADD231PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 B8 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd231pd_ymm_ymm_ymmm256 = 3537, + // `VFMADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 B8 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd231ps_xmm_k1z_xmm_xmmm128b32 = 3538, + // `VFMADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 B8 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd231ps_ymm_k1z_ymm_ymmm256b32 = 3539, + // `VFMADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 B8 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd231ps_zmm_k1z_zmm_zmmm512b32_er = 3540, + // `VFMADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 B8 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd231pd_xmm_k1z_xmm_xmmm128b64 = 3541, + // `VFMADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 B8 /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd231pd_ymm_k1z_ymm_ymmm256b64 = 3542, + // `VFMADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 B8 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd231pd_zmm_k1z_zmm_zmmm512b64_er = 3543, + // `VFMADD231SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 B9 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd231ss_xmm_xmm_xmmm32 = 3544, + // `VFMADD231SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 B9 /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmadd231sd_xmm_xmm_xmmm64 = 3545, + // `VFMADD231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 B9 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd231ss_xmm_k1z_xmm_xmmm32_er = 3546, + // `VFMADD231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 B9 /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmadd231sd_xmm_k1z_xmm_xmmm64_er = 3547, + // `VFMSUB231PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 BA /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub231ps_xmm_xmm_xmmm128 = 3548, + // `VFMSUB231PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 BA /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub231ps_ymm_ymm_ymmm256 = 3549, + // `VFMSUB231PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 BA /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub231pd_xmm_xmm_xmmm128 = 3550, + // `VFMSUB231PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 BA /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub231pd_ymm_ymm_ymmm256 = 3551, + // `VFMSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 BA /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub231ps_xmm_k1z_xmm_xmmm128b32 = 3552, + // `VFMSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 BA /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub231ps_ymm_k1z_ymm_ymmm256b32 = 3553, + // `VFMSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 BA /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub231ps_zmm_k1z_zmm_zmmm512b32_er = 3554, + // `VFMSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 BA /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub231pd_xmm_k1z_xmm_xmmm128b64 = 3555, + // `VFMSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 BA /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub231pd_ymm_k1z_ymm_ymmm256b64 = 3556, + // `VFMSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 BA /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub231pd_zmm_k1z_zmm_zmmm512b64_er = 3557, + // `VFMSUB231SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 BB /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub231ss_xmm_xmm_xmmm32 = 3558, + // `VFMSUB231SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 BB /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfmsub231sd_xmm_xmm_xmmm64 = 3559, + // `VFMSUB231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 BB /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub231ss_xmm_k1z_xmm_xmmm32_er = 3560, + // `VFMSUB231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 BB /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfmsub231sd_xmm_k1z_xmm_xmmm64_er = 3561, + // `VFNMADD231PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 BC /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd231ps_xmm_xmm_xmmm128 = 3562, + // `VFNMADD231PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 BC /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd231ps_ymm_ymm_ymmm256 = 3563, + // `VFNMADD231PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 BC /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd231pd_xmm_xmm_xmmm128 = 3564, + // `VFNMADD231PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 BC /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd231pd_ymm_ymm_ymmm256 = 3565, + // `VFNMADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 BC /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd231ps_xmm_k1z_xmm_xmmm128b32 = 3566, + // `VFNMADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 BC /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd231ps_ymm_k1z_ymm_ymmm256b32 = 3567, + // `VFNMADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 BC /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd231ps_zmm_k1z_zmm_zmmm512b32_er = 3568, + // `VFNMADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 BC /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd231pd_xmm_k1z_xmm_xmmm128b64 = 3569, + // `VFNMADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 BC /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd231pd_ymm_k1z_ymm_ymmm256b64 = 3570, + // `VFNMADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 BC /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd231pd_zmm_k1z_zmm_zmmm512b64_er = 3571, + // `VFNMADD231SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 BD /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd231ss_xmm_xmm_xmmm32 = 3572, + // `VFNMADD231SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 BD /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmadd231sd_xmm_xmm_xmmm64 = 3573, + // `VFNMADD231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 BD /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd231ss_xmm_k1z_xmm_xmmm32_er = 3574, + // `VFNMADD231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 BD /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmadd231sd_xmm_k1z_xmm_xmmm64_er = 3575, + // `VFNMSUB231PS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 BE /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub231ps_xmm_xmm_xmmm128 = 3576, + // `VFNMSUB231PS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 BE /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub231ps_ymm_ymm_ymmm256 = 3577, + // `VFNMSUB231PD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 BE /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub231pd_xmm_xmm_xmmm128 = 3578, + // `VFNMSUB231PD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 BE /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub231pd_ymm_ymm_ymmm256 = 3579, + // `VFNMSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 BE /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub231ps_xmm_k1z_xmm_xmmm128b32 = 3580, + // `VFNMSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 BE /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub231ps_ymm_k1z_ymm_ymmm256b32 = 3581, + // `VFNMSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.66.0F38.W0 BE /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub231ps_zmm_k1z_zmm_zmmm512b32_er = 3582, + // `VFNMSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 BE /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub231pd_xmm_k1z_xmm_xmmm128b64 = 3583, + // `VFNMSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 BE /r` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub231pd_ymm_k1z_ymm_ymmm256b64 = 3584, + // `VFNMSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}` + // + // `EVEX.512.66.0F38.W1 BE /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub231pd_zmm_k1z_zmm_zmmm512b64_er = 3585, + // `VFNMSUB231SS xmm1, xmm2, xmm3/m32` + // + // `VEX.LIG.66.0F38.W0 BF /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub231ss_xmm_xmm_xmmm32 = 3586, + // `VFNMSUB231SD xmm1, xmm2, xmm3/m64` + // + // `VEX.LIG.66.0F38.W1 BF /r` + // + // `FMA` + // + // `16/32/64-bit` + VEX_Vfnmsub231sd_xmm_xmm_xmmm64 = 3587, + // `VFNMSUB231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.66.0F38.W0 BF /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub231ss_xmm_k1z_xmm_xmmm32_er = 3588, + // `VFNMSUB231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.66.0F38.W1 BF /r` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfnmsub231sd_xmm_k1z_xmm_xmmm64_er = 3589, + // `VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.66.0F38.W0 C4 /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpconflictd_xmm_k1z_xmmm128b32 = 3590, + // `VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.66.0F38.W0 C4 /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpconflictd_ymm_k1z_ymmm256b32 = 3591, + // `VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst` + // + // `EVEX.512.66.0F38.W0 C4 /r` + // + // `AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpconflictd_zmm_k1z_zmmm512b32 = 3592, + // `VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.0F38.W1 C4 /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpconflictq_xmm_k1z_xmmm128b64 = 3593, + // `VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.0F38.W1 C4 /r` + // + // `AVX512VL and AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpconflictq_ymm_k1z_ymmm256b64 = 3594, + // `VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst` + // + // `EVEX.512.66.0F38.W1 C4 /r` + // + // `AVX512CD` + // + // `16/32/64-bit` + EVEX_Vpconflictq_zmm_k1z_zmmm512b64 = 3595, + // `VGATHERPF0DPS vm32z {k1}` + // + // `EVEX.512.66.0F38.W0 C6 /1 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vgatherpf0dps_vm32z_k1 = 3596, + // `VGATHERPF0DPD vm32y {k1}` + // + // `EVEX.512.66.0F38.W1 C6 /1 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vgatherpf0dpd_vm32y_k1 = 3597, + // `VGATHERPF1DPS vm32z {k1}` + // + // `EVEX.512.66.0F38.W0 C6 /2 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vgatherpf1dps_vm32z_k1 = 3598, + // `VGATHERPF1DPD vm32y {k1}` + // + // `EVEX.512.66.0F38.W1 C6 /2 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vgatherpf1dpd_vm32y_k1 = 3599, + // `VSCATTERPF0DPS vm32z {k1}` + // + // `EVEX.512.66.0F38.W0 C6 /5 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vscatterpf0dps_vm32z_k1 = 3600, + // `VSCATTERPF0DPD vm32y {k1}` + // + // `EVEX.512.66.0F38.W1 C6 /5 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vscatterpf0dpd_vm32y_k1 = 3601, + // `VSCATTERPF1DPS vm32z {k1}` + // + // `EVEX.512.66.0F38.W0 C6 /6 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vscatterpf1dps_vm32z_k1 = 3602, + // `VSCATTERPF1DPD vm32y {k1}` + // + // `EVEX.512.66.0F38.W1 C6 /6 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vscatterpf1dpd_vm32y_k1 = 3603, + // `VGATHERPF0QPS vm64z {k1}` + // + // `EVEX.512.66.0F38.W0 C7 /1 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vgatherpf0qps_vm64z_k1 = 3604, + // `VGATHERPF0QPD vm64z {k1}` + // + // `EVEX.512.66.0F38.W1 C7 /1 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vgatherpf0qpd_vm64z_k1 = 3605, + // `VGATHERPF1QPS vm64z {k1}` + // + // `EVEX.512.66.0F38.W0 C7 /2 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vgatherpf1qps_vm64z_k1 = 3606, + // `VGATHERPF1QPD vm64z {k1}` + // + // `EVEX.512.66.0F38.W1 C7 /2 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vgatherpf1qpd_vm64z_k1 = 3607, + // `VSCATTERPF0QPS vm64z {k1}` + // + // `EVEX.512.66.0F38.W0 C7 /5 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vscatterpf0qps_vm64z_k1 = 3608, + // `VSCATTERPF0QPD vm64z {k1}` + // + // `EVEX.512.66.0F38.W1 C7 /5 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vscatterpf0qpd_vm64z_k1 = 3609, + // `VSCATTERPF1QPS vm64z {k1}` + // + // `EVEX.512.66.0F38.W0 C7 /6 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vscatterpf1qps_vm64z_k1 = 3610, + // `VSCATTERPF1QPD vm64z {k1}` + // + // `EVEX.512.66.0F38.W1 C7 /6 /vsib` + // + // `AVX512PF` + // + // `16/32/64-bit` + EVEX_Vscatterpf1qpd_vm64z_k1 = 3611, + // `SHA1NEXTE xmm1, xmm2/m128` + // + // `NP 0F 38 C8 /r` + // + // `SHA` + // + // `16/32/64-bit` + Sha1nexte_xmm_xmmm128 = 3612, + // `VEXP2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}` + // + // `EVEX.512.66.0F38.W0 C8 /r` + // + // `AVX512ER` + // + // `16/32/64-bit` + EVEX_Vexp2ps_zmm_k1z_zmmm512b32_sae = 3613, + // `VEXP2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}` + // + // `EVEX.512.66.0F38.W1 C8 /r` + // + // `AVX512ER` + // + // `16/32/64-bit` + EVEX_Vexp2pd_zmm_k1z_zmmm512b64_sae = 3614, + // `SHA1MSG1 xmm1, xmm2/m128` + // + // `NP 0F 38 C9 /r` + // + // `SHA` + // + // `16/32/64-bit` + Sha1msg1_xmm_xmmm128 = 3615, + // `SHA1MSG2 xmm1, xmm2/m128` + // + // `NP 0F 38 CA /r` + // + // `SHA` + // + // `16/32/64-bit` + Sha1msg2_xmm_xmmm128 = 3616, + // `VRCP28PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}` + // + // `EVEX.512.66.0F38.W0 CA /r` + // + // `AVX512ER` + // + // `16/32/64-bit` + EVEX_Vrcp28ps_zmm_k1z_zmmm512b32_sae = 3617, + // `VRCP28PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}` + // + // `EVEX.512.66.0F38.W1 CA /r` + // + // `AVX512ER` + // + // `16/32/64-bit` + EVEX_Vrcp28pd_zmm_k1z_zmmm512b64_sae = 3618, + // `SHA256RNDS2 xmm1, xmm2/m128, ` + // + // `NP 0F 38 CB /r` + // + // `SHA` + // + // `16/32/64-bit` + Sha256rnds2_xmm_xmmm128 = 3619, + // `VRCP28SS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}` + // + // `EVEX.LIG.66.0F38.W0 CB /r` + // + // `AVX512ER` + // + // `16/32/64-bit` + EVEX_Vrcp28ss_xmm_k1z_xmm_xmmm32_sae = 3620, + // `VRCP28SD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}` + // + // `EVEX.LIG.66.0F38.W1 CB /r` + // + // `AVX512ER` + // + // `16/32/64-bit` + EVEX_Vrcp28sd_xmm_k1z_xmm_xmmm64_sae = 3621, + // `SHA256MSG1 xmm1, xmm2/m128` + // + // `NP 0F 38 CC /r` + // + // `SHA` + // + // `16/32/64-bit` + Sha256msg1_xmm_xmmm128 = 3622, + // `VRSQRT28PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}` + // + // `EVEX.512.66.0F38.W0 CC /r` + // + // `AVX512ER` + // + // `16/32/64-bit` + EVEX_Vrsqrt28ps_zmm_k1z_zmmm512b32_sae = 3623, + // `VRSQRT28PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}` + // + // `EVEX.512.66.0F38.W1 CC /r` + // + // `AVX512ER` + // + // `16/32/64-bit` + EVEX_Vrsqrt28pd_zmm_k1z_zmmm512b64_sae = 3624, + // `SHA256MSG2 xmm1, xmm2/m128` + // + // `NP 0F 38 CD /r` + // + // `SHA` + // + // `16/32/64-bit` + Sha256msg2_xmm_xmmm128 = 3625, + // `VRSQRT28SS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}` + // + // `EVEX.LIG.66.0F38.W0 CD /r` + // + // `AVX512ER` + // + // `16/32/64-bit` + EVEX_Vrsqrt28ss_xmm_k1z_xmm_xmmm32_sae = 3626, + // `VRSQRT28SD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}` + // + // `EVEX.LIG.66.0F38.W1 CD /r` + // + // `AVX512ER` + // + // `16/32/64-bit` + EVEX_Vrsqrt28sd_xmm_k1z_xmm_xmmm64_sae = 3627, + // `GF2P8MULB xmm1, xmm2/m128` + // + // `66 0F 38 CF /r` + // + // `GFNI` + // + // `16/32/64-bit` + Gf2p8mulb_xmm_xmmm128 = 3628, + // `VGF2P8MULB xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 CF /r` + // + // `AVX and GFNI` + // + // `16/32/64-bit` + VEX_Vgf2p8mulb_xmm_xmm_xmmm128 = 3629, + // `VGF2P8MULB ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 CF /r` + // + // `AVX and GFNI` + // + // `16/32/64-bit` + VEX_Vgf2p8mulb_ymm_ymm_ymmm256 = 3630, + // `VGF2P8MULB xmm1 {k1}{z}, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.W0 CF /r` + // + // `AVX512VL and GFNI` + // + // `16/32/64-bit` + EVEX_Vgf2p8mulb_xmm_k1z_xmm_xmmm128 = 3631, + // `VGF2P8MULB ymm1 {k1}{z}, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.W0 CF /r` + // + // `AVX512VL and GFNI` + // + // `16/32/64-bit` + EVEX_Vgf2p8mulb_ymm_k1z_ymm_ymmm256 = 3632, + // `VGF2P8MULB zmm1 {k1}{z}, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.W0 CF /r` + // + // `AVX512F and GFNI` + // + // `16/32/64-bit` + EVEX_Vgf2p8mulb_zmm_k1z_zmm_zmmm512 = 3633, + // `AESIMC xmm1, xmm2/m128` + // + // `66 0F 38 DB /r` + // + // `AES` + // + // `16/32/64-bit` + Aesimc_xmm_xmmm128 = 3634, + // `VAESIMC xmm1, xmm2/m128` + // + // `VEX.128.66.0F38.WIG DB /r` + // + // `AES and AVX` + // + // `16/32/64-bit` + VEX_Vaesimc_xmm_xmmm128 = 3635, + // `AESENC xmm1, xmm2/m128` + // + // `66 0F 38 DC /r` + // + // `AES` + // + // `16/32/64-bit` + Aesenc_xmm_xmmm128 = 3636, + // `VAESENC xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG DC /r` + // + // `AES and AVX` + // + // `16/32/64-bit` + VEX_Vaesenc_xmm_xmm_xmmm128 = 3637, + // `VAESENC ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG DC /r` + // + // `VAES` + // + // `16/32/64-bit` + VEX_Vaesenc_ymm_ymm_ymmm256 = 3638, + // `VAESENC xmm1, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.WIG DC /r` + // + // `AVX512VL and VAES` + // + // `16/32/64-bit` + EVEX_Vaesenc_xmm_xmm_xmmm128 = 3639, + // `VAESENC ymm1, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.WIG DC /r` + // + // `AVX512VL and VAES` + // + // `16/32/64-bit` + EVEX_Vaesenc_ymm_ymm_ymmm256 = 3640, + // `VAESENC zmm1, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.WIG DC /r` + // + // `AVX512F and VAES` + // + // `16/32/64-bit` + EVEX_Vaesenc_zmm_zmm_zmmm512 = 3641, + // `AESENCLAST xmm1, xmm2/m128` + // + // `66 0F 38 DD /r` + // + // `AES` + // + // `16/32/64-bit` + Aesenclast_xmm_xmmm128 = 3642, + // `VAESENCLAST xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG DD /r` + // + // `AES and AVX` + // + // `16/32/64-bit` + VEX_Vaesenclast_xmm_xmm_xmmm128 = 3643, + // `VAESENCLAST ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG DD /r` + // + // `VAES` + // + // `16/32/64-bit` + VEX_Vaesenclast_ymm_ymm_ymmm256 = 3644, + // `VAESENCLAST xmm1, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.WIG DD /r` + // + // `AVX512VL and VAES` + // + // `16/32/64-bit` + EVEX_Vaesenclast_xmm_xmm_xmmm128 = 3645, + // `VAESENCLAST ymm1, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.WIG DD /r` + // + // `AVX512VL and VAES` + // + // `16/32/64-bit` + EVEX_Vaesenclast_ymm_ymm_ymmm256 = 3646, + // `VAESENCLAST zmm1, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.WIG DD /r` + // + // `AVX512F and VAES` + // + // `16/32/64-bit` + EVEX_Vaesenclast_zmm_zmm_zmmm512 = 3647, + // `AESDEC xmm1, xmm2/m128` + // + // `66 0F 38 DE /r` + // + // `AES` + // + // `16/32/64-bit` + Aesdec_xmm_xmmm128 = 3648, + // `VAESDEC xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG DE /r` + // + // `AES and AVX` + // + // `16/32/64-bit` + VEX_Vaesdec_xmm_xmm_xmmm128 = 3649, + // `VAESDEC ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG DE /r` + // + // `VAES` + // + // `16/32/64-bit` + VEX_Vaesdec_ymm_ymm_ymmm256 = 3650, + // `VAESDEC xmm1, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.WIG DE /r` + // + // `AVX512VL and VAES` + // + // `16/32/64-bit` + EVEX_Vaesdec_xmm_xmm_xmmm128 = 3651, + // `VAESDEC ymm1, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.WIG DE /r` + // + // `AVX512VL and VAES` + // + // `16/32/64-bit` + EVEX_Vaesdec_ymm_ymm_ymmm256 = 3652, + // `VAESDEC zmm1, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.WIG DE /r` + // + // `AVX512F and VAES` + // + // `16/32/64-bit` + EVEX_Vaesdec_zmm_zmm_zmmm512 = 3653, + // `AESDECLAST xmm1, xmm2/m128` + // + // `66 0F 38 DF /r` + // + // `AES` + // + // `16/32/64-bit` + Aesdeclast_xmm_xmmm128 = 3654, + // `VAESDECLAST xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.WIG DF /r` + // + // `AES and AVX` + // + // `16/32/64-bit` + VEX_Vaesdeclast_xmm_xmm_xmmm128 = 3655, + // `VAESDECLAST ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.WIG DF /r` + // + // `VAES` + // + // `16/32/64-bit` + VEX_Vaesdeclast_ymm_ymm_ymmm256 = 3656, + // `VAESDECLAST xmm1, xmm2, xmm3/m128` + // + // `EVEX.128.66.0F38.WIG DF /r` + // + // `AVX512VL and VAES` + // + // `16/32/64-bit` + EVEX_Vaesdeclast_xmm_xmm_xmmm128 = 3657, + // `VAESDECLAST ymm1, ymm2, ymm3/m256` + // + // `EVEX.256.66.0F38.WIG DF /r` + // + // `AVX512VL and VAES` + // + // `16/32/64-bit` + EVEX_Vaesdeclast_ymm_ymm_ymmm256 = 3658, + // `VAESDECLAST zmm1, zmm2, zmm3/m512` + // + // `EVEX.512.66.0F38.WIG DF /r` + // + // `AVX512F and VAES` + // + // `16/32/64-bit` + EVEX_Vaesdeclast_zmm_zmm_zmmm512 = 3659, + // `MOVBE r16, m16` + // + // `o16 0F 38 F0 /r` + // + // `MOVBE` + // + // `16/32/64-bit` + Movbe_r16_m16 = 3660, + // `MOVBE r32, m32` + // + // `o32 0F 38 F0 /r` + // + // `MOVBE` + // + // `16/32/64-bit` + Movbe_r32_m32 = 3661, + // `MOVBE r64, m64` + // + // `o64 0F 38 F0 /r` + // + // `MOVBE` + // + // `64-bit` + Movbe_r64_m64 = 3662, + // `CRC32 r32, r/m8` + // + // `F2 0F 38 F0 /r` + // + // `SSE4.2` + // + // `16/32/64-bit` + Crc32_r32_rm8 = 3663, + // `CRC32 r64, r/m8` + // + // `F2 o64 0F 38 F0 /r` + // + // `SSE4.2` + // + // `64-bit` + Crc32_r64_rm8 = 3664, + // `MOVBE m16, r16` + // + // `o16 0F 38 F1 /r` + // + // `MOVBE` + // + // `16/32/64-bit` + Movbe_m16_r16 = 3665, + // `MOVBE m32, r32` + // + // `o32 0F 38 F1 /r` + // + // `MOVBE` + // + // `16/32/64-bit` + Movbe_m32_r32 = 3666, + // `MOVBE m64, r64` + // + // `o64 0F 38 F1 /r` + // + // `MOVBE` + // + // `64-bit` + Movbe_m64_r64 = 3667, + // `CRC32 r32, r/m16` + // + // `o16 F2 0F 38 F1 /r` + // + // `SSE4.2` + // + // `16/32/64-bit` + Crc32_r32_rm16 = 3668, + // `CRC32 r32, r/m32` + // + // `o32 F2 0F 38 F1 /r` + // + // `SSE4.2` + // + // `16/32/64-bit` + Crc32_r32_rm32 = 3669, + // `CRC32 r64, r/m64` + // + // `F2 o64 0F 38 F1 /r` + // + // `SSE4.2` + // + // `64-bit` + Crc32_r64_rm64 = 3670, + // `ANDN r32a, r32b, r/m32` + // + // `VEX.LZ.0F38.W0 F2 /r` + // + // `BMI1` + // + // `16/32/64-bit` + VEX_Andn_r32_r32_rm32 = 3671, + // `ANDN r64a, r64b, r/m64` + // + // `VEX.LZ.0F38.W1 F2 /r` + // + // `BMI1` + // + // `64-bit` + VEX_Andn_r64_r64_rm64 = 3672, + // `BLSR r32, r/m32` + // + // `VEX.LZ.0F38.W0 F3 /1` + // + // `BMI1` + // + // `16/32/64-bit` + VEX_Blsr_r32_rm32 = 3673, + // `BLSR r64, r/m64` + // + // `VEX.LZ.0F38.W1 F3 /1` + // + // `BMI1` + // + // `64-bit` + VEX_Blsr_r64_rm64 = 3674, + // `BLSMSK r32, r/m32` + // + // `VEX.LZ.0F38.W0 F3 /2` + // + // `BMI1` + // + // `16/32/64-bit` + VEX_Blsmsk_r32_rm32 = 3675, + // `BLSMSK r64, r/m64` + // + // `VEX.LZ.0F38.W1 F3 /2` + // + // `BMI1` + // + // `64-bit` + VEX_Blsmsk_r64_rm64 = 3676, + // `BLSI r32, r/m32` + // + // `VEX.LZ.0F38.W0 F3 /3` + // + // `BMI1` + // + // `16/32/64-bit` + VEX_Blsi_r32_rm32 = 3677, + // `BLSI r64, r/m64` + // + // `VEX.LZ.0F38.W1 F3 /3` + // + // `BMI1` + // + // `64-bit` + VEX_Blsi_r64_rm64 = 3678, + // `BZHI r32a, r/m32, r32b` + // + // `VEX.LZ.0F38.W0 F5 /r` + // + // `BMI2` + // + // `16/32/64-bit` + VEX_Bzhi_r32_rm32_r32 = 3679, + // `BZHI r64a, r/m64, r64b` + // + // `VEX.LZ.0F38.W1 F5 /r` + // + // `BMI2` + // + // `64-bit` + VEX_Bzhi_r64_rm64_r64 = 3680, + // `WRUSSD m32, r32` + // + // `66 0F 38 F5 /r` + // + // `CET_SS` + // + // `16/32/64-bit` + Wrussd_m32_r32 = 3681, + // `WRUSSQ m64, r64` + // + // `66 o64 0F 38 F5 /r` + // + // `CET_SS` + // + // `64-bit` + Wrussq_m64_r64 = 3682, + // `PEXT r32a, r32b, r/m32` + // + // `VEX.LZ.F3.0F38.W0 F5 /r` + // + // `BMI2` + // + // `16/32/64-bit` + VEX_Pext_r32_r32_rm32 = 3683, + // `PEXT r64a, r64b, r/m64` + // + // `VEX.LZ.F3.0F38.W1 F5 /r` + // + // `BMI2` + // + // `64-bit` + VEX_Pext_r64_r64_rm64 = 3684, + // `PDEP r32a, r32b, r/m32` + // + // `VEX.LZ.F2.0F38.W0 F5 /r` + // + // `BMI2` + // + // `16/32/64-bit` + VEX_Pdep_r32_r32_rm32 = 3685, + // `PDEP r64a, r64b, r/m64` + // + // `VEX.LZ.F2.0F38.W1 F5 /r` + // + // `BMI2` + // + // `64-bit` + VEX_Pdep_r64_r64_rm64 = 3686, + // `WRSSD m32, r32` + // + // `NP 0F 38 F6 /r` + // + // `CET_SS` + // + // `16/32/64-bit` + Wrssd_m32_r32 = 3687, + // `WRSSQ m64, r64` + // + // `NP o64 0F 38 F6 /r` + // + // `CET_SS` + // + // `64-bit` + Wrssq_m64_r64 = 3688, + // `ADCX r32, r/m32` + // + // `66 0F 38 F6 /r` + // + // `ADX` + // + // `16/32/64-bit` + Adcx_r32_rm32 = 3689, + // `ADCX r64, r/m64` + // + // `66 o64 0F 38 F6 /r` + // + // `ADX` + // + // `64-bit` + Adcx_r64_rm64 = 3690, + // `ADOX r32, r/m32` + // + // `F3 0F 38 F6 /r` + // + // `ADX` + // + // `16/32/64-bit` + Adox_r32_rm32 = 3691, + // `ADOX r64, r/m64` + // + // `F3 o64 0F 38 F6 /r` + // + // `ADX` + // + // `64-bit` + Adox_r64_rm64 = 3692, + // `MULX r32a, r32b, r/m32` + // + // `VEX.LZ.F2.0F38.W0 F6 /r` + // + // `BMI2` + // + // `16/32/64-bit` + VEX_Mulx_r32_r32_rm32 = 3693, + // `MULX r64a, r64b, r/m64` + // + // `VEX.LZ.F2.0F38.W1 F6 /r` + // + // `BMI2` + // + // `64-bit` + VEX_Mulx_r64_r64_rm64 = 3694, + // `BEXTR r32a, r/m32, r32b` + // + // `VEX.LZ.0F38.W0 F7 /r` + // + // `BMI1` + // + // `16/32/64-bit` + VEX_Bextr_r32_rm32_r32 = 3695, + // `BEXTR r64a, r/m64, r64b` + // + // `VEX.LZ.0F38.W1 F7 /r` + // + // `BMI1` + // + // `64-bit` + VEX_Bextr_r64_rm64_r64 = 3696, + // `SHLX r32a, r/m32, r32b` + // + // `VEX.LZ.66.0F38.W0 F7 /r` + // + // `BMI2` + // + // `16/32/64-bit` + VEX_Shlx_r32_rm32_r32 = 3697, + // `SHLX r64a, r/m64, r64b` + // + // `VEX.LZ.66.0F38.W1 F7 /r` + // + // `BMI2` + // + // `64-bit` + VEX_Shlx_r64_rm64_r64 = 3698, + // `SARX r32a, r/m32, r32b` + // + // `VEX.LZ.F3.0F38.W0 F7 /r` + // + // `BMI2` + // + // `16/32/64-bit` + VEX_Sarx_r32_rm32_r32 = 3699, + // `SARX r64a, r/m64, r64b` + // + // `VEX.LZ.F3.0F38.W1 F7 /r` + // + // `BMI2` + // + // `64-bit` + VEX_Sarx_r64_rm64_r64 = 3700, + // `SHRX r32a, r/m32, r32b` + // + // `VEX.LZ.F2.0F38.W0 F7 /r` + // + // `BMI2` + // + // `16/32/64-bit` + VEX_Shrx_r32_rm32_r32 = 3701, + // `SHRX r64a, r/m64, r64b` + // + // `VEX.LZ.F2.0F38.W1 F7 /r` + // + // `BMI2` + // + // `64-bit` + VEX_Shrx_r64_rm64_r64 = 3702, + // `MOVDIR64B r16, m512` + // + // `a16 66 0F 38 F8 /r` + // + // `MOVDIR64B` + // + // `16/32-bit` + Movdir64b_r16_m512 = 3703, + // `MOVDIR64B r32, m512` + // + // `a32 66 0F 38 F8 /r` + // + // `MOVDIR64B` + // + // `16/32/64-bit` + Movdir64b_r32_m512 = 3704, + // `MOVDIR64B r64, m512` + // + // `a64 66 0F 38 F8 /r` + // + // `MOVDIR64B` + // + // `64-bit` + Movdir64b_r64_m512 = 3705, + // `ENQCMDS r16, m512` + // + // `a16 F3 0F 38 F8 !(11) :rrr:bbb` + // + // `ENQCMD` + // + // `16/32-bit` + Enqcmds_r16_m512 = 3706, + // `ENQCMDS r32, m512` + // + // `a32 F3 0F 38 F8 !(11) :rrr:bbb` + // + // `ENQCMD` + // + // `16/32/64-bit` + Enqcmds_r32_m512 = 3707, + // `ENQCMDS r64, m512` + // + // `a64 F3 0F 38 F8 !(11) :rrr:bbb` + // + // `ENQCMD` + // + // `64-bit` + Enqcmds_r64_m512 = 3708, + // `ENQCMD r16, m512` + // + // `a16 F2 0F 38 F8 !(11) :rrr:bbb` + // + // `ENQCMD` + // + // `16/32-bit` + Enqcmd_r16_m512 = 3709, + // `ENQCMD r32, m512` + // + // `a32 F2 0F 38 F8 !(11) :rrr:bbb` + // + // `ENQCMD` + // + // `16/32/64-bit` + Enqcmd_r32_m512 = 3710, + // `ENQCMD r64, m512` + // + // `a64 F2 0F 38 F8 !(11) :rrr:bbb` + // + // `ENQCMD` + // + // `64-bit` + Enqcmd_r64_m512 = 3711, + // `MOVDIRI m32, r32` + // + // `NP 0F 38 F9 /r` + // + // `MOVDIRI` + // + // `16/32/64-bit` + Movdiri_m32_r32 = 3712, + // `MOVDIRI m64, r64` + // + // `NP o64 0F 38 F9 /r` + // + // `MOVDIRI` + // + // `64-bit` + Movdiri_m64_r64 = 3713, + // `VPERMQ ymm1, ymm2/m256, imm8` + // + // `VEX.256.66.0F3A.W1 00 /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpermq_ymm_ymmm256_imm8 = 3714, + // `VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 00 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermq_ymm_k1z_ymmm256b64_imm8 = 3715, + // `VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 00 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermq_zmm_k1z_zmmm512b64_imm8 = 3716, + // `VPERMPD ymm1, ymm2/m256, imm8` + // + // `VEX.256.66.0F3A.W1 01 /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpermpd_ymm_ymmm256_imm8 = 3717, + // `VPERMPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 01 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermpd_ymm_k1z_ymmm256b64_imm8 = 3718, + // `VPERMPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 01 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermpd_zmm_k1z_zmmm512b64_imm8 = 3719, + // `VPBLENDD xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F3A.W0 02 /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpblendd_xmm_xmm_xmmm128_imm8 = 3720, + // `VPBLENDD ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.W0 02 /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpblendd_ymm_ymm_ymmm256_imm8 = 3721, + // `VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 03 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Valignd_xmm_k1z_xmm_xmmm128b32_imm8 = 3722, + // `VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 03 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Valignd_ymm_k1z_ymm_ymmm256b32_imm8 = 3723, + // `VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F3A.W0 03 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Valignd_zmm_k1z_zmm_zmmm512b32_imm8 = 3724, + // `VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 03 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Valignq_xmm_k1z_xmm_xmmm128b64_imm8 = 3725, + // `VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 03 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Valignq_ymm_k1z_ymm_ymmm256b64_imm8 = 3726, + // `VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 03 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Valignq_zmm_k1z_zmm_zmmm512b64_imm8 = 3727, + // `VPERMILPS xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F3A.W0 04 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpermilps_xmm_xmmm128_imm8 = 3728, + // `VPERMILPS ymm1, ymm2/m256, imm8` + // + // `VEX.256.66.0F3A.W0 04 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpermilps_ymm_ymmm256_imm8 = 3729, + // `VPERMILPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 04 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilps_xmm_k1z_xmmm128b32_imm8 = 3730, + // `VPERMILPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 04 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilps_ymm_k1z_ymmm256b32_imm8 = 3731, + // `VPERMILPS zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F3A.W0 04 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilps_zmm_k1z_zmmm512b32_imm8 = 3732, + // `VPERMILPD xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F3A.W0 05 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpermilpd_xmm_xmmm128_imm8 = 3733, + // `VPERMILPD ymm1, ymm2/m256, imm8` + // + // `VEX.256.66.0F3A.W0 05 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpermilpd_ymm_ymmm256_imm8 = 3734, + // `VPERMILPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 05 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilpd_xmm_k1z_xmmm128b64_imm8 = 3735, + // `VPERMILPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 05 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilpd_ymm_k1z_ymmm256b64_imm8 = 3736, + // `VPERMILPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 05 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpermilpd_zmm_k1z_zmmm512b64_imm8 = 3737, + // `VPERM2F128 ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.W0 06 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vperm2f128_ymm_ymm_ymmm256_imm8 = 3738, + // `ROUNDPS xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 08 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Roundps_xmm_xmmm128_imm8 = 3739, + // `VROUNDPS xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 08 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vroundps_xmm_xmmm128_imm8 = 3740, + // `VROUNDPS ymm1, ymm2/m256, imm8` + // + // `VEX.256.66.0F3A.WIG 08 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vroundps_ymm_ymmm256_imm8 = 3741, + // `VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 08 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrndscaleps_xmm_k1z_xmmm128b32_imm8 = 3742, + // `VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 08 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrndscaleps_ymm_k1z_ymmm256b32_imm8 = 3743, + // `VRNDSCALEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8` + // + // `EVEX.512.66.0F3A.W0 08 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrndscaleps_zmm_k1z_zmmm512b32_imm8_sae = 3744, + // `ROUNDPD xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 09 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Roundpd_xmm_xmmm128_imm8 = 3745, + // `VROUNDPD xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 09 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vroundpd_xmm_xmmm128_imm8 = 3746, + // `VROUNDPD ymm1, ymm2/m256, imm8` + // + // `VEX.256.66.0F3A.WIG 09 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vroundpd_ymm_ymmm256_imm8 = 3747, + // `VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 09 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrndscalepd_xmm_k1z_xmmm128b64_imm8 = 3748, + // `VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 09 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vrndscalepd_ymm_k1z_ymmm256b64_imm8 = 3749, + // `VRNDSCALEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8` + // + // `EVEX.512.66.0F3A.W1 09 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrndscalepd_zmm_k1z_zmmm512b64_imm8_sae = 3750, + // `ROUNDSS xmm1, xmm2/m32, imm8` + // + // `66 0F 3A 0A /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Roundss_xmm_xmmm32_imm8 = 3751, + // `VROUNDSS xmm1, xmm2, xmm3/m32, imm8` + // + // `VEX.LIG.66.0F3A.WIG 0A /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vroundss_xmm_xmm_xmmm32_imm8 = 3752, + // `VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8` + // + // `EVEX.LIG.66.0F3A.W0 0A /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrndscaless_xmm_k1z_xmm_xmmm32_imm8_sae = 3753, + // `ROUNDSD xmm1, xmm2/m64, imm8` + // + // `66 0F 3A 0B /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Roundsd_xmm_xmmm64_imm8 = 3754, + // `VROUNDSD xmm1, xmm2, xmm3/m64, imm8` + // + // `VEX.LIG.66.0F3A.WIG 0B /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vroundsd_xmm_xmm_xmmm64_imm8 = 3755, + // `VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8` + // + // `EVEX.LIG.66.0F3A.W1 0B /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vrndscalesd_xmm_k1z_xmm_xmmm64_imm8_sae = 3756, + // `BLENDPS xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 0C /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Blendps_xmm_xmmm128_imm8 = 3757, + // `VBLENDPS xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 0C /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vblendps_xmm_xmm_xmmm128_imm8 = 3758, + // `VBLENDPS ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.WIG 0C /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vblendps_ymm_ymm_ymmm256_imm8 = 3759, + // `BLENDPD xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 0D /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Blendpd_xmm_xmmm128_imm8 = 3760, + // `VBLENDPD xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 0D /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vblendpd_xmm_xmm_xmmm128_imm8 = 3761, + // `VBLENDPD ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.WIG 0D /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vblendpd_ymm_ymm_ymmm256_imm8 = 3762, + // `PBLENDW xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 0E /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pblendw_xmm_xmmm128_imm8 = 3763, + // `VPBLENDW xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 0E /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpblendw_xmm_xmm_xmmm128_imm8 = 3764, + // `VPBLENDW ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.WIG 0E /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpblendw_ymm_ymm_ymmm256_imm8 = 3765, + // `PALIGNR mm1, mm2/m64, imm8` + // + // `NP 0F 3A 0F /r ib` + // + // `SSSE3` + // + // `16/32/64-bit` + Palignr_mm_mmm64_imm8 = 3766, + // `PALIGNR xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 0F /r ib` + // + // `SSSE3` + // + // `16/32/64-bit` + Palignr_xmm_xmmm128_imm8 = 3767, + // `VPALIGNR xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 0F /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpalignr_xmm_xmm_xmmm128_imm8 = 3768, + // `VPALIGNR ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.WIG 0F /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpalignr_ymm_ymm_ymmm256_imm8 = 3769, + // `VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8` + // + // `EVEX.128.66.0F3A.WIG 0F /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpalignr_xmm_k1z_xmm_xmmm128_imm8 = 3770, + // `VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8` + // + // `EVEX.256.66.0F3A.WIG 0F /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpalignr_ymm_k1z_ymm_ymmm256_imm8 = 3771, + // `VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8` + // + // `EVEX.512.66.0F3A.WIG 0F /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpalignr_zmm_k1z_zmm_zmmm512_imm8 = 3772, + // `PEXTRB r32/m8, xmm2, imm8` + // + // `66 0F 3A 14 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pextrb_r32m8_xmm_imm8 = 3773, + // `PEXTRB r64/m8, xmm2, imm8` + // + // `66 o64 0F 3A 14 /r ib` + // + // `SSE4.1` + // + // `64-bit` + Pextrb_r64m8_xmm_imm8 = 3774, + // `VPEXTRB r32/m8, xmm2, imm8` + // + // `VEX.128.66.0F3A.W0 14 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpextrb_r32m8_xmm_imm8 = 3775, + // `VPEXTRB r64/m8, xmm2, imm8` + // + // `VEX.128.66.0F3A.W1 14 /r ib` + // + // `AVX` + // + // `64-bit` + VEX_Vpextrb_r64m8_xmm_imm8 = 3776, + // `VPEXTRB r32/m8, xmm2, imm8` + // + // `EVEX.128.66.0F3A.W0 14 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpextrb_r32m8_xmm_imm8 = 3777, + // `VPEXTRB r64/m8, xmm2, imm8` + // + // `EVEX.128.66.0F3A.W1 14 /r ib` + // + // `AVX512BW` + // + // `64-bit` + EVEX_Vpextrb_r64m8_xmm_imm8 = 3778, + // `PEXTRW r32/m16, xmm, imm8` + // + // `66 0F 3A 15 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pextrw_r32m16_xmm_imm8 = 3779, + // `PEXTRW r64/m16, xmm, imm8` + // + // `66 o64 0F 3A 15 /r ib` + // + // `SSE4.1` + // + // `64-bit` + Pextrw_r64m16_xmm_imm8 = 3780, + // `VPEXTRW r32/m16, xmm2, imm8` + // + // `VEX.128.66.0F3A.W0 15 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpextrw_r32m16_xmm_imm8 = 3781, + // `VPEXTRW r64/m16, xmm2, imm8` + // + // `VEX.128.66.0F3A.W1 15 /r ib` + // + // `AVX` + // + // `64-bit` + VEX_Vpextrw_r64m16_xmm_imm8 = 3782, + // `VPEXTRW r32/m16, xmm2, imm8` + // + // `EVEX.128.66.0F3A.W0 15 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpextrw_r32m16_xmm_imm8 = 3783, + // `VPEXTRW r64/m16, xmm2, imm8` + // + // `EVEX.128.66.0F3A.W1 15 /r ib` + // + // `AVX512BW` + // + // `64-bit` + EVEX_Vpextrw_r64m16_xmm_imm8 = 3784, + // `PEXTRD r/m32, xmm2, imm8` + // + // `66 0F 3A 16 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pextrd_rm32_xmm_imm8 = 3785, + // `PEXTRQ r/m64, xmm2, imm8` + // + // `66 o64 0F 3A 16 /r ib` + // + // `SSE4.1` + // + // `64-bit` + Pextrq_rm64_xmm_imm8 = 3786, + // `VPEXTRD r/m32, xmm2, imm8` + // + // `VEX.128.66.0F3A.W0 16 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpextrd_rm32_xmm_imm8 = 3787, + // `VPEXTRQ r/m64, xmm2, imm8` + // + // `VEX.128.66.0F3A.W1 16 /r ib` + // + // `AVX` + // + // `64-bit` + VEX_Vpextrq_rm64_xmm_imm8 = 3788, + // `VPEXTRD r/m32, xmm2, imm8` + // + // `EVEX.128.66.0F3A.W0 16 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpextrd_rm32_xmm_imm8 = 3789, + // `VPEXTRQ r/m64, xmm2, imm8` + // + // `EVEX.128.66.0F3A.W1 16 /r ib` + // + // `AVX512DQ` + // + // `64-bit` + EVEX_Vpextrq_rm64_xmm_imm8 = 3790, + // `EXTRACTPS r/m32, xmm1, imm8` + // + // `66 0F 3A 17 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Extractps_rm32_xmm_imm8 = 3791, + // `EXTRACTPS r64/m32, xmm1, imm8` + // + // `66 o64 0F 3A 17 /r ib` + // + // `SSE4.1` + // + // `64-bit` + Extractps_r64m32_xmm_imm8 = 3792, + // `VEXTRACTPS r/m32, xmm1, imm8` + // + // `VEX.128.66.0F3A.W0 17 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vextractps_rm32_xmm_imm8 = 3793, + // `VEXTRACTPS r64/m32, xmm1, imm8` + // + // `VEX.128.66.0F3A.W1 17 /r ib` + // + // `AVX` + // + // `64-bit` + VEX_Vextractps_r64m32_xmm_imm8 = 3794, + // `VEXTRACTPS r/m32, xmm1, imm8` + // + // `EVEX.128.66.0F3A.W0 17 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vextractps_rm32_xmm_imm8 = 3795, + // `VEXTRACTPS r64/m32, xmm1, imm8` + // + // `EVEX.128.66.0F3A.W1 17 /r ib` + // + // `AVX512F` + // + // `64-bit` + EVEX_Vextractps_r64m32_xmm_imm8 = 3796, + // `VINSERTF128 ymm1, ymm2, xmm3/m128, imm8` + // + // `VEX.256.66.0F3A.W0 18 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vinsertf128_ymm_ymm_xmmm128_imm8 = 3797, + // `VINSERTF32X4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8` + // + // `EVEX.256.66.0F3A.W0 18 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vinsertf32x4_ymm_k1z_ymm_xmmm128_imm8 = 3798, + // `VINSERTF32X4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8` + // + // `EVEX.512.66.0F3A.W0 18 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vinsertf32x4_zmm_k1z_zmm_xmmm128_imm8 = 3799, + // `VINSERTF64X2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8` + // + // `EVEX.256.66.0F3A.W1 18 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vinsertf64x2_ymm_k1z_ymm_xmmm128_imm8 = 3800, + // `VINSERTF64X2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8` + // + // `EVEX.512.66.0F3A.W1 18 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vinsertf64x2_zmm_k1z_zmm_xmmm128_imm8 = 3801, + // `VEXTRACTF128 xmm1/m128, ymm2, imm8` + // + // `VEX.256.66.0F3A.W0 19 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vextractf128_xmmm128_ymm_imm8 = 3802, + // `VEXTRACTF32X4 xmm1/m128 {k1}{z}, ymm2, imm8` + // + // `EVEX.256.66.0F3A.W0 19 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vextractf32x4_xmmm128_k1z_ymm_imm8 = 3803, + // `VEXTRACTF32X4 xmm1/m128 {k1}{z}, zmm2, imm8` + // + // `EVEX.512.66.0F3A.W0 19 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vextractf32x4_xmmm128_k1z_zmm_imm8 = 3804, + // `VEXTRACTF64X2 xmm1/m128 {k1}{z}, ymm2, imm8` + // + // `EVEX.256.66.0F3A.W1 19 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vextractf64x2_xmmm128_k1z_ymm_imm8 = 3805, + // `VEXTRACTF64X2 xmm1/m128 {k1}{z}, zmm2, imm8` + // + // `EVEX.512.66.0F3A.W1 19 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vextractf64x2_xmmm128_k1z_zmm_imm8 = 3806, + // `VINSERTF32X8 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8` + // + // `EVEX.512.66.0F3A.W0 1A /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vinsertf32x8_zmm_k1z_zmm_ymmm256_imm8 = 3807, + // `VINSERTF64X4 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8` + // + // `EVEX.512.66.0F3A.W1 1A /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vinsertf64x4_zmm_k1z_zmm_ymmm256_imm8 = 3808, + // `VEXTRACTF32X8 ymm1/m256 {k1}{z}, zmm2, imm8` + // + // `EVEX.512.66.0F3A.W0 1B /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vextractf32x8_ymmm256_k1z_zmm_imm8 = 3809, + // `VEXTRACTF64X4 ymm1/m256 {k1}{z}, zmm2, imm8` + // + // `EVEX.512.66.0F3A.W1 1B /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vextractf64x4_ymmm256_k1z_zmm_imm8 = 3810, + // `VCVTPS2PH xmm1/m64, xmm2, imm8` + // + // `VEX.128.66.0F3A.W0 1D /r ib` + // + // `F16C` + // + // `16/32/64-bit` + VEX_Vcvtps2ph_xmmm64_xmm_imm8 = 3811, + // `VCVTPS2PH xmm1/m128, ymm2, imm8` + // + // `VEX.256.66.0F3A.W0 1D /r ib` + // + // `F16C` + // + // `16/32/64-bit` + VEX_Vcvtps2ph_xmmm128_ymm_imm8 = 3812, + // `VCVTPS2PH xmm1/m64 {k1}{z}, xmm2, imm8` + // + // `EVEX.128.66.0F3A.W0 1D /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2ph_xmmm64_k1z_xmm_imm8 = 3813, + // `VCVTPS2PH xmm1/m128 {k1}{z}, ymm2, imm8` + // + // `EVEX.256.66.0F3A.W0 1D /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2ph_xmmm128_k1z_ymm_imm8 = 3814, + // `VCVTPS2PH ymm1/m256 {k1}{z}, zmm2{sae}, imm8` + // + // `EVEX.512.66.0F3A.W0 1D /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vcvtps2ph_ymmm256_k1z_zmm_imm8_sae = 3815, + // `VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 1E /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpud_kr_k1_xmm_xmmm128b32_imm8 = 3816, + // `VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 1E /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpud_kr_k1_ymm_ymmm256b32_imm8 = 3817, + // `VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F3A.W0 1E /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpud_kr_k1_zmm_zmmm512b32_imm8 = 3818, + // `VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 1E /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpuq_kr_k1_xmm_xmmm128b64_imm8 = 3819, + // `VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 1E /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpuq_kr_k1_ymm_ymmm256b64_imm8 = 3820, + // `VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 1E /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpuq_kr_k1_zmm_zmmm512b64_imm8 = 3821, + // `VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 1F /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpd_kr_k1_xmm_xmmm128b32_imm8 = 3822, + // `VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 1F /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpd_kr_k1_ymm_ymmm256b32_imm8 = 3823, + // `VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F3A.W0 1F /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpd_kr_k1_zmm_zmmm512b32_imm8 = 3824, + // `VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 1F /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpq_kr_k1_xmm_xmmm128b64_imm8 = 3825, + // `VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 1F /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpq_kr_k1_ymm_ymmm256b64_imm8 = 3826, + // `VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 1F /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpcmpq_kr_k1_zmm_zmmm512b64_imm8 = 3827, + // `PINSRB xmm1, r32/m8, imm8` + // + // `66 0F 3A 20 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pinsrb_xmm_r32m8_imm8 = 3828, + // `PINSRB xmm1, r64/m8, imm8` + // + // `66 o64 0F 3A 20 /r ib` + // + // `SSE4.1` + // + // `64-bit` + Pinsrb_xmm_r64m8_imm8 = 3829, + // `VPINSRB xmm1, xmm2, r32/m8, imm8` + // + // `VEX.128.66.0F3A.W0 20 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpinsrb_xmm_xmm_r32m8_imm8 = 3830, + // `VPINSRB xmm1, xmm2, r64/m8, imm8` + // + // `VEX.128.66.0F3A.W1 20 /r ib` + // + // `AVX` + // + // `64-bit` + VEX_Vpinsrb_xmm_xmm_r64m8_imm8 = 3831, + // `VPINSRB xmm1, xmm2, r32/m8, imm8` + // + // `EVEX.128.66.0F3A.W0 20 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpinsrb_xmm_xmm_r32m8_imm8 = 3832, + // `VPINSRB xmm1, xmm2, r64/m8, imm8` + // + // `EVEX.128.66.0F3A.W1 20 /r ib` + // + // `AVX512BW` + // + // `64-bit` + EVEX_Vpinsrb_xmm_xmm_r64m8_imm8 = 3833, + // `INSERTPS xmm1, xmm2/m32, imm8` + // + // `66 0F 3A 21 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Insertps_xmm_xmmm32_imm8 = 3834, + // `VINSERTPS xmm1, xmm2, xmm3/m32, imm8` + // + // `VEX.128.66.0F3A.WIG 21 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vinsertps_xmm_xmm_xmmm32_imm8 = 3835, + // `VINSERTPS xmm1, xmm2, xmm3/m32, imm8` + // + // `EVEX.128.66.0F3A.W0 21 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vinsertps_xmm_xmm_xmmm32_imm8 = 3836, + // `PINSRD xmm1, r/m32, imm8` + // + // `66 0F 3A 22 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Pinsrd_xmm_rm32_imm8 = 3837, + // `PINSRQ xmm1, r/m64, imm8` + // + // `66 o64 0F 3A 22 /r ib` + // + // `SSE4.1` + // + // `64-bit` + Pinsrq_xmm_rm64_imm8 = 3838, + // `VPINSRD xmm1, xmm2, r/m32, imm8` + // + // `VEX.128.66.0F3A.W0 22 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpinsrd_xmm_xmm_rm32_imm8 = 3839, + // `VPINSRQ xmm1, xmm2, r/m64, imm8` + // + // `VEX.128.66.0F3A.W1 22 /r ib` + // + // `AVX` + // + // `64-bit` + VEX_Vpinsrq_xmm_xmm_rm64_imm8 = 3840, + // `VPINSRD xmm1, xmm2, r/m32, imm8` + // + // `EVEX.128.66.0F3A.W0 22 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vpinsrd_xmm_xmm_rm32_imm8 = 3841, + // `VPINSRQ xmm1, xmm2, r/m64, imm8` + // + // `EVEX.128.66.0F3A.W1 22 /r ib` + // + // `AVX512DQ` + // + // `64-bit` + EVEX_Vpinsrq_xmm_xmm_rm64_imm8 = 3842, + // `VSHUFF32X4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 23 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vshuff32x4_ymm_k1z_ymm_ymmm256b32_imm8 = 3843, + // `VSHUFF32X4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F3A.W0 23 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vshuff32x4_zmm_k1z_zmm_zmmm512b32_imm8 = 3844, + // `VSHUFF64X2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 23 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vshuff64x2_ymm_k1z_ymm_ymmm256b64_imm8 = 3845, + // `VSHUFF64X2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 23 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vshuff64x2_zmm_k1z_zmm_zmmm512b64_imm8 = 3846, + // `VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 25 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpternlogd_xmm_k1z_xmm_xmmm128b32_imm8 = 3847, + // `VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 25 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpternlogd_ymm_k1z_ymm_ymmm256b32_imm8 = 3848, + // `VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F3A.W0 25 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpternlogd_zmm_k1z_zmm_zmmm512b32_imm8 = 3849, + // `VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 25 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpternlogq_xmm_k1z_xmm_xmmm128b64_imm8 = 3850, + // `VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 25 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vpternlogq_ymm_k1z_ymm_ymmm256b64_imm8 = 3851, + // `VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 25 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vpternlogq_zmm_k1z_zmm_zmmm512b64_imm8 = 3852, + // `VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 26 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetmantps_xmm_k1z_xmmm128b32_imm8 = 3853, + // `VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 26 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetmantps_ymm_k1z_ymmm256b32_imm8 = 3854, + // `VGETMANTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8` + // + // `EVEX.512.66.0F3A.W0 26 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetmantps_zmm_k1z_zmmm512b32_imm8_sae = 3855, + // `VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 26 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetmantpd_xmm_k1z_xmmm128b64_imm8 = 3856, + // `VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 26 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetmantpd_ymm_k1z_ymmm256b64_imm8 = 3857, + // `VGETMANTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8` + // + // `EVEX.512.66.0F3A.W1 26 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetmantpd_zmm_k1z_zmmm512b64_imm8_sae = 3858, + // `VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8` + // + // `EVEX.LIG.66.0F3A.W0 27 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetmantss_xmm_k1z_xmm_xmmm32_imm8_sae = 3859, + // `VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8` + // + // `EVEX.LIG.66.0F3A.W1 27 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vgetmantsd_xmm_k1z_xmm_xmmm64_imm8_sae = 3860, + // `KSHIFTRB k1, k2, imm8` + // + // `VEX.L0.66.0F3A.W0 30 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kshiftrb_kr_kr_imm8 = 3861, + // `KSHIFTRW k1, k2, imm8` + // + // `VEX.L0.66.0F3A.W1 30 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kshiftrw_kr_kr_imm8 = 3862, + // `KSHIFTRD k1, k2, imm8` + // + // `VEX.L0.66.0F3A.W0 31 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kshiftrd_kr_kr_imm8 = 3863, + // `KSHIFTRQ k1, k2, imm8` + // + // `VEX.L0.66.0F3A.W1 31 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kshiftrq_kr_kr_imm8 = 3864, + // `KSHIFTLB k1, k2, imm8` + // + // `VEX.L0.66.0F3A.W0 32 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + VEX_Kshiftlb_kr_kr_imm8 = 3865, + // `KSHIFTLW k1, k2, imm8` + // + // `VEX.L0.66.0F3A.W1 32 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + VEX_Kshiftlw_kr_kr_imm8 = 3866, + // `KSHIFTLD k1, k2, imm8` + // + // `VEX.L0.66.0F3A.W0 33 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kshiftld_kr_kr_imm8 = 3867, + // `KSHIFTLQ k1, k2, imm8` + // + // `VEX.L0.66.0F3A.W1 33 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + VEX_Kshiftlq_kr_kr_imm8 = 3868, + // `VINSERTI128 ymm1, ymm2, xmm3/m128, imm8` + // + // `VEX.256.66.0F3A.W0 38 /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vinserti128_ymm_ymm_xmmm128_imm8 = 3869, + // `VINSERTI32X4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8` + // + // `EVEX.256.66.0F3A.W0 38 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vinserti32x4_ymm_k1z_ymm_xmmm128_imm8 = 3870, + // `VINSERTI32X4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8` + // + // `EVEX.512.66.0F3A.W0 38 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vinserti32x4_zmm_k1z_zmm_xmmm128_imm8 = 3871, + // `VINSERTI64X2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8` + // + // `EVEX.256.66.0F3A.W1 38 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vinserti64x2_ymm_k1z_ymm_xmmm128_imm8 = 3872, + // `VINSERTI64X2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8` + // + // `EVEX.512.66.0F3A.W1 38 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vinserti64x2_zmm_k1z_zmm_xmmm128_imm8 = 3873, + // `VEXTRACTI128 xmm1/m128, ymm2, imm8` + // + // `VEX.256.66.0F3A.W0 39 /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vextracti128_xmmm128_ymm_imm8 = 3874, + // `VEXTRACTI32X4 xmm1/m128 {k1}{z}, ymm2, imm8` + // + // `EVEX.256.66.0F3A.W0 39 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vextracti32x4_xmmm128_k1z_ymm_imm8 = 3875, + // `VEXTRACTI32X4 xmm1/m128 {k1}{z}, zmm2, imm8` + // + // `EVEX.512.66.0F3A.W0 39 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vextracti32x4_xmmm128_k1z_zmm_imm8 = 3876, + // `VEXTRACTI64X2 xmm1/m128 {k1}{z}, ymm2, imm8` + // + // `EVEX.256.66.0F3A.W1 39 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vextracti64x2_xmmm128_k1z_ymm_imm8 = 3877, + // `VEXTRACTI64X2 xmm1/m128 {k1}{z}, zmm2, imm8` + // + // `EVEX.512.66.0F3A.W1 39 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vextracti64x2_xmmm128_k1z_zmm_imm8 = 3878, + // `VINSERTI32X8 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8` + // + // `EVEX.512.66.0F3A.W0 3A /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vinserti32x8_zmm_k1z_zmm_ymmm256_imm8 = 3879, + // `VINSERTI64X4 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8` + // + // `EVEX.512.66.0F3A.W1 3A /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vinserti64x4_zmm_k1z_zmm_ymmm256_imm8 = 3880, + // `VEXTRACTI32X8 ymm1/m256 {k1}{z}, zmm2, imm8` + // + // `EVEX.512.66.0F3A.W0 3B /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vextracti32x8_ymmm256_k1z_zmm_imm8 = 3881, + // `VEXTRACTI64X4 ymm1/m256 {k1}{z}, zmm2, imm8` + // + // `EVEX.512.66.0F3A.W1 3B /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vextracti64x4_ymmm256_k1z_zmm_imm8 = 3882, + // `VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8` + // + // `EVEX.128.66.0F3A.W0 3E /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpub_kr_k1_xmm_xmmm128_imm8 = 3883, + // `VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8` + // + // `EVEX.256.66.0F3A.W0 3E /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpub_kr_k1_ymm_ymmm256_imm8 = 3884, + // `VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8` + // + // `EVEX.512.66.0F3A.W0 3E /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpub_kr_k1_zmm_zmmm512_imm8 = 3885, + // `VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8` + // + // `EVEX.128.66.0F3A.W1 3E /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpuw_kr_k1_xmm_xmmm128_imm8 = 3886, + // `VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8` + // + // `EVEX.256.66.0F3A.W1 3E /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpuw_kr_k1_ymm_ymmm256_imm8 = 3887, + // `VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8` + // + // `EVEX.512.66.0F3A.W1 3E /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpuw_kr_k1_zmm_zmmm512_imm8 = 3888, + // `VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8` + // + // `EVEX.128.66.0F3A.W0 3F /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpb_kr_k1_xmm_xmmm128_imm8 = 3889, + // `VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8` + // + // `EVEX.256.66.0F3A.W0 3F /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpb_kr_k1_ymm_ymmm256_imm8 = 3890, + // `VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8` + // + // `EVEX.512.66.0F3A.W0 3F /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpb_kr_k1_zmm_zmmm512_imm8 = 3891, + // `VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8` + // + // `EVEX.128.66.0F3A.W1 3F /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpw_kr_k1_xmm_xmmm128_imm8 = 3892, + // `VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8` + // + // `EVEX.256.66.0F3A.W1 3F /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpw_kr_k1_ymm_ymmm256_imm8 = 3893, + // `VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8` + // + // `EVEX.512.66.0F3A.W1 3F /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vpcmpw_kr_k1_zmm_zmmm512_imm8 = 3894, + // `DPPS xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 40 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Dpps_xmm_xmmm128_imm8 = 3895, + // `VDPPS xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 40 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vdpps_xmm_xmm_xmmm128_imm8 = 3896, + // `VDPPS ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.WIG 40 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vdpps_ymm_ymm_ymmm256_imm8 = 3897, + // `DPPD xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 41 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Dppd_xmm_xmmm128_imm8 = 3898, + // `VDPPD xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 41 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vdppd_xmm_xmm_xmmm128_imm8 = 3899, + // `MPSADBW xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 42 /r ib` + // + // `SSE4.1` + // + // `16/32/64-bit` + Mpsadbw_xmm_xmmm128_imm8 = 3900, + // `VMPSADBW xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 42 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vmpsadbw_xmm_xmm_xmmm128_imm8 = 3901, + // `VMPSADBW ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.WIG 42 /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vmpsadbw_ymm_ymm_ymmm256_imm8 = 3902, + // `VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8` + // + // `EVEX.128.66.0F3A.W0 42 /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vdbpsadbw_xmm_k1z_xmm_xmmm128_imm8 = 3903, + // `VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8` + // + // `EVEX.256.66.0F3A.W0 42 /r ib` + // + // `AVX512VL and AVX512BW` + // + // `16/32/64-bit` + EVEX_Vdbpsadbw_ymm_k1z_ymm_ymmm256_imm8 = 3904, + // `VDBPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8` + // + // `EVEX.512.66.0F3A.W0 42 /r ib` + // + // `AVX512BW` + // + // `16/32/64-bit` + EVEX_Vdbpsadbw_zmm_k1z_zmm_zmmm512_imm8 = 3905, + // `VSHUFI32X4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 43 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vshufi32x4_ymm_k1z_ymm_ymmm256b32_imm8 = 3906, + // `VSHUFI32X4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F3A.W0 43 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vshufi32x4_zmm_k1z_zmm_zmmm512b32_imm8 = 3907, + // `VSHUFI64X2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 43 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vshufi64x2_ymm_k1z_ymm_ymmm256b64_imm8 = 3908, + // `VSHUFI64X2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 43 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vshufi64x2_zmm_k1z_zmm_zmmm512b64_imm8 = 3909, + // `PCLMULQDQ xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 44 /r ib` + // + // `PCLMULQDQ` + // + // `16/32/64-bit` + Pclmulqdq_xmm_xmmm128_imm8 = 3910, + // `VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 44 /r ib` + // + // `PCLMULQDQ and AVX` + // + // `16/32/64-bit` + VEX_Vpclmulqdq_xmm_xmm_xmmm128_imm8 = 3911, + // `VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.WIG 44 /r ib` + // + // `VPCLMULQDQ` + // + // `16/32/64-bit` + VEX_Vpclmulqdq_ymm_ymm_ymmm256_imm8 = 3912, + // `VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8` + // + // `EVEX.128.66.0F3A.WIG 44 /r ib` + // + // `AVX512VL and VPCLMULQDQ` + // + // `16/32/64-bit` + EVEX_Vpclmulqdq_xmm_xmm_xmmm128_imm8 = 3913, + // `VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8` + // + // `EVEX.256.66.0F3A.WIG 44 /r ib` + // + // `AVX512VL and VPCLMULQDQ` + // + // `16/32/64-bit` + EVEX_Vpclmulqdq_ymm_ymm_ymmm256_imm8 = 3914, + // `VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8` + // + // `EVEX.512.66.0F3A.WIG 44 /r ib` + // + // `AVX512F and VPCLMULQDQ` + // + // `16/32/64-bit` + EVEX_Vpclmulqdq_zmm_zmm_zmmm512_imm8 = 3915, + // `VPERM2I128 ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.W0 46 /r ib` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vperm2i128_ymm_ymm_ymmm256_imm8 = 3916, + // `VPERMIL2PS xmm1, xmm2, xmm3/m128, xmm4, imm4` + // + // `VEX.128.66.0F3A.W0 48 /r /is5` + // + // `XOP` + // + // `16/32/64-bit` + VEX_Vpermil2ps_xmm_xmm_xmmm128_xmm_imm4 = 3917, + // `VPERMIL2PS ymm1, ymm2, ymm3/m256, ymm4, imm4` + // + // `VEX.256.66.0F3A.W0 48 /r /is5` + // + // `XOP` + // + // `16/32/64-bit` + VEX_Vpermil2ps_ymm_ymm_ymmm256_ymm_imm4 = 3918, + // `VPERMIL2PS xmm1, xmm2, xmm3, xmm4/m128, imm4` + // + // `VEX.128.66.0F3A.W1 48 /r /is5` + // + // `XOP` + // + // `16/32/64-bit` + VEX_Vpermil2ps_xmm_xmm_xmm_xmmm128_imm4 = 3919, + // `VPERMIL2PS ymm1, ymm2, ymm3, ymm4/m256, imm4` + // + // `VEX.256.66.0F3A.W1 48 /r /is5` + // + // `XOP` + // + // `16/32/64-bit` + VEX_Vpermil2ps_ymm_ymm_ymm_ymmm256_imm4 = 3920, + // `VPERMIL2PD xmm1, xmm2, xmm3/m128, xmm4, imm4` + // + // `VEX.128.66.0F3A.W0 49 /r /is5` + // + // `XOP` + // + // `16/32/64-bit` + VEX_Vpermil2pd_xmm_xmm_xmmm128_xmm_imm4 = 3921, + // `VPERMIL2PD ymm1, ymm2, ymm3/m256, ymm4, imm4` + // + // `VEX.256.66.0F3A.W0 49 /r /is5` + // + // `XOP` + // + // `16/32/64-bit` + VEX_Vpermil2pd_ymm_ymm_ymmm256_ymm_imm4 = 3922, + // `VPERMIL2PD xmm1, xmm2, xmm3, xmm4/m128, imm4` + // + // `VEX.128.66.0F3A.W1 49 /r /is5` + // + // `XOP` + // + // `16/32/64-bit` + VEX_Vpermil2pd_xmm_xmm_xmm_xmmm128_imm4 = 3923, + // `VPERMIL2PD ymm1, ymm2, ymm3, ymm4/m256, imm4` + // + // `VEX.256.66.0F3A.W1 49 /r /is5` + // + // `XOP` + // + // `16/32/64-bit` + VEX_Vpermil2pd_ymm_ymm_ymm_ymmm256_imm4 = 3924, + // `VBLENDVPS xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 4A /r /is4` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vblendvps_xmm_xmm_xmmm128_xmm = 3925, + // `VBLENDVPS ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 4A /r /is4` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vblendvps_ymm_ymm_ymmm256_ymm = 3926, + // `VBLENDVPD xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 4B /r /is4` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vblendvpd_xmm_xmm_xmmm128_xmm = 3927, + // `VBLENDVPD ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 4B /r /is4` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vblendvpd_ymm_ymm_ymmm256_ymm = 3928, + // `VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 4C /r /is4` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpblendvb_xmm_xmm_xmmm128_xmm = 3929, + // `VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 4C /r /is4` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vpblendvb_ymm_ymm_ymmm256_ymm = 3930, + // `VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 50 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vrangeps_xmm_k1z_xmm_xmmm128b32_imm8 = 3931, + // `VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 50 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vrangeps_ymm_k1z_ymm_ymmm256b32_imm8 = 3932, + // `VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8` + // + // `EVEX.512.66.0F3A.W0 50 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vrangeps_zmm_k1z_zmm_zmmm512b32_imm8_sae = 3933, + // `VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 50 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vrangepd_xmm_k1z_xmm_xmmm128b64_imm8 = 3934, + // `VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 50 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vrangepd_ymm_k1z_ymm_ymmm256b64_imm8 = 3935, + // `VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8` + // + // `EVEX.512.66.0F3A.W1 50 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vrangepd_zmm_k1z_zmm_zmmm512b64_imm8_sae = 3936, + // `VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8` + // + // `EVEX.LIG.66.0F3A.W0 51 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vrangess_xmm_k1z_xmm_xmmm32_imm8_sae = 3937, + // `VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8` + // + // `EVEX.LIG.66.0F3A.W1 51 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vrangesd_xmm_k1z_xmm_xmmm64_imm8_sae = 3938, + // `VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 54 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfixupimmps_xmm_k1z_xmm_xmmm128b32_imm8 = 3939, + // `VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 54 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfixupimmps_ymm_k1z_ymm_ymmm256b32_imm8 = 3940, + // `VFIXUPIMMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8` + // + // `EVEX.512.66.0F3A.W0 54 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfixupimmps_zmm_k1z_zmm_zmmm512b32_imm8_sae = 3941, + // `VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 54 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfixupimmpd_xmm_k1z_xmm_xmmm128b64_imm8 = 3942, + // `VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 54 /r ib` + // + // `AVX512VL and AVX512F` + // + // `16/32/64-bit` + EVEX_Vfixupimmpd_ymm_k1z_ymm_ymmm256b64_imm8 = 3943, + // `VFIXUPIMMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8` + // + // `EVEX.512.66.0F3A.W1 54 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfixupimmpd_zmm_k1z_zmm_zmmm512b64_imm8_sae = 3944, + // `VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8` + // + // `EVEX.LIG.66.0F3A.W0 55 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfixupimmss_xmm_k1z_xmm_xmmm32_imm8_sae = 3945, + // `VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8` + // + // `EVEX.LIG.66.0F3A.W1 55 /r ib` + // + // `AVX512F` + // + // `16/32/64-bit` + EVEX_Vfixupimmsd_xmm_k1z_xmm_xmmm64_imm8_sae = 3946, + // `VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 56 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vreduceps_xmm_k1z_xmmm128b32_imm8 = 3947, + // `VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 56 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vreduceps_ymm_k1z_ymmm256b32_imm8 = 3948, + // `VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8` + // + // `EVEX.512.66.0F3A.W0 56 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vreduceps_zmm_k1z_zmmm512b32_imm8_sae = 3949, + // `VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 56 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vreducepd_xmm_k1z_xmmm128b64_imm8 = 3950, + // `VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 56 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vreducepd_ymm_k1z_ymmm256b64_imm8 = 3951, + // `VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8` + // + // `EVEX.512.66.0F3A.W1 56 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vreducepd_zmm_k1z_zmmm512b64_imm8_sae = 3952, + // `VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8` + // + // `EVEX.LIG.66.0F3A.W0 57 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vreducess_xmm_k1z_xmm_xmmm32_imm8_sae = 3953, + // `VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8` + // + // `EVEX.LIG.66.0F3A.W1 57 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vreducesd_xmm_k1z_xmm_xmmm64_imm8_sae = 3954, + // `VFMADDSUBPS xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 5C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddsubps_xmm_xmm_xmmm128_xmm = 3955, + // `VFMADDSUBPS ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 5C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddsubps_ymm_ymm_ymmm256_ymm = 3956, + // `VFMADDSUBPS xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 5C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddsubps_xmm_xmm_xmm_xmmm128 = 3957, + // `VFMADDSUBPS ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 5C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddsubps_ymm_ymm_ymm_ymmm256 = 3958, + // `VFMADDSUBPD xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 5D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddsubpd_xmm_xmm_xmmm128_xmm = 3959, + // `VFMADDSUBPD ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 5D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddsubpd_ymm_ymm_ymmm256_ymm = 3960, + // `VFMADDSUBPD xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 5D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddsubpd_xmm_xmm_xmm_xmmm128 = 3961, + // `VFMADDSUBPD ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 5D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddsubpd_ymm_ymm_ymm_ymmm256 = 3962, + // `VFMSUBADDPS xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 5E /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubaddps_xmm_xmm_xmmm128_xmm = 3963, + // `VFMSUBADDPS ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 5E /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubaddps_ymm_ymm_ymmm256_ymm = 3964, + // `VFMSUBADDPS xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 5E /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubaddps_xmm_xmm_xmm_xmmm128 = 3965, + // `VFMSUBADDPS ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 5E /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubaddps_ymm_ymm_ymm_ymmm256 = 3966, + // `VFMSUBADDPD xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 5F /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubaddpd_xmm_xmm_xmmm128_xmm = 3967, + // `VFMSUBADDPD ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 5F /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubaddpd_ymm_ymm_ymmm256_ymm = 3968, + // `VFMSUBADDPD xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 5F /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubaddpd_xmm_xmm_xmm_xmmm128 = 3969, + // `VFMSUBADDPD ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 5F /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubaddpd_ymm_ymm_ymm_ymmm256 = 3970, + // `PCMPESTRM xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 60 /r ib` + // + // `SSE4.2` + // + // `16/32/64-bit` + Pcmpestrm_xmm_xmmm128_imm8 = 3971, + // `PCMPESTRM64 xmm1, xmm2/m128, imm8` + // + // `66 o64 0F 3A 60 /r ib` + // + // `SSE4.2` + // + // `64-bit` + Pcmpestrm64_xmm_xmmm128_imm8 = 3972, + // `VPCMPESTRM xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F3A.W0 60 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpestrm_xmm_xmmm128_imm8 = 3973, + // `VPCMPESTRM64 xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F3A.W1 60 /r ib` + // + // `AVX` + // + // `64-bit` + VEX_Vpcmpestrm64_xmm_xmmm128_imm8 = 3974, + // `PCMPESTRI xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 61 /r ib` + // + // `SSE4.2` + // + // `16/32/64-bit` + Pcmpestri_xmm_xmmm128_imm8 = 3975, + // `PCMPESTRI64 xmm1, xmm2/m128, imm8` + // + // `66 o64 0F 3A 61 /r ib` + // + // `SSE4.2` + // + // `64-bit` + Pcmpestri64_xmm_xmmm128_imm8 = 3976, + // `VPCMPESTRI xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F3A.W0 61 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpestri_xmm_xmmm128_imm8 = 3977, + // `VPCMPESTRI64 xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F3A.W1 61 /r ib` + // + // `AVX` + // + // `64-bit` + VEX_Vpcmpestri64_xmm_xmmm128_imm8 = 3978, + // `PCMPISTRM xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 62 /r ib` + // + // `SSE4.2` + // + // `16/32/64-bit` + Pcmpistrm_xmm_xmmm128_imm8 = 3979, + // `VPCMPISTRM xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 62 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpistrm_xmm_xmmm128_imm8 = 3980, + // `PCMPISTRI xmm1, xmm2/m128, imm8` + // + // `66 0F 3A 63 /r ib` + // + // `SSE4.2` + // + // `16/32/64-bit` + Pcmpistri_xmm_xmmm128_imm8 = 3981, + // `VPCMPISTRI xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F3A.WIG 63 /r ib` + // + // `AVX` + // + // `16/32/64-bit` + VEX_Vpcmpistri_xmm_xmmm128_imm8 = 3982, + // `VFPCLASSPS k2 {k1}, xmm2/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 66 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vfpclassps_kr_k1_xmmm128b32_imm8 = 3983, + // `VFPCLASSPS k2 {k1}, ymm2/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 66 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vfpclassps_kr_k1_ymmm256b32_imm8 = 3984, + // `VFPCLASSPS k2 {k1}, zmm2/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F3A.W0 66 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vfpclassps_kr_k1_zmmm512b32_imm8 = 3985, + // `VFPCLASSPD k2 {k1}, xmm2/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 66 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vfpclasspd_kr_k1_xmmm128b64_imm8 = 3986, + // `VFPCLASSPD k2 {k1}, ymm2/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 66 /r ib` + // + // `AVX512VL and AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vfpclasspd_kr_k1_ymmm256b64_imm8 = 3987, + // `VFPCLASSPD k2 {k1}, zmm2/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 66 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vfpclasspd_kr_k1_zmmm512b64_imm8 = 3988, + // `VFPCLASSSS k2 {k1}, xmm2/m32, imm8` + // + // `EVEX.LIG.66.0F3A.W0 67 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vfpclassss_kr_k1_xmmm32_imm8 = 3989, + // `VFPCLASSSD k2 {k1}, xmm2/m64, imm8` + // + // `EVEX.LIG.66.0F3A.W1 67 /r ib` + // + // `AVX512DQ` + // + // `16/32/64-bit` + EVEX_Vfpclasssd_kr_k1_xmmm64_imm8 = 3990, + // `VFMADDPS xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 68 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddps_xmm_xmm_xmmm128_xmm = 3991, + // `VFMADDPS ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 68 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddps_ymm_ymm_ymmm256_ymm = 3992, + // `VFMADDPS xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 68 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddps_xmm_xmm_xmm_xmmm128 = 3993, + // `VFMADDPS ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 68 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddps_ymm_ymm_ymm_ymmm256 = 3994, + // `VFMADDPD xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 69 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddpd_xmm_xmm_xmmm128_xmm = 3995, + // `VFMADDPD ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 69 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddpd_ymm_ymm_ymmm256_ymm = 3996, + // `VFMADDPD xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 69 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddpd_xmm_xmm_xmm_xmmm128 = 3997, + // `VFMADDPD ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 69 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddpd_ymm_ymm_ymm_ymmm256 = 3998, + // `VFMADDSS xmm1, xmm2, xmm3/m32, xmm4` + // + // `VEX.LIG.66.0F3A.W0 6A /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddss_xmm_xmm_xmmm32_xmm = 3999, + // `VFMADDSS xmm1, xmm2, xmm3, xmm4/m32` + // + // `VEX.LIG.66.0F3A.W1 6A /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddss_xmm_xmm_xmm_xmmm32 = 4000, + // `VFMADDSD xmm1, xmm2, xmm3/m64, xmm4` + // + // `VEX.LIG.66.0F3A.W0 6B /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddsd_xmm_xmm_xmmm64_xmm = 4001, + // `VFMADDSD xmm1, xmm2, xmm3, xmm4/m64` + // + // `VEX.LIG.66.0F3A.W1 6B /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmaddsd_xmm_xmm_xmm_xmmm64 = 4002, + // `VFMSUBPS xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 6C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubps_xmm_xmm_xmmm128_xmm = 4003, + // `VFMSUBPS ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 6C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubps_ymm_ymm_ymmm256_ymm = 4004, + // `VFMSUBPS xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 6C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubps_xmm_xmm_xmm_xmmm128 = 4005, + // `VFMSUBPS ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 6C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubps_ymm_ymm_ymm_ymmm256 = 4006, + // `VFMSUBPD xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 6D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubpd_xmm_xmm_xmmm128_xmm = 4007, + // `VFMSUBPD ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 6D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubpd_ymm_ymm_ymmm256_ymm = 4008, + // `VFMSUBPD xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 6D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubpd_xmm_xmm_xmm_xmmm128 = 4009, + // `VFMSUBPD ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 6D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubpd_ymm_ymm_ymm_ymmm256 = 4010, + // `VFMSUBSS xmm1, xmm2, xmm3/m32, xmm4` + // + // `VEX.LIG.66.0F3A.W0 6E /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubss_xmm_xmm_xmmm32_xmm = 4011, + // `VFMSUBSS xmm1, xmm2, xmm3, xmm4/m32` + // + // `VEX.LIG.66.0F3A.W1 6E /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubss_xmm_xmm_xmm_xmmm32 = 4012, + // `VFMSUBSD xmm1, xmm2, xmm3/m64, xmm4` + // + // `VEX.LIG.66.0F3A.W0 6F /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubsd_xmm_xmm_xmmm64_xmm = 4013, + // `VFMSUBSD xmm1, xmm2, xmm3, xmm4/m64` + // + // `VEX.LIG.66.0F3A.W1 6F /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfmsubsd_xmm_xmm_xmm_xmmm64 = 4014, + // `VPSHLDW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8` + // + // `EVEX.128.66.0F3A.W1 70 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldw_xmm_k1z_xmm_xmmm128_imm8 = 4015, + // `VPSHLDW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8` + // + // `EVEX.256.66.0F3A.W1 70 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldw_ymm_k1z_ymm_ymmm256_imm8 = 4016, + // `VPSHLDW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8` + // + // `EVEX.512.66.0F3A.W1 70 /r ib` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldw_zmm_k1z_zmm_zmmm512_imm8 = 4017, + // `VPSHLDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 71 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldd_xmm_k1z_xmm_xmmm128b32_imm8 = 4018, + // `VPSHLDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 71 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldd_ymm_k1z_ymm_ymmm256b32_imm8 = 4019, + // `VPSHLDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F3A.W0 71 /r ib` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldd_zmm_k1z_zmm_zmmm512b32_imm8 = 4020, + // `VPSHLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 71 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldq_xmm_k1z_xmm_xmmm128b64_imm8 = 4021, + // `VPSHLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 71 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldq_ymm_k1z_ymm_ymmm256b64_imm8 = 4022, + // `VPSHLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 71 /r ib` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshldq_zmm_k1z_zmm_zmmm512b64_imm8 = 4023, + // `VPSHRDW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8` + // + // `EVEX.128.66.0F3A.W1 72 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdw_xmm_k1z_xmm_xmmm128_imm8 = 4024, + // `VPSHRDW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8` + // + // `EVEX.256.66.0F3A.W1 72 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdw_ymm_k1z_ymm_ymmm256_imm8 = 4025, + // `VPSHRDW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8` + // + // `EVEX.512.66.0F3A.W1 72 /r ib` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdw_zmm_k1z_zmm_zmmm512_imm8 = 4026, + // `VPSHRDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8` + // + // `EVEX.128.66.0F3A.W0 73 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdd_xmm_k1z_xmm_xmmm128b32_imm8 = 4027, + // `VPSHRDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8` + // + // `EVEX.256.66.0F3A.W0 73 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdd_ymm_k1z_ymm_ymmm256b32_imm8 = 4028, + // `VPSHRDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8` + // + // `EVEX.512.66.0F3A.W0 73 /r ib` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdd_zmm_k1z_zmm_zmmm512b32_imm8 = 4029, + // `VPSHRDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 73 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdq_xmm_k1z_xmm_xmmm128b64_imm8 = 4030, + // `VPSHRDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 73 /r ib` + // + // `AVX512VL and AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdq_ymm_k1z_ymm_ymmm256b64_imm8 = 4031, + // `VPSHRDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 73 /r ib` + // + // `AVX512_VBMI2` + // + // `16/32/64-bit` + EVEX_Vpshrdq_zmm_k1z_zmm_zmmm512b64_imm8 = 4032, + // `VFNMADDPS xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 78 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddps_xmm_xmm_xmmm128_xmm = 4033, + // `VFNMADDPS ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 78 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddps_ymm_ymm_ymmm256_ymm = 4034, + // `VFNMADDPS xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 78 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddps_xmm_xmm_xmm_xmmm128 = 4035, + // `VFNMADDPS ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 78 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddps_ymm_ymm_ymm_ymmm256 = 4036, + // `VFNMADDPD xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 79 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddpd_xmm_xmm_xmmm128_xmm = 4037, + // `VFNMADDPD ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 79 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddpd_ymm_ymm_ymmm256_ymm = 4038, + // `VFNMADDPD xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 79 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddpd_xmm_xmm_xmm_xmmm128 = 4039, + // `VFNMADDPD ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 79 /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddpd_ymm_ymm_ymm_ymmm256 = 4040, + // `VFNMADDSS xmm1, xmm2, xmm3/m32, xmm4` + // + // `VEX.LIG.66.0F3A.W0 7A /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddss_xmm_xmm_xmmm32_xmm = 4041, + // `VFNMADDSS xmm1, xmm2, xmm3, xmm4/m32` + // + // `VEX.LIG.66.0F3A.W1 7A /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddss_xmm_xmm_xmm_xmmm32 = 4042, + // `VFNMADDSD xmm1, xmm2, xmm3/m64, xmm4` + // + // `VEX.LIG.66.0F3A.W0 7B /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddsd_xmm_xmm_xmmm64_xmm = 4043, + // `VFNMADDSD xmm1, xmm2, xmm3, xmm4/m64` + // + // `VEX.LIG.66.0F3A.W1 7B /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmaddsd_xmm_xmm_xmm_xmmm64 = 4044, + // `VFNMSUBPS xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 7C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubps_xmm_xmm_xmmm128_xmm = 4045, + // `VFNMSUBPS ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 7C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubps_ymm_ymm_ymmm256_ymm = 4046, + // `VFNMSUBPS xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 7C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubps_xmm_xmm_xmm_xmmm128 = 4047, + // `VFNMSUBPS ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 7C /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubps_ymm_ymm_ymm_ymmm256 = 4048, + // `VFNMSUBPD xmm1, xmm2, xmm3/m128, xmm4` + // + // `VEX.128.66.0F3A.W0 7D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubpd_xmm_xmm_xmmm128_xmm = 4049, + // `VFNMSUBPD ymm1, ymm2, ymm3/m256, ymm4` + // + // `VEX.256.66.0F3A.W0 7D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubpd_ymm_ymm_ymmm256_ymm = 4050, + // `VFNMSUBPD xmm1, xmm2, xmm3, xmm4/m128` + // + // `VEX.128.66.0F3A.W1 7D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubpd_xmm_xmm_xmm_xmmm128 = 4051, + // `VFNMSUBPD ymm1, ymm2, ymm3, ymm4/m256` + // + // `VEX.256.66.0F3A.W1 7D /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubpd_ymm_ymm_ymm_ymmm256 = 4052, + // `VFNMSUBSS xmm1, xmm2, xmm3/m32, xmm4` + // + // `VEX.LIG.66.0F3A.W0 7E /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubss_xmm_xmm_xmmm32_xmm = 4053, + // `VFNMSUBSS xmm1, xmm2, xmm3, xmm4/m32` + // + // `VEX.LIG.66.0F3A.W1 7E /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubss_xmm_xmm_xmm_xmmm32 = 4054, + // `VFNMSUBSD xmm1, xmm2, xmm3/m64, xmm4` + // + // `VEX.LIG.66.0F3A.W0 7F /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubsd_xmm_xmm_xmmm64_xmm = 4055, + // `VFNMSUBSD xmm1, xmm2, xmm3, xmm4/m64` + // + // `VEX.LIG.66.0F3A.W1 7F /r /is4` + // + // `FMA4` + // + // `16/32/64-bit` + VEX_Vfnmsubsd_xmm_xmm_xmm_xmmm64 = 4056, + // `SHA1RNDS4 xmm1, xmm2/m128, imm8` + // + // `NP 0F 3A CC /r ib` + // + // `SHA` + // + // `16/32/64-bit` + Sha1rnds4_xmm_xmmm128_imm8 = 4057, + // `GF2P8AFFINEQB xmm1, xmm2/m128, imm8` + // + // `66 0F 3A CE /r ib` + // + // `GFNI` + // + // `16/32/64-bit` + Gf2p8affineqb_xmm_xmmm128_imm8 = 4058, + // `VGF2P8AFFINEQB xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F3A.W1 CE /r ib` + // + // `AVX and GFNI` + // + // `16/32/64-bit` + VEX_Vgf2p8affineqb_xmm_xmm_xmmm128_imm8 = 4059, + // `VGF2P8AFFINEQB ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.W1 CE /r ib` + // + // `AVX and GFNI` + // + // `16/32/64-bit` + VEX_Vgf2p8affineqb_ymm_ymm_ymmm256_imm8 = 4060, + // `VGF2P8AFFINEQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 CE /r ib` + // + // `AVX512VL and GFNI` + // + // `16/32/64-bit` + EVEX_Vgf2p8affineqb_xmm_k1z_xmm_xmmm128b64_imm8 = 4061, + // `VGF2P8AFFINEQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 CE /r ib` + // + // `AVX512VL and GFNI` + // + // `16/32/64-bit` + EVEX_Vgf2p8affineqb_ymm_k1z_ymm_ymmm256b64_imm8 = 4062, + // `VGF2P8AFFINEQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 CE /r ib` + // + // `AVX512F and GFNI` + // + // `16/32/64-bit` + EVEX_Vgf2p8affineqb_zmm_k1z_zmm_zmmm512b64_imm8 = 4063, + // `GF2P8AFFINEINVQB xmm1, xmm2/m128, imm8` + // + // `66 0F 3A CF /r ib` + // + // `GFNI` + // + // `16/32/64-bit` + Gf2p8affineinvqb_xmm_xmmm128_imm8 = 4064, + // `VGF2P8AFFINEINVQB xmm1, xmm2, xmm3/m128, imm8` + // + // `VEX.128.66.0F3A.W1 CF /r ib` + // + // `AVX and GFNI` + // + // `16/32/64-bit` + VEX_Vgf2p8affineinvqb_xmm_xmm_xmmm128_imm8 = 4065, + // `VGF2P8AFFINEINVQB ymm1, ymm2, ymm3/m256, imm8` + // + // `VEX.256.66.0F3A.W1 CF /r ib` + // + // `AVX and GFNI` + // + // `16/32/64-bit` + VEX_Vgf2p8affineinvqb_ymm_ymm_ymmm256_imm8 = 4066, + // `VGF2P8AFFINEINVQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8` + // + // `EVEX.128.66.0F3A.W1 CF /r ib` + // + // `AVX512VL and GFNI` + // + // `16/32/64-bit` + EVEX_Vgf2p8affineinvqb_xmm_k1z_xmm_xmmm128b64_imm8 = 4067, + // `VGF2P8AFFINEINVQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8` + // + // `EVEX.256.66.0F3A.W1 CF /r ib` + // + // `AVX512VL and GFNI` + // + // `16/32/64-bit` + EVEX_Vgf2p8affineinvqb_ymm_k1z_ymm_ymmm256b64_imm8 = 4068, + // `VGF2P8AFFINEINVQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8` + // + // `EVEX.512.66.0F3A.W1 CF /r ib` + // + // `AVX512F and GFNI` + // + // `16/32/64-bit` + EVEX_Vgf2p8affineinvqb_zmm_k1z_zmm_zmmm512b64_imm8 = 4069, + // `AESKEYGENASSIST xmm1, xmm2/m128, imm8` + // + // `66 0F 3A DF /r ib` + // + // `AES` + // + // `16/32/64-bit` + Aeskeygenassist_xmm_xmmm128_imm8 = 4070, + // `VAESKEYGENASSIST xmm1, xmm2/m128, imm8` + // + // `VEX.128.66.0F3A.WIG DF /r ib` + // + // `AES and AVX` + // + // `16/32/64-bit` + VEX_Vaeskeygenassist_xmm_xmmm128_imm8 = 4071, + // `RORX r32, r/m32, imm8` + // + // `VEX.LZ.F2.0F3A.W0 F0 /r ib` + // + // `BMI2` + // + // `16/32/64-bit` + VEX_Rorx_r32_rm32_imm8 = 4072, + // `RORX r64, r/m64, imm8` + // + // `VEX.LZ.F2.0F3A.W1 F0 /r ib` + // + // `BMI2` + // + // `64-bit` + VEX_Rorx_r64_rm64_imm8 = 4073, + // `VPMACSSWW xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 85 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmacssww_xmm_xmm_xmmm128_xmm = 4074, + // `VPMACSSWD xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 86 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmacsswd_xmm_xmm_xmmm128_xmm = 4075, + // `VPMACSSDQL xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 87 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmacssdql_xmm_xmm_xmmm128_xmm = 4076, + // `VPMACSSDD xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 8E /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmacssdd_xmm_xmm_xmmm128_xmm = 4077, + // `VPMACSSDQH xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 8F /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmacssdqh_xmm_xmm_xmmm128_xmm = 4078, + // `VPMACSWW xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 95 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmacsww_xmm_xmm_xmmm128_xmm = 4079, + // `VPMACSWD xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 96 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmacswd_xmm_xmm_xmmm128_xmm = 4080, + // `VPMACSDQL xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 97 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmacsdql_xmm_xmm_xmmm128_xmm = 4081, + // `VPMACSDD xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 9E /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmacsdd_xmm_xmm_xmmm128_xmm = 4082, + // `VPMACSDQH xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 9F /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmacsdqh_xmm_xmm_xmmm128_xmm = 4083, + // `VPCMOV xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 A2 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcmov_xmm_xmm_xmmm128_xmm = 4084, + // `VPCMOV ymm1, ymm2, ymm3/m256, ymm4` + // + // `XOP.256.X8.W0 A2 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcmov_ymm_ymm_ymmm256_ymm = 4085, + // `VPCMOV xmm1, xmm2, xmm3, xmm4/m128` + // + // `XOP.128.X8.W1 A2 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcmov_xmm_xmm_xmm_xmmm128 = 4086, + // `VPCMOV ymm1, ymm2, ymm3, ymm4/m256` + // + // `XOP.256.X8.W1 A2 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcmov_ymm_ymm_ymm_ymmm256 = 4087, + // `VPPERM xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 A3 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpperm_xmm_xmm_xmmm128_xmm = 4088, + // `VPPERM xmm1, xmm2, xmm3, xmm4/m128` + // + // `XOP.128.X8.W1 A3 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpperm_xmm_xmm_xmm_xmmm128 = 4089, + // `VPMADCSSWD xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 A6 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmadcsswd_xmm_xmm_xmmm128_xmm = 4090, + // `VPMADCSWD xmm1, xmm2, xmm3/m128, xmm4` + // + // `XOP.128.X8.W0 B6 /r /is4` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpmadcswd_xmm_xmm_xmmm128_xmm = 4091, + // `VPROTB xmm1, xmm2/m128, imm8` + // + // `XOP.128.X8.W0 C0 /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotb_xmm_xmmm128_imm8 = 4092, + // `VPROTW xmm1, xmm2/m128, imm8` + // + // `XOP.128.X8.W0 C1 /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotw_xmm_xmmm128_imm8 = 4093, + // `VPROTD xmm1, xmm2/m128, imm8` + // + // `XOP.128.X8.W0 C2 /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotd_xmm_xmmm128_imm8 = 4094, + // `VPROTQ xmm1, xmm2/m128, imm8` + // + // `XOP.128.X8.W0 C3 /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotq_xmm_xmmm128_imm8 = 4095, + // `VPCOMB xmm1, xmm2, xmm3/m128, imm8` + // + // `XOP.128.X8.W0 CC /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcomb_xmm_xmm_xmmm128_imm8 = 4096, + // `VPCOMW xmm1, xmm2, xmm3/m128, imm8` + // + // `XOP.128.X8.W0 CD /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcomw_xmm_xmm_xmmm128_imm8 = 4097, + // `VPCOMD xmm1, xmm2, xmm3/m128, imm8` + // + // `XOP.128.X8.W0 CE /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcomd_xmm_xmm_xmmm128_imm8 = 4098, + // `VPCOMQ xmm1, xmm2, xmm3/m128, imm8` + // + // `XOP.128.X8.W0 CF /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcomq_xmm_xmm_xmmm128_imm8 = 4099, + // `VPCOMUB xmm1, xmm2, xmm3/m128, imm8` + // + // `XOP.128.X8.W0 EC /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcomub_xmm_xmm_xmmm128_imm8 = 4100, + // `VPCOMUW xmm1, xmm2, xmm3/m128, imm8` + // + // `XOP.128.X8.W0 ED /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcomuw_xmm_xmm_xmmm128_imm8 = 4101, + // `VPCOMUD xmm1, xmm2, xmm3/m128, imm8` + // + // `XOP.128.X8.W0 EE /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcomud_xmm_xmm_xmmm128_imm8 = 4102, + // `VPCOMUQ xmm1, xmm2, xmm3/m128, imm8` + // + // `XOP.128.X8.W0 EF /r ib` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpcomuq_xmm_xmm_xmmm128_imm8 = 4103, + // `BLCFILL r32, r/m32` + // + // `XOP.L0.X9.W0 01 /1` + // + // `TBM` + // + // `16/32/64-bit` + XOP_Blcfill_r32_rm32 = 4104, + // `BLCFILL r64, r/m64` + // + // `XOP.L0.X9.W1 01 /1` + // + // `TBM` + // + // `64-bit` + XOP_Blcfill_r64_rm64 = 4105, + // `BLSFILL r32, r/m32` + // + // `XOP.L0.X9.W0 01 /2` + // + // `TBM` + // + // `16/32/64-bit` + XOP_Blsfill_r32_rm32 = 4106, + // `BLSFILL r64, r/m64` + // + // `XOP.L0.X9.W1 01 /2` + // + // `TBM` + // + // `64-bit` + XOP_Blsfill_r64_rm64 = 4107, + // `BLCS r32, r/m32` + // + // `XOP.L0.X9.W0 01 /3` + // + // `TBM` + // + // `16/32/64-bit` + XOP_Blcs_r32_rm32 = 4108, + // `BLCS r64, r/m64` + // + // `XOP.L0.X9.W1 01 /3` + // + // `TBM` + // + // `64-bit` + XOP_Blcs_r64_rm64 = 4109, + // `TZMSK r32, r/m32` + // + // `XOP.L0.X9.W0 01 /4` + // + // `TBM` + // + // `16/32/64-bit` + XOP_Tzmsk_r32_rm32 = 4110, + // `TZMSK r64, r/m64` + // + // `XOP.L0.X9.W1 01 /4` + // + // `TBM` + // + // `64-bit` + XOP_Tzmsk_r64_rm64 = 4111, + // `BLCIC r32, r/m32` + // + // `XOP.L0.X9.W0 01 /5` + // + // `TBM` + // + // `16/32/64-bit` + XOP_Blcic_r32_rm32 = 4112, + // `BLCIC r64, r/m64` + // + // `XOP.L0.X9.W1 01 /5` + // + // `TBM` + // + // `64-bit` + XOP_Blcic_r64_rm64 = 4113, + // `BLSIC r32, r/m32` + // + // `XOP.L0.X9.W0 01 /6` + // + // `TBM` + // + // `16/32/64-bit` + XOP_Blsic_r32_rm32 = 4114, + // `BLSIC r64, r/m64` + // + // `XOP.L0.X9.W1 01 /6` + // + // `TBM` + // + // `64-bit` + XOP_Blsic_r64_rm64 = 4115, + // `T1MSKC r32, r/m32` + // + // `XOP.L0.X9.W0 01 /7` + // + // `TBM` + // + // `16/32/64-bit` + XOP_T1mskc_r32_rm32 = 4116, + // `T1MSKC r64, r/m64` + // + // `XOP.L0.X9.W1 01 /7` + // + // `TBM` + // + // `64-bit` + XOP_T1mskc_r64_rm64 = 4117, + // `BLCMSK r32, r/m32` + // + // `XOP.L0.X9.W0 02 /1` + // + // `TBM` + // + // `16/32/64-bit` + XOP_Blcmsk_r32_rm32 = 4118, + // `BLCMSK r64, r/m64` + // + // `XOP.L0.X9.W1 02 /1` + // + // `TBM` + // + // `64-bit` + XOP_Blcmsk_r64_rm64 = 4119, + // `BLCI r32, r/m32` + // + // `XOP.L0.X9.W0 02 /6` + // + // `TBM` + // + // `16/32/64-bit` + XOP_Blci_r32_rm32 = 4120, + // `BLCI r64, r/m64` + // + // `XOP.L0.X9.W1 02 /6` + // + // `TBM` + // + // `64-bit` + XOP_Blci_r64_rm64 = 4121, + // `LLWPCB r32` + // + // `XOP.L0.X9.W0 12 /0` + // + // `LWP` + // + // `16/32/64-bit` + XOP_Llwpcb_r32 = 4122, + // `LLWPCB r64` + // + // `XOP.L0.X9.W1 12 /0` + // + // `LWP` + // + // `64-bit` + XOP_Llwpcb_r64 = 4123, + // `SLWPCB r32` + // + // `XOP.L0.X9.W0 12 /1` + // + // `LWP` + // + // `16/32/64-bit` + XOP_Slwpcb_r32 = 4124, + // `SLWPCB r64` + // + // `XOP.L0.X9.W1 12 /1` + // + // `LWP` + // + // `64-bit` + XOP_Slwpcb_r64 = 4125, + // `VFRCZPS xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 80 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vfrczps_xmm_xmmm128 = 4126, + // `VFRCZPS ymm1, ymm2/m256` + // + // `XOP.256.X9.W0 80 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vfrczps_ymm_ymmm256 = 4127, + // `VFRCZPD xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 81 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vfrczpd_xmm_xmmm128 = 4128, + // `VFRCZPD ymm1, ymm2/m256` + // + // `XOP.256.X9.W0 81 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vfrczpd_ymm_ymmm256 = 4129, + // `VFRCZSS xmm1, xmm2/m32` + // + // `XOP.128.X9.W0 82 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vfrczss_xmm_xmmm32 = 4130, + // `VFRCZSD xmm1, xmm2/m64` + // + // `XOP.128.X9.W0 83 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vfrczsd_xmm_xmmm64 = 4131, + // `VPROTB xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 90 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotb_xmm_xmmm128_xmm = 4132, + // `VPROTB xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 90 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotb_xmm_xmm_xmmm128 = 4133, + // `VPROTW xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 91 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotw_xmm_xmmm128_xmm = 4134, + // `VPROTW xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 91 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotw_xmm_xmm_xmmm128 = 4135, + // `VPROTD xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 92 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotd_xmm_xmmm128_xmm = 4136, + // `VPROTD xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 92 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotd_xmm_xmm_xmmm128 = 4137, + // `VPROTQ xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 93 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotq_xmm_xmmm128_xmm = 4138, + // `VPROTQ xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 93 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vprotq_xmm_xmm_xmmm128 = 4139, + // `VPSHLB xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 94 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshlb_xmm_xmmm128_xmm = 4140, + // `VPSHLB xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 94 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshlb_xmm_xmm_xmmm128 = 4141, + // `VPSHLW xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 95 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshlw_xmm_xmmm128_xmm = 4142, + // `VPSHLW xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 95 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshlw_xmm_xmm_xmmm128 = 4143, + // `VPSHLD xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 96 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshld_xmm_xmmm128_xmm = 4144, + // `VPSHLD xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 96 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshld_xmm_xmm_xmmm128 = 4145, + // `VPSHLQ xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 97 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshlq_xmm_xmmm128_xmm = 4146, + // `VPSHLQ xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 97 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshlq_xmm_xmm_xmmm128 = 4147, + // `VPSHAB xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 98 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshab_xmm_xmmm128_xmm = 4148, + // `VPSHAB xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 98 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshab_xmm_xmm_xmmm128 = 4149, + // `VPSHAW xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 99 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshaw_xmm_xmmm128_xmm = 4150, + // `VPSHAW xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 99 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshaw_xmm_xmm_xmmm128 = 4151, + // `VPSHAD xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 9A /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshad_xmm_xmmm128_xmm = 4152, + // `VPSHAD xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 9A /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshad_xmm_xmm_xmmm128 = 4153, + // `VPSHAQ xmm1, xmm2/m128, xmm3` + // + // `XOP.128.X9.W0 9B /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshaq_xmm_xmmm128_xmm = 4154, + // `VPSHAQ xmm1, xmm2, xmm3/m128` + // + // `XOP.128.X9.W1 9B /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vpshaq_xmm_xmm_xmmm128 = 4155, + // `VPHADDBW xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 C1 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphaddbw_xmm_xmmm128 = 4156, + // `VPHADDBD xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 C2 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphaddbd_xmm_xmmm128 = 4157, + // `VPHADDBQ xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 C3 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphaddbq_xmm_xmmm128 = 4158, + // `VPHADDWD xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 C6 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphaddwd_xmm_xmmm128 = 4159, + // `VPHADDWQ xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 C7 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphaddwq_xmm_xmmm128 = 4160, + // `VPHADDDQ xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 CB /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphadddq_xmm_xmmm128 = 4161, + // `VPHADDUBW xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 D1 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphaddubw_xmm_xmmm128 = 4162, + // `VPHADDUBD xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 D2 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphaddubd_xmm_xmmm128 = 4163, + // `VPHADDUBQ xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 D3 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphaddubq_xmm_xmmm128 = 4164, + // `VPHADDUWD xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 D6 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphadduwd_xmm_xmmm128 = 4165, + // `VPHADDUWQ xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 D7 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphadduwq_xmm_xmmm128 = 4166, + // `VPHADDUDQ xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 DB /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphaddudq_xmm_xmmm128 = 4167, + // `VPHSUBBW xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 E1 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphsubbw_xmm_xmmm128 = 4168, + // `VPHSUBWD xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 E2 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphsubwd_xmm_xmmm128 = 4169, + // `VPHSUBDQ xmm1, xmm2/m128` + // + // `XOP.128.X9.W0 E3 /r` + // + // `XOP` + // + // `16/32/64-bit` + XOP_Vphsubdq_xmm_xmmm128 = 4170, + // `BEXTR r32, r/m32, imm32` + // + // `XOP.L0.XA.W0 10 /r id` + // + // `TBM` + // + // `16/32/64-bit` + XOP_Bextr_r32_rm32_imm32 = 4171, + // `BEXTR r64, r/m64, imm32` + // + // `XOP.L0.XA.W1 10 /r id` + // + // `TBM` + // + // `64-bit` + XOP_Bextr_r64_rm64_imm32 = 4172, + // `LWPINS r32, r/m32, imm32` + // + // `XOP.L0.XA.W0 12 /0 id` + // + // `LWP` + // + // `16/32/64-bit` + XOP_Lwpins_r32_rm32_imm32 = 4173, + // `LWPINS r64, r/m32, imm32` + // + // `XOP.L0.XA.W1 12 /0 id` + // + // `LWP` + // + // `64-bit` + XOP_Lwpins_r64_rm32_imm32 = 4174, + // `LWPVAL r32, r/m32, imm32` + // + // `XOP.L0.XA.W0 12 /1 id` + // + // `LWP` + // + // `16/32/64-bit` + XOP_Lwpval_r32_rm32_imm32 = 4175, + // `LWPVAL r64, r/m32, imm32` + // + // `XOP.L0.XA.W1 12 /1 id` + // + // `LWP` + // + // `64-bit` + XOP_Lwpval_r64_rm32_imm32 = 4176, + // `PI2FW mm, mm/m64` + // + // `0F 0F /r 0C` + // + // `3DNOWEXT` + // + // `16/32/64-bit` + D3NOW_Pi2fw_mm_mmm64 = 4177, + // `PI2FD mm, mm/m64` + // + // `0F 0F /r 0D` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pi2fd_mm_mmm64 = 4178, + // `PF2IW mm, mm/m64` + // + // `0F 0F /r 1C` + // + // `3DNOWEXT` + // + // `16/32/64-bit` + D3NOW_Pf2iw_mm_mmm64 = 4179, + // `PF2ID mm, mm/m64` + // + // `0F 0F /r 1D` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pf2id_mm_mmm64 = 4180, + // `PFRCPV mm, mm/m64` + // + // `0F 0F /r 86` + // + // `AMD Geode GX/LX` + // + // `16/32-bit` + D3NOW_Pfrcpv_mm_mmm64 = 4181, + // `PFRSQRTV mm, mm/m64` + // + // `0F 0F /r 87` + // + // `AMD Geode GX/LX` + // + // `16/32-bit` + D3NOW_Pfrsqrtv_mm_mmm64 = 4182, + // `PFNACC mm, mm/m64` + // + // `0F 0F /r 8A` + // + // `3DNOWEXT` + // + // `16/32/64-bit` + D3NOW_Pfnacc_mm_mmm64 = 4183, + // `PFPNACC mm, mm/m64` + // + // `0F 0F /r 8E` + // + // `3DNOWEXT` + // + // `16/32/64-bit` + D3NOW_Pfpnacc_mm_mmm64 = 4184, + // `PFCMPGE mm, mm/m64` + // + // `0F 0F /r 90` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfcmpge_mm_mmm64 = 4185, + // `PFMIN mm, mm/m64` + // + // `0F 0F /r 94` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfmin_mm_mmm64 = 4186, + // `PFRCP mm, mm/m64` + // + // `0F 0F /r 96` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfrcp_mm_mmm64 = 4187, + // `PFRSQRT mm, mm/m64` + // + // `0F 0F /r 97` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfrsqrt_mm_mmm64 = 4188, + // `PFSUB mm, mm/m64` + // + // `0F 0F /r 9A` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfsub_mm_mmm64 = 4189, + // `PFADD mm, mm/m64` + // + // `0F 0F /r 9E` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfadd_mm_mmm64 = 4190, + // `PFCMPGT mm, mm/m64` + // + // `0F 0F /r A0` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfcmpgt_mm_mmm64 = 4191, + // `PFMAX mm, mm/m64` + // + // `0F 0F /r A4` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfmax_mm_mmm64 = 4192, + // `PFRCPIT1 mm, mm/m64` + // + // `0F 0F /r A6` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfrcpit1_mm_mmm64 = 4193, + // `PFRSQIT1 mm, mm/m64` + // + // `0F 0F /r A7` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfrsqit1_mm_mmm64 = 4194, + // `PFSUBR mm, mm/m64` + // + // `0F 0F /r AA` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfsubr_mm_mmm64 = 4195, + // `PFACC mm, mm/m64` + // + // `0F 0F /r AE` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfacc_mm_mmm64 = 4196, + // `PFCMPEQ mm, mm/m64` + // + // `0F 0F /r B0` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfcmpeq_mm_mmm64 = 4197, + // `PFMUL mm, mm/m64` + // + // `0F 0F /r B4` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfmul_mm_mmm64 = 4198, + // `PFRCPIT2 mm, mm/m64` + // + // `0F 0F /r B6` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pfrcpit2_mm_mmm64 = 4199, + // `PMULHRW mm, mm/m64` + // + // `0F 0F /r B7` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pmulhrw_mm_mmm64 = 4200, + // `PSWAPD mm, mm/m64` + // + // `0F 0F /r BB` + // + // `3DNOWEXT` + // + // `16/32/64-bit` + D3NOW_Pswapd_mm_mmm64 = 4201, + // `PAVGUSB mm, mm/m64` + // + // `0F 0F /r BF` + // + // `3DNOW` + // + // `16/32/64-bit` + D3NOW_Pavgusb_mm_mmm64 = 4202, + // `RMPADJUST` + // + // `F3 0F 01 FE` + // + // `SEV-SNP` + // + // `64-bit` + Rmpadjust = 4203, + // `RMPUPDATE` + // + // `F2 0F 01 FE` + // + // `SEV-SNP` + // + // `64-bit` + Rmpupdate = 4204, + // `PSMASH` + // + // `F3 0F 01 FF` + // + // `SEV-SNP` + // + // `64-bit` + Psmash = 4205, + // `PVALIDATE` + // + // `a16 F2 0F 01 FF` + // + // `SEV-SNP` + // + // `16/32-bit` + Pvalidatew = 4206, + // `PVALIDATE` + // + // `a32 F2 0F 01 FF` + // + // `SEV-SNP` + // + // `16/32/64-bit` + Pvalidated = 4207, + // `PVALIDATE` + // + // `a64 F2 0F 01 FF` + // + // `SEV-SNP` + // + // `64-bit` + Pvalidateq = 4208, + // `SERIALIZE` + // + // `NP 0F 01 E8` + // + // `SERIALIZE` + // + // `16/32/64-bit` + Serialize = 4209, + // `XSUSLDTRK` + // + // `F2 0F 01 E8` + // + // `TSXLDTRK` + // + // `16/32/64-bit` + Xsusldtrk = 4210, + // `XRESLDTRK` + // + // `F2 0F 01 E9` + // + // `TSXLDTRK` + // + // `16/32/64-bit` + Xresldtrk = 4211, + // `INVLPGB` + // + // `a16 NP 0F 01 FE` + // + // `INVLPGB` + // + // `16/32-bit` + Invlpgbw = 4212, + // `INVLPGB` + // + // `a32 NP 0F 01 FE` + // + // `INVLPGB` + // + // `16/32/64-bit` + Invlpgbd = 4213, + // `INVLPGB` + // + // `a64 NP 0F 01 FE` + // + // `INVLPGB` + // + // `64-bit` + Invlpgbq = 4214, + // `TLBSYNC` + // + // `NP 0F 01 FF` + // + // `INVLPGB` + // + // `16/32/64-bit` + Tlbsync = 4215, + // `PREFETCHW m8` + // + // `0F 0D /3` + // + // `PREFETCHW` + // + // `16/32/64-bit` + Prefetchreserved3_m8 = 4216, + // `PREFETCH m8` + // + // `0F 0D /4` + // + // `PREFETCHW` + // + // `16/32/64-bit` + Prefetchreserved4_m8 = 4217, + // `PREFETCH m8` + // + // `0F 0D /5` + // + // `PREFETCHW` + // + // `16/32/64-bit` + Prefetchreserved5_m8 = 4218, + // `PREFETCH m8` + // + // `0F 0D /6` + // + // `PREFETCHW` + // + // `16/32/64-bit` + Prefetchreserved6_m8 = 4219, + // `PREFETCH m8` + // + // `0F 0D /7` + // + // `PREFETCHW` + // + // `16/32/64-bit` + Prefetchreserved7_m8 = 4220, + // `UD0` + // + // `0F FF` + // + // `286+` + // + // `16/32/64-bit` + Ud0 = 4221, + // `VMGEXIT` + // + // `F3 0F 01 D9` + // + // `SEV-ES` + // + // `16/32/64-bit` + Vmgexit = 4222, + // `GETSECQ` + // + // `NP o64 0F 37` + // + // `SMX` + // + // `64-bit` + Getsecq = 4223, + // `LDTILECFG m512` + // + // `VEX.128.0F38.W0 49 !(11) :000:bbb` + // + // `AMX-TILE` + // + // `64-bit` + VEX_Ldtilecfg_m512 = 4224, + // `TILERELEASE` + // + // `VEX.128.0F38.W0 49 C0` + // + // `AMX-TILE` + // + // `64-bit` + VEX_Tilerelease = 4225, + // `STTILECFG m512` + // + // `VEX.128.66.0F38.W0 49 !(11) :000:bbb` + // + // `AMX-TILE` + // + // `64-bit` + VEX_Sttilecfg_m512 = 4226, + // `TILEZERO tmm1` + // + // `VEX.128.F2.0F38.W0 49 11:rrr:000` + // + // `AMX-TILE` + // + // `64-bit` + VEX_Tilezero_tmm = 4227, + // `TILELOADDT1 tmm1, sibmem` + // + // `VEX.128.66.0F38.W0 4B !(11) :rrr:100` + // + // `AMX-TILE` + // + // `64-bit` + VEX_Tileloaddt1_tmm_sibmem = 4228, + // `TILESTORED sibmem, tmm1` + // + // `VEX.128.F3.0F38.W0 4B !(11) :rrr:100` + // + // `AMX-TILE` + // + // `64-bit` + VEX_Tilestored_sibmem_tmm = 4229, + // `TILELOADD tmm1, sibmem` + // + // `VEX.128.F2.0F38.W0 4B !(11) :rrr:100` + // + // `AMX-TILE` + // + // `64-bit` + VEX_Tileloadd_tmm_sibmem = 4230, + // `TDPBF16PS tmm1, tmm2, tmm3` + // + // `VEX.128.F3.0F38.W0 5C 11:rrr:bbb` + // + // `AMX-BF16` + // + // `64-bit` + VEX_Tdpbf16ps_tmm_tmm_tmm = 4231, + // `TDPBUUD tmm1, tmm2, tmm3` + // + // `VEX.128.0F38.W0 5E 11:rrr:bbb` + // + // `AMX-INT8` + // + // `64-bit` + VEX_Tdpbuud_tmm_tmm_tmm = 4232, + // `TDPBUSD tmm1, tmm2, tmm3` + // + // `VEX.128.66.0F38.W0 5E 11:rrr:bbb` + // + // `AMX-INT8` + // + // `64-bit` + VEX_Tdpbusd_tmm_tmm_tmm = 4233, + // `TDPBSUD tmm1, tmm2, tmm3` + // + // `VEX.128.F3.0F38.W0 5E 11:rrr:bbb` + // + // `AMX-INT8` + // + // `64-bit` + VEX_Tdpbsud_tmm_tmm_tmm = 4234, + // `TDPBSSD tmm1, tmm2, tmm3` + // + // `VEX.128.F2.0F38.W0 5E 11:rrr:bbb` + // + // `AMX-INT8` + // + // `64-bit` + VEX_Tdpbssd_tmm_tmm_tmm = 4235, + // `FNSTDW AX` + // + // `DF E1` + // + // `387 SL` + // + // `16/32-bit` + Fnstdw_AX = 4236, + // `FNSTSG AX` + // + // `DF E2` + // + // `387 SL` + // + // `16/32-bit` + Fnstsg_AX = 4237, + // `RDSHR r/m32` + // + // `0F 36 /0` + // + // `Cyrix 6x86MX, M II, III` + // + // `16/32-bit` + Rdshr_rm32 = 4238, + // `WRSHR r/m32` + // + // `0F 37 /0` + // + // `Cyrix 6x86MX, M II, III` + // + // `16/32-bit` + Wrshr_rm32 = 4239, + // `SMINT` + // + // `0F 38` + // + // `Cyrix 6x86MX+, AMD Geode GX/LX` + // + // `16/32-bit` + Smint = 4240, + // `DMINT` + // + // `0F 39` + // + // `AMD Geode GX/LX` + // + // `16/32-bit` + Dmint = 4241, + // `RDM` + // + // `0F 3A` + // + // `AMD Geode GX/LX` + // + // `16/32-bit` + Rdm = 4242, + // `SVDC m80, Sreg` + // + // `0F 78 /r` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Svdc_m80_Sreg = 4243, + // `RSDC Sreg, m80` + // + // `0F 79 /r` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Rsdc_Sreg_m80 = 4244, + // `SVLDT m80` + // + // `0F 7A /0` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Svldt_m80 = 4245, + // `RSLDT m80` + // + // `0F 7B /0` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Rsldt_m80 = 4246, + // `SVTS m80` + // + // `0F 7C /0` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Svts_m80 = 4247, + // `RSTS m80` + // + // `0F 7D /0` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Rsts_m80 = 4248, + // `SMINT` + // + // `0F 7E` + // + // `Cyrix 6x86 or earlier` + // + // `16/32-bit` + Smint_0F7E = 4249, + // `BB0_RESET` + // + // `0F 3A` + // + // `Cyrix MediaGX, GXm, GXLV, GX1` + // + // `16/32-bit` + Bb0_reset = 4250, + // `BB1_RESET` + // + // `0F 3B` + // + // `Cyrix MediaGX, GXm, GXLV, GX1` + // + // `16/32-bit` + Bb1_reset = 4251, + // `CPU_WRITE` + // + // `0F 3C` + // + // `Cyrix MediaGX, GXm, GXLV, GX1` + // + // `16/32-bit` + Cpu_write = 4252, + // `CPU_READ` + // + // `0F 3D` + // + // `Cyrix MediaGX, GXm, GXLV, GX1` + // + // `16/32-bit` + Cpu_read = 4253, + // `ALTINST` + // + // `0F 3F` + // + // `Centaur AIS` + // + // `16/32-bit` + Altinst = 4254, + // `PAVEB mm, mm/m64` + // + // `0F 50 /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Paveb_mm_mmm64 = 4255, + // `PADDSIW mm, mm/m64` + // + // `0F 51 /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Paddsiw_mm_mmm64 = 4256, + // `PMAGW mm, mm/m64` + // + // `0F 52 /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Pmagw_mm_mmm64 = 4257, + // `PDISTIB mm, m64` + // + // `0F 54 /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Pdistib_mm_m64 = 4258, + // `PSUBSIW mm, mm/m64` + // + // `0F 55 /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Psubsiw_mm_mmm64 = 4259, + // `PMVZB mm, m64` + // + // `0F 58 /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Pmvzb_mm_m64 = 4260, + // `PMULHRW mm, mm/m64` + // + // `0F 59 /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Pmulhrw_mm_mmm64 = 4261, + // `PMVNZB mm, m64` + // + // `0F 5A /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Pmvnzb_mm_m64 = 4262, + // `PMVLZB mm, m64` + // + // `0F 5B /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Pmvlzb_mm_m64 = 4263, + // `PMVGEZB mm, m64` + // + // `0F 5C /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Pmvgezb_mm_m64 = 4264, + // `PMULHRIW mm, mm/m64` + // + // `0F 5D /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Pmulhriw_mm_mmm64 = 4265, + // `PMACHRIW mm, m64` + // + // `0F 5E /r` + // + // `CYRIX_EMMI` + // + // `16/32-bit` + Pmachriw_mm_m64 = 4266, + // `UNDOC` + // + // `D9 D7` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Cyrix_D9D7 = 4267, + // `UNDOC` + // + // `D9 E2` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Cyrix_D9E2 = 4268, + // `FTSTP` + // + // `D9 E6` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Ftstp = 4269, + // `UNDOC` + // + // `D9 E7` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Cyrix_D9E7 = 4270, + // `FRINT2` + // + // `DB FC` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Frint2 = 4271, + // `FRICHOP` + // + // `DD FC` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Frichop = 4272, + // `UNDOC` + // + // `DE D8` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Cyrix_DED8 = 4273, + // `UNDOC` + // + // `DE DA` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Cyrix_DEDA = 4274, + // `UNDOC` + // + // `DE DC` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Cyrix_DEDC = 4275, + // `UNDOC` + // + // `DE DD` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Cyrix_DEDD = 4276, + // `UNDOC` + // + // `DE DE` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Cyrix_DEDE = 4277, + // `FRINEAR` + // + // `DF FC` + // + // `Cyrix, AMD Geode GX/LX` + // + // `16/32-bit` + Frinear = 4278, + // `TDCALL` + // + // `66 0F 01 CC` + // + // `TDX` + // + // `16/32/64-bit` + Tdcall = 4279, + // `SEAMRET` + // + // `66 0F 01 CD` + // + // `TDX` + // + // `64-bit` + Seamret = 4280, + // `SEAMOPS` + // + // `66 0F 01 CE` + // + // `TDX` + // + // `64-bit` + Seamops = 4281, + // `SEAMCALL` + // + // `66 0F 01 CF` + // + // `TDX` + // + // `64-bit` + Seamcall = 4282, + // `AESENCWIDE128KL m384, ` + // + // `F3 0F 38 D8 !(11) :000:bbb` + // + // `AESKLE and WIDE_KL` + // + // `16/32/64-bit` + Aesencwide128kl_m384 = 4283, + // `AESDECWIDE128KL m384, ` + // + // `F3 0F 38 D8 !(11) :001:bbb` + // + // `AESKLE and WIDE_KL` + // + // `16/32/64-bit` + Aesdecwide128kl_m384 = 4284, + // `AESENCWIDE256KL m512, ` + // + // `F3 0F 38 D8 !(11) :010:bbb` + // + // `AESKLE and WIDE_KL` + // + // `16/32/64-bit` + Aesencwide256kl_m512 = 4285, + // `AESDECWIDE256KL m512, ` + // + // `F3 0F 38 D8 !(11) :011:bbb` + // + // `AESKLE and WIDE_KL` + // + // `16/32/64-bit` + Aesdecwide256kl_m512 = 4286, + // `LOADIWKEY xmm1, xmm2, , ` + // + // `F3 0F 38 DC 11:rrr:bbb` + // + // `KL` + // + // `16/32/64-bit` + Loadiwkey_xmm_xmm = 4287, + // `AESENC128KL xmm, m384` + // + // `F3 0F 38 DC !(11) :rrr:bbb` + // + // `AESKLE` + // + // `16/32/64-bit` + Aesenc128kl_xmm_m384 = 4288, + // `AESDEC128KL xmm, m384` + // + // `F3 0F 38 DD !(11) :rrr:bbb` + // + // `AESKLE` + // + // `16/32/64-bit` + Aesdec128kl_xmm_m384 = 4289, + // `AESENC256KL xmm, m512` + // + // `F3 0F 38 DE !(11) :rrr:bbb` + // + // `AESKLE` + // + // `16/32/64-bit` + Aesenc256kl_xmm_m512 = 4290, + // `AESDEC256KL xmm, m512` + // + // `F3 0F 38 DF !(11) :rrr:bbb` + // + // `AESKLE` + // + // `16/32/64-bit` + Aesdec256kl_xmm_m512 = 4291, + // `ENCODEKEY128 r32, r32, , ` + // + // `F3 0F 38 FA 11:rrr:bbb` + // + // `AESKLE` + // + // `16/32/64-bit` + Encodekey128_r32_r32 = 4292, + // `ENCODEKEY256 r32, r32, ` + // + // `F3 0F 38 FB 11:rrr:bbb` + // + // `AESKLE` + // + // `16/32/64-bit` + Encodekey256_r32_r32 = 4293, + // `VBROADCASTSS xmm1, xmm2` + // + // `VEX.128.66.0F38.W0 18 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vbroadcastss_xmm_xmm = 4294, + // `VBROADCASTSS ymm1, xmm2` + // + // `VEX.256.66.0F38.W0 18 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vbroadcastss_ymm_xmm = 4295, + // `VBROADCASTSD ymm1, xmm2` + // + // `VEX.256.66.0F38.W0 19 /r` + // + // `AVX2` + // + // `16/32/64-bit` + VEX_Vbroadcastsd_ymm_xmm = 4296, + // `VMGEXIT` + // + // `F2 0F 01 D9` + // + // `SEV-ES` + // + // `16/32/64-bit` + Vmgexit_F2 = 4297, + // `UIRET` + // + // `F3 0F 01 EC` + // + // `UINTR` + // + // `64-bit` + Uiret = 4298, + // `TESTUI` + // + // `F3 0F 01 ED` + // + // `UINTR` + // + // `64-bit` + Testui = 4299, + // `CLUI` + // + // `F3 0F 01 EE` + // + // `UINTR` + // + // `64-bit` + Clui = 4300, + // `STUI` + // + // `F3 0F 01 EF` + // + // `UINTR` + // + // `64-bit` + Stui = 4301, + // `SENDUIPI r64` + // + // `F3 0F C7 /6` + // + // `UINTR` + // + // `64-bit` + Senduipi_r64 = 4302, + // `HRESET imm8, ` + // + // `F3 0F 3A F0 C0 ib` + // + // `HRESET` + // + // `16/32/64-bit` + Hreset_imm8 = 4303, + // `VPDPBUSD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 50 /r` + // + // `AVX-VNNI` + // + // `16/32/64-bit` + VEX_Vpdpbusd_xmm_xmm_xmmm128 = 4304, + // `VPDPBUSD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 50 /r` + // + // `AVX-VNNI` + // + // `16/32/64-bit` + VEX_Vpdpbusd_ymm_ymm_ymmm256 = 4305, + // `VPDPBUSDS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 51 /r` + // + // `AVX-VNNI` + // + // `16/32/64-bit` + VEX_Vpdpbusds_xmm_xmm_xmmm128 = 4306, + // `VPDPBUSDS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 51 /r` + // + // `AVX-VNNI` + // + // `16/32/64-bit` + VEX_Vpdpbusds_ymm_ymm_ymmm256 = 4307, + // `VPDPWSSD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 52 /r` + // + // `AVX-VNNI` + // + // `16/32/64-bit` + VEX_Vpdpwssd_xmm_xmm_xmmm128 = 4308, + // `VPDPWSSD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 52 /r` + // + // `AVX-VNNI` + // + // `16/32/64-bit` + VEX_Vpdpwssd_ymm_ymm_ymmm256 = 4309, + // `VPDPWSSDS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W0 53 /r` + // + // `AVX-VNNI` + // + // `16/32/64-bit` + VEX_Vpdpwssds_xmm_xmm_xmmm128 = 4310, + // `VPDPWSSDS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W0 53 /r` + // + // `AVX-VNNI` + // + // `16/32/64-bit` + VEX_Vpdpwssds_ymm_ymm_ymmm256 = 4311, + // `CCS_HASH` + // + // `a16 F3 0F A6 E8` + // + // `PADLOCK_GMI` + // + // `16/32-bit` + Ccs_hash_16 = 4312, + // `CCS_HASH` + // + // `a32 F3 0F A6 E8` + // + // `PADLOCK_GMI` + // + // `16/32/64-bit` + Ccs_hash_32 = 4313, + // `CCS_HASH` + // + // `a64 F3 0F A6 E8` + // + // `PADLOCK_GMI` + // + // `64-bit` + Ccs_hash_64 = 4314, + // `CCS_ENCRYPT` + // + // `a16 F3 0F A7 F0` + // + // `PADLOCK_GMI` + // + // `16/32-bit` + Ccs_encrypt_16 = 4315, + // `CCS_ENCRYPT` + // + // `a32 F3 0F A7 F0` + // + // `PADLOCK_GMI` + // + // `16/32/64-bit` + Ccs_encrypt_32 = 4316, + // `CCS_ENCRYPT` + // + // `a64 F3 0F A7 F0` + // + // `PADLOCK_GMI` + // + // `64-bit` + Ccs_encrypt_64 = 4317, + // `LKGS r/m16` + // + // `o16 F2 0F 00 /6` + // + // `LKGS` + // + // `64-bit` + Lkgs_rm16 = 4318, + // `LKGS r32/m16` + // + // `o32 F2 0F 00 /6` + // + // `LKGS` + // + // `64-bit` + Lkgs_r32m16 = 4319, + // `LKGS r64/m16` + // + // `F2 o64 0F 00 /6` + // + // `LKGS` + // + // `64-bit` + Lkgs_r64m16 = 4320, + // `ERETU` + // + // `F3 0F 01 CA` + // + // `FRED` + // + // `64-bit` + Eretu = 4321, + // `ERETS` + // + // `F2 0F 01 CA` + // + // `FRED` + // + // `64-bit` + Erets = 4322, + // `VADDPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.MAP5.W0 58 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vaddph_xmm_k1z_xmm_xmmm128b16 = 4323, + // `VADDPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.MAP5.W0 58 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vaddph_ymm_k1z_ymm_ymmm256b16 = 4324, + // `VADDPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.MAP5.W0 58 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vaddph_zmm_k1z_zmm_zmmm512b16_er = 4325, + // `VADDSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.F3.MAP5.W0 58 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vaddsh_xmm_k1z_xmm_xmmm16_er = 4326, + // `VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8` + // + // `EVEX.128.0F3A.W0 C2 /r ib` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcmpph_kr_k1_xmm_xmmm128b16_imm8 = 4327, + // `VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8` + // + // `EVEX.256.0F3A.W0 C2 /r ib` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcmpph_kr_k1_ymm_ymmm256b16_imm8 = 4328, + // `VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8` + // + // `EVEX.512.0F3A.W0 C2 /r ib` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcmpph_kr_k1_zmm_zmmm512b16_imm8_sae = 4329, + // `VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8` + // + // `EVEX.LIG.F3.0F3A.W0 C2 /r ib` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcmpsh_kr_k1_xmm_xmmm16_imm8_sae = 4330, + // `VCOMISH xmm1, xmm2/m16{sae}` + // + // `EVEX.LIG.MAP5.W0 2F /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcomish_xmm_xmmm16_sae = 4331, + // `VCVTDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.MAP5.W0 5B /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtdq2ph_xmm_k1z_xmmm128b32 = 4332, + // `VCVTDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.MAP5.W0 5B /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtdq2ph_xmm_k1z_ymmm256b32 = 4333, + // `VCVTDQ2PH ymm1 {k1}{z}, zmm2/m512/m32bcst{er}` + // + // `EVEX.512.MAP5.W0 5B /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtdq2ph_ymm_k1z_zmmm512b32_er = 4334, + // `VCVTPD2PH xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.66.MAP5.W1 5A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtpd2ph_xmm_k1z_xmmm128b64 = 4335, + // `VCVTPD2PH xmm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.66.MAP5.W1 5A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtpd2ph_xmm_k1z_ymmm256b64 = 4336, + // `VCVTPD2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.66.MAP5.W1 5A /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtpd2ph_xmm_k1z_zmmm512b64_er = 4337, + // `VCVTPH2DQ xmm1 {k1}{z}, xmm2/m64/m16bcst` + // + // `EVEX.128.66.MAP5.W0 5B /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2dq_xmm_k1z_xmmm64b16 = 4338, + // `VCVTPH2DQ ymm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.256.66.MAP5.W0 5B /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2dq_ymm_k1z_xmmm128b16 = 4339, + // `VCVTPH2DQ zmm1 {k1}{z}, ymm2/m256/m16bcst{er}` + // + // `EVEX.512.66.MAP5.W0 5B /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2dq_zmm_k1z_ymmm256b16_er = 4340, + // `VCVTPH2PD xmm1 {k1}{z}, xmm2/m32/m16bcst` + // + // `EVEX.128.MAP5.W0 5A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2pd_xmm_k1z_xmmm32b16 = 4341, + // `VCVTPH2PD ymm1 {k1}{z}, xmm2/m64/m16bcst` + // + // `EVEX.256.MAP5.W0 5A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2pd_ymm_k1z_xmmm64b16 = 4342, + // `VCVTPH2PD zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}` + // + // `EVEX.512.MAP5.W0 5A /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2pd_zmm_k1z_xmmm128b16_sae = 4343, + // `VCVTPH2PSX xmm1 {k1}{z}, xmm2/m64/m16bcst` + // + // `EVEX.128.66.MAP6.W0 13 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2psx_xmm_k1z_xmmm64b16 = 4344, + // `VCVTPH2PSX ymm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.256.66.MAP6.W0 13 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2psx_ymm_k1z_xmmm128b16 = 4345, + // `VCVTPH2PSX zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}` + // + // `EVEX.512.66.MAP6.W0 13 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2psx_zmm_k1z_ymmm256b16_sae = 4346, + // `VCVTPH2QQ xmm1 {k1}{z}, xmm2/m32/m16bcst` + // + // `EVEX.128.66.MAP5.W0 7B /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2qq_xmm_k1z_xmmm32b16 = 4347, + // `VCVTPH2QQ ymm1 {k1}{z}, xmm2/m64/m16bcst` + // + // `EVEX.256.66.MAP5.W0 7B /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2qq_ymm_k1z_xmmm64b16 = 4348, + // `VCVTPH2QQ zmm1 {k1}{z}, xmm2/m128/m16bcst{er}` + // + // `EVEX.512.66.MAP5.W0 7B /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2qq_zmm_k1z_xmmm128b16_er = 4349, + // `VCVTPH2UDQ xmm1 {k1}{z}, xmm2/m64/m16bcst` + // + // `EVEX.128.MAP5.W0 79 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2udq_xmm_k1z_xmmm64b16 = 4350, + // `VCVTPH2UDQ ymm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.256.MAP5.W0 79 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2udq_ymm_k1z_xmmm128b16 = 4351, + // `VCVTPH2UDQ zmm1 {k1}{z}, ymm2/m256/m16bcst{er}` + // + // `EVEX.512.MAP5.W0 79 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2udq_zmm_k1z_ymmm256b16_er = 4352, + // `VCVTPH2UQQ xmm1 {k1}{z}, xmm2/m32/m16bcst` + // + // `EVEX.128.66.MAP5.W0 79 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2uqq_xmm_k1z_xmmm32b16 = 4353, + // `VCVTPH2UQQ ymm1 {k1}{z}, xmm2/m64/m16bcst` + // + // `EVEX.256.66.MAP5.W0 79 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2uqq_ymm_k1z_xmmm64b16 = 4354, + // `VCVTPH2UQQ zmm1 {k1}{z}, xmm2/m128/m16bcst{er}` + // + // `EVEX.512.66.MAP5.W0 79 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2uqq_zmm_k1z_xmmm128b16_er = 4355, + // `VCVTPH2UW xmm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.128.MAP5.W0 7D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2uw_xmm_k1z_xmmm128b16 = 4356, + // `VCVTPH2UW ymm1 {k1}{z}, ymm2/m256/m16bcst` + // + // `EVEX.256.MAP5.W0 7D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2uw_ymm_k1z_ymmm256b16 = 4357, + // `VCVTPH2UW zmm1 {k1}{z}, zmm2/m512/m16bcst{er}` + // + // `EVEX.512.MAP5.W0 7D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2uw_zmm_k1z_zmmm512b16_er = 4358, + // `VCVTPH2W xmm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.128.66.MAP5.W0 7D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2w_xmm_k1z_xmmm128b16 = 4359, + // `VCVTPH2W ymm1 {k1}{z}, ymm2/m256/m16bcst` + // + // `EVEX.256.66.MAP5.W0 7D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2w_ymm_k1z_ymmm256b16 = 4360, + // `VCVTPH2W zmm1 {k1}{z}, zmm2/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP5.W0 7D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtph2w_zmm_k1z_zmmm512b16_er = 4361, + // `VCVTPS2PHX xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.66.MAP5.W0 1D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtps2phx_xmm_k1z_xmmm128b32 = 4362, + // `VCVTPS2PHX xmm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.66.MAP5.W0 1D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtps2phx_xmm_k1z_ymmm256b32 = 4363, + // `VCVTPS2PHX ymm1 {k1}{z}, zmm2/m512/m32bcst{er}` + // + // `EVEX.512.66.MAP5.W0 1D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtps2phx_ymm_k1z_zmmm512b32_er = 4364, + // `VCVTQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.MAP5.W1 5B /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtqq2ph_xmm_k1z_xmmm128b64 = 4365, + // `VCVTQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.MAP5.W1 5B /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtqq2ph_xmm_k1z_ymmm256b64 = 4366, + // `VCVTQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.MAP5.W1 5B /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtqq2ph_xmm_k1z_zmmm512b64_er = 4367, + // `VCVTSD2SH xmm1 {k1}{z}, xmm2, xmm3/m64{er}` + // + // `EVEX.LIG.F2.MAP5.W1 5A /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtsd2sh_xmm_k1z_xmm_xmmm64_er = 4368, + // `VCVTSH2SD xmm1 {k1}{z}, xmm2, xmm3/m16{sae}` + // + // `EVEX.LIG.F3.MAP5.W0 5A /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtsh2sd_xmm_k1z_xmm_xmmm16_sae = 4369, + // `VCVTSH2SI r32, xmm1/m16{er}` + // + // `EVEX.LIG.F3.MAP5.W0 2D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtsh2si_r32_xmmm16_er = 4370, + // `VCVTSH2SI r64, xmm1/m16{er}` + // + // `EVEX.LIG.F3.MAP5.W1 2D /r` + // + // `AVX512-FP16` + // + // `64-bit` + EVEX_Vcvtsh2si_r64_xmmm16_er = 4371, + // `VCVTSH2SS xmm1 {k1}{z}, xmm2, xmm3/m16{sae}` + // + // `EVEX.LIG.MAP6.W0 13 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtsh2ss_xmm_k1z_xmm_xmmm16_sae = 4372, + // `VCVTSH2USI r32, xmm1/m16{er}` + // + // `EVEX.LIG.F3.MAP5.W0 79 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtsh2usi_r32_xmmm16_er = 4373, + // `VCVTSH2USI r64, xmm1/m16{er}` + // + // `EVEX.LIG.F3.MAP5.W1 79 /r` + // + // `AVX512-FP16` + // + // `64-bit` + EVEX_Vcvtsh2usi_r64_xmmm16_er = 4374, + // `VCVTSI2SH xmm1, xmm2, r/m32{er}` + // + // `EVEX.LIG.F3.MAP5.W0 2A /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtsi2sh_xmm_xmm_rm32_er = 4375, + // `VCVTSI2SH xmm1, xmm2, r/m64{er}` + // + // `EVEX.LIG.F3.MAP5.W1 2A /r` + // + // `AVX512-FP16` + // + // `64-bit` + EVEX_Vcvtsi2sh_xmm_xmm_rm64_er = 4376, + // `VCVTSS2SH xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.MAP5.W0 1D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtss2sh_xmm_k1z_xmm_xmmm32_er = 4377, + // `VCVTTPH2DQ xmm1 {k1}{z}, xmm2/m64/m16bcst` + // + // `EVEX.128.F3.MAP5.W0 5B /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2dq_xmm_k1z_xmmm64b16 = 4378, + // `VCVTTPH2DQ ymm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.256.F3.MAP5.W0 5B /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2dq_ymm_k1z_xmmm128b16 = 4379, + // `VCVTTPH2DQ zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}` + // + // `EVEX.512.F3.MAP5.W0 5B /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2dq_zmm_k1z_ymmm256b16_sae = 4380, + // `VCVTTPH2QQ xmm1 {k1}{z}, xmm2/m32/m16bcst` + // + // `EVEX.128.66.MAP5.W0 7A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2qq_xmm_k1z_xmmm32b16 = 4381, + // `VCVTTPH2QQ ymm1 {k1}{z}, xmm2/m64/m16bcst` + // + // `EVEX.256.66.MAP5.W0 7A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2qq_ymm_k1z_xmmm64b16 = 4382, + // `VCVTTPH2QQ zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}` + // + // `EVEX.512.66.MAP5.W0 7A /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2qq_zmm_k1z_xmmm128b16_sae = 4383, + // `VCVTTPH2UDQ xmm1 {k1}{z}, xmm2/m64/m16bcst` + // + // `EVEX.128.MAP5.W0 78 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2udq_xmm_k1z_xmmm64b16 = 4384, + // `VCVTTPH2UDQ ymm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.256.MAP5.W0 78 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2udq_ymm_k1z_xmmm128b16 = 4385, + // `VCVTTPH2UDQ zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}` + // + // `EVEX.512.MAP5.W0 78 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2udq_zmm_k1z_ymmm256b16_sae = 4386, + // `VCVTTPH2UQQ xmm1 {k1}{z}, xmm2/m32/m16bcst` + // + // `EVEX.128.66.MAP5.W0 78 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2uqq_xmm_k1z_xmmm32b16 = 4387, + // `VCVTTPH2UQQ ymm1 {k1}{z}, xmm2/m64/m16bcst` + // + // `EVEX.256.66.MAP5.W0 78 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2uqq_ymm_k1z_xmmm64b16 = 4388, + // `VCVTTPH2UQQ zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}` + // + // `EVEX.512.66.MAP5.W0 78 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2uqq_zmm_k1z_xmmm128b16_sae = 4389, + // `VCVTTPH2UW xmm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.128.MAP5.W0 7C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2uw_xmm_k1z_xmmm128b16 = 4390, + // `VCVTTPH2UW ymm1 {k1}{z}, ymm2/m256/m16bcst` + // + // `EVEX.256.MAP5.W0 7C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2uw_ymm_k1z_ymmm256b16 = 4391, + // `VCVTTPH2UW zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}` + // + // `EVEX.512.MAP5.W0 7C /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2uw_zmm_k1z_zmmm512b16_sae = 4392, + // `VCVTTPH2W xmm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.128.66.MAP5.W0 7C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2w_xmm_k1z_xmmm128b16 = 4393, + // `VCVTTPH2W ymm1 {k1}{z}, ymm2/m256/m16bcst` + // + // `EVEX.256.66.MAP5.W0 7C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2w_ymm_k1z_ymmm256b16 = 4394, + // `VCVTTPH2W zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}` + // + // `EVEX.512.66.MAP5.W0 7C /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttph2w_zmm_k1z_zmmm512b16_sae = 4395, + // `VCVTTSH2SI r32, xmm1/m16{sae}` + // + // `EVEX.LIG.F3.MAP5.W0 2C /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttsh2si_r32_xmmm16_sae = 4396, + // `VCVTTSH2SI r64, xmm1/m16{sae}` + // + // `EVEX.LIG.F3.MAP5.W1 2C /r` + // + // `AVX512-FP16` + // + // `64-bit` + EVEX_Vcvttsh2si_r64_xmmm16_sae = 4397, + // `VCVTTSH2USI r32, xmm1/m16{sae}` + // + // `EVEX.LIG.F3.MAP5.W0 78 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvttsh2usi_r32_xmmm16_sae = 4398, + // `VCVTTSH2USI r64, xmm1/m16{sae}` + // + // `EVEX.LIG.F3.MAP5.W1 78 /r` + // + // `AVX512-FP16` + // + // `64-bit` + EVEX_Vcvttsh2usi_r64_xmmm16_sae = 4399, + // `VCVTUDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcst` + // + // `EVEX.128.F2.MAP5.W0 7A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtudq2ph_xmm_k1z_xmmm128b32 = 4400, + // `VCVTUDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcst` + // + // `EVEX.256.F2.MAP5.W0 7A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtudq2ph_xmm_k1z_ymmm256b32 = 4401, + // `VCVTUDQ2PH ymm1 {k1}{z}, zmm2/m512/m32bcst{er}` + // + // `EVEX.512.F2.MAP5.W0 7A /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtudq2ph_ymm_k1z_zmmm512b32_er = 4402, + // `VCVTUQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcst` + // + // `EVEX.128.F2.MAP5.W1 7A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtuqq2ph_xmm_k1z_xmmm128b64 = 4403, + // `VCVTUQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcst` + // + // `EVEX.256.F2.MAP5.W1 7A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtuqq2ph_xmm_k1z_ymmm256b64 = 4404, + // `VCVTUQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}` + // + // `EVEX.512.F2.MAP5.W1 7A /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtuqq2ph_xmm_k1z_zmmm512b64_er = 4405, + // `VCVTUSI2SH xmm1, xmm2, r/m32{er}` + // + // `EVEX.LIG.F3.MAP5.W0 7B /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtusi2sh_xmm_xmm_rm32_er = 4406, + // `VCVTUSI2SH xmm1, xmm2, r/m64{er}` + // + // `EVEX.LIG.F3.MAP5.W1 7B /r` + // + // `AVX512-FP16` + // + // `64-bit` + EVEX_Vcvtusi2sh_xmm_xmm_rm64_er = 4407, + // `VCVTUW2PH xmm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.128.F2.MAP5.W0 7D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtuw2ph_xmm_k1z_xmmm128b16 = 4408, + // `VCVTUW2PH ymm1 {k1}{z}, ymm2/m256/m16bcst` + // + // `EVEX.256.F2.MAP5.W0 7D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtuw2ph_ymm_k1z_ymmm256b16 = 4409, + // `VCVTUW2PH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}` + // + // `EVEX.512.F2.MAP5.W0 7D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtuw2ph_zmm_k1z_zmmm512b16_er = 4410, + // `VCVTW2PH xmm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.128.F3.MAP5.W0 7D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtw2ph_xmm_k1z_xmmm128b16 = 4411, + // `VCVTW2PH ymm1 {k1}{z}, ymm2/m256/m16bcst` + // + // `EVEX.256.F3.MAP5.W0 7D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtw2ph_ymm_k1z_ymmm256b16 = 4412, + // `VCVTW2PH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}` + // + // `EVEX.512.F3.MAP5.W0 7D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vcvtw2ph_zmm_k1z_zmmm512b16_er = 4413, + // `VDIVPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.MAP5.W0 5E /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vdivph_xmm_k1z_xmm_xmmm128b16 = 4414, + // `VDIVPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.MAP5.W0 5E /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vdivph_ymm_k1z_ymm_ymmm256b16 = 4415, + // `VDIVPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.MAP5.W0 5E /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vdivph_zmm_k1z_zmm_zmmm512b16_er = 4416, + // `VDIVSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.F3.MAP5.W0 5E /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vdivsh_xmm_k1z_xmm_xmmm16_er = 4417, + // `VFCMADDCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.F2.MAP6.W0 56 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfcmaddcph_xmm_k1z_xmm_xmmm128b32 = 4418, + // `VFCMADDCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.F2.MAP6.W0 56 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfcmaddcph_ymm_k1z_ymm_ymmm256b32 = 4419, + // `VFCMADDCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.F2.MAP6.W0 56 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfcmaddcph_zmm_k1z_zmm_zmmm512b32_er = 4420, + // `VFMADDCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.F3.MAP6.W0 56 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddcph_xmm_k1z_xmm_xmmm128b32 = 4421, + // `VFMADDCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.F3.MAP6.W0 56 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddcph_ymm_k1z_ymm_ymmm256b32 = 4422, + // `VFMADDCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.F3.MAP6.W0 56 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddcph_zmm_k1z_zmm_zmmm512b32_er = 4423, + // `VFCMADDCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.F2.MAP6.W0 57 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfcmaddcsh_xmm_k1z_xmm_xmmm32_er = 4424, + // `VFMADDCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.F3.MAP6.W0 57 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddcsh_xmm_k1z_xmm_xmmm32_er = 4425, + // `VFCMULCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.F2.MAP6.W0 D6 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfcmulcph_xmm_k1z_xmm_xmmm128b32 = 4426, + // `VFCMULCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.F2.MAP6.W0 D6 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfcmulcph_ymm_k1z_ymm_ymmm256b32 = 4427, + // `VFCMULCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.F2.MAP6.W0 D6 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfcmulcph_zmm_k1z_zmm_zmmm512b32_er = 4428, + // `VFMULCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst` + // + // `EVEX.128.F3.MAP6.W0 D6 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmulcph_xmm_k1z_xmm_xmmm128b32 = 4429, + // `VFMULCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst` + // + // `EVEX.256.F3.MAP6.W0 D6 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmulcph_ymm_k1z_ymm_ymmm256b32 = 4430, + // `VFMULCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}` + // + // `EVEX.512.F3.MAP6.W0 D6 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmulcph_zmm_k1z_zmm_zmmm512b32_er = 4431, + // `VFCMULCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.F2.MAP6.W0 D7 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfcmulcsh_xmm_k1z_xmm_xmmm32_er = 4432, + // `VFMULCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}` + // + // `EVEX.LIG.F3.MAP6.W0 D7 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmulcsh_xmm_k1z_xmm_xmmm32_er = 4433, + // `VFMADDSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 96 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddsub132ph_xmm_k1z_xmm_xmmm128b16 = 4434, + // `VFMADDSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 96 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddsub132ph_ymm_k1z_ymm_ymmm256b16 = 4435, + // `VFMADDSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 96 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddsub132ph_zmm_k1z_zmm_zmmm512b16_er = 4436, + // `VFMADDSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 A6 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddsub213ph_xmm_k1z_xmm_xmmm128b16 = 4437, + // `VFMADDSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 A6 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddsub213ph_ymm_k1z_ymm_ymmm256b16 = 4438, + // `VFMADDSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 A6 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddsub213ph_zmm_k1z_zmm_zmmm512b16_er = 4439, + // `VFMADDSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 B6 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddsub231ph_xmm_k1z_xmm_xmmm128b16 = 4440, + // `VFMADDSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 B6 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddsub231ph_ymm_k1z_ymm_ymmm256b16 = 4441, + // `VFMADDSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 B6 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmaddsub231ph_zmm_k1z_zmm_zmmm512b16_er = 4442, + // `VFMSUBADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 97 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsubadd132ph_xmm_k1z_xmm_xmmm128b16 = 4443, + // `VFMSUBADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 97 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsubadd132ph_ymm_k1z_ymm_ymmm256b16 = 4444, + // `VFMSUBADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 97 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsubadd132ph_zmm_k1z_zmm_zmmm512b16_er = 4445, + // `VFMSUBADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 A7 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsubadd213ph_xmm_k1z_xmm_xmmm128b16 = 4446, + // `VFMSUBADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 A7 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsubadd213ph_ymm_k1z_ymm_ymmm256b16 = 4447, + // `VFMSUBADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 A7 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsubadd213ph_zmm_k1z_zmm_zmmm512b16_er = 4448, + // `VFMSUBADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 B7 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsubadd231ph_xmm_k1z_xmm_xmmm128b16 = 4449, + // `VFMSUBADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 B7 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsubadd231ph_ymm_k1z_ymm_ymmm256b16 = 4450, + // `VFMSUBADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 B7 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsubadd231ph_zmm_k1z_zmm_zmmm512b16_er = 4451, + // `VFMADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 98 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd132ph_xmm_k1z_xmm_xmmm128b16 = 4452, + // `VFMADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 98 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd132ph_ymm_k1z_ymm_ymmm256b16 = 4453, + // `VFMADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 98 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd132ph_zmm_k1z_zmm_zmmm512b16_er = 4454, + // `VFMADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 A8 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd213ph_xmm_k1z_xmm_xmmm128b16 = 4455, + // `VFMADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 A8 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd213ph_ymm_k1z_ymm_ymmm256b16 = 4456, + // `VFMADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 A8 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd213ph_zmm_k1z_zmm_zmmm512b16_er = 4457, + // `VFMADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 B8 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd231ph_xmm_k1z_xmm_xmmm128b16 = 4458, + // `VFMADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 B8 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd231ph_ymm_k1z_ymm_ymmm256b16 = 4459, + // `VFMADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 B8 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd231ph_zmm_k1z_zmm_zmmm512b16_er = 4460, + // `VFNMADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 9C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd132ph_xmm_k1z_xmm_xmmm128b16 = 4461, + // `VFNMADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 9C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd132ph_ymm_k1z_ymm_ymmm256b16 = 4462, + // `VFNMADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 9C /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd132ph_zmm_k1z_zmm_zmmm512b16_er = 4463, + // `VFNMADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 AC /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd213ph_xmm_k1z_xmm_xmmm128b16 = 4464, + // `VFNMADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 AC /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd213ph_ymm_k1z_ymm_ymmm256b16 = 4465, + // `VFNMADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 AC /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd213ph_zmm_k1z_zmm_zmmm512b16_er = 4466, + // `VFNMADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 BC /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd231ph_xmm_k1z_xmm_xmmm128b16 = 4467, + // `VFNMADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 BC /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd231ph_ymm_k1z_ymm_ymmm256b16 = 4468, + // `VFNMADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 BC /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd231ph_zmm_k1z_zmm_zmmm512b16_er = 4469, + // `VFMADD132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 99 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd132sh_xmm_k1z_xmm_xmmm16_er = 4470, + // `VFMADD213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 A9 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd213sh_xmm_k1z_xmm_xmmm16_er = 4471, + // `VFMADD231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 B9 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmadd231sh_xmm_k1z_xmm_xmmm16_er = 4472, + // `VFNMADD132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 9D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd132sh_xmm_k1z_xmm_xmmm16_er = 4473, + // `VFNMADD213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 AD /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd213sh_xmm_k1z_xmm_xmmm16_er = 4474, + // `VFNMADD231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 BD /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmadd231sh_xmm_k1z_xmm_xmmm16_er = 4475, + // `VFMSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 9A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub132ph_xmm_k1z_xmm_xmmm128b16 = 4476, + // `VFMSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 9A /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub132ph_ymm_k1z_ymm_ymmm256b16 = 4477, + // `VFMSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 9A /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub132ph_zmm_k1z_zmm_zmmm512b16_er = 4478, + // `VFMSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 AA /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub213ph_xmm_k1z_xmm_xmmm128b16 = 4479, + // `VFMSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 AA /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub213ph_ymm_k1z_ymm_ymmm256b16 = 4480, + // `VFMSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 AA /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub213ph_zmm_k1z_zmm_zmmm512b16_er = 4481, + // `VFMSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 BA /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub231ph_xmm_k1z_xmm_xmmm128b16 = 4482, + // `VFMSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 BA /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub231ph_ymm_k1z_ymm_ymmm256b16 = 4483, + // `VFMSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 BA /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub231ph_zmm_k1z_zmm_zmmm512b16_er = 4484, + // `VFNMSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 9E /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub132ph_xmm_k1z_xmm_xmmm128b16 = 4485, + // `VFNMSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 9E /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub132ph_ymm_k1z_ymm_ymmm256b16 = 4486, + // `VFNMSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 9E /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub132ph_zmm_k1z_zmm_zmmm512b16_er = 4487, + // `VFNMSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 AE /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub213ph_xmm_k1z_xmm_xmmm128b16 = 4488, + // `VFNMSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 AE /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub213ph_ymm_k1z_ymm_ymmm256b16 = 4489, + // `VFNMSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 AE /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub213ph_zmm_k1z_zmm_zmmm512b16_er = 4490, + // `VFNMSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 BE /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub231ph_xmm_k1z_xmm_xmmm128b16 = 4491, + // `VFNMSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 BE /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub231ph_ymm_k1z_ymm_ymmm256b16 = 4492, + // `VFNMSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 BE /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub231ph_zmm_k1z_zmm_zmmm512b16_er = 4493, + // `VFMSUB132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 9B /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub132sh_xmm_k1z_xmm_xmmm16_er = 4494, + // `VFMSUB213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 AB /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub213sh_xmm_k1z_xmm_xmmm16_er = 4495, + // `VFMSUB231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 BB /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfmsub231sh_xmm_k1z_xmm_xmmm16_er = 4496, + // `VFNMSUB132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 9F /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub132sh_xmm_k1z_xmm_xmmm16_er = 4497, + // `VFNMSUB213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 AF /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub213sh_xmm_k1z_xmm_xmmm16_er = 4498, + // `VFNMSUB231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 BF /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfnmsub231sh_xmm_k1z_xmm_xmmm16_er = 4499, + // `VFPCLASSPH k1 {k2}, xmm2/m128/m16bcst, imm8` + // + // `EVEX.128.0F3A.W0 66 /r ib` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfpclassph_kr_k1_xmmm128b16_imm8 = 4500, + // `VFPCLASSPH k1 {k2}, ymm2/m256/m16bcst, imm8` + // + // `EVEX.256.0F3A.W0 66 /r ib` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfpclassph_kr_k1_ymmm256b16_imm8 = 4501, + // `VFPCLASSPH k1 {k2}, zmm2/m512/m16bcst, imm8` + // + // `EVEX.512.0F3A.W0 66 /r ib` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfpclassph_kr_k1_zmmm512b16_imm8 = 4502, + // `VFPCLASSSH k1 {k2}, xmm2/m16, imm8` + // + // `EVEX.LIG.0F3A.W0 67 /r ib` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vfpclasssh_kr_k1_xmmm16_imm8 = 4503, + // `VGETEXPPH xmm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 42 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vgetexpph_xmm_k1z_xmmm128b16 = 4504, + // `VGETEXPPH ymm1 {k1}{z}, ymm2/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 42 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vgetexpph_ymm_k1z_ymmm256b16 = 4505, + // `VGETEXPPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}` + // + // `EVEX.512.66.MAP6.W0 42 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vgetexpph_zmm_k1z_zmmm512b16_sae = 4506, + // `VGETEXPSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}` + // + // `EVEX.LIG.66.MAP6.W0 43 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vgetexpsh_xmm_k1z_xmm_xmmm16_sae = 4507, + // `VGETMANTPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8` + // + // `EVEX.128.0F3A.W0 26 /r ib` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vgetmantph_xmm_k1z_xmmm128b16_imm8 = 4508, + // `VGETMANTPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8` + // + // `EVEX.256.0F3A.W0 26 /r ib` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vgetmantph_ymm_k1z_ymmm256b16_imm8 = 4509, + // `VGETMANTPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8` + // + // `EVEX.512.0F3A.W0 26 /r ib` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vgetmantph_zmm_k1z_zmmm512b16_imm8_sae = 4510, + // `VGETMANTSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8` + // + // `EVEX.LIG.0F3A.W0 27 /r ib` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vgetmantsh_xmm_k1z_xmm_xmmm16_imm8_sae = 4511, + // `VMAXPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.MAP5.W0 5F /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmaxph_xmm_k1z_xmm_xmmm128b16 = 4512, + // `VMAXPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.MAP5.W0 5F /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmaxph_ymm_k1z_ymm_ymmm256b16 = 4513, + // `VMAXPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{sae}` + // + // `EVEX.512.MAP5.W0 5F /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmaxph_zmm_k1z_zmm_zmmm512b16_sae = 4514, + // `VMAXSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}` + // + // `EVEX.LIG.F3.MAP5.W0 5F /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmaxsh_xmm_k1z_xmm_xmmm16_sae = 4515, + // `VMINPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.MAP5.W0 5D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vminph_xmm_k1z_xmm_xmmm128b16 = 4516, + // `VMINPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.MAP5.W0 5D /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vminph_ymm_k1z_ymm_ymmm256b16 = 4517, + // `VMINPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{sae}` + // + // `EVEX.512.MAP5.W0 5D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vminph_zmm_k1z_zmm_zmmm512b16_sae = 4518, + // `VMINSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}` + // + // `EVEX.LIG.F3.MAP5.W0 5D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vminsh_xmm_k1z_xmm_xmmm16_sae = 4519, + // `VMOVSH xmm1 {k1}{z}, m16` + // + // `EVEX.LIG.F3.MAP5.W0 10 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmovsh_xmm_k1z_m16 = 4520, + // `VMOVSH m16 {k1}, xmm1` + // + // `EVEX.LIG.F3.MAP5.W0 11 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmovsh_m16_k1_xmm = 4521, + // `VMOVSH xmm1 {k1}{z}, xmm2, xmm3` + // + // `EVEX.LIG.F3.MAP5.W0 10 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmovsh_xmm_k1z_xmm_xmm = 4522, + // `VMOVSH xmm1 {k1}{z}, xmm2, xmm3` + // + // `EVEX.LIG.F3.MAP5.W0 11 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmovsh_xmm_k1z_xmm_xmm_MAP5_11 = 4523, + // `VMOVW xmm1, r32/m16` + // + // `EVEX.128.66.MAP5.W0 6E /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmovw_xmm_r32m16 = 4524, + // `VMOVW xmm1, r64/m16` + // + // `EVEX.128.66.MAP5.W1 6E /r` + // + // `AVX512-FP16` + // + // `64-bit` + EVEX_Vmovw_xmm_r64m16 = 4525, + // `VMOVW r32/m16, xmm1` + // + // `EVEX.128.66.MAP5.W0 7E /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmovw_r32m16_xmm = 4526, + // `VMOVW r64/m16, xmm1` + // + // `EVEX.128.66.MAP5.W1 7E /r` + // + // `AVX512-FP16` + // + // `64-bit` + EVEX_Vmovw_r64m16_xmm = 4527, + // `VMULPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.MAP5.W0 59 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmulph_xmm_k1z_xmm_xmmm128b16 = 4528, + // `VMULPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.MAP5.W0 59 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmulph_ymm_k1z_ymm_ymmm256b16 = 4529, + // `VMULPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.MAP5.W0 59 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmulph_zmm_k1z_zmm_zmmm512b16_er = 4530, + // `VMULSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.F3.MAP5.W0 59 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vmulsh_xmm_k1z_xmm_xmmm16_er = 4531, + // `VRCPPH xmm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 4C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrcpph_xmm_k1z_xmmm128b16 = 4532, + // `VRCPPH ymm1 {k1}{z}, ymm2/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 4C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrcpph_ymm_k1z_ymmm256b16 = 4533, + // `VRCPPH zmm1 {k1}{z}, zmm2/m512/m16bcst` + // + // `EVEX.512.66.MAP6.W0 4C /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrcpph_zmm_k1z_zmmm512b16 = 4534, + // `VRCPSH xmm1 {k1}{z}, xmm2, xmm3/m16` + // + // `EVEX.LIG.66.MAP6.W0 4D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrcpsh_xmm_k1z_xmm_xmmm16 = 4535, + // `VREDUCEPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8` + // + // `EVEX.128.0F3A.W0 56 /r ib` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vreduceph_xmm_k1z_xmmm128b16_imm8 = 4536, + // `VREDUCEPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8` + // + // `EVEX.256.0F3A.W0 56 /r ib` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vreduceph_ymm_k1z_ymmm256b16_imm8 = 4537, + // `VREDUCEPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8` + // + // `EVEX.512.0F3A.W0 56 /r ib` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vreduceph_zmm_k1z_zmmm512b16_imm8_sae = 4538, + // `VREDUCESH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8` + // + // `EVEX.LIG.0F3A.W0 57 /r ib` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vreducesh_xmm_k1z_xmm_xmmm16_imm8_sae = 4539, + // `VRNDSCALEPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8` + // + // `EVEX.128.0F3A.W0 08 /r ib` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrndscaleph_xmm_k1z_xmmm128b16_imm8 = 4540, + // `VRNDSCALEPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8` + // + // `EVEX.256.0F3A.W0 08 /r ib` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrndscaleph_ymm_k1z_ymmm256b16_imm8 = 4541, + // `VRNDSCALEPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8` + // + // `EVEX.512.0F3A.W0 08 /r ib` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrndscaleph_zmm_k1z_zmmm512b16_imm8_sae = 4542, + // `VRNDSCALESH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8` + // + // `EVEX.LIG.0F3A.W0 0A /r ib` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrndscalesh_xmm_k1z_xmm_xmmm16_imm8_sae = 4543, + // `VRSQRTPH xmm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 4E /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrsqrtph_xmm_k1z_xmmm128b16 = 4544, + // `VRSQRTPH ymm1 {k1}{z}, ymm2/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 4E /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrsqrtph_ymm_k1z_ymmm256b16 = 4545, + // `VRSQRTPH zmm1 {k1}{z}, zmm2/m512/m16bcst` + // + // `EVEX.512.66.MAP6.W0 4E /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrsqrtph_zmm_k1z_zmmm512b16 = 4546, + // `VRSQRTSH xmm1 {k1}{z}, xmm2, xmm3/m16` + // + // `EVEX.LIG.66.MAP6.W0 4F /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vrsqrtsh_xmm_k1z_xmm_xmmm16 = 4547, + // `VSCALEFPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.66.MAP6.W0 2C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vscalefph_xmm_k1z_xmm_xmmm128b16 = 4548, + // `VSCALEFPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.66.MAP6.W0 2C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vscalefph_ymm_k1z_ymm_ymmm256b16 = 4549, + // `VSCALEFPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.66.MAP6.W0 2C /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vscalefph_zmm_k1z_zmm_zmmm512b16_er = 4550, + // `VSCALEFSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.66.MAP6.W0 2D /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vscalefsh_xmm_k1z_xmm_xmmm16_er = 4551, + // `VSQRTPH xmm1 {k1}{z}, xmm2/m128/m16bcst` + // + // `EVEX.128.MAP5.W0 51 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vsqrtph_xmm_k1z_xmmm128b16 = 4552, + // `VSQRTPH ymm1 {k1}{z}, ymm2/m256/m16bcst` + // + // `EVEX.256.MAP5.W0 51 /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vsqrtph_ymm_k1z_ymmm256b16 = 4553, + // `VSQRTPH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}` + // + // `EVEX.512.MAP5.W0 51 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vsqrtph_zmm_k1z_zmmm512b16_er = 4554, + // `VSQRTSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.F3.MAP5.W0 51 /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vsqrtsh_xmm_k1z_xmm_xmmm16_er = 4555, + // `VSUBPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst` + // + // `EVEX.128.MAP5.W0 5C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vsubph_xmm_k1z_xmm_xmmm128b16 = 4556, + // `VSUBPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst` + // + // `EVEX.256.MAP5.W0 5C /r` + // + // `AVX512VL and AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vsubph_ymm_k1z_ymm_ymmm256b16 = 4557, + // `VSUBPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}` + // + // `EVEX.512.MAP5.W0 5C /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vsubph_zmm_k1z_zmm_zmmm512b16_er = 4558, + // `VSUBSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}` + // + // `EVEX.LIG.F3.MAP5.W0 5C /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vsubsh_xmm_k1z_xmm_xmmm16_er = 4559, + // `VUCOMISH xmm1, xmm2/m16{sae}` + // + // `EVEX.LIG.MAP5.W0 2E /r` + // + // `AVX512-FP16` + // + // `16/32/64-bit` + EVEX_Vucomish_xmm_xmmm16_sae = 4560, + // `RDUDBG` + // + // `0F 0E` + // + // `UDBG` + // + // `16/32/64-bit` + Rdudbg = 4561, + // `WRUDBG` + // + // `0F 0F` + // + // `UDBG` + // + // `16/32/64-bit` + Wrudbg = 4562, + // `JKZD k1, rel8` + // + // `VEX.128.W0 74 cb` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Jkzd_kr_rel8_64 = 4563, + // `JKNZD k1, rel8` + // + // `VEX.128.W0 75 cb` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Jknzd_kr_rel8_64 = 4564, + // `VPREFETCHNTA m8` + // + // `VEX.128.0F.WIG 18 /0` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Vprefetchnta_m8 = 4565, + // `VPREFETCH0 m8` + // + // `VEX.128.0F.WIG 18 /1` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Vprefetch0_m8 = 4566, + // `VPREFETCH1 m8` + // + // `VEX.128.0F.WIG 18 /2` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Vprefetch1_m8 = 4567, + // `VPREFETCH2 m8` + // + // `VEX.128.0F.WIG 18 /3` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Vprefetch2_m8 = 4568, + // `VPREFETCHENTA m8` + // + // `VEX.128.0F.WIG 18 /4` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Vprefetchenta_m8 = 4569, + // `VPREFETCHE0 m8` + // + // `VEX.128.0F.WIG 18 /5` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Vprefetche0_m8 = 4570, + // `VPREFETCHE1 m8` + // + // `VEX.128.0F.WIG 18 /6` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Vprefetche1_m8 = 4571, + // `VPREFETCHE2 m8` + // + // `VEX.128.0F.WIG 18 /7` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Vprefetche2_m8 = 4572, + // `KAND k1, k2` + // + // `VEX.128.0F.W0 41 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kand_kr_kr = 4573, + // `KANDN k1, k2` + // + // `VEX.128.0F.W0 42 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kandn_kr_kr = 4574, + // `KANDNR k1, k2` + // + // `VEX.128.0F.W0 43 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kandnr_kr_kr = 4575, + // `KNOT k1, k2` + // + // `VEX.128.0F.W0 44 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Knot_kr_kr = 4576, + // `KOR k1, k2` + // + // `VEX.128.0F.W0 45 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kor_kr_kr = 4577, + // `KXNOR k1, k2` + // + // `VEX.128.0F.W0 46 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kxnor_kr_kr = 4578, + // `KXOR k1, k2` + // + // `VEX.128.0F.W0 47 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kxor_kr_kr = 4579, + // `KMERGE2L1H k1, k2` + // + // `VEX.128.0F.W0 48 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kmerge2l1h_kr_kr = 4580, + // `KMERGE2L1L k1, k2` + // + // `VEX.128.0F.W0 49 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kmerge2l1l_kr_kr = 4581, + // `JKZD k1, rel32` + // + // `VEX.128.0F.W0 84 cd` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Jkzd_kr_rel32_64 = 4582, + // `JKNZD k1, rel32` + // + // `VEX.128.0F.W0 85 cd` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Jknzd_kr_rel32_64 = 4583, + // `KMOV k1, k2` + // + // `VEX.128.0F.W0 90 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kmov_kr_kr = 4584, + // `KMOV k1, r32` + // + // `VEX.128.0F.W0 92 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kmov_kr_r32 = 4585, + // `KMOV r32, k1` + // + // `VEX.128.0F.W0 93 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kmov_r32_kr = 4586, + // `KCONCATH r64, k1, k2` + // + // `VEX.128.0F.W0 95 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kconcath_r64_kr_kr = 4587, + // `KCONCATL r64, k1, k2` + // + // `VEX.128.0F.W0 97 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kconcatl_r64_kr_kr = 4588, + // `KORTEST k1, k2` + // + // `VEX.128.0F.W0 98 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kortest_kr_kr = 4589, + // `DELAY r32` + // + // `VEX.128.F3.0F.W0 AE /6` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Delay_r32 = 4590, + // `DELAY r64` + // + // `VEX.128.F3.0F.W1 AE /6` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Delay_r64 = 4591, + // `SPFLT r32` + // + // `VEX.128.F2.0F.W0 AE /6` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Spflt_r32 = 4592, + // `SPFLT r64` + // + // `VEX.128.F2.0F.W1 AE /6` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Spflt_r64 = 4593, + // `CLEVICT1 m8` + // + // `VEX.128.F3.0F.WIG AE /7` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Clevict1_m8 = 4594, + // `CLEVICT0 m8` + // + // `VEX.128.F2.0F.WIG AE /7` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Clevict0_m8 = 4595, + // `POPCNT r32, r32` + // + // `VEX.128.F3.0F.W0 B8 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Popcnt_r32_r32 = 4596, + // `POPCNT r64, r64` + // + // `VEX.128.F3.0F.W1 B8 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Popcnt_r64_r64 = 4597, + // `TZCNT r32, r32` + // + // `VEX.128.F3.0F.W0 BC /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Tzcnt_r32_r32 = 4598, + // `TZCNT r64, r64` + // + // `VEX.128.F3.0F.W1 BC /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Tzcnt_r64_r64 = 4599, + // `TZCNTI r32, r32` + // + // `VEX.128.F2.0F.W0 BC /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Tzcnti_r32_r32 = 4600, + // `TZCNTI r64, r64` + // + // `VEX.128.F2.0F.W1 BC /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Tzcnti_r64_r64 = 4601, + // `LZCNT r32, r32` + // + // `VEX.128.F3.0F.W0 BD /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Lzcnt_r32_r32 = 4602, + // `LZCNT r64, r64` + // + // `VEX.128.F3.0F.W1 BD /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Lzcnt_r64_r64 = 4603, + // `UNDOC r32, r/m32` + // + // `VEX.128.F3.0F38.W0 F0 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Undoc_r32_rm32_128_F3_0F38_W0_F0 = 4604, + // `UNDOC r64, r/m64` + // + // `VEX.128.F3.0F38.W1 F0 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Undoc_r64_rm64_128_F3_0F38_W1_F0 = 4605, + // `UNDOC r32, r/m32` + // + // `VEX.128.F2.0F38.W0 F0 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Undoc_r32_rm32_128_F2_0F38_W0_F0 = 4606, + // `UNDOC r64, r/m64` + // + // `VEX.128.F2.0F38.W1 F0 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Undoc_r64_rm64_128_F2_0F38_W1_F0 = 4607, + // `UNDOC r32, r/m32` + // + // `VEX.128.F2.0F38.W0 F1 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Undoc_r32_rm32_128_F2_0F38_W0_F1 = 4608, + // `UNDOC r64, r/m64` + // + // `VEX.128.F2.0F38.W1 F1 /r` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Undoc_r64_rm64_128_F2_0F38_W1_F1 = 4609, + // `KEXTRACT k1, r64, imm8` + // + // `VEX.128.66.0F3A.W0 3E /r ib` + // + // `KNC` + // + // `64-bit` + VEX_KNC_Kextract_kr_r64_imm8 = 4610, + // `VPREFETCHNTA m` + // + // `MVEX.512.0F.WIG 18 /0` + // + // `KNC` + // + // `64-bit` + MVEX_Vprefetchnta_m = 4611, + // `VPREFETCH0 m` + // + // `MVEX.512.0F.WIG 18 /1` + // + // `KNC` + // + // `64-bit` + MVEX_Vprefetch0_m = 4612, + // `VPREFETCH1 m` + // + // `MVEX.512.0F.WIG 18 /2` + // + // `KNC` + // + // `64-bit` + MVEX_Vprefetch1_m = 4613, + // `VPREFETCH2 m` + // + // `MVEX.512.0F.WIG 18 /3` + // + // `KNC` + // + // `64-bit` + MVEX_Vprefetch2_m = 4614, + // `VPREFETCHENTA m` + // + // `MVEX.512.0F.WIG 18 /4` + // + // `KNC` + // + // `64-bit` + MVEX_Vprefetchenta_m = 4615, + // `VPREFETCHE0 m` + // + // `MVEX.512.0F.WIG 18 /5` + // + // `KNC` + // + // `64-bit` + MVEX_Vprefetche0_m = 4616, + // `VPREFETCHE1 m` + // + // `MVEX.512.0F.WIG 18 /6` + // + // `KNC` + // + // `64-bit` + MVEX_Vprefetche1_m = 4617, + // `VPREFETCHE2 m` + // + // `MVEX.512.0F.WIG 18 /7` + // + // `KNC` + // + // `64-bit` + MVEX_Vprefetche2_m = 4618, + // `VMOVAPS zmm1 {k1}, Sf32(zmm2/mt)` + // + // `MVEX.512.0F.W0 28 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovaps_zmm_k1_zmmmt = 4619, + // `VMOVAPD zmm1 {k1}, Sf64(zmm2/mt)` + // + // `MVEX.512.66.0F.W1 28 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovapd_zmm_k1_zmmmt = 4620, + // `VMOVAPS mt {k1}, Df32(zmm1)` + // + // `MVEX.512.0F.W0 29 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovaps_mt_k1_zmm = 4621, + // `VMOVAPD mt {k1}, Df64(zmm1)` + // + // `MVEX.512.66.0F.W1 29 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovapd_mt_k1_zmm = 4622, + // `VMOVNRAPD m {k1}, Df64(zmm1)` + // + // `MVEX.512.F3.0F.W1.EH0 29 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovnrapd_m_k1_zmm = 4623, + // `VMOVNRNGOAPD m {k1}, Df64(zmm1)` + // + // `MVEX.512.F3.0F.W1.EH1 29 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovnrngoapd_m_k1_zmm = 4624, + // `VMOVNRAPS m {k1}, Df32(zmm1)` + // + // `MVEX.512.F2.0F.W0.EH0 29 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovnraps_m_k1_zmm = 4625, + // `VMOVNRNGOAPS m {k1}, Df32(zmm1)` + // + // `MVEX.512.F2.0F.W0.EH1 29 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovnrngoaps_m_k1_zmm = 4626, + // `VADDPS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.0F.W0 58 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vaddps_zmm_k1_zmm_zmmmt = 4627, + // `VADDPD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W1 58 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vaddpd_zmm_k1_zmm_zmmmt = 4628, + // `VMULPS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.0F.W0 59 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmulps_zmm_k1_zmm_zmmmt = 4629, + // `VMULPD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W1 59 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmulpd_zmm_k1_zmm_zmmmt = 4630, + // `VCVTPS2PD zmm1 {k1}, Sf32(zmm2/mt)` + // + // `MVEX.512.0F.W0 5A /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vcvtps2pd_zmm_k1_zmmmt = 4631, + // `VCVTPD2PS zmm1 {k1}, Sf64(zmm2/mt)` + // + // `MVEX.512.66.0F.W1 5A /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vcvtpd2ps_zmm_k1_zmmmt = 4632, + // `VSUBPS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.0F.W0 5C /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vsubps_zmm_k1_zmm_zmmmt = 4633, + // `VSUBPD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W1 5C /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vsubpd_zmm_k1_zmm_zmmmt = 4634, + // `VPCMPGTD k2 {k1}, zmm1, Si32(zmm2/mt)` + // + // `MVEX.NDS.512.66.0F.W0 66 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpcmpgtd_kr_k1_zmm_zmmmt = 4635, + // `VMOVDQA32 zmm1 {k1}, Si32(zmm2/mt)` + // + // `MVEX.512.66.0F.W0 6F /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovdqa32_zmm_k1_zmmmt = 4636, + // `VMOVDQA64 zmm1 {k1}, Si64(zmm2/mt)` + // + // `MVEX.512.66.0F.W1 6F /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovdqa64_zmm_k1_zmmmt = 4637, + // `VPSHUFD zmm1 {k1}, zmm2/mt, imm8` + // + // `MVEX.512.66.0F.W0 70 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vpshufd_zmm_k1_zmmmt_imm8 = 4638, + // `VPSRLD zmm1 {k1}, Si32(zmm2/mt), imm8` + // + // `MVEX.NDD.512.66.0F.W0 72 /2 ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vpsrld_zmm_k1_zmmmt_imm8 = 4639, + // `VPSRAD zmm1 {k1}, Si32(zmm2/mt), imm8` + // + // `MVEX.NDD.512.66.0F.W0 72 /4 ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vpsrad_zmm_k1_zmmmt_imm8 = 4640, + // `VPSLLD zmm1 {k1}, Si32(zmm2/mt), imm8` + // + // `MVEX.NDD.512.66.0F.W0 72 /6 ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vpslld_zmm_k1_zmmmt_imm8 = 4641, + // `VPCMPEQD k2 {k1}, zmm1, Si32(zmm2/mt)` + // + // `MVEX.NDS.512.66.0F.W0 76 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpcmpeqd_kr_k1_zmm_zmmmt = 4642, + // `VCVTUDQ2PD zmm1 {k1}, Si32(zmm2/mt)` + // + // `MVEX.512.F3.0F.W0 7A /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vcvtudq2pd_zmm_k1_zmmmt = 4643, + // `VMOVDQA32 mt {k1}, Di32(zmm1)` + // + // `MVEX.512.66.0F.W0 7F /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovdqa32_mt_k1_zmm = 4644, + // `VMOVDQA64 mt {k1}, Di64(zmm1)` + // + // `MVEX.512.66.0F.W1 7F /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vmovdqa64_mt_k1_zmm = 4645, + // `CLEVICT1 m` + // + // `MVEX.512.F3.0F.WIG AE /7` + // + // `KNC` + // + // `64-bit` + MVEX_Clevict1_m = 4646, + // `CLEVICT0 m` + // + // `MVEX.512.F2.0F.WIG AE /7` + // + // `KNC` + // + // `64-bit` + MVEX_Clevict0_m = 4647, + // `VCMPPS k2 {k1}, zmm1, Sf32(zmm2/mt), imm8` + // + // `MVEX.NDS.512.0F.W0 C2 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vcmpps_kr_k1_zmm_zmmmt_imm8 = 4648, + // `VCMPPD k2 {k1}, zmm1, Sf64(zmm2/mt), imm8` + // + // `MVEX.NDS.512.66.0F.W1 C2 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vcmppd_kr_k1_zmm_zmmmt_imm8 = 4649, + // `VPANDD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W0 DB /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpandd_zmm_k1_zmm_zmmmt = 4650, + // `VPANDQ zmm1 {k1}, zmm2, Si64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W1 DB /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpandq_zmm_k1_zmm_zmmmt = 4651, + // `VPANDND zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W0 DF /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpandnd_zmm_k1_zmm_zmmmt = 4652, + // `VPANDNQ zmm1 {k1}, zmm2, Si64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W1 DF /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpandnq_zmm_k1_zmm_zmmmt = 4653, + // `VCVTDQ2PD zmm1 {k1}, Si32(zmm2/mt)` + // + // `MVEX.512.F3.0F.W0 E6 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vcvtdq2pd_zmm_k1_zmmmt = 4654, + // `VPORD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W0 EB /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpord_zmm_k1_zmm_zmmmt = 4655, + // `VPORQ zmm1 {k1}, zmm2, Si64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W1 EB /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vporq_zmm_k1_zmm_zmmmt = 4656, + // `VPXORD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W0 EF /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpxord_zmm_k1_zmm_zmmmt = 4657, + // `VPXORQ zmm1 {k1}, zmm2, Si64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W1 EF /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpxorq_zmm_k1_zmm_zmmmt = 4658, + // `VPSUBD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W0 FA /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpsubd_zmm_k1_zmm_zmmmt = 4659, + // `VPADDD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F.W0 FE /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpaddd_zmm_k1_zmm_zmmmt = 4660, + // `VBROADCASTSS zmm1 {k1}, Uf32(mt)` + // + // `MVEX.512.66.0F38.W0 18 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vbroadcastss_zmm_k1_mt = 4661, + // `VBROADCASTSD zmm1 {k1}, Uf64(mt)` + // + // `MVEX.512.66.0F38.W1 19 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vbroadcastsd_zmm_k1_mt = 4662, + // `VBROADCASTF32X4 zmm1 {k1}, Uf32(mt)` + // + // `MVEX.512.66.0F38.W0 1A /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vbroadcastf32x4_zmm_k1_mt = 4663, + // `VBROADCASTF64X4 zmm1 {k1}, Uf64(mt)` + // + // `MVEX.512.66.0F38.W1 1B /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vbroadcastf64x4_zmm_k1_mt = 4664, + // `VPTESTMD k2 {k1}, zmm1, Si32(zmm2/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 27 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vptestmd_kr_k1_zmm_zmmmt = 4665, + // `VPERMD zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 36 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpermd_zmm_k1_zmm_zmmmt = 4666, + // `VPMINSD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 39 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpminsd_zmm_k1_zmm_zmmmt = 4667, + // `VPMINUD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 3B /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpminud_zmm_k1_zmm_zmmmt = 4668, + // `VPMAXSD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 3D /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpmaxsd_zmm_k1_zmm_zmmmt = 4669, + // `VPMAXUD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 3F /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpmaxud_zmm_k1_zmm_zmmmt = 4670, + // `VPMULLD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 40 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpmulld_zmm_k1_zmm_zmmmt = 4671, + // `VGETEXPPS zmm1 {k1}, Sf32(zmm2/mt)` + // + // `MVEX.512.66.0F38.W0 42 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vgetexpps_zmm_k1_zmmmt = 4672, + // `VGETEXPPD zmm1 {k1}, Sf64(zmm2/mt)` + // + // `MVEX.512.66.0F38.W1 42 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vgetexppd_zmm_k1_zmmmt = 4673, + // `VPSRLVD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 45 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpsrlvd_zmm_k1_zmm_zmmmt = 4674, + // `VPSRAVD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 46 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpsravd_zmm_k1_zmm_zmmmt = 4675, + // `VPSLLVD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 47 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpsllvd_zmm_k1_zmm_zmmmt = 4676, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 48 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_48 = 4677, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 49 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_49 = 4678, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 4A /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_4A = 4679, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 4B /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_4B = 4680, + // `VADDNPS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 50 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vaddnps_zmm_k1_zmm_zmmmt = 4681, + // `VADDNPD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 50 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vaddnpd_zmm_k1_zmm_zmmmt = 4682, + // `VGMAXABSPS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 51 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vgmaxabsps_zmm_k1_zmm_zmmmt = 4683, + // `VGMINPS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 52 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vgminps_zmm_k1_zmm_zmmmt = 4684, + // `VGMINPD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 52 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vgminpd_zmm_k1_zmm_zmmmt = 4685, + // `VGMAXPS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 53 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vgmaxps_zmm_k1_zmm_zmmmt = 4686, + // `VGMAXPD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 53 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vgmaxpd_zmm_k1_zmm_zmmmt = 4687, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 54 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_54 = 4688, + // `VFIXUPNANPS zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 55 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfixupnanps_zmm_k1_zmm_zmmmt = 4689, + // `VFIXUPNANPD zmm1 {k1}, zmm2, Si64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 55 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfixupnanpd_zmm_k1_zmm_zmmmt = 4690, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 56 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_56 = 4691, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 57 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_57 = 4692, + // `VPBROADCASTD zmm1 {k1}, Ui32(mt)` + // + // `MVEX.512.66.0F38.W0 58 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpbroadcastd_zmm_k1_mt = 4693, + // `VPBROADCASTQ zmm1 {k1}, Ui64(mt)` + // + // `MVEX.512.66.0F38.W1 59 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpbroadcastq_zmm_k1_mt = 4694, + // `VBROADCASTI32X4 zmm1 {k1}, Ui32(mt)` + // + // `MVEX.512.66.0F38.W0 5A /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vbroadcasti32x4_zmm_k1_mt = 4695, + // `VBROADCASTI64X4 zmm1 {k1}, Ui64(mt)` + // + // `MVEX.512.66.0F38.W1 5B /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vbroadcasti64x4_zmm_k1_mt = 4696, + // `VPADCD zmm1 {k1}, k2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 5C /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpadcd_zmm_k1_kr_zmmmt = 4697, + // `VPADDSETCD zmm1 {k1}, k2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 5D /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpaddsetcd_zmm_k1_kr_zmmmt = 4698, + // `VPSBBD zmm1 {k1}, k2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 5E /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpsbbd_zmm_k1_kr_zmmmt = 4699, + // `VPSUBSETBD zmm1 {k1}, k2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 5F /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpsubsetbd_zmm_k1_kr_zmmmt = 4700, + // `VPBLENDMD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 64 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpblendmd_zmm_k1_zmm_zmmmt = 4701, + // `VPBLENDMQ zmm1 {k1}, zmm2, Si64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 64 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpblendmq_zmm_k1_zmm_zmmmt = 4702, + // `VBLENDMPS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 65 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vblendmps_zmm_k1_zmm_zmmmt = 4703, + // `VBLENDMPD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 65 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vblendmpd_zmm_k1_zmm_zmmmt = 4704, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 67 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_67 = 4705, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 68 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_68 = 4706, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 69 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_69 = 4707, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 6A /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_6A = 4708, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 6B /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_6B = 4709, + // `VPSUBRD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 6C /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpsubrd_zmm_k1_zmm_zmmmt = 4710, + // `VSUBRPS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 6D /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vsubrps_zmm_k1_zmm_zmmmt = 4711, + // `VSUBRPD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 6D /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vsubrpd_zmm_k1_zmm_zmmmt = 4712, + // `VPSBBRD zmm1 {k1}, k2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 6E /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpsbbrd_zmm_k1_kr_zmmmt = 4713, + // `VPSUBRSETBD zmm1 {k1}, k2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 6F /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpsubrsetbd_zmm_k1_kr_zmmmt = 4714, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 70 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_70 = 4715, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 71 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_71 = 4716, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 72 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_72 = 4717, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 73 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_73 = 4718, + // `VPCMPLTD k2 {k1}, zmm1, Si32(zmm2/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 74 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpcmpltd_kr_k1_zmm_zmmmt = 4719, + // `VSCALEPS zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 84 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vscaleps_zmm_k1_zmm_zmmmt = 4720, + // `VPMULHUD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 86 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpmulhud_zmm_k1_zmm_zmmmt = 4721, + // `VPMULHD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 87 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpmulhd_zmm_k1_zmm_zmmmt = 4722, + // `VPGATHERDD zmm1 {k1}, Ui32(mvt)` + // + // `MVEX.512.66.0F38.W0 90 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vpgatherdd_zmm_k1_mvt = 4723, + // `VPGATHERDQ zmm1 {k1}, Ui64(mvt)` + // + // `MVEX.512.66.0F38.W1 90 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vpgatherdq_zmm_k1_mvt = 4724, + // `VGATHERDPS zmm1 {k1}, Uf32(mvt)` + // + // `MVEX.512.66.0F38.W0 92 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vgatherdps_zmm_k1_mvt = 4725, + // `VGATHERDPD zmm1 {k1}, Uf64(mvt)` + // + // `MVEX.512.66.0F38.W1 92 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vgatherdpd_zmm_k1_mvt = 4726, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 94 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_94 = 4727, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W1 94 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W1_94 = 4728, + // `VFMADD132PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 98 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmadd132ps_zmm_k1_zmm_zmmmt = 4729, + // `VFMADD132PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 98 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmadd132pd_zmm_k1_zmm_zmmmt = 4730, + // `VFMSUB132PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 9A /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmsub132ps_zmm_k1_zmm_zmmmt = 4731, + // `VFMSUB132PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 9A /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmsub132pd_zmm_k1_zmm_zmmmt = 4732, + // `VFNMADD132PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 9C /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmadd132ps_zmm_k1_zmm_zmmmt = 4733, + // `VFNMADD132PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 9C /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmadd132pd_zmm_k1_zmm_zmmmt = 4734, + // `VFNMSUB132PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 9E /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmsub132ps_zmm_k1_zmm_zmmmt = 4735, + // `VFNMSUB132PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 9E /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmsub132pd_zmm_k1_zmm_zmmmt = 4736, + // `VPSCATTERDD mvt {k1}, Di32(zmm1)` + // + // `MVEX.512.66.0F38.W0 A0 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vpscatterdd_mvt_k1_zmm = 4737, + // `VPSCATTERDQ mvt {k1}, Di64(zmm1)` + // + // `MVEX.512.66.0F38.W1 A0 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vpscatterdq_mvt_k1_zmm = 4738, + // `VSCATTERDPS mvt {k1}, Df32(zmm1)` + // + // `MVEX.512.66.0F38.W0 A2 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vscatterdps_mvt_k1_zmm = 4739, + // `VSCATTERDPD mvt {k1}, Df64(zmm1)` + // + // `MVEX.512.66.0F38.W1 A2 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vscatterdpd_mvt_k1_zmm = 4740, + // `VFMADD233PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 A4 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmadd233ps_zmm_k1_zmm_zmmmt = 4741, + // `VFMADD213PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 A8 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmadd213ps_zmm_k1_zmm_zmmmt = 4742, + // `VFMADD213PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 A8 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmadd213pd_zmm_k1_zmm_zmmmt = 4743, + // `VFMSUB213PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 AA /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmsub213ps_zmm_k1_zmm_zmmmt = 4744, + // `VFMSUB213PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 AA /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmsub213pd_zmm_k1_zmm_zmmmt = 4745, + // `VFNMADD213PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 AC /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmadd213ps_zmm_k1_zmm_zmmmt = 4746, + // `VFNMADD213PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 AC /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmadd213pd_zmm_k1_zmm_zmmmt = 4747, + // `VFNMSUB213PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 AE /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmsub213ps_zmm_k1_zmm_zmmmt = 4748, + // `VFNMSUB213PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 AE /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmsub213pd_zmm_k1_zmm_zmmmt = 4749, + // `UNDOC zmm1 {k1}, mvt` + // + // `MVEX.512.66.0F38.W0 B0 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_B0 = 4750, + // `UNDOC zmm1 {k1}, mvt` + // + // `MVEX.512.66.0F38.W0 B2 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_B2 = 4751, + // `VPMADD233D zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 B4 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpmadd233d_zmm_k1_zmm_zmmmt = 4752, + // `VPMADD231D zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 B5 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpmadd231d_zmm_k1_zmm_zmmmt = 4753, + // `VFMADD231PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 B8 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmadd231ps_zmm_k1_zmm_zmmmt = 4754, + // `VFMADD231PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 B8 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmadd231pd_zmm_k1_zmm_zmmmt = 4755, + // `VFMSUB231PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 BA /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmsub231ps_zmm_k1_zmm_zmmmt = 4756, + // `VFMSUB231PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 BA /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfmsub231pd_zmm_k1_zmm_zmmmt = 4757, + // `VFNMADD231PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 BC /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmadd231ps_zmm_k1_zmm_zmmmt = 4758, + // `VFNMADD231PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 BC /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmadd231pd_zmm_k1_zmm_zmmmt = 4759, + // `VFNMSUB231PS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 BE /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmsub231ps_zmm_k1_zmm_zmmmt = 4760, + // `VFNMSUB231PD zmm1 {k1}, zmm2, Sf64(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W1 BE /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vfnmsub231pd_zmm_k1_zmm_zmmmt = 4761, + // `UNDOC zmm1 {k1}, mvt` + // + // `MVEX.512.66.0F38.W0 C0 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_C0 = 4762, + // `VGATHERPF0HINTDPS Uf32(mvt) {k1}` + // + // `MVEX.512.66.0F38.W0 C6 /0 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vgatherpf0hintdps_mvt_k1 = 4763, + // `VGATHERPF0HINTDPD Uf64(mvt) {k1}` + // + // `MVEX.512.66.0F38.W1 C6 /0 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vgatherpf0hintdpd_mvt_k1 = 4764, + // `VGATHERPF0DPS Uf32(mvt) {k1}` + // + // `MVEX.512.66.0F38.W0 C6 /1 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vgatherpf0dps_mvt_k1 = 4765, + // `VGATHERPF1DPS Uf32(mvt) {k1}` + // + // `MVEX.512.66.0F38.W0 C6 /2 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vgatherpf1dps_mvt_k1 = 4766, + // `VSCATTERPF0HINTDPS Uf32(mvt) {k1}` + // + // `MVEX.512.66.0F38.W0 C6 /4 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vscatterpf0hintdps_mvt_k1 = 4767, + // `VSCATTERPF0HINTDPD Uf64(mvt) {k1}` + // + // `MVEX.512.66.0F38.W1 C6 /4 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vscatterpf0hintdpd_mvt_k1 = 4768, + // `VSCATTERPF0DPS Uf32(mvt) {k1}` + // + // `MVEX.512.66.0F38.W0 C6 /5 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vscatterpf0dps_mvt_k1 = 4769, + // `VSCATTERPF1DPS Uf32(mvt) {k1}` + // + // `MVEX.512.66.0F38.W0 C6 /6 /vsib` + // + // `KNC` + // + // `64-bit` + MVEX_Vscatterpf1dps_mvt_k1 = 4770, + // `VEXP223PS zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 C8 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vexp223ps_zmm_k1_zmmmt = 4771, + // `VLOG2PS zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 C9 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vlog2ps_zmm_k1_zmmmt = 4772, + // `VRCP23PS zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 CA /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vrcp23ps_zmm_k1_zmmmt = 4773, + // `VRSQRT23PS zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 CB /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vrsqrt23ps_zmm_k1_zmmmt = 4774, + // `VADDSETSPS zmm1 {k1}, zmm2, Sf32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 CC /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vaddsetsps_zmm_k1_zmm_zmmmt = 4775, + // `VPADDSETSD zmm1 {k1}, zmm2, Si32(zmm3/mt)` + // + // `MVEX.NDS.512.66.0F38.W0 CD /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpaddsetsd_zmm_k1_zmm_zmmmt = 4776, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 CE /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_CE = 4777, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W1 CE /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W1_CE = 4778, + // `UNDOC zmm1 {k1}, zmm2, zmm3/mt` + // + // `MVEX.NDS.512.66.0F38.W0 CF /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_CF = 4779, + // `VLOADUNPACKLD zmm1 {k1}, Ui32(mt)` + // + // `MVEX.512.0F38.W0 D0 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vloadunpackld_zmm_k1_mt = 4780, + // `VLOADUNPACKLQ zmm1 {k1}, Ui64(mt)` + // + // `MVEX.512.0F38.W1 D0 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vloadunpacklq_zmm_k1_mt = 4781, + // `VPACKSTORELD mt {k1}, Di32(zmm1)` + // + // `MVEX.512.66.0F38.W0 D0 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpackstoreld_mt_k1_zmm = 4782, + // `VPACKSTORELQ mt {k1}, Di64(zmm1)` + // + // `MVEX.512.66.0F38.W1 D0 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpackstorelq_mt_k1_zmm = 4783, + // `VLOADUNPACKLPS zmm1 {k1}, Uf32(mt)` + // + // `MVEX.512.0F38.W0 D1 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vloadunpacklps_zmm_k1_mt = 4784, + // `VLOADUNPACKLPD zmm1 {k1}, Uf64(mt)` + // + // `MVEX.512.0F38.W1 D1 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vloadunpacklpd_zmm_k1_mt = 4785, + // `VPACKSTORELPS mt {k1}, Df32(zmm1)` + // + // `MVEX.512.66.0F38.W0 D1 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpackstorelps_mt_k1_zmm = 4786, + // `VPACKSTORELPD mt {k1}, Df64(zmm1)` + // + // `MVEX.512.66.0F38.W1 D1 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpackstorelpd_mt_k1_zmm = 4787, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.0F38.W0 D2 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D2 = 4788, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 D2 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_D2 = 4789, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.0F38.W0 D3 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D3 = 4790, + // `VLOADUNPACKHD zmm1 {k1}, Ui32(mt)` + // + // `MVEX.512.0F38.W0 D4 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vloadunpackhd_zmm_k1_mt = 4791, + // `VLOADUNPACKHQ zmm1 {k1}, Ui64(mt)` + // + // `MVEX.512.0F38.W1 D4 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vloadunpackhq_zmm_k1_mt = 4792, + // `VPACKSTOREHD mt {k1}, Di32(zmm1)` + // + // `MVEX.512.66.0F38.W0 D4 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpackstorehd_mt_k1_zmm = 4793, + // `VPACKSTOREHQ mt {k1}, Di64(zmm1)` + // + // `MVEX.512.66.0F38.W1 D4 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpackstorehq_mt_k1_zmm = 4794, + // `VLOADUNPACKHPS zmm1 {k1}, Uf32(mt)` + // + // `MVEX.512.0F38.W0 D5 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vloadunpackhps_zmm_k1_mt = 4795, + // `VLOADUNPACKHPD zmm1 {k1}, Uf64(mt)` + // + // `MVEX.512.0F38.W1 D5 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vloadunpackhpd_zmm_k1_mt = 4796, + // `VPACKSTOREHPS mt {k1}, Df32(zmm1)` + // + // `MVEX.512.66.0F38.W0 D5 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpackstorehps_mt_k1_zmm = 4797, + // `VPACKSTOREHPD mt {k1}, Df64(zmm1)` + // + // `MVEX.512.66.0F38.W1 D5 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Vpackstorehpd_mt_k1_zmm = 4798, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.0F38.W0 D6 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D6 = 4799, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.66.0F38.W0 D6 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_D6 = 4800, + // `UNDOC zmm1 {k1}, zmm2/mt` + // + // `MVEX.512.0F38.W0 D7 /r` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D7 = 4801, + // `VALIGND zmm1 {k1}, zmm2, zmm3/mt, imm8` + // + // `MVEX.NDS.512.66.0F3A.W0 03 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Valignd_zmm_k1_zmm_zmmmt_imm8 = 4802, + // `VPERMF32X4 zmm1 {k1}, zmm2/mt, imm8` + // + // `MVEX.512.66.0F3A.W0 07 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vpermf32x4_zmm_k1_zmmmt_imm8 = 4803, + // `VPCMPUD k2 {k1}, zmm1, Si32(zmm2/mt), imm8` + // + // `MVEX.NDS.512.66.0F3A.W0 1E /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vpcmpud_kr_k1_zmm_zmmmt_imm8 = 4804, + // `VPCMPD k2 {k1}, zmm1, Si32(zmm2/mt), imm8` + // + // `MVEX.NDS.512.66.0F3A.W0 1F /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vpcmpd_kr_k1_zmm_zmmmt_imm8 = 4805, + // `VGETMANTPS zmm1 {k1}, Sf32(zmm2/mt), imm8` + // + // `MVEX.512.66.0F3A.W0 26 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vgetmantps_zmm_k1_zmmmt_imm8 = 4806, + // `VGETMANTPD zmm1 {k1}, Sf64(zmm2/mt), imm8` + // + // `MVEX.512.66.0F3A.W1 26 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vgetmantpd_zmm_k1_zmmmt_imm8 = 4807, + // `VRNDFXPNTPS zmm1 {k1}, Sf32(zmm2/mt), imm8` + // + // `MVEX.512.66.0F3A.W0 52 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vrndfxpntps_zmm_k1_zmmmt_imm8 = 4808, + // `VRNDFXPNTPD zmm1 {k1}, Sf64(zmm2/mt), imm8` + // + // `MVEX.512.66.0F3A.W1 52 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vrndfxpntpd_zmm_k1_zmmmt_imm8 = 4809, + // `VCVTFXPNTUDQ2PS zmm1 {k1}, Si32(zmm2/mt), imm8` + // + // `MVEX.512.0F3A.W0 CA /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vcvtfxpntudq2ps_zmm_k1_zmmmt_imm8 = 4810, + // `VCVTFXPNTPS2UDQ zmm1 {k1}, Sf32(zmm2/mt), imm8` + // + // `MVEX.512.66.0F3A.W0 CA /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vcvtfxpntps2udq_zmm_k1_zmmmt_imm8 = 4811, + // `VCVTFXPNTPD2UDQ zmm1 {k1}, Sf64(zmm2/mt), imm8` + // + // `MVEX.512.F2.0F3A.W1 CA /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vcvtfxpntpd2udq_zmm_k1_zmmmt_imm8 = 4812, + // `VCVTFXPNTDQ2PS zmm1 {k1}, Si32(zmm2/mt), imm8` + // + // `MVEX.512.0F3A.W0 CB /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vcvtfxpntdq2ps_zmm_k1_zmmmt_imm8 = 4813, + // `VCVTFXPNTPS2DQ zmm1 {k1}, Sf32(zmm2/mt), imm8` + // + // `MVEX.512.66.0F3A.W0 CB /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vcvtfxpntps2dq_zmm_k1_zmmmt_imm8 = 4814, + // `UNDOC zmm1 {k1}, zmm2/mt, imm8` + // + // `MVEX.512.66.0F3A.W0 D0 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_imm8_512_66_0F3A_W0_D0 = 4815, + // `UNDOC zmm1 {k1}, zmm2/mt, imm8` + // + // `MVEX.512.66.0F3A.W0 D1 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Undoc_zmm_k1_zmmmt_imm8_512_66_0F3A_W0_D1 = 4816, + // `VCVTFXPNTPD2DQ zmm1 {k1}, Sf64(zmm2/mt), imm8` + // + // `MVEX.512.F2.0F3A.W1 E6 /r ib` + // + // `KNC` + // + // `64-bit` + MVEX_Vcvtfxpntpd2dq_zmm_k1_zmmmt_imm8 = 4817, + // `UNDOC` + // + // `a16 F3 0F A6 F0` + // + // `PADLOCK_UNDOC` + // + // `16/32-bit` + Via_undoc_F30FA6F0_16 = 4818, + // `UNDOC` + // + // `a32 F3 0F A6 F0` + // + // `PADLOCK_UNDOC` + // + // `16/32/64-bit` + Via_undoc_F30FA6F0_32 = 4819, + // `UNDOC` + // + // `a64 F3 0F A6 F0` + // + // `PADLOCK_UNDOC` + // + // `64-bit` + Via_undoc_F30FA6F0_64 = 4820, + // `UNDOC` + // + // `a16 F3 0F A6 F8` + // + // `PADLOCK_UNDOC` + // + // `16/32-bit` + Via_undoc_F30FA6F8_16 = 4821, + // `UNDOC` + // + // `a32 F3 0F A6 F8` + // + // `PADLOCK_UNDOC` + // + // `16/32/64-bit` + Via_undoc_F30FA6F8_32 = 4822, + // `UNDOC` + // + // `a64 F3 0F A6 F8` + // + // `PADLOCK_UNDOC` + // + // `64-bit` + Via_undoc_F30FA6F8_64 = 4823, + // `XSHA512` + // + // `a16 F3 0F A6 E0` + // + // `PADLOCK_PHE` + // + // `16/32-bit` + Xsha512_16 = 4824, + // `XSHA512` + // + // `a32 F3 0F A6 E0` + // + // `PADLOCK_PHE` + // + // `16/32/64-bit` + Xsha512_32 = 4825, + // `XSHA512` + // + // `a64 F3 0F A6 E0` + // + // `PADLOCK_PHE` + // + // `64-bit` + Xsha512_64 = 4826, + // `XSTORE_ALT` + // + // `a16 F3 0F A7 F8` + // + // `PADLOCK_RNG` + // + // `16/32-bit` + Xstore_alt_16 = 4827, + // `XSTORE_ALT` + // + // `a32 F3 0F A7 F8` + // + // `PADLOCK_RNG` + // + // `16/32/64-bit` + Xstore_alt_32 = 4828, + // `XSTORE_ALT` + // + // `a64 F3 0F A7 F8` + // + // `PADLOCK_RNG` + // + // `64-bit` + Xstore_alt_64 = 4829, + // `XSHA512_ALT` + // + // `a16 F3 0F A6 D8` + // + // `PADLOCK_PHE` + // + // `16/32-bit` + Xsha512_alt_16 = 4830, + // `XSHA512_ALT` + // + // `a32 F3 0F A6 D8` + // + // `PADLOCK_PHE` + // + // `16/32/64-bit` + Xsha512_alt_32 = 4831, + // `XSHA512_ALT` + // + // `a64 F3 0F A6 D8` + // + // `PADLOCK_PHE` + // + // `64-bit` + Xsha512_alt_64 = 4832, + // A zero-sized instruction. Can be used as a label. + Zero_bytes = 4833, + // `WRMSRNS` + // + // `NP 0F 01 C6` + // + // `WRMSRNS` + // + // `16/32/64-bit` + Wrmsrns = 4834, + // `WRMSRLIST` + // + // `F3 0F 01 C6` + // + // `MSRLIST` + // + // `64-bit` + Wrmsrlist = 4835, + // `RDMSRLIST` + // + // `F2 0F 01 C6` + // + // `MSRLIST` + // + // `64-bit` + Rdmsrlist = 4836, + // `RMPQUERY` + // + // `F3 0F 01 FD` + // + // `RMPQUERY` + // + // `64-bit` + Rmpquery = 4837, + // `PREFETCHIT1 m8` + // + // `0F 18 /6` + // + // `PREFETCHITI` + // + // `16/32/64-bit` + Prefetchit1_m8 = 4838, + // `PREFETCHIT0 m8` + // + // `0F 18 /7` + // + // `PREFETCHITI` + // + // `16/32/64-bit` + Prefetchit0_m8 = 4839, + // `AADD m32, r32` + // + // `NP 0F 38 FC !(11):rrr:bbb` + // + // `RAO-INT` + // + // `16/32/64-bit` + Aadd_m32_r32 = 4840, + // `AADD m64, r64` + // + // `NP o64 0F 38 FC !(11):rrr:bbb` + // + // `RAO-INT` + // + // `64-bit` + Aadd_m64_r64 = 4841, + // `AAND m32, r32` + // + // `66 0F 38 FC !(11):rrr:bbb` + // + // `RAO-INT` + // + // `16/32/64-bit` + Aand_m32_r32 = 4842, + // `AAND m64, r64` + // + // `66 o64 0F 38 FC !(11):rrr:bbb` + // + // `RAO-INT` + // + // `64-bit` + Aand_m64_r64 = 4843, + // `AXOR m32, r32` + // + // `F3 0F 38 FC !(11):rrr:bbb` + // + // `RAO-INT` + // + // `16/32/64-bit` + Axor_m32_r32 = 4844, + // `AXOR m64, r64` + // + // `F3 o64 0F 38 FC !(11):rrr:bbb` + // + // `RAO-INT` + // + // `64-bit` + Axor_m64_r64 = 4845, + // `AOR m32, r32` + // + // `F2 0F 38 FC !(11):rrr:bbb` + // + // `RAO-INT` + // + // `16/32/64-bit` + Aor_m32_r32 = 4846, + // `AOR m64, r64` + // + // `F2 o64 0F 38 FC !(11):rrr:bbb` + // + // `RAO-INT` + // + // `64-bit` + Aor_m64_r64 = 4847, + // `VPDPBUUD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F38.W0 50 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbuud_xmm_xmm_xmmm128 = 4848, + // `VPDPBUUD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F38.W0 50 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbuud_ymm_ymm_ymmm256 = 4849, + // `VPDPBSUD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.F3.0F38.W0 50 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbsud_xmm_xmm_xmmm128 = 4850, + // `VPDPBSUD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.F3.0F38.W0 50 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbsud_ymm_ymm_ymmm256 = 4851, + // `VPDPBSSD xmm1, xmm2, xmm3/m128` + // + // `VEX.128.F2.0F38.W0 50 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbssd_xmm_xmm_xmmm128 = 4852, + // `VPDPBSSD ymm1, ymm2, ymm3/m256` + // + // `VEX.256.F2.0F38.W0 50 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbssd_ymm_ymm_ymmm256 = 4853, + // `VPDPBUUDS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.0F38.W0 51 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbuuds_xmm_xmm_xmmm128 = 4854, + // `VPDPBUUDS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.0F38.W0 51 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbuuds_ymm_ymm_ymmm256 = 4855, + // `VPDPBSUDS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.F3.0F38.W0 51 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbsuds_xmm_xmm_xmmm128 = 4856, + // `VPDPBSUDS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.F3.0F38.W0 51 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbsuds_ymm_ymm_ymmm256 = 4857, + // `VPDPBSSDS xmm1, xmm2, xmm3/m128` + // + // `VEX.128.F2.0F38.W0 51 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbssds_xmm_xmm_xmmm128 = 4858, + // `VPDPBSSDS ymm1, ymm2, ymm3/m256` + // + // `VEX.256.F2.0F38.W0 51 /r` + // + // `AVX-VNNI-INT8` + // + // `16/32/64-bit` + VEX_Vpdpbssds_ymm_ymm_ymmm256 = 4859, + // `TDPFP16PS tmm1, tmm2, tmm3` + // + // `VEX.128.F2.0F38.W0 5C 11:rrr:bbb` + // + // `AMX-FP16` + // + // `64-bit` + VEX_Tdpfp16ps_tmm_tmm_tmm = 4860, + // `VCVTNEPS2BF16 xmm1, xmm2/m128` + // + // `VEX.128.F3.0F38.W0 72 /r` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vcvtneps2bf16_xmm_xmmm128 = 4861, + // `VCVTNEPS2BF16 xmm1, ymm2/m256` + // + // `VEX.256.F3.0F38.W0 72 /r` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vcvtneps2bf16_xmm_ymmm256 = 4862, + // `VCVTNEOPH2PS xmm1, m128` + // + // `VEX.128.0F38.W0 B0 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vcvtneoph2ps_xmm_m128 = 4863, + // `VCVTNEOPH2PS ymm1, m256` + // + // `VEX.256.0F38.W0 B0 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vcvtneoph2ps_ymm_m256 = 4864, + // `VCVTNEEPH2PS xmm1, m128` + // + // `VEX.128.66.0F38.W0 B0 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vcvtneeph2ps_xmm_m128 = 4865, + // `VCVTNEEPH2PS ymm1, m256` + // + // `VEX.256.66.0F38.W0 B0 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vcvtneeph2ps_ymm_m256 = 4866, + // `VCVTNEEBF162PS xmm1, m128` + // + // `VEX.128.F3.0F38.W0 B0 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vcvtneebf162ps_xmm_m128 = 4867, + // `VCVTNEEBF162PS ymm1, m256` + // + // `VEX.256.F3.0F38.W0 B0 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vcvtneebf162ps_ymm_m256 = 4868, + // `VCVTNEOBF162PS xmm1, m128` + // + // `VEX.128.F2.0F38.W0 B0 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vcvtneobf162ps_xmm_m128 = 4869, + // `VCVTNEOBF162PS ymm1, m256` + // + // `VEX.256.F2.0F38.W0 B0 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vcvtneobf162ps_ymm_m256 = 4870, + // `VBCSTNESH2PS xmm1, m16` + // + // `VEX.128.66.0F38.W0 B1 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vbcstnesh2ps_xmm_m16 = 4871, + // `VBCSTNESH2PS ymm1, m16` + // + // `VEX.256.66.0F38.W0 B1 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vbcstnesh2ps_ymm_m16 = 4872, + // `VBCSTNEBF162PS xmm1, m16` + // + // `VEX.128.F3.0F38.W0 B1 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vbcstnebf162ps_xmm_m16 = 4873, + // `VBCSTNEBF162PS ymm1, m16` + // + // `VEX.256.F3.0F38.W0 B1 !(11):rrr:bbb` + // + // `AVX-NE-CONVERT` + // + // `16/32/64-bit` + VEX_Vbcstnebf162ps_ymm_m16 = 4874, + // `VPMADD52LUQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 B4 /r` + // + // `AVX-IFMA` + // + // `16/32/64-bit` + VEX_Vpmadd52luq_xmm_xmm_xmmm128 = 4875, + // `VPMADD52LUQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 B4 /r` + // + // `AVX-IFMA` + // + // `16/32/64-bit` + VEX_Vpmadd52luq_ymm_ymm_ymmm256 = 4876, + // `VPMADD52HUQ xmm1, xmm2, xmm3/m128` + // + // `VEX.128.66.0F38.W1 B5 /r` + // + // `AVX-IFMA` + // + // `16/32/64-bit` + VEX_Vpmadd52huq_xmm_xmm_xmmm128 = 4877, + // `VPMADD52HUQ ymm1, ymm2, ymm3/m256` + // + // `VEX.256.66.0F38.W1 B5 /r` + // + // `AVX-IFMA` + // + // `16/32/64-bit` + VEX_Vpmadd52huq_ymm_ymm_ymmm256 = 4878, + // `CMPOXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 E0 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpoxadd_m32_r32_r32 = 4879, + // `CMPOXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 E0 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpoxadd_m64_r64_r64 = 4880, + // `CMPNOXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 E1 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnoxadd_m32_r32_r32 = 4881, + // `CMPNOXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 E1 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnoxadd_m64_r64_r64 = 4882, + // `CMPBXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 E2 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpbxadd_m32_r32_r32 = 4883, + // `CMPBXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 E2 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpbxadd_m64_r64_r64 = 4884, + // `CMPNBXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 E3 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnbxadd_m32_r32_r32 = 4885, + // `CMPNBXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 E3 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnbxadd_m64_r64_r64 = 4886, + // `CMPZXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 E4 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpzxadd_m32_r32_r32 = 4887, + // `CMPZXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 E4 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpzxadd_m64_r64_r64 = 4888, + // `CMPNZXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 E5 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnzxadd_m32_r32_r32 = 4889, + // `CMPNZXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 E5 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnzxadd_m64_r64_r64 = 4890, + // `CMPBEXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 E6 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpbexadd_m32_r32_r32 = 4891, + // `CMPBEXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 E6 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpbexadd_m64_r64_r64 = 4892, + // `CMPNBEXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 E7 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnbexadd_m32_r32_r32 = 4893, + // `CMPNBEXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 E7 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnbexadd_m64_r64_r64 = 4894, + // `CMPSXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 E8 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpsxadd_m32_r32_r32 = 4895, + // `CMPSXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 E8 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpsxadd_m64_r64_r64 = 4896, + // `CMPNSXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 E9 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnsxadd_m32_r32_r32 = 4897, + // `CMPNSXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 E9 !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnsxadd_m64_r64_r64 = 4898, + // `CMPPXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 EA !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmppxadd_m32_r32_r32 = 4899, + // `CMPPXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 EA !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmppxadd_m64_r64_r64 = 4900, + // `CMPNPXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 EB !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnpxadd_m32_r32_r32 = 4901, + // `CMPNPXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 EB !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnpxadd_m64_r64_r64 = 4902, + // `CMPLXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 EC !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmplxadd_m32_r32_r32 = 4903, + // `CMPLXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 EC !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmplxadd_m64_r64_r64 = 4904, + // `CMPNLXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 ED !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnlxadd_m32_r32_r32 = 4905, + // `CMPNLXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 ED !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnlxadd_m64_r64_r64 = 4906, + // `CMPLEXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 EE !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmplexadd_m32_r32_r32 = 4907, + // `CMPLEXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 EE !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmplexadd_m64_r64_r64 = 4908, + // `CMPNLEXADD m32, r32, r32` + // + // `VEX.128.66.0F38.W0 EF !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnlexadd_m32_r32_r32 = 4909, + // `CMPNLEXADD m64, r64, r64` + // + // `VEX.128.66.0F38.W1 EF !(11):rrr:bbb` + // + // `CMPCCXADD` + // + // `64-bit` + VEX_Cmpnlexadd_m64_r64_r64 = 4910, + // `TCMMRLFP16PS tmm1, tmm2, tmm3` + // + // `VEX.128.0F38.W0 6C 11:rrr:bbb` + // + // `AMX-COMPLEX` + // + // `64-bit` + VEX_Tcmmrlfp16ps_tmm_tmm_tmm = 4911, + // `TCMMIMFP16PS tmm1, tmm2, tmm3` + // + // `VEX.128.66.0F38.W0 6C 11:rrr:bbb` + // + // `AMX-COMPLEX` + // + // `64-bit` + VEX_Tcmmimfp16ps_tmm_tmm_tmm = 4912, + /// `PBNDKB` + /// + /// `NP 0F 01 C7` + /// + /// `TSE` + /// + /// `64-bit` + Pbndkb = 4913, + /// `VSHA512RNDS2 ymm1, ymm2, xmm3` + /// + /// `VEX.256.F2.0F38.W0 CB 11:rrr:bbb` + /// + /// `AVX and SHA512` + /// + /// `16/32/64-bit` + VEX_Vsha512rnds2_ymm_ymm_xmm = 4914, + /// `VSHA512MSG1 ymm1, xmm2` + /// + /// `VEX.256.F2.0F38.W0 CC 11:rrr:bbb` + /// + /// `AVX and SHA512` + /// + /// `16/32/64-bit` + VEX_Vsha512msg1_ymm_xmm = 4915, + /// `VSHA512MSG2 ymm1, ymm2` + /// + /// `VEX.256.F2.0F38.W0 CD 11:rrr:bbb` + /// + /// `AVX and SHA512` + /// + /// `16/32/64-bit` + VEX_Vsha512msg2_ymm_ymm = 4916, + /// `VPDPWUUD xmm1, xmm2, xmm3/m128` + /// + /// `VEX.128.0F38.W0 D2 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwuud_xmm_xmm_xmmm128 = 4917, + /// `VPDPWUUD ymm1, ymm2, ymm3/m256` + /// + /// `VEX.256.0F38.W0 D2 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwuud_ymm_ymm_ymmm256 = 4918, + /// `VPDPWUSD xmm1, xmm2, xmm3/m128` + /// + /// `VEX.128.66.0F38.W0 D2 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwusd_xmm_xmm_xmmm128 = 4919, + /// `VPDPWUSD ymm1, ymm2, ymm3/m256` + /// + /// `VEX.256.66.0F38.W0 D2 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwusd_ymm_ymm_ymmm256 = 4920, + /// `VPDPWSUD xmm1, xmm2, xmm3/m128` + /// + /// `VEX.128.F3.0F38.W0 D2 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwsud_xmm_xmm_xmmm128 = 4921, + /// `VPDPWSUD ymm1, ymm2, ymm3/m256` + /// + /// `VEX.256.F3.0F38.W0 D2 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwsud_ymm_ymm_ymmm256 = 4922, + /// `VPDPWUUDS xmm1, xmm2, xmm3/m128` + /// + /// `VEX.128.0F38.W0 D3 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwuuds_xmm_xmm_xmmm128 = 4923, + /// `VPDPWUUDS ymm1, ymm2, ymm3/m256` + /// + /// `VEX.256.0F38.W0 D3 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwuuds_ymm_ymm_ymmm256 = 4924, + /// `VPDPWUSDS xmm1, xmm2, xmm3/m128` + /// + /// `VEX.128.66.0F38.W0 D3 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwusds_xmm_xmm_xmmm128 = 4925, + /// `VPDPWUSDS ymm1, ymm2, ymm3/m256` + /// + /// `VEX.256.66.0F38.W0 D3 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwusds_ymm_ymm_ymmm256 = 4926, + /// `VPDPWSUDS xmm1, xmm2, xmm3/m128` + /// + /// `VEX.128.F3.0F38.W0 D3 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwsuds_xmm_xmm_xmmm128 = 4927, + /// `VPDPWSUDS ymm1, ymm2, ymm3/m256` + /// + /// `VEX.256.F3.0F38.W0 D3 /r` + /// + /// `AVX-VNNI-INT16` + /// + /// `16/32/64-bit` + VEX_Vpdpwsuds_ymm_ymm_ymmm256 = 4928, + /// `VSM3MSG1 xmm1, xmm2, xmm3/m128` + /// + /// `VEX.128.0F38.W0 DA /r` + /// + /// `AVX and SM3` + /// + /// `16/32/64-bit` + VEX_Vsm3msg1_xmm_xmm_xmmm128 = 4929, + /// `VSM3MSG2 xmm1, xmm2, xmm3/m128` + /// + /// `VEX.128.66.0F38.W0 DA /r` + /// + /// `AVX and SM3` + /// + /// `16/32/64-bit` + VEX_Vsm3msg2_xmm_xmm_xmmm128 = 4930, + /// `VSM4KEY4 xmm1, xmm2, xmm3/m128` + /// + /// `VEX.128.F3.0F38.W0 DA /r` + /// + /// `AVX and SM4` + /// + /// `16/32/64-bit` + VEX_Vsm4key4_xmm_xmm_xmmm128 = 4931, + /// `VSM4KEY4 ymm1, ymm2, ymm3/m256` + /// + /// `VEX.256.F3.0F38.W0 DA /r` + /// + /// `AVX and SM4` + /// + /// `16/32/64-bit` + VEX_Vsm4key4_ymm_ymm_ymmm256 = 4932, + /// `VSM4RNDS4 xmm1, xmm2, xmm3/m128` + /// + /// `VEX.128.F2.0F38.W0 DA /r` + /// + /// `AVX and SM4` + /// + /// `16/32/64-bit` + VEX_Vsm4rnds4_xmm_xmm_xmmm128 = 4933, + /// `VSM4RNDS4 ymm1, ymm2, ymm3/m256` + /// + /// `VEX.256.F2.0F38.W0 DA /r` + /// + /// `AVX and SM4` + /// + /// `16/32/64-bit` + VEX_Vsm4rnds4_ymm_ymm_ymmm256 = 4934, + /// `VSM3RNDS2 xmm1, xmm2, xmm3/m128, imm8` + /// + /// `VEX.128.66.0F3A.W0 DE /r ib` + /// + /// `AVX and SM3` + /// + /// `16/32/64-bit` + VEX_Vsm3rnds2_xmm_xmm_xmmm128_imm8 = 4935 + ); + + TMnemonicType = ( + mnINVALID = 0, + mnAaa = 1, + mnAad = 2, + mnAam = 3, + mnAas = 4, + mnAdc = 5, + mnAdcx = 6, + mnAdd = 7, + mnAddpd = 8, + mnAddps = 9, + mnAddsd = 10, + mnAddss = 11, + mnAddsubpd = 12, + mnAddsubps = 13, + mnAdox = 14, + mnAesdec = 15, + mnAesdeclast = 16, + mnAesenc = 17, + mnAesenclast = 18, + mnAesimc = 19, + mnAeskeygenassist = 20, + mnAnd = 21, + mnAndn = 22, + mnAndnpd = 23, + mnAndnps = 24, + mnAndpd = 25, + mnAndps = 26, + mnArpl = 27, + mnBextr = 28, + mnBlcfill = 29, + mnBlci = 30, + mnBlcic = 31, + mnBlcmsk = 32, + mnBlcs = 33, + mnBlendpd = 34, + mnBlendps = 35, + mnBlendvpd = 36, + mnBlendvps = 37, + mnBlsfill = 38, + mnBlsi = 39, + mnBlsic = 40, + mnBlsmsk = 41, + mnBlsr = 42, + mnBndcl = 43, + mnBndcn = 44, + mnBndcu = 45, + mnBndldx = 46, + mnBndmk = 47, + mnBndmov = 48, + mnBndstx = 49, + mnBound = 50, + mnBsf = 51, + mnBsr = 52, + mnBswap = 53, + mnBt = 54, + mnBtc = 55, + mnBtr = 56, + mnBts = 57, + mnBzhi = 58, + mnCall = 59, + mnCbw = 60, + mnCdq = 61, + mnCdqe = 62, + mnCl1invmb = 63, + mnClac = 64, + mnClc = 65, + mnCld = 66, + mnCldemote = 67, + mnClflush = 68, + mnClflushopt = 69, + mnClgi = 70, + mnCli = 71, + mnClrssbsy = 72, + mnClts = 73, + mnClwb = 74, + mnClzero = 75, + mnCmc = 76, + mnCmova = 77, + mnCmovae = 78, + mnCmovb = 79, + mnCmovbe = 80, + mnCmove = 81, + mnCmovg = 82, + mnCmovge = 83, + mnCmovl = 84, + mnCmovle = 85, + mnCmovne = 86, + mnCmovno = 87, + mnCmovnp = 88, + mnCmovns = 89, + mnCmovo = 90, + mnCmovp = 91, + mnCmovs = 92, + mnCmp = 93, + mnCmppd = 94, + mnCmpps = 95, + mnCmpsb = 96, + mnCmpsd = 97, + mnCmpsq = 98, + mnCmpss = 99, + mnCmpsw = 100, + mnCmpxchg = 101, + mnCmpxchg16b = 102, + mnCmpxchg8b = 103, + mnComisd = 104, + mnComiss = 105, + mnCpuid = 106, + mnCqo = 107, + mnCrc32 = 108, + mnCvtdq2pd = 109, + mnCvtdq2ps = 110, + mnCvtpd2dq = 111, + mnCvtpd2pi = 112, + mnCvtpd2ps = 113, + mnCvtpi2pd = 114, + mnCvtpi2ps = 115, + mnCvtps2dq = 116, + mnCvtps2pd = 117, + mnCvtps2pi = 118, + mnCvtsd2si = 119, + mnCvtsd2ss = 120, + mnCvtsi2sd = 121, + mnCvtsi2ss = 122, + mnCvtss2sd = 123, + mnCvtss2si = 124, + mnCvttpd2dq = 125, + mnCvttpd2pi = 126, + mnCvttps2dq = 127, + mnCvttps2pi = 128, + mnCvttsd2si = 129, + mnCvttss2si = 130, + mnCwd = 131, + mnCwde = 132, + mnDaa = 133, + mnDas = 134, + mnDb = 135, + mnDd = 136, + mnDec = 137, + mnDiv = 138, + mnDivpd = 139, + mnDivps = 140, + mnDivsd = 141, + mnDivss = 142, + mnDppd = 143, + mnDpps = 144, + mnDq = 145, + mnDw = 146, + mnEmms = 147, + mnEncls = 148, + mnEnclu = 149, + mnEnclv = 150, + mnEndbr32 = 151, + mnEndbr64 = 152, + mnEnqcmd = 153, + mnEnqcmds = 154, + mnEnter = 155, + mnExtractps = 156, + mnExtrq = 157, + mnF2xm1 = 158, + mnFabs = 159, + mnFadd = 160, + mnFaddp = 161, + mnFbld = 162, + mnFbstp = 163, + mnFchs = 164, + mnFclex = 165, + mnFcmovb = 166, + mnFcmovbe = 167, + mnFcmove = 168, + mnFcmovnb = 169, + mnFcmovnbe = 170, + mnFcmovne = 171, + mnFcmovnu = 172, + mnFcmovu = 173, + mnFcom = 174, + mnFcomi = 175, + mnFcomip = 176, + mnFcomp = 177, + mnFcompp = 178, + mnFcos = 179, + mnFdecstp = 180, + mnFdisi = 181, + mnFdiv = 182, + mnFdivp = 183, + mnFdivr = 184, + mnFdivrp = 185, + mnFemms = 186, + mnFeni = 187, + mnFfree = 188, + mnFfreep = 189, + mnFiadd = 190, + mnFicom = 191, + mnFicomp = 192, + mnFidiv = 193, + mnFidivr = 194, + mnFild = 195, + mnFimul = 196, + mnFincstp = 197, + mnFinit = 198, + mnFist = 199, + mnFistp = 200, + mnFisttp = 201, + mnFisub = 202, + mnFisubr = 203, + mnFld = 204, + mnFld1 = 205, + mnFldcw = 206, + mnFldenv = 207, + mnFldl2e = 208, + mnFldl2t = 209, + mnFldlg2 = 210, + mnFldln2 = 211, + mnFldpi = 212, + mnFldz = 213, + mnFmul = 214, + mnFmulp = 215, + mnFnclex = 216, + mnFndisi = 217, + mnFneni = 218, + mnFninit = 219, + mnFnop = 220, + mnFnsave = 221, + mnFnsetpm = 222, + mnFnstcw = 223, + mnFnstenv = 224, + mnFnstsw = 225, + mnFpatan = 226, + mnFprem = 227, + mnFprem1 = 228, + mnFptan = 229, + mnFrndint = 230, + mnFrstor = 231, + mnFrstpm = 232, + mnFsave = 233, + mnFscale = 234, + mnFsetpm = 235, + mnFsin = 236, + mnFsincos = 237, + mnFsqrt = 238, + mnFst = 239, + mnFstcw = 240, + mnFstdw = 241, + mnFstenv = 242, + mnFstp = 243, + mnFstpnce = 244, + mnFstsg = 245, + mnFstsw = 246, + mnFsub = 247, + mnFsubp = 248, + mnFsubr = 249, + mnFsubrp = 250, + mnFtst = 251, + mnFucom = 252, + mnFucomi = 253, + mnFucomip = 254, + mnFucomp = 255, + mnFucompp = 256, + mnFxam = 257, + mnFxch = 258, + mnFxrstor = 259, + mnFxrstor64 = 260, + mnFxsave = 261, + mnFxsave64 = 262, + mnFxtract = 263, + mnFyl2x = 264, + mnFyl2xp1 = 265, + mnGetsec = 266, + mnGf2p8affineinvqb = 267, + mnGf2p8affineqb = 268, + mnGf2p8mulb = 269, + mnHaddpd = 270, + mnHaddps = 271, + mnHlt = 272, + mnHsubpd = 273, + mnHsubps = 274, + mnIbts = 275, + mnIdiv = 276, + mnImul = 277, + mnIn = 278, + mnInc = 279, + mnIncsspd = 280, + mnIncsspq = 281, + mnInsb = 282, + mnInsd = 283, + mnInsertps = 284, + mnInsertq = 285, + mnInsw = 286, + mnInt = 287, + mnInt1 = 288, + mnInto = 289, + mnInvd = 290, + mnInvept = 291, + mnInvlpg = 292, + mnInvlpga = 293, + mnInvpcid = 294, + mnInvvpid = 295, + mnIret = 296, + mnJa = 297, + mnJae = 298, + mnJb = 299, + mnJbe = 300, + mnJcxz = 301, + mnJe = 302, + mnJecxz = 303, + mnJg = 304, + mnJge = 305, + mnJl = 306, + mnJle = 307, + mnJmp = 308, + mnJmpe = 309, + mnJne = 310, + mnJno = 311, + mnJnp = 312, + mnJns = 313, + mnJo = 314, + mnJp = 315, + mnJrcxz = 316, + mnJs = 317, + mnKaddb = 318, + mnKaddd = 319, + mnKaddq = 320, + mnKaddw = 321, + mnKandb = 322, + mnKandd = 323, + mnKandnb = 324, + mnKandnd = 325, + mnKandnq = 326, + mnKandnw = 327, + mnKandq = 328, + mnKandw = 329, + mnKmovb = 330, + mnKmovd = 331, + mnKmovq = 332, + mnKmovw = 333, + mnKnotb = 334, + mnKnotd = 335, + mnKnotq = 336, + mnKnotw = 337, + mnKorb = 338, + mnKord = 339, + mnKorq = 340, + mnKortestb = 341, + mnKortestd = 342, + mnKortestq = 343, + mnKortestw = 344, + mnKorw = 345, + mnKshiftlb = 346, + mnKshiftld = 347, + mnKshiftlq = 348, + mnKshiftlw = 349, + mnKshiftrb = 350, + mnKshiftrd = 351, + mnKshiftrq = 352, + mnKshiftrw = 353, + mnKtestb = 354, + mnKtestd = 355, + mnKtestq = 356, + mnKtestw = 357, + mnKunpckbw = 358, + mnKunpckdq = 359, + mnKunpckwd = 360, + mnKxnorb = 361, + mnKxnord = 362, + mnKxnorq = 363, + mnKxnorw = 364, + mnKxorb = 365, + mnKxord = 366, + mnKxorq = 367, + mnKxorw = 368, + mnLahf = 369, + mnLar = 370, + mnLddqu = 371, + mnLdmxcsr = 372, + mnLds = 373, + mnLea = 374, + mnLeave = 375, + mnLes = 376, + mnLfence = 377, + mnLfs = 378, + mnLgdt = 379, + mnLgs = 380, + mnLidt = 381, + mnLldt = 382, + mnLlwpcb = 383, + mnLmsw = 384, + mnLoadall = 385, + mnLodsb = 386, + mnLodsd = 387, + mnLodsq = 388, + mnLodsw = 389, + mnLoop = 390, + mnLoope = 391, + mnLoopne = 392, + mnLsl = 393, + mnLss = 394, + mnLtr = 395, + mnLwpins = 396, + mnLwpval = 397, + mnLzcnt = 398, + mnMaskmovdqu = 399, + mnMaskmovq = 400, + mnMaxpd = 401, + mnMaxps = 402, + mnMaxsd = 403, + mnMaxss = 404, + mnMcommit = 405, + mnMfence = 406, + mnMinpd = 407, + mnMinps = 408, + mnMinsd = 409, + mnMinss = 410, + mnMonitor = 411, + mnMonitorx = 412, + mnMontmul = 413, + mnMov = 414, + mnMovapd = 415, + mnMovaps = 416, + mnMovbe = 417, + mnMovd = 418, + mnMovddup = 419, + mnMovdir64b = 420, + mnMovdiri = 421, + mnMovdq2q = 422, + mnMovdqa = 423, + mnMovdqu = 424, + mnMovhlps = 425, + mnMovhpd = 426, + mnMovhps = 427, + mnMovlhps = 428, + mnMovlpd = 429, + mnMovlps = 430, + mnMovmskpd = 431, + mnMovmskps = 432, + mnMovntdq = 433, + mnMovntdqa = 434, + mnMovnti = 435, + mnMovntpd = 436, + mnMovntps = 437, + mnMovntq = 438, + mnMovntsd = 439, + mnMovntss = 440, + mnMovq = 441, + mnMovq2dq = 442, + mnMovsb = 443, + mnMovsd = 444, + mnMovshdup = 445, + mnMovsldup = 446, + mnMovsq = 447, + mnMovss = 448, + mnMovsw = 449, + mnMovsx = 450, + mnMovsxd = 451, + mnMovupd = 452, + mnMovups = 453, + mnMovzx = 454, + mnMpsadbw = 455, + mnMul = 456, + mnMulpd = 457, + mnMulps = 458, + mnMulsd = 459, + mnMulss = 460, + mnMulx = 461, + mnMwait = 462, + mnMwaitx = 463, + mnNeg = 464, + mnNop = 465, + mnNot = 466, + mnOr = 467, + mnOrpd = 468, + mnOrps = 469, + mnOut = 470, + mnOutsb = 471, + mnOutsd = 472, + mnOutsw = 473, + mnPabsb = 474, + mnPabsd = 475, + mnPabsw = 476, + mnPackssdw = 477, + mnPacksswb = 478, + mnPackusdw = 479, + mnPackuswb = 480, + mnPaddb = 481, + mnPaddd = 482, + mnPaddq = 483, + mnPaddsb = 484, + mnPaddsw = 485, + mnPaddusb = 486, + mnPaddusw = 487, + mnPaddw = 488, + mnPalignr = 489, + mnPand = 490, + mnPandn = 491, + mnPause = 492, + mnPavgb = 493, + mnPavgusb = 494, + mnPavgw = 495, + mnPblendvb = 496, + mnPblendw = 497, + mnPclmulqdq = 498, + mnPcmpeqb = 499, + mnPcmpeqd = 500, + mnPcmpeqq = 501, + mnPcmpeqw = 502, + mnPcmpestri = 503, + mnPcmpestri64 = 504, + mnPcmpestrm = 505, + mnPcmpestrm64 = 506, + mnPcmpgtb = 507, + mnPcmpgtd = 508, + mnPcmpgtq = 509, + mnPcmpgtw = 510, + mnPcmpistri = 511, + mnPcmpistrm = 512, + mnPcommit = 513, + mnPconfig = 514, + mnPdep = 515, + mnPext = 516, + mnPextrb = 517, + mnPextrd = 518, + mnPextrq = 519, + mnPextrw = 520, + mnPf2id = 521, + mnPf2iw = 522, + mnPfacc = 523, + mnPfadd = 524, + mnPfcmpeq = 525, + mnPfcmpge = 526, + mnPfcmpgt = 527, + mnPfmax = 528, + mnPfmin = 529, + mnPfmul = 530, + mnPfnacc = 531, + mnPfpnacc = 532, + mnPfrcp = 533, + mnPfrcpit1 = 534, + mnPfrcpit2 = 535, + mnPfrcpv = 536, + mnPfrsqit1 = 537, + mnPfrsqrt = 538, + mnPfrsqrtv = 539, + mnPfsub = 540, + mnPfsubr = 541, + mnPhaddd = 542, + mnPhaddsw = 543, + mnPhaddw = 544, + mnPhminposuw = 545, + mnPhsubd = 546, + mnPhsubsw = 547, + mnPhsubw = 548, + mnPi2fd = 549, + mnPi2fw = 550, + mnPinsrb = 551, + mnPinsrd = 552, + mnPinsrq = 553, + mnPinsrw = 554, + mnPmaddubsw = 555, + mnPmaddwd = 556, + mnPmaxsb = 557, + mnPmaxsd = 558, + mnPmaxsw = 559, + mnPmaxub = 560, + mnPmaxud = 561, + mnPmaxuw = 562, + mnPminsb = 563, + mnPminsd = 564, + mnPminsw = 565, + mnPminub = 566, + mnPminud = 567, + mnPminuw = 568, + mnPmovmskb = 569, + mnPmovsxbd = 570, + mnPmovsxbq = 571, + mnPmovsxbw = 572, + mnPmovsxdq = 573, + mnPmovsxwd = 574, + mnPmovsxwq = 575, + mnPmovzxbd = 576, + mnPmovzxbq = 577, + mnPmovzxbw = 578, + mnPmovzxdq = 579, + mnPmovzxwd = 580, + mnPmovzxwq = 581, + mnPmuldq = 582, + mnPmulhrsw = 583, + mnPmulhrw = 584, + mnPmulhuw = 585, + mnPmulhw = 586, + mnPmulld = 587, + mnPmullw = 588, + mnPmuludq = 589, + mnPop = 590, + mnPopa = 591, + mnPopcnt = 592, + mnPopf = 593, + mnPor = 594, + mnPrefetch = 595, + mnPrefetchnta = 596, + mnPrefetcht0 = 597, + mnPrefetcht1 = 598, + mnPrefetcht2 = 599, + mnPrefetchw = 600, + mnPrefetchwt1 = 601, + mnPsadbw = 602, + mnPshufb = 603, + mnPshufd = 604, + mnPshufhw = 605, + mnPshuflw = 606, + mnPshufw = 607, + mnPsignb = 608, + mnPsignd = 609, + mnPsignw = 610, + mnPslld = 611, + mnPslldq = 612, + mnPsllq = 613, + mnPsllw = 614, + mnPsrad = 615, + mnPsraw = 616, + mnPsrld = 617, + mnPsrldq = 618, + mnPsrlq = 619, + mnPsrlw = 620, + mnPsubb = 621, + mnPsubd = 622, + mnPsubq = 623, + mnPsubsb = 624, + mnPsubsw = 625, + mnPsubusb = 626, + mnPsubusw = 627, + mnPsubw = 628, + mnPswapd = 629, + mnPtest = 630, + mnPtwrite = 631, + mnPunpckhbw = 632, + mnPunpckhdq = 633, + mnPunpckhqdq = 634, + mnPunpckhwd = 635, + mnPunpcklbw = 636, + mnPunpckldq = 637, + mnPunpcklqdq = 638, + mnPunpcklwd = 639, + mnPush = 640, + mnPusha = 641, + mnPushf = 642, + mnPxor = 643, + mnRcl = 644, + mnRcpps = 645, + mnRcpss = 646, + mnRcr = 647, + mnRdfsbase = 648, + mnRdgsbase = 649, + mnRdmsr = 650, + mnRdpid = 651, + mnRdpkru = 652, + mnRdpmc = 653, + mnRdpru = 654, + mnRdrand = 655, + mnRdseed = 656, + mnRdsspd = 657, + mnRdsspq = 658, + mnRdtsc = 659, + mnRdtscp = 660, + mnReservednop = 661, + mnRet = 662, + mnRetf = 663, + mnRol = 664, + mnRor = 665, + mnRorx = 666, + mnRoundpd = 667, + mnRoundps = 668, + mnRoundsd = 669, + mnRoundss = 670, + mnRsm = 671, + mnRsqrtps = 672, + mnRsqrtss = 673, + mnRstorssp = 674, + mnSahf = 675, + mnSal = 676, + mnSalc = 677, + mnSar = 678, + mnSarx = 679, + mnSaveprevssp = 680, + mnSbb = 681, + mnScasb = 682, + mnScasd = 683, + mnScasq = 684, + mnScasw = 685, + mnSeta = 686, + mnSetae = 687, + mnSetb = 688, + mnSetbe = 689, + mnSete = 690, + mnSetg = 691, + mnSetge = 692, + mnSetl = 693, + mnSetle = 694, + mnSetne = 695, + mnSetno = 696, + mnSetnp = 697, + mnSetns = 698, + mnSeto = 699, + mnSetp = 700, + mnSets = 701, + mnSetssbsy = 702, + mnSfence = 703, + mnSgdt = 704, + mnSha1msg1 = 705, + mnSha1msg2 = 706, + mnSha1nexte = 707, + mnSha1rnds4 = 708, + mnSha256msg1 = 709, + mnSha256msg2 = 710, + mnSha256rnds2 = 711, + mnShl = 712, + mnShld = 713, + mnShlx = 714, + mnShr = 715, + mnShrd = 716, + mnShrx = 717, + mnShufpd = 718, + mnShufps = 719, + mnSidt = 720, + mnSkinit = 721, + mnSldt = 722, + mnSlwpcb = 723, + mnSmsw = 724, + mnSqrtpd = 725, + mnSqrtps = 726, + mnSqrtsd = 727, + mnSqrtss = 728, + mnStac = 729, + mnStc = 730, + mnStd = 731, + mnStgi = 732, + mnSti = 733, + mnStmxcsr = 734, + mnStosb = 735, + mnStosd = 736, + mnStosq = 737, + mnStosw = 738, + mnStr = 739, + mnSub = 740, + mnSubpd = 741, + mnSubps = 742, + mnSubsd = 743, + mnSubss = 744, + mnSwapgs = 745, + mnSyscall = 746, + mnSysenter = 747, + mnSysexit = 748, + mnSysret = 749, + mnT1mskc = 750, + mnTest = 751, + mnTpause = 752, + mnTzcnt = 753, + mnTzmsk = 754, + mnUcomisd = 755, + mnUcomiss = 756, + mnUd0 = 757, + mnUd1 = 758, + mnUd2 = 759, + mnUmonitor = 760, + mnUmov = 761, + mnUmwait = 762, + mnUnpckhpd = 763, + mnUnpckhps = 764, + mnUnpcklpd = 765, + mnUnpcklps = 766, + mnV4fmaddps = 767, + mnV4fmaddss = 768, + mnV4fnmaddps = 769, + mnV4fnmaddss = 770, + mnVaddpd = 771, + mnVaddps = 772, + mnVaddsd = 773, + mnVaddss = 774, + mnVaddsubpd = 775, + mnVaddsubps = 776, + mnVaesdec = 777, + mnVaesdeclast = 778, + mnVaesenc = 779, + mnVaesenclast = 780, + mnVaesimc = 781, + mnVaeskeygenassist = 782, + mnValignd = 783, + mnValignq = 784, + mnVandnpd = 785, + mnVandnps = 786, + mnVandpd = 787, + mnVandps = 788, + mnVblendmpd = 789, + mnVblendmps = 790, + mnVblendpd = 791, + mnVblendps = 792, + mnVblendvpd = 793, + mnVblendvps = 794, + mnVbroadcastf128 = 795, + mnVbroadcastf32x2 = 796, + mnVbroadcastf32x4 = 797, + mnVbroadcastf32x8 = 798, + mnVbroadcastf64x2 = 799, + mnVbroadcastf64x4 = 800, + mnVbroadcasti128 = 801, + mnVbroadcasti32x2 = 802, + mnVbroadcasti32x4 = 803, + mnVbroadcasti32x8 = 804, + mnVbroadcasti64x2 = 805, + mnVbroadcasti64x4 = 806, + mnVbroadcastsd = 807, + mnVbroadcastss = 808, + mnVcmppd = 809, + mnVcmpps = 810, + mnVcmpsd = 811, + mnVcmpss = 812, + mnVcomisd = 813, + mnVcomiss = 814, + mnVcompresspd = 815, + mnVcompressps = 816, + mnVcvtdq2pd = 817, + mnVcvtdq2ps = 818, + mnVcvtne2ps2bf16 = 819, + mnVcvtneps2bf16 = 820, + mnVcvtpd2dq = 821, + mnVcvtpd2ps = 822, + mnVcvtpd2qq = 823, + mnVcvtpd2udq = 824, + mnVcvtpd2uqq = 825, + mnVcvtph2ps = 826, + mnVcvtps2dq = 827, + mnVcvtps2pd = 828, + mnVcvtps2ph = 829, + mnVcvtps2qq = 830, + mnVcvtps2udq = 831, + mnVcvtps2uqq = 832, + mnVcvtqq2pd = 833, + mnVcvtqq2ps = 834, + mnVcvtsd2si = 835, + mnVcvtsd2ss = 836, + mnVcvtsd2usi = 837, + mnVcvtsi2sd = 838, + mnVcvtsi2ss = 839, + mnVcvtss2sd = 840, + mnVcvtss2si = 841, + mnVcvtss2usi = 842, + mnVcvttpd2dq = 843, + mnVcvttpd2qq = 844, + mnVcvttpd2udq = 845, + mnVcvttpd2uqq = 846, + mnVcvttps2dq = 847, + mnVcvttps2qq = 848, + mnVcvttps2udq = 849, + mnVcvttps2uqq = 850, + mnVcvttsd2si = 851, + mnVcvttsd2usi = 852, + mnVcvttss2si = 853, + mnVcvttss2usi = 854, + mnVcvtudq2pd = 855, + mnVcvtudq2ps = 856, + mnVcvtuqq2pd = 857, + mnVcvtuqq2ps = 858, + mnVcvtusi2sd = 859, + mnVcvtusi2ss = 860, + mnVdbpsadbw = 861, + mnVdivpd = 862, + mnVdivps = 863, + mnVdivsd = 864, + mnVdivss = 865, + mnVdpbf16ps = 866, + mnVdppd = 867, + mnVdpps = 868, + mnVerr = 869, + mnVerw = 870, + mnVexp2pd = 871, + mnVexp2ps = 872, + mnVexpandpd = 873, + mnVexpandps = 874, + mnVextractf128 = 875, + mnVextractf32x4 = 876, + mnVextractf32x8 = 877, + mnVextractf64x2 = 878, + mnVextractf64x4 = 879, + mnVextracti128 = 880, + mnVextracti32x4 = 881, + mnVextracti32x8 = 882, + mnVextracti64x2 = 883, + mnVextracti64x4 = 884, + mnVextractps = 885, + mnVfixupimmpd = 886, + mnVfixupimmps = 887, + mnVfixupimmsd = 888, + mnVfixupimmss = 889, + mnVfmadd132pd = 890, + mnVfmadd132ps = 891, + mnVfmadd132sd = 892, + mnVfmadd132ss = 893, + mnVfmadd213pd = 894, + mnVfmadd213ps = 895, + mnVfmadd213sd = 896, + mnVfmadd213ss = 897, + mnVfmadd231pd = 898, + mnVfmadd231ps = 899, + mnVfmadd231sd = 900, + mnVfmadd231ss = 901, + mnVfmaddpd = 902, + mnVfmaddps = 903, + mnVfmaddsd = 904, + mnVfmaddss = 905, + mnVfmaddsub132pd = 906, + mnVfmaddsub132ps = 907, + mnVfmaddsub213pd = 908, + mnVfmaddsub213ps = 909, + mnVfmaddsub231pd = 910, + mnVfmaddsub231ps = 911, + mnVfmaddsubpd = 912, + mnVfmaddsubps = 913, + mnVfmsub132pd = 914, + mnVfmsub132ps = 915, + mnVfmsub132sd = 916, + mnVfmsub132ss = 917, + mnVfmsub213pd = 918, + mnVfmsub213ps = 919, + mnVfmsub213sd = 920, + mnVfmsub213ss = 921, + mnVfmsub231pd = 922, + mnVfmsub231ps = 923, + mnVfmsub231sd = 924, + mnVfmsub231ss = 925, + mnVfmsubadd132pd = 926, + mnVfmsubadd132ps = 927, + mnVfmsubadd213pd = 928, + mnVfmsubadd213ps = 929, + mnVfmsubadd231pd = 930, + mnVfmsubadd231ps = 931, + mnVfmsubaddpd = 932, + mnVfmsubaddps = 933, + mnVfmsubpd = 934, + mnVfmsubps = 935, + mnVfmsubsd = 936, + mnVfmsubss = 937, + mnVfnmadd132pd = 938, + mnVfnmadd132ps = 939, + mnVfnmadd132sd = 940, + mnVfnmadd132ss = 941, + mnVfnmadd213pd = 942, + mnVfnmadd213ps = 943, + mnVfnmadd213sd = 944, + mnVfnmadd213ss = 945, + mnVfnmadd231pd = 946, + mnVfnmadd231ps = 947, + mnVfnmadd231sd = 948, + mnVfnmadd231ss = 949, + mnVfnmaddpd = 950, + mnVfnmaddps = 951, + mnVfnmaddsd = 952, + mnVfnmaddss = 953, + mnVfnmsub132pd = 954, + mnVfnmsub132ps = 955, + mnVfnmsub132sd = 956, + mnVfnmsub132ss = 957, + mnVfnmsub213pd = 958, + mnVfnmsub213ps = 959, + mnVfnmsub213sd = 960, + mnVfnmsub213ss = 961, + mnVfnmsub231pd = 962, + mnVfnmsub231ps = 963, + mnVfnmsub231sd = 964, + mnVfnmsub231ss = 965, + mnVfnmsubpd = 966, + mnVfnmsubps = 967, + mnVfnmsubsd = 968, + mnVfnmsubss = 969, + mnVfpclasspd = 970, + mnVfpclassps = 971, + mnVfpclasssd = 972, + mnVfpclassss = 973, + mnVfrczpd = 974, + mnVfrczps = 975, + mnVfrczsd = 976, + mnVfrczss = 977, + mnVgatherdpd = 978, + mnVgatherdps = 979, + mnVgatherpf0dpd = 980, + mnVgatherpf0dps = 981, + mnVgatherpf0qpd = 982, + mnVgatherpf0qps = 983, + mnVgatherpf1dpd = 984, + mnVgatherpf1dps = 985, + mnVgatherpf1qpd = 986, + mnVgatherpf1qps = 987, + mnVgatherqpd = 988, + mnVgatherqps = 989, + mnVgetexppd = 990, + mnVgetexpps = 991, + mnVgetexpsd = 992, + mnVgetexpss = 993, + mnVgetmantpd = 994, + mnVgetmantps = 995, + mnVgetmantsd = 996, + mnVgetmantss = 997, + mnVgf2p8affineinvqb = 998, + mnVgf2p8affineqb = 999, + mnVgf2p8mulb = 1000, + mnVhaddpd = 1001, + mnVhaddps = 1002, + mnVhsubpd = 1003, + mnVhsubps = 1004, + mnVinsertf128 = 1005, + mnVinsertf32x4 = 1006, + mnVinsertf32x8 = 1007, + mnVinsertf64x2 = 1008, + mnVinsertf64x4 = 1009, + mnVinserti128 = 1010, + mnVinserti32x4 = 1011, + mnVinserti32x8 = 1012, + mnVinserti64x2 = 1013, + mnVinserti64x4 = 1014, + mnVinsertps = 1015, + mnVlddqu = 1016, + mnVldmxcsr = 1017, + mnVmaskmovdqu = 1018, + mnVmaskmovpd = 1019, + mnVmaskmovps = 1020, + mnVmaxpd = 1021, + mnVmaxps = 1022, + mnVmaxsd = 1023, + mnVmaxss = 1024, + mnVmcall = 1025, + mnVmclear = 1026, + mnVmfunc = 1027, + mnVminpd = 1028, + mnVminps = 1029, + mnVminsd = 1030, + mnVminss = 1031, + mnVmlaunch = 1032, + mnVmload = 1033, + mnVmmcall = 1034, + mnVmovapd = 1035, + mnVmovaps = 1036, + mnVmovd = 1037, + mnVmovddup = 1038, + mnVmovdqa = 1039, + mnVmovdqa32 = 1040, + mnVmovdqa64 = 1041, + mnVmovdqu = 1042, + mnVmovdqu16 = 1043, + mnVmovdqu32 = 1044, + mnVmovdqu64 = 1045, + mnVmovdqu8 = 1046, + mnVmovhlps = 1047, + mnVmovhpd = 1048, + mnVmovhps = 1049, + mnVmovlhps = 1050, + mnVmovlpd = 1051, + mnVmovlps = 1052, + mnVmovmskpd = 1053, + mnVmovmskps = 1054, + mnVmovntdq = 1055, + mnVmovntdqa = 1056, + mnVmovntpd = 1057, + mnVmovntps = 1058, + mnVmovq = 1059, + mnVmovsd = 1060, + mnVmovshdup = 1061, + mnVmovsldup = 1062, + mnVmovss = 1063, + mnVmovupd = 1064, + mnVmovups = 1065, + mnVmpsadbw = 1066, + mnVmptrld = 1067, + mnVmptrst = 1068, + mnVmread = 1069, + mnVmresume = 1070, + mnVmrun = 1071, + mnVmsave = 1072, + mnVmulpd = 1073, + mnVmulps = 1074, + mnVmulsd = 1075, + mnVmulss = 1076, + mnVmwrite = 1077, + mnVmxoff = 1078, + mnVmxon = 1079, + mnVorpd = 1080, + mnVorps = 1081, + mnVp2intersectd = 1082, + mnVp2intersectq = 1083, + mnVp4dpwssd = 1084, + mnVp4dpwssds = 1085, + mnVpabsb = 1086, + mnVpabsd = 1087, + mnVpabsq = 1088, + mnVpabsw = 1089, + mnVpackssdw = 1090, + mnVpacksswb = 1091, + mnVpackusdw = 1092, + mnVpackuswb = 1093, + mnVpaddb = 1094, + mnVpaddd = 1095, + mnVpaddq = 1096, + mnVpaddsb = 1097, + mnVpaddsw = 1098, + mnVpaddusb = 1099, + mnVpaddusw = 1100, + mnVpaddw = 1101, + mnVpalignr = 1102, + mnVpand = 1103, + mnVpandd = 1104, + mnVpandn = 1105, + mnVpandnd = 1106, + mnVpandnq = 1107, + mnVpandq = 1108, + mnVpavgb = 1109, + mnVpavgw = 1110, + mnVpblendd = 1111, + mnVpblendmb = 1112, + mnVpblendmd = 1113, + mnVpblendmq = 1114, + mnVpblendmw = 1115, + mnVpblendvb = 1116, + mnVpblendw = 1117, + mnVpbroadcastb = 1118, + mnVpbroadcastd = 1119, + mnVpbroadcastmb2q = 1120, + mnVpbroadcastmw2d = 1121, + mnVpbroadcastq = 1122, + mnVpbroadcastw = 1123, + mnVpclmulqdq = 1124, + mnVpcmov = 1125, + mnVpcmpb = 1126, + mnVpcmpd = 1127, + mnVpcmpeqb = 1128, + mnVpcmpeqd = 1129, + mnVpcmpeqq = 1130, + mnVpcmpeqw = 1131, + mnVpcmpestri = 1132, + mnVpcmpestri64 = 1133, + mnVpcmpestrm = 1134, + mnVpcmpestrm64 = 1135, + mnVpcmpgtb = 1136, + mnVpcmpgtd = 1137, + mnVpcmpgtq = 1138, + mnVpcmpgtw = 1139, + mnVpcmpistri = 1140, + mnVpcmpistrm = 1141, + mnVpcmpq = 1142, + mnVpcmpub = 1143, + mnVpcmpud = 1144, + mnVpcmpuq = 1145, + mnVpcmpuw = 1146, + mnVpcmpw = 1147, + mnVpcomb = 1148, + mnVpcomd = 1149, + mnVpcompressb = 1150, + mnVpcompressd = 1151, + mnVpcompressq = 1152, + mnVpcompressw = 1153, + mnVpcomq = 1154, + mnVpcomub = 1155, + mnVpcomud = 1156, + mnVpcomuq = 1157, + mnVpcomuw = 1158, + mnVpcomw = 1159, + mnVpconflictd = 1160, + mnVpconflictq = 1161, + mnVpdpbusd = 1162, + mnVpdpbusds = 1163, + mnVpdpwssd = 1164, + mnVpdpwssds = 1165, + mnVperm2f128 = 1166, + mnVperm2i128 = 1167, + mnVpermb = 1168, + mnVpermd = 1169, + mnVpermi2b = 1170, + mnVpermi2d = 1171, + mnVpermi2pd = 1172, + mnVpermi2ps = 1173, + mnVpermi2q = 1174, + mnVpermi2w = 1175, + mnVpermil2pd = 1176, + mnVpermil2ps = 1177, + mnVpermilpd = 1178, + mnVpermilps = 1179, + mnVpermpd = 1180, + mnVpermps = 1181, + mnVpermq = 1182, + mnVpermt2b = 1183, + mnVpermt2d = 1184, + mnVpermt2pd = 1185, + mnVpermt2ps = 1186, + mnVpermt2q = 1187, + mnVpermt2w = 1188, + mnVpermw = 1189, + mnVpexpandb = 1190, + mnVpexpandd = 1191, + mnVpexpandq = 1192, + mnVpexpandw = 1193, + mnVpextrb = 1194, + mnVpextrd = 1195, + mnVpextrq = 1196, + mnVpextrw = 1197, + mnVpgatherdd = 1198, + mnVpgatherdq = 1199, + mnVpgatherqd = 1200, + mnVpgatherqq = 1201, + mnVphaddbd = 1202, + mnVphaddbq = 1203, + mnVphaddbw = 1204, + mnVphaddd = 1205, + mnVphadddq = 1206, + mnVphaddsw = 1207, + mnVphaddubd = 1208, + mnVphaddubq = 1209, + mnVphaddubw = 1210, + mnVphaddudq = 1211, + mnVphadduwd = 1212, + mnVphadduwq = 1213, + mnVphaddw = 1214, + mnVphaddwd = 1215, + mnVphaddwq = 1216, + mnVphminposuw = 1217, + mnVphsubbw = 1218, + mnVphsubd = 1219, + mnVphsubdq = 1220, + mnVphsubsw = 1221, + mnVphsubw = 1222, + mnVphsubwd = 1223, + mnVpinsrb = 1224, + mnVpinsrd = 1225, + mnVpinsrq = 1226, + mnVpinsrw = 1227, + mnVplzcntd = 1228, + mnVplzcntq = 1229, + mnVpmacsdd = 1230, + mnVpmacsdqh = 1231, + mnVpmacsdql = 1232, + mnVpmacssdd = 1233, + mnVpmacssdqh = 1234, + mnVpmacssdql = 1235, + mnVpmacsswd = 1236, + mnVpmacssww = 1237, + mnVpmacswd = 1238, + mnVpmacsww = 1239, + mnVpmadcsswd = 1240, + mnVpmadcswd = 1241, + mnVpmadd52huq = 1242, + mnVpmadd52luq = 1243, + mnVpmaddubsw = 1244, + mnVpmaddwd = 1245, + mnVpmaskmovd = 1246, + mnVpmaskmovq = 1247, + mnVpmaxsb = 1248, + mnVpmaxsd = 1249, + mnVpmaxsq = 1250, + mnVpmaxsw = 1251, + mnVpmaxub = 1252, + mnVpmaxud = 1253, + mnVpmaxuq = 1254, + mnVpmaxuw = 1255, + mnVpminsb = 1256, + mnVpminsd = 1257, + mnVpminsq = 1258, + mnVpminsw = 1259, + mnVpminub = 1260, + mnVpminud = 1261, + mnVpminuq = 1262, + mnVpminuw = 1263, + mnVpmovb2m = 1264, + mnVpmovd2m = 1265, + mnVpmovdb = 1266, + mnVpmovdw = 1267, + mnVpmovm2b = 1268, + mnVpmovm2d = 1269, + mnVpmovm2q = 1270, + mnVpmovm2w = 1271, + mnVpmovmskb = 1272, + mnVpmovq2m = 1273, + mnVpmovqb = 1274, + mnVpmovqd = 1275, + mnVpmovqw = 1276, + mnVpmovsdb = 1277, + mnVpmovsdw = 1278, + mnVpmovsqb = 1279, + mnVpmovsqd = 1280, + mnVpmovsqw = 1281, + mnVpmovswb = 1282, + mnVpmovsxbd = 1283, + mnVpmovsxbq = 1284, + mnVpmovsxbw = 1285, + mnVpmovsxdq = 1286, + mnVpmovsxwd = 1287, + mnVpmovsxwq = 1288, + mnVpmovusdb = 1289, + mnVpmovusdw = 1290, + mnVpmovusqb = 1291, + mnVpmovusqd = 1292, + mnVpmovusqw = 1293, + mnVpmovuswb = 1294, + mnVpmovw2m = 1295, + mnVpmovwb = 1296, + mnVpmovzxbd = 1297, + mnVpmovzxbq = 1298, + mnVpmovzxbw = 1299, + mnVpmovzxdq = 1300, + mnVpmovzxwd = 1301, + mnVpmovzxwq = 1302, + mnVpmuldq = 1303, + mnVpmulhrsw = 1304, + mnVpmulhuw = 1305, + mnVpmulhw = 1306, + mnVpmulld = 1307, + mnVpmullq = 1308, + mnVpmullw = 1309, + mnVpmultishiftqb = 1310, + mnVpmuludq = 1311, + mnVpopcntb = 1312, + mnVpopcntd = 1313, + mnVpopcntq = 1314, + mnVpopcntw = 1315, + mnVpor = 1316, + mnVpord = 1317, + mnVporq = 1318, + mnVpperm = 1319, + mnVprold = 1320, + mnVprolq = 1321, + mnVprolvd = 1322, + mnVprolvq = 1323, + mnVprord = 1324, + mnVprorq = 1325, + mnVprorvd = 1326, + mnVprorvq = 1327, + mnVprotb = 1328, + mnVprotd = 1329, + mnVprotq = 1330, + mnVprotw = 1331, + mnVpsadbw = 1332, + mnVpscatterdd = 1333, + mnVpscatterdq = 1334, + mnVpscatterqd = 1335, + mnVpscatterqq = 1336, + mnVpshab = 1337, + mnVpshad = 1338, + mnVpshaq = 1339, + mnVpshaw = 1340, + mnVpshlb = 1341, + mnVpshld = 1342, + mnVpshldd = 1343, + mnVpshldq = 1344, + mnVpshldvd = 1345, + mnVpshldvq = 1346, + mnVpshldvw = 1347, + mnVpshldw = 1348, + mnVpshlq = 1349, + mnVpshlw = 1350, + mnVpshrdd = 1351, + mnVpshrdq = 1352, + mnVpshrdvd = 1353, + mnVpshrdvq = 1354, + mnVpshrdvw = 1355, + mnVpshrdw = 1356, + mnVpshufb = 1357, + mnVpshufbitqmb = 1358, + mnVpshufd = 1359, + mnVpshufhw = 1360, + mnVpshuflw = 1361, + mnVpsignb = 1362, + mnVpsignd = 1363, + mnVpsignw = 1364, + mnVpslld = 1365, + mnVpslldq = 1366, + mnVpsllq = 1367, + mnVpsllvd = 1368, + mnVpsllvq = 1369, + mnVpsllvw = 1370, + mnVpsllw = 1371, + mnVpsrad = 1372, + mnVpsraq = 1373, + mnVpsravd = 1374, + mnVpsravq = 1375, + mnVpsravw = 1376, + mnVpsraw = 1377, + mnVpsrld = 1378, + mnVpsrldq = 1379, + mnVpsrlq = 1380, + mnVpsrlvd = 1381, + mnVpsrlvq = 1382, + mnVpsrlvw = 1383, + mnVpsrlw = 1384, + mnVpsubb = 1385, + mnVpsubd = 1386, + mnVpsubq = 1387, + mnVpsubsb = 1388, + mnVpsubsw = 1389, + mnVpsubusb = 1390, + mnVpsubusw = 1391, + mnVpsubw = 1392, + mnVpternlogd = 1393, + mnVpternlogq = 1394, + mnVptest = 1395, + mnVptestmb = 1396, + mnVptestmd = 1397, + mnVptestmq = 1398, + mnVptestmw = 1399, + mnVptestnmb = 1400, + mnVptestnmd = 1401, + mnVptestnmq = 1402, + mnVptestnmw = 1403, + mnVpunpckhbw = 1404, + mnVpunpckhdq = 1405, + mnVpunpckhqdq = 1406, + mnVpunpckhwd = 1407, + mnVpunpcklbw = 1408, + mnVpunpckldq = 1409, + mnVpunpcklqdq = 1410, + mnVpunpcklwd = 1411, + mnVpxor = 1412, + mnVpxord = 1413, + mnVpxorq = 1414, + mnVrangepd = 1415, + mnVrangeps = 1416, + mnVrangesd = 1417, + mnVrangess = 1418, + mnVrcp14pd = 1419, + mnVrcp14ps = 1420, + mnVrcp14sd = 1421, + mnVrcp14ss = 1422, + mnVrcp28pd = 1423, + mnVrcp28ps = 1424, + mnVrcp28sd = 1425, + mnVrcp28ss = 1426, + mnVrcpps = 1427, + mnVrcpss = 1428, + mnVreducepd = 1429, + mnVreduceps = 1430, + mnVreducesd = 1431, + mnVreducess = 1432, + mnVrndscalepd = 1433, + mnVrndscaleps = 1434, + mnVrndscalesd = 1435, + mnVrndscaless = 1436, + mnVroundpd = 1437, + mnVroundps = 1438, + mnVroundsd = 1439, + mnVroundss = 1440, + mnVrsqrt14pd = 1441, + mnVrsqrt14ps = 1442, + mnVrsqrt14sd = 1443, + mnVrsqrt14ss = 1444, + mnVrsqrt28pd = 1445, + mnVrsqrt28ps = 1446, + mnVrsqrt28sd = 1447, + mnVrsqrt28ss = 1448, + mnVrsqrtps = 1449, + mnVrsqrtss = 1450, + mnVscalefpd = 1451, + mnVscalefps = 1452, + mnVscalefsd = 1453, + mnVscalefss = 1454, + mnVscatterdpd = 1455, + mnVscatterdps = 1456, + mnVscatterpf0dpd = 1457, + mnVscatterpf0dps = 1458, + mnVscatterpf0qpd = 1459, + mnVscatterpf0qps = 1460, + mnVscatterpf1dpd = 1461, + mnVscatterpf1dps = 1462, + mnVscatterpf1qpd = 1463, + mnVscatterpf1qps = 1464, + mnVscatterqpd = 1465, + mnVscatterqps = 1466, + mnVshuff32x4 = 1467, + mnVshuff64x2 = 1468, + mnVshufi32x4 = 1469, + mnVshufi64x2 = 1470, + mnVshufpd = 1471, + mnVshufps = 1472, + mnVsqrtpd = 1473, + mnVsqrtps = 1474, + mnVsqrtsd = 1475, + mnVsqrtss = 1476, + mnVstmxcsr = 1477, + mnVsubpd = 1478, + mnVsubps = 1479, + mnVsubsd = 1480, + mnVsubss = 1481, + mnVtestpd = 1482, + mnVtestps = 1483, + mnVucomisd = 1484, + mnVucomiss = 1485, + mnVunpckhpd = 1486, + mnVunpckhps = 1487, + mnVunpcklpd = 1488, + mnVunpcklps = 1489, + mnVxorpd = 1490, + mnVxorps = 1491, + mnVzeroall = 1492, + mnVzeroupper = 1493, + mnWait = 1494, + mnWbinvd = 1495, + mnWbnoinvd = 1496, + mnWrfsbase = 1497, + mnWrgsbase = 1498, + mnWrmsr = 1499, + mnWrpkru = 1500, + mnWrssd = 1501, + mnWrssq = 1502, + mnWrussd = 1503, + mnWrussq = 1504, + mnXabort = 1505, + mnXadd = 1506, + mnXbegin = 1507, + mnXbts = 1508, + mnXchg = 1509, + mnXcryptcbc = 1510, + mnXcryptcfb = 1511, + mnXcryptctr = 1512, + mnXcryptecb = 1513, + mnXcryptofb = 1514, + mnXend = 1515, + mnXgetbv = 1516, + mnXlatb = 1517, + mnXor = 1518, + mnXorpd = 1519, + mnXorps = 1520, + mnXrstor = 1521, + mnXrstor64 = 1522, + mnXrstors = 1523, + mnXrstors64 = 1524, + mnXsave = 1525, + mnXsave64 = 1526, + mnXsavec = 1527, + mnXsavec64 = 1528, + mnXsaveopt = 1529, + mnXsaveopt64 = 1530, + mnXsaves = 1531, + mnXsaves64 = 1532, + mnXsetbv = 1533, + mnXsha1 = 1534, + mnXsha256 = 1535, + mnXstore = 1536, + mnXtest = 1537, + mnRmpadjust = 1538, + mnRmpupdate = 1539, + mnPsmash = 1540, + mnPvalidate = 1541, + mnSerialize = 1542, + mnXsusldtrk = 1543, + mnXresldtrk = 1544, + mnInvlpgb = 1545, + mnTlbsync = 1546, + mnVmgexit = 1547, + mnGetsecq = 1548, + mnSysexitq = 1549, + mnLdtilecfg = 1550, + mnTilerelease = 1551, + mnSttilecfg = 1552, + mnTilezero = 1553, + mnTileloaddt1 = 1554, + mnTilestored = 1555, + mnTileloadd = 1556, + mnTdpbf16ps = 1557, + mnTdpbuud = 1558, + mnTdpbusd = 1559, + mnTdpbsud = 1560, + mnTdpbssd = 1561, + mnSysretq = 1562, + mnFnstdw = 1563, + mnFnstsg = 1564, + mnRdshr = 1565, + mnWrshr = 1566, + mnSmint = 1567, + mnDmint = 1568, + mnRdm = 1569, + mnSvdc = 1570, + mnRsdc = 1571, + mnSvldt = 1572, + mnRsldt = 1573, + mnSvts = 1574, + mnRsts = 1575, + mnBb0_reset = 1576, + mnBb1_reset = 1577, + mnCpu_write = 1578, + mnCpu_read = 1579, + mnAltinst = 1580, + mnPaveb = 1581, + mnPaddsiw = 1582, + mnPmagw = 1583, + mnPdistib = 1584, + mnPsubsiw = 1585, + mnPmvzb = 1586, + mnPmvnzb = 1587, + mnPmvlzb = 1588, + mnPmvgezb = 1589, + mnPmulhriw = 1590, + mnPmachriw = 1591, + mnFtstp = 1592, + mnFrint2 = 1593, + mnFrichop = 1594, + mnFrinear = 1595, + mnUndoc = 1596, + mnTdcall = 1597, + mnSeamret = 1598, + mnSeamops = 1599, + mnSeamcall = 1600, + mnAesencwide128kl = 1601, + mnAesdecwide128kl = 1602, + mnAesencwide256kl = 1603, + mnAesdecwide256kl = 1604, + mnLoadiwkey = 1605, + mnAesenc128kl = 1606, + mnAesdec128kl = 1607, + mnAesenc256kl = 1608, + mnAesdec256kl = 1609, + mnEncodekey128 = 1610, + mnEncodekey256 = 1611, + mnPushad = 1612, + mnPopad = 1613, + mnPushfd = 1614, + mnPushfq = 1615, + mnPopfd = 1616, + mnPopfq = 1617, + mnIretd = 1618, + mnIretq = 1619, + mnInt3 = 1620, + mnUiret = 1621, + mnTestui = 1622, + mnClui = 1623, + mnStui = 1624, + mnSenduipi = 1625, + mnHreset = 1626, + mnCcs_hash = 1627, + mnCcs_encrypt = 1628, + mnLkgs = 1629, + mnEretu = 1630, + mnErets = 1631, + mnStoreall = 1632, + mnVaddph = 1633, + mnVaddsh = 1634, + mnVcmpph = 1635, + mnVcmpsh = 1636, + mnVcomish = 1637, + mnVcvtdq2ph = 1638, + mnVcvtpd2ph = 1639, + mnVcvtph2dq = 1640, + mnVcvtph2pd = 1641, + mnVcvtph2psx = 1642, + mnVcvtph2qq = 1643, + mnVcvtph2udq = 1644, + mnVcvtph2uqq = 1645, + mnVcvtph2uw = 1646, + mnVcvtph2w = 1647, + mnVcvtps2phx = 1648, + mnVcvtqq2ph = 1649, + mnVcvtsd2sh = 1650, + mnVcvtsh2sd = 1651, + mnVcvtsh2si = 1652, + mnVcvtsh2ss = 1653, + mnVcvtsh2usi = 1654, + mnVcvtsi2sh = 1655, + mnVcvtss2sh = 1656, + mnVcvttph2dq = 1657, + mnVcvttph2qq = 1658, + mnVcvttph2udq = 1659, + mnVcvttph2uqq = 1660, + mnVcvttph2uw = 1661, + mnVcvttph2w = 1662, + mnVcvttsh2si = 1663, + mnVcvttsh2usi = 1664, + mnVcvtudq2ph = 1665, + mnVcvtuqq2ph = 1666, + mnVcvtusi2sh = 1667, + mnVcvtuw2ph = 1668, + mnVcvtw2ph = 1669, + mnVdivph = 1670, + mnVdivsh = 1671, + mnVfcmaddcph = 1672, + mnVfmaddcph = 1673, + mnVfcmaddcsh = 1674, + mnVfmaddcsh = 1675, + mnVfcmulcph = 1676, + mnVfmulcph = 1677, + mnVfcmulcsh = 1678, + mnVfmulcsh = 1679, + mnVfmaddsub132ph = 1680, + mnVfmaddsub213ph = 1681, + mnVfmaddsub231ph = 1682, + mnVfmsubadd132ph = 1683, + mnVfmsubadd213ph = 1684, + mnVfmsubadd231ph = 1685, + mnVfmadd132ph = 1686, + mnVfmadd213ph = 1687, + mnVfmadd231ph = 1688, + mnVfnmadd132ph = 1689, + mnVfnmadd213ph = 1690, + mnVfnmadd231ph = 1691, + mnVfmadd132sh = 1692, + mnVfmadd213sh = 1693, + mnVfmadd231sh = 1694, + mnVfnmadd132sh = 1695, + mnVfnmadd213sh = 1696, + mnVfnmadd231sh = 1697, + mnVfmsub132ph = 1698, + mnVfmsub213ph = 1699, + mnVfmsub231ph = 1700, + mnVfnmsub132ph = 1701, + mnVfnmsub213ph = 1702, + mnVfnmsub231ph = 1703, + mnVfmsub132sh = 1704, + mnVfmsub213sh = 1705, + mnVfmsub231sh = 1706, + mnVfnmsub132sh = 1707, + mnVfnmsub213sh = 1708, + mnVfnmsub231sh = 1709, + mnVfpclassph = 1710, + mnVfpclasssh = 1711, + mnVgetexpph = 1712, + mnVgetexpsh = 1713, + mnVgetmantph = 1714, + mnVgetmantsh = 1715, + mnVmaxph = 1716, + mnVmaxsh = 1717, + mnVminph = 1718, + mnVminsh = 1719, + mnVmovsh = 1720, + mnVmovw = 1721, + mnVmulph = 1722, + mnVmulsh = 1723, + mnVrcpph = 1724, + mnVrcpsh = 1725, + mnVreduceph = 1726, + mnVreducesh = 1727, + mnVrndscaleph = 1728, + mnVrndscalesh = 1729, + mnVrsqrtph = 1730, + mnVrsqrtsh = 1731, + mnVscalefph = 1732, + mnVscalefsh = 1733, + mnVsqrtph = 1734, + mnVsqrtsh = 1735, + mnVsubph = 1736, + mnVsubsh = 1737, + mnVucomish = 1738, + mnRdudbg = 1739, + mnWrudbg = 1740, + mnClevict0 = 1741, + mnClevict1 = 1742, + mnDelay = 1743, + mnJknzd = 1744, + mnJkzd = 1745, + mnKand = 1746, + mnKandn = 1747, + mnKandnr = 1748, + mnKconcath = 1749, + mnKconcatl = 1750, + mnKextract = 1751, + mnKmerge2l1h = 1752, + mnKmerge2l1l = 1753, + mnKmov = 1754, + mnKnot = 1755, + mnKor = 1756, + mnKortest = 1757, + mnKxnor = 1758, + mnKxor = 1759, + mnSpflt = 1760, + mnTzcnti = 1761, + mnVaddnpd = 1762, + mnVaddnps = 1763, + mnVaddsetsps = 1764, + mnVcvtfxpntdq2ps = 1765, + mnVcvtfxpntpd2dq = 1766, + mnVcvtfxpntpd2udq = 1767, + mnVcvtfxpntps2dq = 1768, + mnVcvtfxpntps2udq = 1769, + mnVcvtfxpntudq2ps = 1770, + mnVexp223ps = 1771, + mnVfixupnanpd = 1772, + mnVfixupnanps = 1773, + mnVfmadd233ps = 1774, + mnVgatherpf0hintdpd = 1775, + mnVgatherpf0hintdps = 1776, + mnVgmaxabsps = 1777, + mnVgmaxpd = 1778, + mnVgmaxps = 1779, + mnVgminpd = 1780, + mnVgminps = 1781, + mnVloadunpackhd = 1782, + mnVloadunpackhpd = 1783, + mnVloadunpackhps = 1784, + mnVloadunpackhq = 1785, + mnVloadunpackld = 1786, + mnVloadunpacklpd = 1787, + mnVloadunpacklps = 1788, + mnVloadunpacklq = 1789, + mnVlog2ps = 1790, + mnVmovnrapd = 1791, + mnVmovnraps = 1792, + mnVmovnrngoapd = 1793, + mnVmovnrngoaps = 1794, + mnVpackstorehd = 1795, + mnVpackstorehpd = 1796, + mnVpackstorehps = 1797, + mnVpackstorehq = 1798, + mnVpackstoreld = 1799, + mnVpackstorelpd = 1800, + mnVpackstorelps = 1801, + mnVpackstorelq = 1802, + mnVpadcd = 1803, + mnVpaddsetcd = 1804, + mnVpaddsetsd = 1805, + mnVpcmpltd = 1806, + mnVpermf32x4 = 1807, + mnVpmadd231d = 1808, + mnVpmadd233d = 1809, + mnVpmulhd = 1810, + mnVpmulhud = 1811, + mnVprefetch0 = 1812, + mnVprefetch1 = 1813, + mnVprefetch2 = 1814, + mnVprefetche0 = 1815, + mnVprefetche1 = 1816, + mnVprefetche2 = 1817, + mnVprefetchenta = 1818, + mnVprefetchnta = 1819, + mnVpsbbd = 1820, + mnVpsbbrd = 1821, + mnVpsubrd = 1822, + mnVpsubrsetbd = 1823, + mnVpsubsetbd = 1824, + mnVrcp23ps = 1825, + mnVrndfxpntpd = 1826, + mnVrndfxpntps = 1827, + mnVrsqrt23ps = 1828, + mnVscaleps = 1829, + mnVscatterpf0hintdpd = 1830, + mnVscatterpf0hintdps = 1831, + mnVsubrpd = 1832, + mnVsubrps = 1833, + mnXsha512 = 1834, + mnXstore_alt = 1835, + mnXsha512_alt = 1836, + mnZero_bytes = 1837, + mnAadd = 1838, + mnAand = 1839, + mnAor = 1840, + mnAxor = 1841, + mnCmpbexadd = 1842, + mnCmpbxadd = 1843, + mnCmplexadd = 1844, + mnCmplxadd = 1845, + mnCmpnbexadd = 1846, + mnCmpnbxadd = 1847, + mnCmpnlexadd = 1848, + mnCmpnlxadd = 1849, + mnCmpnoxadd = 1850, + mnCmpnpxadd = 1851, + mnCmpnsxadd = 1852, + mnCmpnzxadd = 1853, + mnCmpoxadd = 1854, + mnCmppxadd = 1855, + mnCmpsxadd = 1856, + mnCmpzxadd = 1857, + mnPrefetchit0 = 1858, + mnPrefetchit1 = 1859, + mnRdmsrlist = 1860, + mnRmpquery = 1861, + mnTdpfp16ps = 1862, + mnVbcstnebf162ps = 1863, + mnVbcstnesh2ps = 1864, + mnVcvtneebf162ps = 1865, + mnVcvtneeph2ps = 1866, + mnVcvtneobf162ps = 1867, + mnVcvtneoph2ps = 1868, + mnVpdpbssd = 1869, + mnVpdpbssds = 1870, + mnVpdpbsud = 1871, + mnVpdpbsuds = 1872, + mnVpdpbuud = 1873, + mnVpdpbuuds = 1874, + mnWrmsrlist = 1875, + mnWrmsrns = 1876, + mnTcmmrlfp16ps = 1877, + mnTcmmimfp16ps = 1878, + mnPbndkb = 1879, + mnVpdpwsud = 1880, + mnVpdpwsuds = 1881, + mnVpdpwusd = 1882, + mnVpdpwusds = 1883, + mnVpdpwuud = 1884, + mnVpdpwuuds = 1885, + mnVsha512msg1 = 1886, + mnVsha512msg2 = 1887, + mnVsha512rnds2 = 1888, + mnVsm3msg1 = 1889, + mnVsm3msg2 = 1890, + mnVsm3rnds2 = 1891, + mnVsm4key4 = 1892, + mnVsm4rnds4 = 1893 + ); + + TMnemonic = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + Mnemonic : TMnemonicType; + {$IFDEF UNICODE} + class operator Equal( const self, AMnemonic : TMnemonic ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AMnemonic : TMnemonic ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TMnemonic; const AMnemonic : array of TMnemonicType ) : Boolean; + class operator GreaterThan( const self, AMnemonic : TMnemonic ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AMnemonic : TMnemonic ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AMnemonic : TMnemonic ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AMnemonic : TMnemonic ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMnemonic : TMnemonic ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMnemonic : TMnemonic ) : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMnemonic : Word ) : TMnemonic; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMnemonic : TMnemonic ) : TMnemonicType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMnemonic : TMnemonicType ) : TMnemonic; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TEncodingKindType = ( + // Legacy encoding + Legacy = 0, + // VEX encoding + VEX = 1, + // EVEX encoding + EVEX = 2, + // XOP encoding + XOP = 3, + // 3DNow! encoding + D3NOW = 4, + // MVEX encoding + MVEX = 5 + ); + + TEncodingKind = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + EncodingKind : TEncodingKindType; + {$IFDEF UNICODE} + class operator Equal( const self, AEncodingKind : TEncodingKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AEncodingKind : TEncodingKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TEncodingKind; const AEncodingKind : array of TEncodingKindType ) : Boolean; + class operator GreaterThan( const self, AEncodingKind : TEncodingKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AEncodingKind : TEncodingKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AEncodingKind : TEncodingKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AEncodingKind : TEncodingKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AEncodingKind : TEncodingKind ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AEncodingKind : TEncodingKind ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AEncodingKind : Byte ) : TEncodingKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AEncodingKind : TEncodingKind ) : TEncodingKindType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AEncodingKind : TEncodingKindType ) : TEncodingKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + +type + TCPUidFeatureType = ( + // 8086 or later + cifINTEL8086 = 0, + // 8086 only + cifINTEL8086_ONLY = 1, + // 80186 or later + cifINTEL186 = 2, + // 80286 or later + cifINTEL286 = 3, + // 80286 only + cifINTEL286_ONLY = 4, + // 80386 or later + cifINTEL386 = 5, + // 80386 only + cifINTEL386_ONLY = 6, + // 80386 A0-B0 stepping only (`XBTS`, `IBTS` instructions) + cifINTEL386_A0_ONLY = 7, + // Intel486 or later + cifINTEL486 = 8, + // Intel486 A stepping only (`CMPXCHG`) + cifINTEL486_A_ONLY = 9, + // UMOV (80386 and Intel486) + cifUMOV = 10, + // IA-64 + cifIA64 = 11, + // CPUID.80000001H:EDX.LM\[bit 29\] + cifX64 = 12, + // CPUID.(EAX=07H, ECX=0H):EBX.ADX\[bit 19\] + cifADX = 13, + // CPUID.01H:ECX.AES\[bit 25\] + cifAES = 14, + // CPUID.01H:ECX.AVX\[bit 28\] + cifAVX = 15, + // CPUID.(EAX=07H, ECX=0H):EBX.AVX2\[bit 5\] + cifAVX2 = 16, + // CPUID.(EAX=07H, ECX=0H):EDX.AVX512_4FMAPS\[bit 3\] + cifAVX512_4FMAPS = 17, + // CPUID.(EAX=07H, ECX=0H):EDX.AVX512_4VNNIW\[bit 2\] + cifAVX512_4VNNIW = 18, + // CPUID.(EAX=07H, ECX=1H):EAX.AVX512_BF16\[bit 5\] + cifAVX512_BF16 = 19, + // CPUID.(EAX=07H, ECX=0H):ECX.AVX512_BITALG\[bit 12\] + cifAVX512_BITALG = 20, + // CPUID.(EAX=07H, ECX=0H):EBX.AVX512_IFMA\[bit 21\] + cifAVX512_IFMA = 21, + // CPUID.(EAX=07H, ECX=0H):ECX.AVX512_VBMI\[bit 1\] + cifAVX512_VBMI = 22, + // CPUID.(EAX=07H, ECX=0H):ECX.AVX512_VBMI2\[bit 6\] + cifAVX512_VBMI2 = 23, + // CPUID.(EAX=07H, ECX=0H):ECX.AVX512_VNNI\[bit 11\] + cifAVX512_VNNI = 24, + // CPUID.(EAX=07H, ECX=0H):EDX.AVX512_VP2INTERSECT\[bit 08\] + cifAVX512_VP2INTERSECT = 25, + // CPUID.(EAX=07H, ECX=0H):ECX.AVX512_VPOPCNTDQ\[bit 14\] + cifAVX512_VPOPCNTDQ = 26, + // CPUID.(EAX=07H, ECX=0H):EBX.AVX512BW\[bit 30\] + cifAVX512BW = 27, + // CPUID.(EAX=07H, ECX=0H):EBX.AVX512CD\[bit 28\] + cifAVX512CD = 28, + // CPUID.(EAX=07H, ECX=0H):EBX.AVX512DQ\[bit 17\] + cifAVX512DQ = 29, + // CPUID.(EAX=07H, ECX=0H):EBX.AVX512ER\[bit 27\] + cifAVX512ER = 30, + // CPUID.(EAX=07H, ECX=0H):EBX.AVX512F\[bit 16\] + cifAVX512F = 31, + // CPUID.(EAX=07H, ECX=0H):EBX.AVX512PF\[bit 26\] + cifAVX512PF = 32, + // CPUID.(EAX=07H, ECX=0H):EBX.AVX512VL\[bit 31\] + cifAVX512VL = 33, + // CPUID.(EAX=07H, ECX=0H):EBX.BMI1\[bit 3\] + cifBMI1 = 34, + // CPUID.(EAX=07H, ECX=0H):EBX.BMI2\[bit 8\] + cifBMI2 = 35, + // CPUID.(EAX=07H, ECX=0H):EDX.CET_IBT\[bit 20\] + cifCET_IBT = 36, + // CPUID.(EAX=07H, ECX=0H):ECX.CET_SS\[bit 7\] + cifCET_SS = 37, + // `CL1INVMB` instruction (Intel SCC = Single-Chip Computer) + cifCL1INVMB = 38, + // CPUID.(EAX=07H, ECX=0H):ECX.CLDEMOTE\[bit 25\] + cifCLDEMOTE = 39, + // CPUID.(EAX=07H, ECX=0H):EBX.CLFLUSHOPT\[bit 23\] + cifCLFLUSHOPT = 40, + // CPUID.01H:EDX.CLFSH\[bit 19\] + cifCLFSH = 41, + // CPUID.(EAX=07H, ECX=0H):EBX.CLWB\[bit 24\] + cifCLWB = 42, + // CPUID.80000008H:EBX.CLZERO\[bit 0\] + cifCLZERO = 43, + // CPUID.01H:EDX.CMOV\[bit 15\] + cifCMOV = 44, + // CPUID.01H:ECX.CMPXCHG16B\[bit 13\] + cifCMPXCHG16B = 45, + // `RFLAGS.ID` can be toggled + cifCPUID = 46, + // CPUID.01H:EDX.CX8\[bit 8\] + cifCX8 = 47, + // CPUID.80000001H:EDX.3DNOW\[bit 31\] + cifD3NOW = 48, + // CPUID.80000001H:EDX.3DNOWEXT\[bit 30\] + cifD3NOWEXT = 49, + // CPUID.(EAX=12H, ECX=0H):EAX.OSS\[bit 5\] + cifOSS = 50, + // CPUID.(EAX=07H, ECX=0H):ECX.ENQCMD\[bit 29\] + cifENQCMD = 51, + // CPUID.01H:ECX.F16C\[bit 29\] + cifF16C = 52, + // CPUID.01H:ECX.FMA\[bit 12\] + cifFMA = 53, + // CPUID.80000001H:ECX.FMA4\[bit 16\] + cifFMA4 = 54, + // 8087 or later (CPUID.01H:EDX.FPU\[bit 0\]) + cifFPU = 55, + // 80287 or later + cifFPU287 = 56, + // 80287XL only + cifFPU287XL_ONLY = 57, + // 80387 or later + cifFPU387 = 58, + // 80387SL only + cifFPU387SL_ONLY = 59, + // CPUID.(EAX=07H, ECX=0H):EBX.FSGSBASE\[bit 0\] + cifFSGSBASE = 60, + // CPUID.01H:EDX.FXSR\[bit 24\] + cifFXSR = 61, + // Cyrix (AMD Geode GX/LX) 3DNow! instructions + cifCYRIX_D3NOW = 62, + // CPUID.(EAX=07H, ECX=0H):ECX.GFNI\[bit 8\] + cifGFNI = 63, + // CPUID.(EAX=07H, ECX=0H):EBX.HLE\[bit 4\] + cifHLE = 64, + // [`HLE`] or [`RTM`] + // + // [`HLE`]: enum.CpuidFeature.html#variant.HLE + // [`RTM`]: enum.CpuidFeature.html#variant.RTM + cifHLE_or_RTM = 65, + // IA32_VMX_EPT_VPID_CAP\[bit 20\] + cifINVEPT = 66, + // CPUID.(EAX=07H, ECX=0H):EBX.INVPCID\[bit 10\] + cifINVPCID = 67, + // IA32_VMX_EPT_VPID_CAP\[bit 32\] + cifINVVPID = 68, + // CPUID.80000001H:ECX.LWP\[bit 15\] + cifLWP = 69, + // CPUID.80000001H:ECX.LZCNT\[bit 5\] + cifLZCNT = 70, + // CPUID.80000008H:EBX.MCOMMIT\[bit 8\] + cifMCOMMIT = 71, + // CPUID.01H:EDX.MMX\[bit 23\] + cifMMX = 72, + // CPUID.01H:ECX.MONITOR\[bit 3\] + cifMONITOR = 73, + // CPUID.80000001H:ECX.MONITORX\[bit 29\] + cifMONITORX = 74, + // CPUID.01H:ECX.MOVBE\[bit 22\] + cifMOVBE = 75, + // CPUID.(EAX=07H, ECX=0H):ECX.MOVDIR64B\[bit 28\] + cifMOVDIR64B = 76, + // CPUID.(EAX=07H, ECX=0H):ECX.MOVDIRI\[bit 27\] + cifMOVDIRI = 77, + // CPUID.(EAX=07H, ECX=0H):EBX.MPX\[bit 14\] + cifMPX = 78, + // CPUID.01H:EDX.MSR\[bit 5\] + cifMSR = 79, + // Multi-byte nops (`0F1F /0`): CPUID.01H.EAX\[Bits 11:8\] = 0110B or 1111B + cifMULTIBYTENOP = 80, + // CPUID.0C0000000H:EAX >= 0C0000001H AND CPUID.0C0000001H:EDX.ACE\[Bits 7:6\] = 11B (\[6\] = exists, \[7\] = enabled) + cifPADLOCK_ACE = 81, + // CPUID.0C0000000H:EAX >= 0C0000001H AND CPUID.0C0000001H:EDX.PHE\[Bits 11:10\] = 11B (\[10\] = exists, \[11\] = enabled) + cifPADLOCK_PHE = 82, + // CPUID.0C0000000H:EAX >= 0C0000001H AND CPUID.0C0000001H:EDX.PMM\[Bits 13:12\] = 11B (\[12\] = exists, \[13\] = enabled) + cifPADLOCK_PMM = 83, + // CPUID.0C0000000H:EAX >= 0C0000001H AND CPUID.0C0000001H:EDX.RNG\[Bits 3:2\] = 11B (\[2\] = exists, \[3\] = enabled) + cifPADLOCK_RNG = 84, + // `PAUSE` instruction (Pentium 4 or later) + cifPAUSE = 85, + // CPUID.01H:ECX.PCLMULQDQ\[bit 1\] + cifPCLMULQDQ = 86, + // CPUID.(EAX=07H, ECX=0H):EBX.PCOMMIT\[bit 22\] + cifPCOMMIT = 87, + // CPUID.(EAX=07H, ECX=0H):EDX.PCONFIG\[bit 18\] + cifPCONFIG = 88, + // CPUID.(EAX=07H, ECX=0H):ECX.PKU\[bit 3\] + cifPKU = 89, + // CPUID.01H:ECX.POPCNT\[bit 23\] + cifPOPCNT = 90, + // CPUID.80000001H:ECX.PREFETCHW\[bit 8\] + cifPREFETCHW = 91, + // CPUID.(EAX=07H, ECX=0H):ECX.PREFETCHWT1\[bit 0\] + cifPREFETCHWT1 = 92, + // CPUID.(EAX=14H, ECX=0H):EBX.PTWRITE\[bit 4\] + cifPTWRITE = 93, + // CPUID.(EAX=07H, ECX=0H):ECX.RDPID\[bit 22\] + cifRDPID = 94, + // `RDPMC` instruction (Pentium MMX or later, or Pentium Pro or later) + cifRDPMC = 95, + // CPUID.80000008H:EBX.RDPRU\[bit 4\] + cifRDPRU = 96, + // CPUID.01H:ECX.RDRAND\[bit 30\] + cifRDRAND = 97, + // CPUID.(EAX=07H, ECX=0H):EBX.RDSEED\[bit 18\] + cifRDSEED = 98, + // CPUID.80000001H:EDX.RDTSCP\[bit 27\] + cifRDTSCP = 99, + // CPUID.(EAX=07H, ECX=0H):EBX.RTM\[bit 11\] + cifRTM = 100, + // CPUID.01H:EDX.SEP\[bit 11\] + cifSEP = 101, + // CPUID.(EAX=12H, ECX=0H):EAX.SGX1\[bit 0\] + cifSGX1 = 102, + // CPUID.(EAX=07H, ECX=0H):EBX.SHA\[bit 29\] + cifSHA = 103, + // CPUID.80000001H:ECX.SKINIT\[bit 12\] + cifSKINIT = 104, + // [`SKINIT`] or [`SVM`] + // + // [`SKINIT`]: enum.CpuidFeature.html#variant.SKINIT + // [`SVM`]: enum.CpuidFeature.html#variant.SVM + cifSKINIT_or_SVM = 105, + // CPUID.(EAX=07H, ECX=0H):EBX.SMAP\[bit 20\] + cifSMAP = 106, + // CPUID.01H:ECX.SMX\[bit 6\] + cifSMX = 107, + // CPUID.01H:EDX.SSE\[bit 25\] + cifSSE = 108, + // CPUID.01H:EDX.SSE2\[bit 26\] + cifSSE2 = 109, + // CPUID.01H:ECX.SSE3\[bit 0\] + cifSSE3 = 110, + // CPUID.01H:ECX.SSE4_1\[bit 19\] + cifSSE4_1 = 111, + // CPUID.01H:ECX.SSE4_2\[bit 20\] + cifSSE4_2 = 112, + // CPUID.80000001H:ECX.SSE4A\[bit 6\] + cifSSE4A = 113, + // CPUID.01H:ECX.SSSE3\[bit 9\] + cifSSSE3 = 114, + // CPUID.80000001H:ECX.SVM\[bit 2\] + cifSVM = 115, + // CPUID.8000001FH:EAX.SEV-ES\[bit 3\] + cifSEV_ES = 116, + // CPUID.80000001H:EDX.SYSCALL\[bit 11\] + cifSYSCALL = 117, + // CPUID.80000001H:ECX.TBM\[bit 21\] + cifTBM = 118, + // CPUID.01H:EDX.TSC\[bit 4\] + cifTSC = 119, + // CPUID.(EAX=07H, ECX=0H):ECX.VAES\[bit 9\] + cifVAES = 120, + // CPUID.01H:ECX.VMX\[bit 5\] + cifVMX = 121, + // CPUID.(EAX=07H, ECX=0H):ECX.VPCLMULQDQ\[bit 10\] + cifVPCLMULQDQ = 122, + // CPUID.(EAX=07H, ECX=0H):ECX.WAITPKG\[bit 5\] + cifWAITPKG = 123, + // CPUID.(EAX=80000008H, ECX=0H):EBX.WBNOINVD\[bit 9\] + cifWBNOINVD = 124, + // CPUID.80000001H:ECX.XOP\[bit 11\] + cifXOP = 125, + // CPUID.01H:ECX.XSAVE\[bit 26\] + cifXSAVE = 126, + // CPUID.(EAX=0DH, ECX=1H):EAX.XSAVEC\[bit 1\] + cifXSAVEC = 127, + // CPUID.(EAX=0DH, ECX=1H):EAX.XSAVEOPT\[bit 0\] + cifXSAVEOPT = 128, + // CPUID.(EAX=0DH, ECX=1H):EAX.XSAVES\[bit 3\] + cifXSAVES = 129, + // CPUID.8000001FH:EAX.SEV-SNP\[bit 4\] + cifSEV_SNP = 130, + // CPUID.(EAX=07H, ECX=0H):EDX.SERIALIZE\[bit 14\] + cifSERIALIZE = 131, + // CPUID.(EAX=07H, ECX=0H):EDX.TSXLDTRK\[bit 16\] + cifTSXLDTRK = 132, + // CPUID.80000008H:EBX.INVLPGB\[bit 3\] + cifINVLPGB = 133, + // CPUID.(EAX=07H, ECX=0H):EDX.AMX-BF16\[bit 22\] + cifAMX_BF16 = 134, + // CPUID.(EAX=07H, ECX=0H):EDX.AMX-TILE\[bit 24\] + cifAMX_TILE = 135, + // CPUID.(EAX=07H, ECX=0H):EDX.AMX-INT8\[bit 25\] + cifAMX_INT8 = 136, + // Cyrix FPU instructions (Cyrix, AMD Geode GX/LX) + cifCYRIX_FPU = 137, + // Cyrix SMM instructions: `SVDC`, `RSDC`, `SVLDT`, `RSLDT`, `SVTS`, `RSTS` (Cyrix, AMD Geode GX/LX) + cifCYRIX_SMM = 138, + // Cyrix `SMINT 0F38` (6x86MX and later, AMD Geode GX/LX) + cifCYRIX_SMINT = 139, + // Cyrix `SMINT 0F7E` (6x86 or earlier) + cifCYRIX_SMINT_0F7E = 140, + // Cyrix SMM instructions: `RDSHR`, `WRSHR` (6x86MX, M II, Cyrix III) + cifCYRIX_SHR = 141, + // Cyrix DDI instructions: `BB0_Reset`, `BB1_Reset`, `CPU_READ`, `CPU_WRITE` (MediaGX, GXm, GXLV, GX1) + cifCYRIX_DDI = 142, + // Cyrix AND CPUID.80000001H:EDX.EMMI\[bit 24\] + cifCYRIX_EMMI = 143, + // Cyrix DMI instructions: `DMINT`, `RDM` (AMD Geode GX/LX) + cifCYRIX_DMI = 144, + // CPUID.0C0000000H:EAX >= 0C0000001H AND CPUID.0C0000001H:EDX.AIS\[Bits 1:0\] = 11B (\[0\] = exists, \[1\] = enabled) + cifCENTAUR_AIS = 145, + // MOV to/from TR (80386, Intel486, Cyrix, Geode) + cifMOV_TR = 146, + // `RSM` instruction (some 386s, some 486s, Pentium and later) + cifSMM = 147, + // CPUID.(EAX=??H, ECX=?H):???.????\[bit ??\] + cifTDX = 148, + // CPUID.(EAX=07H, ECX=0H):ECX.KL\[bit 23\] + cifKL = 149, + // CPUID.19H:EBX.AESKLE\[bit 0\] + cifAESKLE = 150, + // CPUID.19H:EBX.WIDE_KL\[bit 2\] + cifWIDE_KL = 151, + // CPUID.(EAX=07H, ECX=0H):EDX.UINTR\[bit 5\] + cifUINTR = 152, + // CPUID.(EAX=07H, ECX=01H):EAX.HRESET\[bit 22\] + cifHRESET = 153, + // CPUID.(EAX=07H, ECX=01H):EAX.AVX-VNNI\[bit 4\] + cifAVX_VNNI = 154, + // CPUID.0C0000000H:EAX >= 0C0000001H AND CPUID.0C0000001H:EDX.GMI\[Bits 5:4\] = 11B (\[4\] = exists, \[5\] = enabled) + cifPADLOCK_GMI = 155, + // CPUID.(EAX=07H, ECX=01H):EAX.FRED\[bit 17\] + cifFRED = 156, + // CPUID.(EAX=07H, ECX=01H):EAX.LKGS\[bit 18\] + cifLKGS = 157, + // CPUID.(EAX=07H, ECX=0H):EDX.AVX512-FP16\[bit 23\] + cifAVX512_FP16 = 158, + // Undocumented Intel `RDUDBG` and `WRUDBG` instructions + cifUDBG = 159, + // Intel Knights Corner + cifKNC = 160, + // Undocumented instruction + cifPADLOCK_UNDOC = 161, + // CPUID.8000001FH:EAX.RMPQUERY\[bit 6\] + cifRMPQUERY = 162, + // CPUID.(EAX=07H, ECX=1H):EAX.RAO-INT\[bit 3\] + cifRAO_INT = 163, + // CPUID.(EAX=07H, ECX=1H):EDX.PREFETCHITI\[bit 14\] + cifPREFETCHITI = 164, + // CPUID.(EAX=07H, ECX=1H):EAX.AMX-FP16\[bit 21\] + cifAMX_FP16 = 165, + // CPUID.(EAX=07H, ECX=1H):EAX.CMPCCXADD\[bit 7\] + cifCMPCCXADD = 166, + // CPUID.(EAX=07H, ECX=1H):EAX.AVX-IFMA\[bit 23\] + cifAVX_IFMA = 167, + // CPUID.(EAX=07H, ECX=1H):EDX.AVX-NE-CONVERT\[bit 5\] + cifAVX_NE_CONVERT = 168, + // CPUID.(EAX=07H, ECX=1H):EDX.AVX-VNNI-INT8\[bit 4\] + cifAVX_VNNI_INT8 = 169, + // CPUID.(EAX=07H, ECX=1H):EAX.MSRLIST\[bit 27\] + cifMSRLIST = 170, + // CPUID.(EAX=07H, ECX=1H):EAX.WRMSRNS\[bit 19\] + cifWRMSRNS = 171, + // CPUID.(EAX=07H, ECX=1H):EDX.AMX-COMPLEX\[bit 8\] + cifAMX_COMPLEX = 172, + // CPUID.(EAX=07H, ECX=1H):EAX.SHA512\[bit 0\] + cifSHA512 = 173, + // CPUID.(EAX=07H, ECX=1H):EAX.SM3\[bit 1\] + cifSM3 = 174, + // CPUID.(EAX=07H, ECX=1H):EAX.SM4\[bit 2\] + cifSM4 = 175, + // CPUID.(EAX=07H, ECX=1H):EBX.TSE\[bit 1\] + cifTSE = 176, + // CPUID.(EAX=07H, ECX=1H):EDX.AVX-VNNI-INT16\[bit 10\] + cifAVX_VNNI_INT16 = 177 + ); + + TCPUidFeature = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + CPUidFeature : TCPUidFeatureType; + {$IFDEF UNICODE} + class operator Equal( const self, ACPUidFeature : TCPUidFeature ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, ACPUidFeature : TCPUidFeature ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TCPUidFeature; const ACPUidFeature : array of TCPUidFeatureType ) : Boolean; + class operator GreaterThan( const self, ACPUidFeature : TCPUidFeature ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, ACPUidFeature : TCPUidFeature ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, ACPUidFeature : TCPUidFeature ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, ACPUidFeature : TCPUidFeature ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACPUidFeature : TCPUidFeature ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACPUidFeature : TCPUidFeature ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACPUidFeature : Byte ) : TCPUidFeature; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACPUidFeature : TCPUidFeature ) : TCPUidFeatureType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACPUidFeature : TCPUidFeatureType ) : TCPUidFeature; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + +const + TCPUIDFeaturesMaxEntries = 5; +type + TCPUIDFeaturesArray = packed record + Entries : Array [ 0..TCPUIDFeaturesMaxEntries-1 ] of TCPUIDFeature; + Count : Byte; + end; + + TFlowControlType = ( + // The next instruction that will be executed is the next instruction in the instruction stream + fcNext = 0, + // It's an unconditional branch instruction: `JMP NEAR`, `JMP FAR` + fcUnconditionalBranch = 1, + // It's an unconditional indirect branch: `JMP NEAR reg`, `JMP NEAR [mem]`, `JMP FAR [mem]` + fcIndirectBranch = 2, + // It's a conditional branch instruction: `Jcc SHORT`, `Jcc NEAR`, `LOOP`, `LOOPcc`, `JRCXZ`, `JKccD SHORT`, `JKccD NEAR` + fcConditionalBranch = 3, + // It's a return instruction: `RET NEAR`, `RET FAR`, `IRET`, `SYSRET`, `SYSEXIT`, `RSM`, `SKINIT`, `RDM`, `UIRET` + fcReturn = 4, + // It's a call instruction: `CALL NEAR`, `CALL FAR`, `SYSCALL`, `SYSENTER`, `VMLAUNCH`, `VMRESUME`, `VMCALL`, `VMMCALL`, `VMGEXIT`, `VMRUN`, `TDCALL`, `SEAMCALL`, `SEAMRET` + fcCall = 5, + // It's an indirect call instruction: `CALL NEAR reg`, `CALL NEAR [mem]`, `CALL FAR [mem]` + fcIndirectCall = 6, + // It's an interrupt instruction: `INT n`, `INT3`, `INT1`, `INTO`, `SMINT`, `DMINT` + fcInterrupt = 7, + // It's `XBEGIN` + fcXbeginXabortXend = 8, + // It's an invalid instruction, eg. [`Code::INVALID`], `UD0`, `UD1`, `UD2` + // + // [`Code::INVALID`]: enum.Code.html#variant.INVALID + fcException = 9 + ); + + TFlowControl = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + FlowControl : TFlowControlType; + {$IFDEF UNICODE} + class operator Equal( const self, AFlowControl : TFlowControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AFlowControl : TFlowControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TFlowControl; const AFlowControl : array of TFlowControlType ) : Boolean; + class operator GreaterThan( const self, AFlowControl : TFlowControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AFlowControl : TFlowControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AFlowControl : TFlowControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AFlowControl : TFlowControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AFlowControl : TFlowControl ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AFlowControl : TFlowControl ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AFlowControl : Byte ) : TFlowControl; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AFlowControl : TFlowControl ) : TFlowControlType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AFlowControl : TFlowControlType ) : TFlowControl; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TConditionCodeType = ( + // The instruction doesn't have a condition code + cc_None = 0, + // Overflow (`OF=1`) + cc_o = 1, + // Not overflow (`OF=0`) + cc_no = 2, + // Below (unsigned) (`CF=1`) + cc_b = 3, + // Above or equal (unsigned) (`CF=0`) + cc_ae = 4, + // Equal / zero (`ZF=1`) + cc_e = 5, + // Not equal / zero (`ZF=0`) + cc_ne = 6, + // Below or equal (unsigned) (`CF=1 or ZF=1`) + cc_be = 7, + // Above (unsigned) (`CF=0 and ZF=0`) + cc_a = 8, + // Signed (`SF=1`) + cc_s = 9, + // Not signed (`SF=0`) + cc_ns = 10, + // Parity (`PF=1`) + cc_p = 11, + // Not parity (`PF=0`) + cc_np = 12, + // Less (signed) (`SF!=OF`) + cc_l = 13, + // Greater than or equal (signed) (`SF=OF`) + cc_ge = 14, + // Less than or equal (signed) (`ZF=1 or SF!=OF`) + cc_le = 15, + // Greater (signed) (`ZF=0 and SF=OF`) + cc_g = 16 + ); + + TConditionCode = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + ConditionCode : TConditionCodeType; + {$IFDEF UNICODE} + class operator Equal( const self, AConditionCode : TConditionCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AConditionCode : TConditionCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TConditionCode; const AConditionCode : array of TConditionCodeType ) : Boolean; + class operator GreaterThan( const self, AConditionCode : TConditionCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AConditionCode : TConditionCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AConditionCode : TConditionCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AConditionCode : TConditionCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AConditionCode : TConditionCode ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AConditionCode : TConditionCode ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AConditionCode : Byte ) : TConditionCode; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AConditionCode : TConditionCode ) : TConditionCodeType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AConditionCode : TConditionCodeType ) : TConditionCode; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Name : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + +const + TConditionCode_Name : Array [ 0..16 ] of String = ( + 'None', + 'Overflow', + 'Not Overflow', + 'Below', + 'Above or Equal', + 'Equal', + 'Not Equal', + 'Below or Equak', + 'Above', + 'Signed (Negative)', + 'Not Signed (Not Negative)', + 'Parity', + 'Not Parity', + 'Less', + 'Greater or Equal', + 'Less or Equal', + 'Greater' + ); + +type + TTupleTypeType = ( + // `N = 1` + ttN1 = 0, + // `N = 2` + ttN2 = 1, + // `N = 4` + ttN4 = 2, + // `N = 8` + ttN8 = 3, + // `N = 16` + ttN16 = 4, + // `N = 32` + ttN32 = 5, + // `N = 64` + ttN64 = 6, + // `N = b ? 4 : 8` + ttN8b4 = 7, + // `N = b ? 4 : 16` + ttN16b4 = 8, + // `N = b ? 4 : 32` + ttN32b4 = 9, + // `N = b ? 4 : 64` + ttN64b4 = 10, + // `N = b ? 8 : 16` + ttN16b8 = 11, + // `N = b ? 8 : 32` + ttN32b8 = 12, + // `N = b ? 8 : 64` + ttN64b8 = 13, + // `N = b ? 2 : 4` + ttN4b2 = 14, + // `N = b ? 2 : 8` + ttN8b2 = 15, + // `N = b ? 2 : 16` + ttN16b2 = 16, + // `N = b ? 2 : 32` + ttN32b2 = 17, + // `N = b ? 2 : 64` + ttN64b2 = 18 + ); + + TTupleType = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + TupleType : TTupleTypeType; + {$IFDEF UNICODE} + class operator Equal( const self, ATupleType : TTupleType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, ATupleType : TTupleType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TTupleType; const ATupleType : array of TTupleTypeType ) : Boolean; + class operator GreaterThan( const self, ATupleType : TTupleType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, ATupleType : TTupleType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, ATupleType : TTupleType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, ATupleType : TTupleType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ATupleType : TTupleType ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ATupleType : TTupleType ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ATupleType : Byte ) : TTupleType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ATupleType : TTupleType ) : TTupleTypeType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ATupleType : TTupleTypeType ) : TTupleType; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TOpCodeTableKindType = ( + // Legacy/`MAP0` table + octkNormal = 0, + // `0F`/`MAP1` table (legacy, VEX, EVEX, MVEX) + octkT0F = 1, + // `0F38`/`MAP2` table (legacy, VEX, EVEX, MVEX) + octkT0F38 = 2, + // `0F3A`/`MAP3` table (legacy, VEX, EVEX, MVEX) + octkT0F3A = 3, + // `MAP5` table (EVEX) + octkMAP5 = 4, + // `MAP6` table (EVEX) + octkMAP6 = 5, + // `MAP8` table (XOP) + octkMAP8 = 6, + // `MAP9` table (XOP) + octkMAP9 = 7, + // `MAP10` table (XOP) + octkMAP10 = 8 + ); + + TOpCodeTableKind = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + OpCodeTableKind : TOpCodeTableKindType; + {$IFDEF UNICODE} + class operator Equal( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TOpCodeTableKind; const AOpCodeTableKind : array of TOpCodeTableKindType ) : Boolean; + class operator GreaterThan( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpCodeTableKind : TOpCodeTableKind ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpCodeTableKind : TOpCodeTableKind ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpCodeTableKind : Byte ) : TOpCodeTableKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpCodeTableKind : TOpCodeTableKind ) : TOpCodeTableKindType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpCodeTableKind : TOpCodeTableKindType ) : TOpCodeTableKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + +type + TMandatoryPrefixType = ( + // No mandatory prefix (legacy and 3DNow! tables only) + mpNone = 0, + // Empty mandatory prefix (no `66`, `F3` or `F2` prefix) + mpPNP = 1, + // `66` prefix + mpP66 = 2, + // `F3` prefix + mpPF3 = 3, + // `F2` prefix + mpPF2 = 4 + ); + + TMandatoryPrefix = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + MandatoryPrefix : TMandatoryPrefixType; + {$IFDEF UNICODE} + class operator Equal( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TMandatoryPrefix; const AMandatoryPrefix : array of TMandatoryPrefixType ) : Boolean; + class operator GreaterThan( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMandatoryPrefix : TMandatoryPrefix ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMandatoryPrefix : TMandatoryPrefix ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMandatoryPrefix : Byte ) : TMandatoryPrefix; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMandatoryPrefix : TMandatoryPrefix ) : TMandatoryPrefixType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMandatoryPrefix : TMandatoryPrefixType ) : TMandatoryPrefix; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TOpCodeOperandKindType = ( + // No operand + ocokNone = 0, + // Far branch 16-bit offset, 16-bit segment/selector + ocokfarbr2_2 = 1, + // Far branch 32-bit offset, 16-bit segment/selector + ocokfarbr4_2 = 2, + // Memory offset without a modrm byte (eg. `MOV AL,[offset]`) + ocokmem_offs = 3, + // Memory (modrm) + ocokmem = 4, + // Memory (modrm), MPX: + // + // 16/32-bit mode: must be 32-bit addressing + // + // 64-bit mode: 64-bit addressing is forced and must not be RIP relative + ocokmem_mpx = 5, + // Memory (modrm), MPX: + // + // 16/32-bit mode: must be 32-bit addressing + // + // 64-bit mode: 64-bit addressing is forced and must not be RIP relative + ocok_mem_mib = 6, + // Memory (modrm), vsib32, `XMM` registers + ocok_mem_vsib32x = 7, + // Memory (modrm), vsib64, `XMM` registers + ocok_mem_vsib64x = 8, + // Memory (modrm), vsib32, `YMM` registers + ocok_mem_vsib32y = 9, + // Memory (modrm), vsib64, `YMM` registers + ocok_mem_vsib64y = 10, + // Memory (modrm), vsib32, `ZMM` registers + ocok_mem_vsib32z = 11, + // Memory (modrm), vsib64, `ZMM` registers + ocok_mem_vsib64z = 12, + // 8-bit GPR or memory + ocok_r8_or_mem = 13, + // 16-bit GPR or memory + ocok_r16_or_mem = 14, + // 32-bit GPR or memory + ocok_r32_or_mem = 15, + // 32-bit GPR or memory, MPX: 16/32-bit mode: must be 32-bit addressing, 64-bit mode: 64-bit addressing is forced + ocok_r32_or_mem_mpx = 16, + // 64-bit GPR or memory + ocok_r64_or_mem = 17, + // 64-bit GPR or memory, MPX: 16/32-bit mode: must be 32-bit addressing, 64-bit mode: 64-bit addressing is forced + ocok_r64_or_mem_mpx = 18, + // `MM` register or memory + ocok_mm_or_mem = 19, + // `XMM` register or memory + ocok_xmm_or_mem = 20, + // `YMM` register or memory + ocok_ymm_or_mem = 21, + // `ZMM` register or memory + ocok_zmm_or_mem = 22, + // `BND` register or memory, MPX: 16/32-bit mode: must be 32-bit addressing, 64-bit mode: 64-bit addressing is forced + ocok_bnd_or_mem_mpx = 23, + // `K` register or memory + ocok_k_or_mem = 24, + // 8-bit GPR encoded in the `reg` field of the modrm byte + ocok_r8_reg = 25, + // 8-bit GPR encoded in the low 3 bits of the opcode + ocok_r8_opcode = 26, + // 16-bit GPR encoded in the `reg` field of the modrm byte + ocok_r16_reg = 27, + // 16-bit GPR encoded in the `reg` field of the modrm byte. This is a memory operand and it uses the address size prefix (`67h`) not the operand size prefix (`66h`). + ocok_r16_reg_mem = 28, + // 16-bit GPR encoded in the `mod + r/m` fields of the modrm byte + ocok_r16_rm = 29, + // 16-bit GPR encoded in the low 3 bits of the opcode + ocok_r16_opcode = 30, + // 32-bit GPR encoded in the `reg` field of the modrm byte + ocok_r32_reg = 31, + // 32-bit GPR encoded in the `reg` field of the modrm byte. This is a memory operand and it uses the address size prefix (`67h`) not the operand size prefix (`66h`). + ocok_r32_reg_mem = 32, + // 32-bit GPR encoded in the `mod + r/m` fields of the modrm byte + ocok_r32_rm = 33, + // 32-bit GPR encoded in the low 3 bits of the opcode + ocok_r32_opcode = 34, + // 32-bit GPR encoded in the the `V'vvvv` field (VEX/EVEX/XOP) + ocok_r32_vvvv = 35, + // 64-bit GPR encoded in the `reg` field of the modrm byte + ocok_r64_reg = 36, + // 64-bit GPR encoded in the `reg` field of the modrm byte. This is a memory operand and it uses the address size prefix (`67h`) not the operand size prefix (`66h`). + ocok_r64_reg_mem = 37, + // 64-bit GPR encoded in the `mod + r/m` fields of the modrm byte + ocok_r64_rm = 38, + // 64-bit GPR encoded in the low 3 bits of the opcode + ocok_r64_opcode = 39, + // 64-bit GPR encoded in the the `V'vvvv` field (VEX/EVEX/XOP) + ocok_r64_vvvv = 40, + // Segment register encoded in the `reg` field of the modrm byte + ocok_seg_reg = 41, + // `K` register encoded in the `reg` field of the modrm byte + ocok_k_reg = 42, + // `K` register (+1) encoded in the `reg` field of the modrm byte + ocok_kp1_reg = 43, + // `K` register encoded in the `mod + r/m` fields of the modrm byte + ocok_k_rm = 44, + // `K` register encoded in the the `V'vvvv` field (VEX/EVEX/MVEX/XOP) + ocok_k_vvvv = 45, + // `MM` register encoded in the `reg` field of the modrm byte + ocok_mm_reg = 46, + // `MM` register encoded in the `mod + r/m` fields of the modrm byte + ocok_mm_rm = 47, + // `XMM` register encoded in the `reg` field of the modrm byte + ocok_xmm_reg = 48, + // `XMM` register encoded in the `mod + r/m` fields of the modrm byte + ocok_xmm_rm = 49, + // `XMM` register encoded in the the `V'vvvv` field (VEX/EVEX/XOP) + ocok_xmm_vvvv = 50, + // `XMM` register (+3) encoded in the the `V'vvvv` field (VEX/EVEX/XOP) + ocok_xmmp3_vvvv = 51, + // `XMM` register encoded in the the high 4 bits of the last 8-bit immediate (VEX/XOP only so only `XMM0`-`XMM15`) + ocok_xmm_is4 = 52, + // `XMM` register encoded in the the high 4 bits of the last 8-bit immediate (VEX/XOP only so only `XMM0`-`XMM15`) + ocok_xmm_is5 = 53, + // `YMM` register encoded in the `reg` field of the modrm byte + ocok_ymm_reg = 54, + // `YMM` register encoded in the `mod + r/m` fields of the modrm byte + ocok_ymm_rm = 55, + // `YMM` register encoded in the the `V'vvvv` field (VEX/EVEX/XOP) + ocok_ymm_vvvv = 56, + // `YMM` register encoded in the the high 4 bits of the last 8-bit immediate (VEX/XOP only so only `YMM0`-`YMM15`) + ocok_ymm_is4 = 57, + // `YMM` register encoded in the the high 4 bits of the last 8-bit immediate (VEX/XOP only so only `YMM0`-`YMM15`) + ocok_ymm_is5 = 58, + // `ZMM` register encoded in the `reg` field of the modrm byte + ocok_zmm_reg = 59, + // `ZMM` register encoded in the `mod + r/m` fields of the modrm byte + ocok_zmm_rm = 60, + // `ZMM` register encoded in the the `V'vvvv` field (VEX/EVEX/MVEX/XOP) + ocok_zmm_vvvv = 61, + // `ZMM` register (+3) encoded in the the `V'vvvv` field (VEX/EVEX/XOP) + ocok_zmmp3_vvvv = 62, + // `CR` register encoded in the `reg` field of the modrm byte + ocok_cr_reg = 63, + // `DR` register encoded in the `reg` field of the modrm byte + ocok_dr_reg = 64, + // `TR` register encoded in the `reg` field of the modrm byte + ocok_tr_reg = 65, + // `BND` register encoded in the `reg` field of the modrm byte + ocok_bnd_reg = 66, + // `ES` register + ocok_es = 67, + // `CS` register + ocok_cs = 68, + // `SS` register + ocok_ss = 69, + // `DS` register + ocok_ds = 70, + // `FS` register + ocok_fs = 71, + // `GS` register + ocok_gs = 72, + // `AL` register + ocok_al = 73, + // `CL` register + ocok_cl = 74, + // `AX` register + ocok_ax = 75, + // `DX` register + ocok_dx = 76, + // `EAX` register + ocok_eax = 77, + // `RAX` register + ocok_rax = 78, + // `ST(0)` register + ocok_st0 = 79, + // `ST(i)` register encoded in the low 3 bits of the opcode + ocok_sti_opcode = 80, + // 4-bit immediate (m2z field, low 4 bits of the /is5 immediate, eg. `VPERMIL2PS`) + ocok_imm4_m2z = 81, + // 8-bit immediate + ocok_imm8 = 82, + // Constant 1 (8-bit immediate) + ocok_imm8_const_1 = 83, + // 8-bit immediate sign extended to 16 bits + ocok_imm8sex16 = 84, + // 8-bit immediate sign extended to 32 bits + ocok_imm8sex32 = 85, + // 8-bit immediate sign extended to 64 bits + ocok_imm8sex64 = 86, + // 16-bit immediate + ocok_imm16 = 87, + // 32-bit immediate + ocok_imm32 = 88, + // 32-bit immediate sign extended to 64 bits + ocok_imm32sex64 = 89, + // 64-bit immediate + ocok_imm64 = 90, + // `seg:[rSI]` memory operand (string instructions) + ocok_seg_rSI = 91, + // `es:[rDI]` memory operand (string instructions) + ocok_es_rDI = 92, + // `seg:[rDI]` memory operand (`(V)MASKMOVQ` instructions) + ocok_seg_rDI = 93, + // `seg:[rBX+al]` memory operand (`XLATB` instruction) + ocok_seg_rBX_al = 94, + // 16-bit branch, 1-byte signed relative offset + ocok_br16_1 = 95, + // 32-bit branch, 1-byte signed relative offset + ocok_br32_1 = 96, + // 64-bit branch, 1-byte signed relative offset + ocok_br64_1 = 97, + // 16-bit branch, 2-byte signed relative offset + ocok_br16_2 = 98, + // 32-bit branch, 4-byte signed relative offset + ocok_br32_4 = 99, + // 64-bit branch, 4-byte signed relative offset + ocok_br64_4 = 100, + // `XBEGIN`, 2-byte signed relative offset + ocok_xbegin_2 = 101, + // `XBEGIN`, 4-byte signed relative offset + ocok_xbegin_4 = 102, + // 2-byte branch offset (`JMPE` instruction) + ocok_brdisp_2 = 103, + // 4-byte branch offset (`JMPE` instruction) + ocok_brdisp_4 = 104, + // Memory (modrm) and the sib byte must be present + ocok_sibmem = 105, + // `TMM` register encoded in the `reg` field of the modrm byte + ocok_tmm_reg = 106, + // `TMM` register encoded in the `mod + r/m` fields of the modrm byte + ocok_tmm_rm = 107, + // `TMM` register encoded in the the `V'vvvv` field (VEX/EVEX/XOP) + ocok_tmm_vvvv = 108 + ); + + TOpCodeOperandKind = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + OpCodeOperandKind : TOpCodeOperandKindType; + {$IFDEF UNICODE} + class operator Equal( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TOpCodeOperandKind; const AOpCodeOperandKind : array of TOpCodeOperandKindType ) : Boolean; + class operator GreaterThan( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpCodeOperandKind : TOpCodeOperandKind ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpCodeOperandKind : TOpCodeOperandKind ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpCodeOperandKind : Byte ) : TOpCodeOperandKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpCodeOperandKind : TOpCodeOperandKind ) : TOpCodeOperandKindType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpCodeOperandKind : TOpCodeOperandKindType ) : TOpCodeOperandKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TMvexEHBitType = ( + // Not hard coded to 0 or 1 so can be used for other purposes + mebNone = 0, + // EH bit must be 0 + mebEH0 = 1, + // EH bit must be 1 + mebEH1 = 2 + ); + + TMvexEHBit = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + MvexEHBit : TMvexEHBitType; + {$IFDEF UNICODE} + class operator Equal( const self, AMvexEHBit : TMvexEHBit ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AMvexEHBit : TMvexEHBit ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TMvexEHBit; const AMvexEHBit : array of TMvexEHBitType ) : Boolean; + class operator GreaterThan( const self, AMvexEHBit : TMvexEHBit ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AMvexEHBit : TMvexEHBit ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AMvexEHBit : TMvexEHBit ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AMvexEHBit : TMvexEHBit ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexEHBit : TMvexEHBit ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexEHBit : TMvexEHBit ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexEHBit : Byte ) : TMvexEHBit; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexEHBit : TMvexEHBit ) : TMvexEHBitType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexEHBit : TMvexEHBitType ) : TMvexEHBit; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TMvexTupleTypeLutKindType = ( + // `i32` elements, eg. `Si32`/`Di32`/`Ui32` + ttlkInt32 = 0, + // `i32` elements, eg. `Si32`/`Di32`/`Ui32` with half memory size (32 bytes instead of 64 bytes, eg. `VCVTUDQ2PD`/`VCVTDQ2PD`) + ttlkInt32_Half = 1, + // `i32` elements, eg. `Si32`/`Di32`/`Ui32` with built-in `{4to16}` broadcast + ttlkInt32_4to16 = 2, + // `i32` elements, eg. `Si32`/`Di32`/`Ui32` with built-in `{1to16}` broadcast or element level + ttlkInt32_1to16_or_elem = 3, + // `i64` elements, eg. `Si64`/`Di64`/`Ui64` + ttlkInt64 = 4, + // `i64` elements, eg. `Si64`/`Di64`/`Ui64` with built-in `{4to8}` broadcast + ttlkInt64_4to8 = 5, + // `i64` elements, eg. `Si64`/`Di64`/`Ui64` with built-in `{1to8}` broadcast or element level + ttlkInt64_1to8_or_elem = 6, + // `f32` elements, eg. `Sf32`/`Df32`/`Uf32` + ttlkFloat32 = 7, + // `f32` elements, eg. `Sf32`/`Df32`/`Uf32` with half memory size (32 bytes instead of 64 bytes, eg. `VCVTPS2PD` + ttlkFloat32_Half = 8, + // `f32` elements, eg. `Sf32`/`Df32`/`Uf32` with built-in `{4to16}` broadcast + ttlkFloat32_4to16 = 9, + // `f32` elements, eg. `Sf32`/`Df32`/`Uf32` with built-in `{1to16}` broadcast or element level + ttlkFloat32_1to16_or_elem = 10, + // `f64` elements, eg. `Sf64`/`Df64`/`Uf64` + ttlkFloat64 = 11, + // `f64` elements, eg. `Sf64`/`Df64`/`Uf64` with built-in `{4to8}` broadcast + ttlkFloat64_4to8 = 12, + // `f64` elements, eg. `Sf64`/`Df64`/`Uf64` with built-in `{1to8}` broadcast or element level + ttlkFloat64_1to8_or_elem = 13 + ); + + TMvexTupleTypeLutKind = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + MvexTupleTypeLutKind : TMvexTupleTypeLutKindType; + {$IFDEF UNICODE} + class operator Equal( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : array of TMvexTupleTypeLutKindType ) : Boolean; + class operator GreaterThan( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexTupleTypeLutKind : Byte ) : TMvexTupleTypeLutKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : TMvexTupleTypeLutKindType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : TMvexTupleTypeLutKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TMvexConvFnType = ( + // No conversion function + mcfNone = 0, + // Sf32(xxx) + mcfSf32 = 1, + // Sf64(xxx) + mcfSf64 = 2, + // Si32(xxx) + mcfSi32 = 3, + // Si64(xxx) + mcfSi64 = 4, + // Uf32(xxx) + mcfUf32 = 5, + // Uf64(xxx) + mcfUf64 = 6, + // Ui32(xxx) + mcfUi32 = 7, + // Ui64(xxx) + mcfUi64 = 8, + // Df32(xxx) + mcfDf32 = 9, + // Df64(xxx) + mcfDf64 = 10, + // Di32(xxx) + mcfDi32 = 11, + // Di64(xxx) + mcfDi64 = 12 + ); + + TMvexConvFn = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + MvexConvFn : TMvexConvFnType; + {$IFDEF UNICODE} + class operator Equal( const self, AMvexConvFn : TMvexConvFn ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AMvexConvFn : TMvexConvFn ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TMvexConvFn; const AMvexConvFn : array of TMvexConvFnType ) : Boolean; + class operator GreaterThan( const self, AMvexConvFn : TMvexConvFn ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AMvexConvFn : TMvexConvFn ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AMvexConvFn : TMvexConvFn ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AMvexConvFn : TMvexConvFn ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexConvFn : TMvexConvFn ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexConvFn : TMvexConvFn ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexConvFn : Byte ) : TMvexConvFn; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexConvFn : TMvexConvFn ) : TMvexConvFnType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexConvFn : TMvexConvFnType ) : TMvexConvFn; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TMemorySizeType = ( + // Unknown size or the instruction doesn't reference any memory (eg. `LEA`) + msUnknown = 0, + // Memory location contains a `u8` + msUInt8 = 1, + // Memory location contains a `u16` + msUInt16 = 2, + // Memory location contains a `u32` + msUInt32 = 3, + // Memory location contains a `u52` + msUInt52 = 4, + // Memory location contains a `u64` + msUInt64 = 5, + // Memory location contains a `u128` + msUInt128 = 6, + // Memory location contains a `u256` + msUInt256 = 7, + // Memory location contains a `u512` + msUInt512 = 8, + // Memory location contains a `i8` + msInt8 = 9, + // Memory location contains a `i16` + msInt16 = 10, + // Memory location contains a `i32` + msInt32 = 11, + // Memory location contains a `i64` + msInt64 = 12, + // Memory location contains a `i128` + msInt128 = 13, + // Memory location contains a `i256` + msInt256 = 14, + // Memory location contains a `i512` + msInt512 = 15, + // Memory location contains a seg:ptr pair, `u16` (offset) + `u16` (segment/selector) + msSegPtr16 = 16, + // Memory location contains a seg:ptr pair, `u32` (offset) + `u16` (segment/selector) + msSegPtr32 = 17, + // Memory location contains a seg:ptr pair, `u64` (offset) + `u16` (segment/selector) + msSegPtr64 = 18, + // Memory location contains a 16-bit offset (`JMP/CALL WORD PTR [mem]`) + msWordOffset = 19, + // Memory location contains a 32-bit offset (`JMP/CALL DWORD PTR [mem]`) + msDwordOffset = 20, + // Memory location contains a 64-bit offset (`JMP/CALL QWORD PTR [mem]`) + msQwordOffset = 21, + // Memory location contains two `u16`s (16-bit `BOUND`) + msBound16_WordWord = 22, + // Memory location contains two `u32`s (32-bit `BOUND`) + msBound32_DwordDword = 23, + // 32-bit `BNDMOV`, 2 x `u32` + msBnd32 = 24, + // 64-bit `BNDMOV`, 2 x `u64` + msBnd64 = 25, + // Memory location contains a 16-bit limit and a 32-bit address (eg. `LGDTW`, `LGDTD`) + msFword6 = 26, + // Memory location contains a 16-bit limit and a 64-bit address (eg. `LGDTQ`) + msFword10 = 27, + // Memory location contains a `f16` + msFloat16 = 28, + // Memory location contains a `f32` + msFloat32 = 29, + // Memory location contains a `f64` + msFloat64 = 30, + // Memory location contains a `f80` + msFloat80 = 31, + // Memory location contains a `f128` + msFloat128 = 32, + // Memory location contains a `bfloat16` + msBFloat16 = 33, + // Memory location contains a 14-byte FPU environment (16-bit `FLDENV`/`FSTENV`) + msFpuEnv14 = 34, + // Memory location contains a 28-byte FPU environment (32/64-bit `FLDENV`/`FSTENV`) + msFpuEnv28 = 35, + // Memory location contains a 94-byte FPU environment (16-bit `FSAVE`/`FRSTOR`) + msFpuState94 = 36, + // Memory location contains a 108-byte FPU environment (32/64-bit `FSAVE`/`FRSTOR`) + msFpuState108 = 37, + // Memory location contains 512-bytes of `FXSAVE`/`FXRSTOR` data + msFxsave_512Byte = 38, + // Memory location contains 512-bytes of `FXSAVE64`/`FXRSTOR64` data + msFxsave64_512Byte = 39, + // 32-bit `XSAVE` area + msXsave = 40, + // 64-bit `XSAVE` area + msXsave64 = 41, + // Memory location contains a 10-byte `bcd` value (`FBLD`/`FBSTP`) + msBcd = 42, + // 64-bit location: TILECFG (`LDTILECFG`/`STTILECFG`) + msTilecfg = 43, + // Tile data + msTile = 44, + // 80-bit segment descriptor and selector: 0-7 = descriptor, 8-9 = selector + msSegmentDescSelector = 45, + // 384-bit AES 128 handle (Key Locker) + msKLHandleAes128 = 46, + // 512-bit AES 256 handle (Key Locker) + msKLHandleAes256 = 47, + // 16-bit location: 2 x `u8` + msPacked16_UInt8 = 48, + // 16-bit location: 2 x `i8` + msPacked16_Int8 = 49, + // 32-bit location: 4 x `u8` + msPacked32_UInt8 = 50, + // 32-bit location: 4 x `i8` + msPacked32_Int8 = 51, + // 32-bit location: 2 x `u16` + msPacked32_UInt16 = 52, + // 32-bit location: 2 x `i16` + msPacked32_Int16 = 53, + // 32-bit location: 2 x `f16` + msPacked32_Float16 = 54, + // 32-bit location: 2 x `bfloat16` + msPacked32_BFloat16 = 55, + // 64-bit location: 8 x `u8` + msPacked64_UInt8 = 56, + // 64-bit location: 8 x `i8` + msPacked64_Int8 = 57, + // 64-bit location: 4 x `u16` + msPacked64_UInt16 = 58, + // 64-bit location: 4 x `i16` + msPacked64_Int16 = 59, + // 64-bit location: 2 x `u32` + msPacked64_UInt32 = 60, + // 64-bit location: 2 x `i32` + msPacked64_Int32 = 61, + // 64-bit location: 4 x `f16` + msPacked64_Float16 = 62, + // 64-bit location: 2 x `f32` + msPacked64_Float32 = 63, + // 128-bit location: 16 x `u8` + msPacked128_UInt8 = 64, + // 128-bit location: 16 x `i8` + msPacked128_Int8 = 65, + // 128-bit location: 8 x `u16` + msPacked128_UInt16 = 66, + // 128-bit location: 8 x `i16` + msPacked128_Int16 = 67, + // 128-bit location: 4 x `u32` + msPacked128_UInt32 = 68, + // 128-bit location: 4 x `i32` + msPacked128_Int32 = 69, + // 128-bit location: 2 x `u52` + msPacked128_UInt52 = 70, + // 128-bit location: 2 x `u64` + msPacked128_UInt64 = 71, + // 128-bit location: 2 x `i64` + msPacked128_Int64 = 72, + // 128-bit location: 8 x `f16` + msPacked128_Float16 = 73, + // 128-bit location: 4 x `f32` + msPacked128_Float32 = 74, + // 128-bit location: 2 x `f64` + msPacked128_Float64 = 75, + // 128-bit location: 4 x (2 x `f16`) + msPacked128_2xFloat16 = 76, + // 128-bit location: 4 x (2 x `bfloat16`) + msPacked128_2xBFloat16 = 77, + // 256-bit location: 32 x `u8` + msPacked256_UInt8 = 78, + // 256-bit location: 32 x `i8` + msPacked256_Int8 = 79, + // 256-bit location: 16 x `u16` + msPacked256_UInt16 = 80, + // 256-bit location: 16 x `i16` + msPacked256_Int16 = 81, + // 256-bit location: 8 x `u32` + msPacked256_UInt32 = 82, + // 256-bit location: 8 x `i32` + msPacked256_Int32 = 83, + // 256-bit location: 4 x `u52` + msPacked256_UInt52 = 84, + // 256-bit location: 4 x `u64` + msPacked256_UInt64 = 85, + // 256-bit location: 4 x `i64` + msPacked256_Int64 = 86, + // 256-bit location: 2 x `u128` + msPacked256_UInt128 = 87, + // 256-bit location: 2 x `i128` + msPacked256_Int128 = 88, + // 256-bit location: 16 x `f16` + msPacked256_Float16 = 89, + // 256-bit location: 8 x `f32` + msPacked256_Float32 = 90, + // 256-bit location: 4 x `f64` + msPacked256_Float64 = 91, + // 256-bit location: 2 x `f128` + msPacked256_Float128 = 92, + // 256-bit location: 8 x (2 x `f16`) + msPacked256_2xFloat16 = 93, + // 256-bit location: 8 x (2 x `bfloat16`) + msPacked256_2xBFloat16 = 94, + // 512-bit location: 64 x `u8` + msPacked512_UInt8 = 95, + // 512-bit location: 64 x `i8` + msPacked512_Int8 = 96, + // 512-bit location: 32 x `u16` + msPacked512_UInt16 = 97, + // 512-bit location: 32 x `i16` + msPacked512_Int16 = 98, + // 512-bit location: 16 x `u32` + msPacked512_UInt32 = 99, + // 512-bit location: 16 x `i32` + msPacked512_Int32 = 100, + // 512-bit location: 8 x `u52` + msPacked512_UInt52 = 101, + // 512-bit location: 8 x `u64` + msPacked512_UInt64 = 102, + // 512-bit location: 8 x `i64` + msPacked512_Int64 = 103, + // 256-bit location: 4 x `u128` + msPacked512_UInt128 = 104, + // 512-bit location: 32 x `f16` + msPacked512_Float16 = 105, + // 512-bit location: 16 x `f32` + msPacked512_Float32 = 106, + // 512-bit location: 8 x `f64` + msPacked512_Float64 = 107, + // 512-bit location: 16 x (2 x `f16`) + msPacked512_2xFloat16 = 108, + // 512-bit location: 16 x (2 x `bfloat16`) + msPacked512_2xBFloat16 = 109, + // Broadcast `f16` to 32-bits + msBroadcast32_Float16 = 110, + // Broadcast `u32` to 64-bits + msBroadcast64_UInt32 = 111, + // Broadcast `i32` to 64-bits + msBroadcast64_Int32 = 112, + // Broadcast `f16` to 64-bits + msBroadcast64_Float16 = 113, + // Broadcast `f32` to 64-bits + msBroadcast64_Float32 = 114, + // Broadcast `i16` to 128-bits + msBroadcast128_Int16 = 115, + // Broadcast `u16` to 128-bits + msBroadcast128_UInt16 = 116, + // Broadcast `u32` to 128-bits + msBroadcast128_UInt32 = 117, + // Broadcast `i32` to 128-bits + msBroadcast128_Int32 = 118, + // Broadcast `u52` to 128-bits + msBroadcast128_UInt52 = 119, + // Broadcast `u64` to 128-bits + msBroadcast128_UInt64 = 120, + // Broadcast `i64` to 128-bits + msBroadcast128_Int64 = 121, + // Broadcast `f16` to 128-bits + msBroadcast128_Float16 = 122, + // Broadcast `f32` to 128-bits + msBroadcast128_Float32 = 123, + // Broadcast `f64` to 128-bits + msBroadcast128_Float64 = 124, + // Broadcast 2 x `i16` to 128-bits + msBroadcast128_2xInt16 = 125, + // Broadcast 2 x `i32` to 128-bits + msBroadcast128_2xInt32 = 126, + // Broadcast 2 x `u32` to 128-bits + msBroadcast128_2xUInt32 = 127, + // Broadcast 2 x `f16` to 128-bits + msBroadcast128_2xFloat16 = 128, + // Broadcast 2 x `bfloat16` to 128-bits + msBroadcast128_2xBFloat16 = 129, + // Broadcast `i16` to 256-bits + msBroadcast256_Int16 = 130, + // Broadcast `u16` to 256-bits + msBroadcast256_UInt16 = 131, + // Broadcast `u32` to 256-bits + msBroadcast256_UInt32 = 132, + // Broadcast `i32` to 256-bits + msBroadcast256_Int32 = 133, + // Broadcast `u52` to 256-bits + msBroadcast256_UInt52 = 134, + // Broadcast `u64` to 256-bits + msBroadcast256_UInt64 = 135, + // Broadcast `i64` to 256-bits + msBroadcast256_Int64 = 136, + // Broadcast `f16` to 256-bits + msBroadcast256_Float16 = 137, + // Broadcast `f32` to 256-bits + msBroadcast256_Float32 = 138, + // Broadcast `f64` to 256-bits + msBroadcast256_Float64 = 139, + // Broadcast 2 x `i16` to 256-bits + msBroadcast256_2xInt16 = 140, + // Broadcast 2 x `i32` to 256-bits + msBroadcast256_2xInt32 = 141, + // Broadcast 2 x `u32` to 256-bits + msBroadcast256_2xUInt32 = 142, + // Broadcast 2 x `f16` to 256-bits + msBroadcast256_2xFloat16 = 143, + // Broadcast 2 x `bfloat16` to 256-bits + msBroadcast256_2xBFloat16 = 144, + // Broadcast `i16` to 512-bits + msBroadcast512_Int16 = 145, + // Broadcast `u16` to 512-bits + msBroadcast512_UInt16 = 146, + // Broadcast `u32` to 512-bits + msBroadcast512_UInt32 = 147, + // Broadcast `i32` to 512-bits + msBroadcast512_Int32 = 148, + // Broadcast `u52` to 512-bits + msBroadcast512_UInt52 = 149, + // Broadcast `u64` to 512-bits + msBroadcast512_UInt64 = 150, + // Broadcast `i64` to 512-bits + msBroadcast512_Int64 = 151, + // Broadcast `f16` to 512-bits + msBroadcast512_Float16 = 152, + // Broadcast `f32` to 512-bits + msBroadcast512_Float32 = 153, + // Broadcast `f64` to 512-bits + msBroadcast512_Float64 = 154, + // Broadcast 2 x `f16` to 512-bits + msBroadcast512_2xFloat16 = 155, + // Broadcast 2 x `i16` to 512-bits + msBroadcast512_2xInt16 = 156, + // Broadcast 2 x `u32` to 512-bits + msBroadcast512_2xUInt32 = 157, + // Broadcast 2 x `i32` to 512-bits + msBroadcast512_2xInt32 = 158, + // Broadcast 2 x `bfloat16` to 512-bits + msBroadcast512_2xBFloat16 = 159 + ); + + TMemorySizeInfo = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + size : Word; + ElementSize : Word; + MemorySize : TMemorySizeType; + ElementType : TMemorySizeType; + // Use flags if more booleans are needed + IsSigned : Boolean; + IsBroadcast : Boolean; + function ElementCount : Word; + function IsPacked : Boolean; + end; + + TMemorySize = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + MemorySize : TMemorySizeType; + {$IFDEF UNICODE} + class operator Equal( const self, AMemorySize : TMemorySize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AMemorySize : TMemorySize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TMemorySize; const AMemorySize : array of TMemorySizeType ) : Boolean; + class operator GreaterThan( const self, AMemorySize : TMemorySize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AMemorySize : TMemorySize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AMemorySize : TMemorySize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AMemorySize : TMemorySize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMemorySize : TMemorySize ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMemorySize : TMemorySize ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMemorySize : Byte ) : TMemorySize; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMemorySize : TMemorySize ) : TMemorySizeType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMemorySize : TMemorySizeType ) : TMemorySize; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function Info : TMemorySizeInfo; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Size : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ElementSize : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ElementType : TMemorySize; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ElementTypeInfo : TMemorySizeInfo; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsSigned : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsPacked : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ElementCount : NativeUInt; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsBroadcast : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + +//const +// OpCodeInfoCharCount = 30; +//type + TOpCodeInfo = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} +// op_code_string : Array [ 0..OpCodeInfoCharCount-1 ] of AnsiChar; +// instruction_string : Array [ 0..OpCodeInfoCharCount-1 ] of AnsiChar; + code : TCodeType; + op_code : Word; + encoding : TEncodingKind; + operand_size : Byte; + address_size : Byte; + l : Byte; + tuple_type : TTupleType; + table : TOpCodeTableKind; + mandatory_prefix : TMandatoryPrefix; + // Group index (0-7) or -1. If it's 0-7, it's stored in the `reg` field of the `modrm` byte. + group_index : ShortInt; + // Group index (0-7) or -1. If it's 0-7, it's stored in the `rm` field of the `modrm` byte. + rm_group_index : ShortInt; + op_kinds : Array [ 0..5 ] of TOpCodeOperandKind; + + function OpCodeString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + function InstructionString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Mnemonic : TMnemonic; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Mode16 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Mode32 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Mode64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsAvailableInMode( Bitness : Cardinal ) : Boolean; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsAvailableInMode( Bitness : TIcedBitness ) : Boolean; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsInstruction : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Fwait : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function W : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsLig : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsWig : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsWig32 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsRmGroup : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsGroup : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexEhBit : TMvexEHBit; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexCanUseEvictionHint : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexCanUseImmRoundingControl : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexIgnoresOpMaskRegister : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexNoSaeRc : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexTupleTypeLutKind : TMvexTupleTypeLutKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexConversionFunc : TMvexConvFn; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexValidConversionFuncsMask : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexValidSwizzleFuncsMask : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MemorySize : TMemorySize; {$IF CompilerVersion >= 23}inline;{$IFEND} + function BroadcastMemorySize : TMemorySize; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanBroadcast : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseRoundingControl : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanSuppressAllExceptions : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseOpMaskRegister : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RequireOpMaskRegister : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseZeroingMasking : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseLockPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseXacquirePrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseXreleasePrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseRepPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseRepnePrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseBndPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseHintTakenPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseNotrackPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IgnoresRoundingControl : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdLockRegBit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function DefaultOpSize64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ForceOpSize64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelForceOpSize64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MustBeCpl0 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Cpl0 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Cpl1 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Cpl2 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Cpl3 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsInputOutput : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsNop : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsReservedNop : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsSerializingIntel : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsSerializingAmd : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MayRequireCpl0 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsCetTracked : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsNonTemporal : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsFpuNoWait : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IgnoresModBits : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function No66 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Nfx : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RequiresUniqueRegNums : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RequiresUniqueDestRegNum : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsPrivileged : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsSaveRestore : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsStackInstruction : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IgnoresSegment : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsOpMaskReadWrite : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RealMode : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ProtectedMode : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Virtual8086Mode : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CompatibilityMode : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function LongMode : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseOutsideSmm : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInSmm : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseOutsideEnclaveSgx : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInEnclaveSgx1 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInEnclaveSgx2 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseOutsideVmxOp : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInVmxRootOp : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInVmxNonRootOp : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseOutsideSeam : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInSeam : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TdxNonRootGenUd : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TdxNonRootGenVe : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TdxNonRootMayGenEx : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelVMExit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelMayVMExit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelSmmVMExit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdVMExit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdMayVMExit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TsxAbort : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TsxImplAbort : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TsxMayAbort : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelDecoder16 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelDecoder32 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelDecoder64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdDecoder16 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdDecoder32 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdDecoder64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function DecoderOption : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OpCodeLen : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OPCount : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TCode = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + Code : TCodeType; + {$IFDEF UNICODE} + class operator Equal( const self, ACode : TCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TCode; const ACode : TCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, ACode : TCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TCode; const ACode : TCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TCode; const ACode : array of TCodeType ) : Boolean; + class operator GreaterThan( const self, ACode : TCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TCode; const ACode : TCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, ACode : TCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TCode; const ACode : TCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, ACode : TCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TCode; const ACode : TCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, ACode : TCode ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TCode; const ACode : TCodeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACode : TCode ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACode : TCode ) : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACode : Word ) : TCode; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACode : TCode ) : TCodeType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACode : TCodeType ) : TCode; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function Mnemonic : TMnemonic; + function OPCode : TOpCodeInfo; + function Encoding : TEncodingKind; + function CPUidFeature : TCPUIDFeaturesArray; + function FlowControl : TFlowControl; + function IsPrivileged : Boolean; + function IsStackInstruction : Boolean; + function IsSaveRestoreInstruction : Boolean; + function IsJccShort : Boolean; + function IsJmpShort : Boolean; + function IsJmpShortOrNear : Boolean; + function IsJmpNear : Boolean; + function IsJmpFar : Boolean; + function IsCallNear : Boolean; + function IsCallFar : Boolean; + function IsJmpNearIndirect : Boolean; + function IsJmpFarIndirect : Boolean; + function IsCallNearIndirect : Boolean; + function IsCallFarIndirect : Boolean; + function IsJkccShortOrNear : Boolean; + function IsJkccNear : Boolean; + function IsJkccShort : Boolean; + function ConditionCode : TConditionCode; + function IsStringInstruction : Boolean; + function IsJcxShort : Boolean; + function IsLoopCC : Boolean; + function IsLoop : Boolean; + + function IsJccShortOrNear : Boolean; + function NegateConditionCode : TCode; + function AsShortBranch : TCode; + function AsNearBranch : TCode; + function IgnoresSegment : Boolean; + function IgnoresIndex : Boolean; + function IsTileStrideIndex : Boolean; + end; + + TRegisterType = ( + None = 0, + AL = 1, + CL = 2, + DL = 3, + BL = 4, + AH = 5, + CH = 6, + DH = 7, + BH = 8, + SPL = 9, + BPL = 10, + SIL = 11, + DIL = 12, + R8L = 13, + R9L = 14, + R10L = 15, + R11L = 16, + R12L = 17, + R13L = 18, + R14L = 19, + R15L = 20, + AX = 21, + CX = 22, + DX = 23, + BX = 24, + SP = 25, + BP = 26, + SI = 27, + DI = 28, + R8W = 29, + R9W = 30, + R10W = 31, + R11W = 32, + R12W = 33, + R13W = 34, + R14W = 35, + R15W = 36, + EAX = 37, + ECX = 38, + EDX = 39, + EBX = 40, + ESP = 41, + EBP = 42, + ESI = 43, + EDI = 44, + R8D = 45, + R9D = 46, + R10D = 47, + R11D = 48, + R12D = 49, + R13D = 50, + R14D = 51, + R15D = 52, + RAX = 53, + RCX = 54, + RDX = 55, + RBX = 56, + RSP = 57, + RBP = 58, + RSI = 59, + RDI = 60, + R8 = 61, + R9 = 62, + R10 = 63, + R11 = 64, + R12 = 65, + R13 = 66, + R14 = 67, + R15 = 68, + EIP = 69, + RIP = 70, + ES = 71, + CS = 72, + SS = 73, + DS = 74, + FS = 75, + GS = 76, + XMM0 = 77, + XMM1 = 78, + XMM2 = 79, + XMM3 = 80, + XMM4 = 81, + XMM5 = 82, + XMM6 = 83, + XMM7 = 84, + XMM8 = 85, + XMM9 = 86, + XMM10 = 87, + XMM11 = 88, + XMM12 = 89, + XMM13 = 90, + XMM14 = 91, + XMM15 = 92, + XMM16 = 93, + XMM17 = 94, + XMM18 = 95, + XMM19 = 96, + XMM20 = 97, + XMM21 = 98, + XMM22 = 99, + XMM23 = 100, + XMM24 = 101, + XMM25 = 102, + XMM26 = 103, + XMM27 = 104, + XMM28 = 105, + XMM29 = 106, + XMM30 = 107, + XMM31 = 108, + YMM0 = 109, + YMM1 = 110, + YMM2 = 111, + YMM3 = 112, + YMM4 = 113, + YMM5 = 114, + YMM6 = 115, + YMM7 = 116, + YMM8 = 117, + YMM9 = 118, + YMM10 = 119, + YMM11 = 120, + YMM12 = 121, + YMM13 = 122, + YMM14 = 123, + YMM15 = 124, + YMM16 = 125, + YMM17 = 126, + YMM18 = 127, + YMM19 = 128, + YMM20 = 129, + YMM21 = 130, + YMM22 = 131, + YMM23 = 132, + YMM24 = 133, + YMM25 = 134, + YMM26 = 135, + YMM27 = 136, + YMM28 = 137, + YMM29 = 138, + YMM30 = 139, + YMM31 = 140, + ZMM0 = 141, + ZMM1 = 142, + ZMM2 = 143, + ZMM3 = 144, + ZMM4 = 145, + ZMM5 = 146, + ZMM6 = 147, + ZMM7 = 148, + ZMM8 = 149, + ZMM9 = 150, + ZMM10 = 151, + ZMM11 = 152, + ZMM12 = 153, + ZMM13 = 154, + ZMM14 = 155, + ZMM15 = 156, + ZMM16 = 157, + ZMM17 = 158, + ZMM18 = 159, + ZMM19 = 160, + ZMM20 = 161, + ZMM21 = 162, + ZMM22 = 163, + ZMM23 = 164, + ZMM24 = 165, + ZMM25 = 166, + ZMM26 = 167, + ZMM27 = 168, + ZMM28 = 169, + ZMM29 = 170, + ZMM30 = 171, + ZMM31 = 172, + K0 = 173, + K1 = 174, + K2 = 175, + K3 = 176, + K4 = 177, + K5 = 178, + K6 = 179, + K7 = 180, + BND0 = 181, + BND1 = 182, + BND2 = 183, + BND3 = 184, + CR0 = 185, + CR1 = 186, + CR2 = 187, + CR3 = 188, + CR4 = 189, + CR5 = 190, + CR6 = 191, + CR7 = 192, + CR8 = 193, + CR9 = 194, + CR10 = 195, + CR11 = 196, + CR12 = 197, + CR13 = 198, + CR14 = 199, + CR15 = 200, + DR0 = 201, + DR1 = 202, + DR2 = 203, + DR3 = 204, + DR4 = 205, + DR5 = 206, + DR6 = 207, + DR7 = 208, + DR8 = 209, + DR9 = 210, + DR10 = 211, + DR11 = 212, + DR12 = 213, + DR13 = 214, + DR14 = 215, + DR15 = 216, + ST0 = 217, + ST1 = 218, + ST2 = 219, + ST3 = 220, + ST4 = 221, + ST5 = 222, + ST6 = 223, + ST7 = 224, + MM0 = 225, + MM1 = 226, + MM2 = 227, + MM3 = 228, + MM4 = 229, + MM5 = 230, + MM6 = 231, + MM7 = 232, + TR0 = 233, + TR1 = 234, + TR2 = 235, + TR3 = 236, + TR4 = 237, + TR5 = 238, + TR6 = 239, + TR7 = 240, + TMM0 = 241, + TMM1 = 242, + TMM2 = 243, + TMM3 = 244, + TMM4 = 245, + TMM5 = 246, + TMM6 = 247, + TMM7 = 248, + // Don't use it! + //[deprecated(since = "1.12.0", note = "Not part of the public API")] + DontUse0 = 249, + // Don't use it! + //[deprecated(since = "1.12.0", note = "Not part of the public API")] + DontUseFA = 250, + // Don't use it! + //[deprecated(since = "1.12.0", note = "Not part of the public API")] + DontUseFB = 251, + // Don't use it! + //[deprecated(since = "1.12.0", note = "Not part of the public API")] + DontUseFC = 252, + // Don't use it! + //[deprecated(since = "1.12.0", note = "Not part of the public API")] + DontUseFD = 253, + // Don't use it! + //[deprecated(since = "1.12.0", note = "Not part of the public API")] + DontUseFE = 254, + // Don't use it! + //[deprecated(since = "1.12.0", note = "Not part of the public API")] + DontUseFF = 255 + ); + + TRegister = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + Register : TRegisterType; + {$IFDEF UNICODE} + class operator Equal( const self, ARegister : TRegister ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TRegister; const ARegister : TRegisterType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, ARegister : TRegister ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TRegister; const ARegister : TRegisterType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TRegister; const ARegister : array of TRegisterType ) : Boolean; + class operator GreaterThan( const self, ARegister : TRegister ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TRegister; const ARegister : TRegisterType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, ARegister : TRegister ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TRegister; const ARegister : TRegisterType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, ARegister : TRegister ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TRegister; const ARegister : TRegisterType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, ARegister : TRegister ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TRegister; const ARegister : TRegisterType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARegister : TRegister ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARegister : TRegister ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARegister : Byte ) : TRegister; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARegister : TRegister ) : TRegisterType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARegister : TRegisterType ) : TRegister; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function Base : TRegister; + function Number : NativeUInt; + function FullRegister : TRegister; + function FullRegister32 : TRegister; + function Size : NativeUInt; + function IsSegmentRegister : Boolean; + function IsGPR : Boolean; + function IsGPR8 : Boolean; + function IsGPR16 : Boolean; + function IsGPR32 : Boolean; + function IsGPR64 : Boolean; + function IsXMM : Boolean; + function IsYMM : Boolean; + function IsZMM : Boolean; + function IsVectorRegister : Boolean; + function IsIP : Boolean; + function IsK : Boolean; + function IsCR : Boolean; + function IsDR : Boolean; + function IsTR : Boolean; + function IsST : Boolean; + function IsBND : Boolean; + function IsMM : Boolean; + function IsTMM : Boolean; + end; + + TOpKindType = ( + // A register ([`Register`]). + // + // This operand kind uses [`Instruction::op0_register()`], [`Instruction::op1_register()`], [`Instruction::op2_register()`], [`Instruction::op3_register()`] or [`Instruction::op4_register()`] depending on operand number. See also [`Instruction::op_register()`]. + // + // [`Register`]: enum.Register.html + // [`Instruction::op0_register()`]: struct.Instruction.html#method.op0_register + // [`Instruction::op1_register()`]: struct.Instruction.html#method.op1_register + // [`Instruction::op2_register()`]: struct.Instruction.html#method.op2_register + // [`Instruction::op3_register()`]: struct.Instruction.html#method.op3_register + // [`Instruction::op4_register()`]: struct.Instruction.html#method.op4_register + // [`Instruction::op_register()`]: struct.Instruction.html#method.op_register + okRegister_ = 0, + // Near 16-bit branch. This operand kind uses [`Instruction::near_branch16()`] + // + // [`Instruction::near_branch16()`]: struct.Instruction.html#method.near_branch16 + okNearBranch16 = 1, + // Near 32-bit branch. This operand kind uses [`Instruction::near_branch32()`] + // + // [`Instruction::near_branch32()`]: struct.Instruction.html#method.near_branch32 + okNearBranch32 = 2, + // Near 64-bit branch. This operand kind uses [`Instruction::near_branch64()`] + // + // [`Instruction::near_branch64()`]: struct.Instruction.html#method.near_branch64 + okNearBranch64 = 3, + // Far 16-bit branch. This operand kind uses [`Instruction::far_branch16()`] and [`Instruction::far_branch_selector()`] + // + // [`Instruction::far_branch16()`]: struct.Instruction.html#method.far_branch16 + // [`Instruction::far_branch_selector()`]: struct.Instruction.html#method.far_branch_selector + okFarBranch16 = 4, + // Far 32-bit branch. This operand kind uses [`Instruction::far_branch32()`] and [`Instruction::far_branch_selector()`] + // + // [`Instruction::far_branch32()`]: struct.Instruction.html#method.far_branch32 + // [`Instruction::far_branch_selector()`]: struct.Instruction.html#method.far_branch_selector + okFarBranch32 = 5, + // 8-bit constant. This operand kind uses [`Instruction::immediate8()`] + // + // [`Instruction::immediate8()`]: struct.Instruction.html#method.immediate8 + okImmediate8 = 6, + // 8-bit constant used by the `ENTER`, `EXTRQ`, `INSERTQ` instructions. This operand kind uses [`Instruction::immediate8_2nd()`] + // + // [`Instruction::immediate8_2nd()`]: struct.Instruction.html#method.immediate8_2nd + okImmediate8_2nd = 7, + // 16-bit constant. This operand kind uses [`Instruction::immediate16()`] + // + // [`Instruction::immediate16()`]: struct.Instruction.html#method.immediate16 + okImmediate16 = 8, + // 32-bit constant. This operand kind uses [`Instruction::immediate32()`] + // + // [`Instruction::immediate32()`]: struct.Instruction.html#method.immediate32 + okImmediate32 = 9, + // 64-bit constant. This operand kind uses [`Instruction::immediate64()`] + // + // [`Instruction::immediate64()`]: struct.Instruction.html#method.immediate64 + okImmediate64 = 10, + // An 8-bit value sign extended to 16 bits. This operand kind uses [`Instruction::immediate8to16()`] + // + // [`Instruction::immediate8to16()`]: struct.Instruction.html#method.immediate8to16 + okImmediate8to16 = 11, + // An 8-bit value sign extended to 32 bits. This operand kind uses [`Instruction::immediate8to32()`] + // + // [`Instruction::immediate8to32()`]: struct.Instruction.html#method.immediate8to32 + okImmediate8to32 = 12, + // An 8-bit value sign extended to 64 bits. This operand kind uses [`Instruction::immediate8to64()`] + // + // [`Instruction::immediate8to64()`]: struct.Instruction.html#method.immediate8to64 + okImmediate8to64 = 13, + // A 32-bit value sign extended to 64 bits. This operand kind uses [`Instruction::immediate32to64()`] + // + // [`Instruction::immediate32to64()`]: struct.Instruction.html#method.immediate32to64 + okImmediate32to64 = 14, + // `seg:[SI]`. This operand kind uses [`Instruction::memory_size()`], [`Instruction::memory_segment()`], [`Instruction::segment_prefix()`] + // + // [`Instruction::memory_size()`]: struct.Instruction.html#method.memory_size + // [`Instruction::memory_segment()`]: struct.Instruction.html#method.memory_segment + // [`Instruction::segment_prefix()`]: struct.Instruction.html#method.segment_prefix + okMemorySegSI = 15, + // `seg:[ESI]`. This operand kind uses [`Instruction::memory_size()`], [`Instruction::memory_segment()`], [`Instruction::segment_prefix()`] + // + // [`Instruction::memory_size()`]: struct.Instruction.html#method.memory_size + // [`Instruction::memory_segment()`]: struct.Instruction.html#method.memory_segment + // [`Instruction::segment_prefix()`]: struct.Instruction.html#method.segment_prefix + okMemorySegESI = 16, + // `seg:[RSI]`. This operand kind uses [`Instruction::memory_size()`], [`Instruction::memory_segment()`], [`Instruction::segment_prefix()`] + // + // [`Instruction::memory_size()`]: struct.Instruction.html#method.memory_size + // [`Instruction::memory_segment()`]: struct.Instruction.html#method.memory_segment + // [`Instruction::segment_prefix()`]: struct.Instruction.html#method.segment_prefix + okMemorySegRSI = 17, + // `seg:[DI]`. This operand kind uses [`Instruction::memory_size()`], [`Instruction::memory_segment()`], [`Instruction::segment_prefix()`] + // + // [`Instruction::memory_size()`]: struct.Instruction.html#method.memory_size + // [`Instruction::memory_segment()`]: struct.Instruction.html#method.memory_segment + // [`Instruction::segment_prefix()`]: struct.Instruction.html#method.segment_prefix + okMemorySegDI = 18, + // `seg:[EDI]`. This operand kind uses [`Instruction::memory_size()`], [`Instruction::memory_segment()`], [`Instruction::segment_prefix()`] + // + // [`Instruction::memory_size()`]: struct.Instruction.html#method.memory_size + // [`Instruction::memory_segment()`]: struct.Instruction.html#method.memory_segment + // [`Instruction::segment_prefix()`]: struct.Instruction.html#method.segment_prefix + okMemorySegEDI = 19, + // `seg:[RDI]`. This operand kind uses [`Instruction::memory_size()`], [`Instruction::memory_segment()`], [`Instruction::segment_prefix()`] + // + // [`Instruction::memory_size()`]: struct.Instruction.html#method.memory_size + // [`Instruction::memory_segment()`]: struct.Instruction.html#method.memory_segment + // [`Instruction::segment_prefix()`]: struct.Instruction.html#method.segment_prefix + okMemorySegRDI = 20, + // `ES:[DI]`. This operand kind uses [`Instruction::memory_size()`] + // + // [`Instruction::memory_size()`]: struct.Instruction.html#method.memory_size + okMemoryESDI = 21, + // `ES:[EDI]`. This operand kind uses [`Instruction::memory_size()`] + // + // [`Instruction::memory_size()`]: struct.Instruction.html#method.memory_size + okMemoryESEDI = 22, + // `ES:[RDI]`. This operand kind uses [`Instruction::memory_size()`] + // + // [`Instruction::memory_size()`]: struct.Instruction.html#method.memory_size + okMemoryESRDI = 23, + // Memory operand. + // + // This operand kind uses [`Instruction::memory_displ_size()`], [`Instruction::memory_size()`], [`Instruction::memory_index_scale()`], [`Instruction::memory_displacement64()`], [`Instruction::memory_base()`], [`Instruction::memory_index()`], [`Instruction::memory_segment()`], [`Instruction::segment_prefix()`] + // + // [`Instruction::memory_displ_size()`]: struct.Instruction.html#method.memory_displ_size + // [`Instruction::memory_size()`]: struct.Instruction.html#method.memory_size + // [`Instruction::memory_index_scale()`]: struct.Instruction.html#method.memory_index_scale + // [`Instruction::memory_displacement64()`]: struct.Instruction.html#method.memory_displacement64 + // [`Instruction::memory_base()`]: struct.Instruction.html#method.memory_base + // [`Instruction::memory_index()`]: struct.Instruction.html#method.memory_index + // [`Instruction::memory_segment()`]: struct.Instruction.html#method.memory_segment + // [`Instruction::segment_prefix()`]: struct.Instruction.html#method.segment_prefix + okMemory = 24 + ); + + TOpKind = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + OpKind : TOpKindType; + {$IFDEF UNICODE} + class operator Equal( const self, AOpKind : TOpKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AOpKind : TOpKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TOpKind; const AOpKind : array of TOpKindType ) : Boolean; + class operator GreaterThan( const self, AOpKind : TOpKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AOpKind : TOpKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AOpKind : TOpKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AOpKind : TOpKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpKind : TOpKind ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpKind : TOpKind ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpKind : Byte ) : TOpKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpKind : TOpKind ) : TOpKindType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpKind : TOpKindType ) : TOpKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + +const + OpKindsMaxEntries = 5; + +type + TOPKindsArray = packed record + Entries : Array [ 0..OpKindsMaxEntries-1 ] of TOpKind; + Count : Byte; + end; + + TInstrScale = ( + Scale1 = 0, + Scale2 = 1, + Scale4 = 2, + Scale8 = 3 + ); + + TFpuStackIncrementInfo = packed record + increment : Integer; + conditional : Boolean; + writes_top : Boolean; + end; + + TMemoryOperand = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + // Segment override or [`Register::None`] + // + // [`Register::None`]: enum.Register.html#variant.None + segment_prefix: TRegister; // FFI-Unsafe: Register, + + // Base register or [`Register::None`] + // + // [`Register::None`]: enum.Register.html#variant.None + base: TRegister; // FFI-Unsafe: Register, + + // Index register or [`Register::None`] + // + // [`Register::None`]: enum.Register.html#variant.None + index: TRegister; // FFI-Unsafe: Register, + + // Index register scale (1, 2, 4, or 8) + scale: Cardinal; + + // Memory displacement + displacement: Int64; + + // 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + displ_size: Cardinal; + + // `true` if it's broadcast memory (EVEX instructions) + is_broadcast: boolean; + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + // * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) + // * `segment_prefix`: Segment override or [`Register::None`] + class function New( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + // * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) + // * `segment_prefix`: Segment override or [`Register::None`] + class function With_Base_Index_Scale_Bcst_Seg( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // + // * `base`: Base register or [`Register::None`] + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + // * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) + // * `segment_prefix`: Segment override or [`Register::None`] + class function With_Base_Displ_Size_Bcst_Seg( ABase: TRegisterType; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + // * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) + // * `segment_prefix`: Segment override or [`Register::None`] + class function With_Index_Scale_Displ_Size_Bcst_Seg( AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `displacement`: Memory displacement + // * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) + // * `segment_prefix`: Segment override or [`Register::None`] + class function With_Base_Displ_Bcst_Seg( ABase: TRegisterType; ADisplacement: Int64; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + class function With_Base_Index_Scale_DisplSize( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + class function With_Base_Index_Scale( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `index`: Index register or [`Register::None`] + class function With_Base_Index( ABase: TRegisterType; AIndex: TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + class function With_Base_Displ_Size( ABase: TRegisterType; ADisplacement: Int64; ADisplSize : Cardinal ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + class function With_Index_Scale_Displ_Size( AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `displacement`: Memory displacement + class function With_Base_Displ( ABase: TRegisterType; ADisplacement: Int64 ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `base`: Base register or [`Register::None`] + class function With_Base( ABase: TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `displacement`: Memory displacement + // * `displ_size`: 2 (16-bit), 4 (32-bit) or 8 (64-bit) + class function With_Displ( ADisplacement: Int64; ADisplSize : Cardinal ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + // * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) + // * `segment_prefix`: Segment override or [`Register::None`] + constructor From( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ); + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + // * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) + // * `segment_prefix`: Segment override or [`Register::None`] + constructor From_Base_Index_Scale_Bcst_Seg( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ); + + // # Arguments + // + // * `base`: Base register or [`Register::None`] + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + // * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) + // * `segment_prefix`: Segment override or [`Register::None`] + constructor From_Base_Displ_Size_Bcst_Seg( ABase: TRegisterType; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ); + + // # Arguments + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + // * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) + // * `segment_prefix`: Segment override or [`Register::None`] + constructor From_Index_Scale_Displ_Size_Bcst_Seg( AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ); + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `displacement`: Memory displacement + // * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) + // * `segment_prefix`: Segment override or [`Register::None`] + constructor From_Base_Displ_Bcst_Seg( ABase: TRegisterType; ADisplacement: Int64; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ); + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + constructor From_Base_Index_Scale_DisplSize( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal ); + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + constructor From_Base_Index_Scale( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal ); + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `index`: Index register or [`Register::None`] + constructor From_Base_Index( ABase: TRegisterType; AIndex: TRegisterType ); + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + constructor From_Base_Displ_Size( ABase: TRegisterType; ADisplacement: Int64; ADisplSize : Cardinal ); + + // # Arguments + // * `index`: Index register or [`Register::None`] + // * `scale`: Index register scale (1, 2, 4, or 8) + // * `displacement`: Memory displacement + // * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + constructor From_Index_Scale_Displ_Size( AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal ); + + // # Arguments + // * `base`: Base register or [`Register::None`] + // * `displacement`: Memory displacement + constructor From_Base_Displ( ABase: TRegisterType; ADisplacement: Int64 ); + + // # Arguments + // * `base`: Base register or [`Register::None`] + constructor From_Base( ABase: TRegisterType ); + + // # Arguments + // * `displacement`: Memory displacement + // * `displ_size`: 2 (16-bit), 4 (32-bit) or 8 (64-bit) + constructor From_Displ( ADisplacement: Int64; ADisplSize : Cardinal ); + end; + + TRFlag = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + Value : Cardinal; + + function IsNone : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OF_ : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function SF : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ZF : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AF : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CF : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function PF : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function DF : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IF_ : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AC : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UIF : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TRFlags = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + Read : TRFlag{Cardinal}; + Written : TRFlag{Cardinal}; + Cleared : TRFlag{Cardinal}; + Set_ : TRFlag{Cardinal}; + Undefined : TRFlag{Cardinal}; + Modified : TRFlag{Cardinal}; + function ReadAsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + function WrittenAsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ClearedAsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + function SetAsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UndefinedAsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ModifiedAsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TCodeSizeType = ( + // Unknown size + csUnknown = 0, + // 16-bit code + csCode16 = 1, + // 32-bit code + csCode32 = 2, + // 64-bit code + csCode64 = 3 + ); + + TCodeSize = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + CodeSize : TCodeSizeType; + {$IFDEF UNICODE} + class operator Equal( const self, ACodeSize : TCodeSize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, ACodeSize : TCodeSize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TCodeSize; const ACodeSize : array of TCodeSizeType ) : Boolean; + class operator GreaterThan( const self, ACodeSize : TCodeSize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, ACodeSize : TCodeSize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, ACodeSize : TCodeSize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, ACodeSize : TCodeSize ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACodeSize : TCodeSize ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACodeSize : TCodeSize ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACodeSize : Byte ) : TCodeSize; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACodeSize : TCodeSize ) : TCodeSizeType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ACodeSize : TCodeSizeType ) : TCodeSize; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TRoundingControlType = ( + // No rounding mode + rcNone = 0, + // Round to nearest (even) + rcRoundToNearest = 1, + // Round down (toward -inf) + rcRoundDown = 2, + // Round up (toward +inf) + rcRoundUp = 3, + // Round toward zero (truncate) + rcRoundTowardZero = 4 + ); + + TRoundingControl = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + RoundingControl : TRoundingControlType; + {$IFDEF UNICODE} + class operator Equal( const self, ARoundingControl : TRoundingControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, ARoundingControl : TRoundingControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TRoundingControl; const ARoundingControl : array of TRoundingControlType ) : Boolean; + class operator GreaterThan( const self, ARoundingControl : TRoundingControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, ARoundingControl : TRoundingControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, ARoundingControl : TRoundingControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, ARoundingControl : TRoundingControl ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARoundingControl : TRoundingControl ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARoundingControl : TRoundingControl ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARoundingControl : Byte ) : TRoundingControl; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARoundingControl : TRoundingControl ) : TRoundingControlType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARoundingControl : TRoundingControlType ) : TRoundingControl; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TMvexRegMemConvType = ( + // No operand conversion + mrmcNone = 0, + // Register swizzle: `zmm0` or `zmm0 {dcba}` + mrmcRegSwizzleNone = 1, + // Register swizzle: `zmm0 {cdab}` + mrmcRegSwizzleCdab = 2, + // Register swizzle: `zmm0 {badc}` + mrmcRegSwizzleBadc = 3, + // Register swizzle: `zmm0 {dacb}` + mrmcRegSwizzleDacb = 4, + // Register swizzle: `zmm0 {aaaa}` + mrmcRegSwizzleAaaa = 5, + // Register swizzle: `zmm0 {bbbb}` + mrmcRegSwizzleBbbb = 6, + // Register swizzle: `zmm0 {cccc}` + mrmcRegSwizzleCccc = 7, + // Register swizzle: `zmm0 {dddd}` + mrmcRegSwizzleDddd = 8, + // Memory Up/DownConv: `[rax]` / `zmm0` + mrmcMemConvNone = 9, + // Memory UpConv: `[rax] {1to16}` or `[rax] {1to8}` + mrmcMemConvBroadcast1 = 10, + // Memory UpConv: `[rax] {4to16}` or `[rax] {4to8}` + mrmcMemConvBroadcast4 = 11, + // Memory Up/DownConv: `[rax] {float16}` / `zmm0 {float16}` + mrmcMemConvFloat16 = 12, + // Memory Up/DownConv: `[rax] {uint8}` / `zmm0 {uint8}` + mrmcMemConvUint8 = 13, + // Memory Up/DownConv: `[rax] {sint8}` / `zmm0 {sint8}` + mrmcMemConvSint8 = 14, + // Memory Up/DownConv: `[rax] {uint16}` / `zmm0 {uint16}` + mrmcMemConvUint16 = 15, + // Memory Up/DownConv: `[rax] {sint16}` / `zmm0 {sint16}` + mrmcMemConvSint16 = 16 + ); + + TMvexRegMemConv = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + MvexRegMemConv : TMvexRegMemConvType; + {$IFDEF UNICODE} + class operator Equal( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TMvexRegMemConv; const AMvexRegMemConv : array of TMvexRegMemConvType ) : Boolean; + class operator GreaterThan( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexRegMemConv : TMvexRegMemConv ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexRegMemConv : TMvexRegMemConv ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexRegMemConv : Byte ) : TMvexRegMemConv; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexRegMemConv : TMvexRegMemConv ) : TMvexRegMemConvType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMvexRegMemConv : TMvexRegMemConvType ) : TMvexRegMemConv; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TVirtualAddressResolverCallback = function( Register: TRegister; Index : NativeUInt; Size : NativeUInt; var Address : UInt64; UserData : Pointer ) : boolean; cdecl; + + TInstruction = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + next_rip : UInt64; + mem_displ : UInt64; + + {$IF Defined( ICED_1210 )} + op_kinds : Array [ 0..3 ] of TOpKind; + flags1 : Cardinal; // InstrFlags1 + immediate : Cardinal; + regs : Array [ 0..3 ] of TRegister; + code : TCode; + scale : TInstrScale; + mem_base_reg : TRegister; + mem_index_reg : TRegister; + displ_size : Byte; + len : Byte; + pad : Byte; + {$ELSEIF Defined( ICED_1190 )} + flags1 : Cardinal; // InstrFlags1 + immediate : Cardinal; + regs : Array [ 0..3 ] of TRegister; + op_kinds : Array [ 0..3 ] of TOpKind; + code : TCode; + mem_base_reg : TRegister; + mem_index_reg : TRegister; + displ_size : Byte; + len : Byte; + pad : Byte; + scale : TInstrScale; + {$ELSE} + flags1 : Cardinal; // InstrFlags1 + immediate : Cardinal; + code : TCode; + mem_base_reg : TRegister; + mem_index_reg : TRegister; + regs : Array [ 0..3 ] of TRegister; + op_kinds : Array [ 0..3 ] of TOpKind; + scale : TInstrScale; + displ_size : Byte; + len : Byte; + pad : Byte; + {$IFEND ICED_1190} + + {$IFDEF UNICODE} + class operator Equal( const self : TInstruction; const Instruction : TInstruction ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TInstruction; const Instruction : TInstruction ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function GetRIP : UInt64; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetRIP( Value : UInt64 ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property RIP : UInt64 read GetRIP write SetRIP; + + function GetIP16 : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetIP16( Value : Word ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property IP16 : Word read GetIP16 write SetIP16; + + function GetIP32 : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetIP32( Value : Cardinal ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property IP32 : Cardinal read GetIP32 write SetIP32; + + function GetNextIP16 : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetNextIP16( Value : Word ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property NextIP16 : Word read GetNextIP16 write SetNextIP16; + + function GetNextIP32 : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetNextIP32( Value : Cardinal ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property NextIP32 : Cardinal read GetNextIP32 write SetNextIP32; + + function GetCodeSize : TCodeSize; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetCodeSize( Value : TCodeSize ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property CodeSize : TCodeSize read GetCodeSize write SetCodeSize; + + function IsValid : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsData : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsProcedureStart : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJump : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsRegJump : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsConditionalJump : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsCall : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsRet : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsFloat : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsFloat64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsEqual( const Instruction : TInstruction; IgnoreRIP : Boolean = True ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsPartialEqual( const Instruction : TInstruction ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsSimiliar( const Instruction : TInstruction; MaxDisplacement : Cardinal = 0 ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function FPU_StackIncrementInfo : TFpuStackIncrementInfo; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Encoding : TEncodingKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Mnemonic : TMnemonic; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CPUIDFeatures : TCPUIDFeaturesArray; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsStackInstruction : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function StackPointerIncrement : Integer; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ConditionCode : TConditionCode; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RFlagsRead : TRFlag{Cardinal}; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RFlagsWritten : TRFlag{Cardinal}; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RFlagsCleared : TRFlag{Cardinal}; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RFlagsSet : TRFlag{Cardinal}; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RFlagsUndefined : TRFlag{Cardinal}; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RFlagsModified : TRFlag{Cardinal}; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RFlags : TRFlags; {$IF CompilerVersion >= 23}inline;{$IFEND} + function FlowControl : TFlowControl; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OPKinds( var OPKindsArray : TOPKindsArray ) : TFlowControl; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MemorySize : TMemorySize; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OPCount : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function VSIB : Integer; {$IF CompilerVersion >= 23}inline;{$IFEND} + function GetLockPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetLockPrefix( Value : Boolean ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property HasLockPrefix : Boolean read GetLockPrefix write SetLockPrefix; + + function IsXacquireInstruction : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsXreleaseInstruction : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function GetHasXacquirePrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetHasXacquirePrefix( Value : Boolean ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property HasXacquirePrefix : Boolean read GetHasXacquirePrefix write SetHasXacquirePrefix; + + function GetHasXreleasePrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetHasXreleasePrefix( Value : Boolean ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property HasXreleasePrefix : Boolean read GetHasXreleasePrefix write SetHasXreleasePrefix; + + function GetHasRepPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetHasRepPrefix( Value : Boolean ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property HasRepPrefix : Boolean read GetHasRepPrefix write SetHasRepPrefix; + + function GetHasRepePrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetHasRepePrefix( Value : Boolean ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property HasRepePrefix : Boolean read GetHasRepePrefix write SetHasRepePrefix; + + function GetHasRepnePrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetHasRepnePrefix( Value : Boolean ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property HasRepnePrefix : Boolean read GetHasRepnePrefix write SetHasRepnePrefix; + + function HasSegmentPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function GetSegmentPrefix : TRegister; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetSegmentPrefix( Value : TRegister ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property SegmentPrefix : TRegister read GetSegmentPrefix write SetSegmentPrefix; + + function MemorySegment : TRegister; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function GetMemoryDisplSize : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetMemoryDisplSize( Value : Cardinal ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property MemoryDisplSize : Cardinal read GetMemoryDisplSize write SetMemoryDisplSize; + + function GetIsBroadcast : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetIsBroadcast( Value : Boolean ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property IsBroadcast : Boolean read GetIsBroadcast write SetIsBroadcast; + + function GetMemoryIndexScale : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetMemoryIndexScale( Value : Cardinal ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property MemoryIndexScale : Cardinal read GetMemoryIndexScale write SetMemoryIndexScale; + + function GetImmediate8 : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetImmediate8( Value : Byte ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property Immediate8 : Byte read GetImmediate8 write SetImmediate8; + + function GetImmediate8_2nd : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetImmediate8_2nd( Value : Byte ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property Immediate8_2nd : Byte read GetImmediate8_2nd write SetImmediate8_2nd; + + function GetImmediate16 : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetImmediate16( Value : Word ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property Immediate16 : Word read GetImmediate16 write SetImmediate16; + + function GetImmediate32 : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetImmediate32( Value : Cardinal ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property Immediate32 : Cardinal read GetImmediate32 write SetImmediate32; + + function GetImmediate64 : UInt64; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetImmediate64( Value : UInt64 ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property Immediate64 : UInt64 read GetImmediate64 write SetImmediate64; + + function GetImmediate8to16 : SmallInt; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetImmediate8to16( Value : SmallInt ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property Immediate8to16 : SmallInt read GetImmediate8to16 write SetImmediate8to16; + + function GetImmediate8to32 : Integer; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetImmediate8to32( Value : Integer ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property Immediate8to32 : Integer read GetImmediate8to32 write SetImmediate8to32; + + function GetImmediate8to64 : Int64; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetImmediate8to64( Value : Int64 ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property Immediate8to64 : Int64 read GetImmediate8to64 write SetImmediate8to64; + + function GetImmediate32to64 : Int64; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetImmediate32to64( Value : Int64 ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property Immediate32to64 : Int64 read GetImmediate32to64 write SetImmediate32to64; + + function GetNearBranch16 : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetNearBranch16( Value : Word ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property NearBranch16 : Word read GetNearBranch16 write SetNearBranch16; + + function GetNearBranch32 : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetNearBranch32( Value : Cardinal ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property NearBranch32 : Cardinal read GetNearBranch32 write SetNearBranch32; + + function GetNearBranch64 : UInt64; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetNearBranch64( Value : UInt64 ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property NearBranch64 : UInt64 read GetNearBranch64 write SetNearBranch64; + + function NearBranchTarget : UInt64; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function GetFarBranch16 : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetFarBranch16( Value : Word ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property FarBranch16 : Word read GetFarBranch16 write SetFarBranch16; + + function GetFarBranch32 : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetFarBranch32( Value : Cardinal ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property FarBranch32 : Cardinal read GetFarBranch32 write SetFarBranch32; + + function GetFarBranchSelector : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetFarBranchSelector( Value : Word ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property FarBranchSelector : Word read GetFarBranchSelector write SetFarBranchSelector; + + function HasOpMask : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function GetZeroingMasking : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetZeroingMasking( Value : Boolean ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property ZeroingMasking : Boolean read GetZeroingMasking write SetZeroingMasking; + + function GetMergingMasking : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetMergingMasking( Value : Boolean ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property MergingMasking : Boolean read GetMergingMasking write SetMergingMasking; + + function GetRoundingControl : TRoundingControl; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetRoundingControl( Value : TRoundingControl ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property RoundingControl : TRoundingControl read GetRoundingControl write SetRoundingControl; + + function GetSuppressAllExceptions : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetSuppressAllExceptions( Value : Boolean ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property SuppressAllExceptions : Boolean read GetSuppressAllExceptions write SetSuppressAllExceptions; + + function MemoryDisplacement32 : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MemoryDisplacement64 : UInt64; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsIP_RelMemoryOperand : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IP_RelMemoryAddress : UInt64; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function IsPrivileged : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsSaveRestoreInstruction : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJccShort : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJmpShort : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJmpShortOrNear : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJmpNear : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJmpFar : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsCallNear : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsCallFar : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJmpNearIndirect : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJmpFarIndirect : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsCallNearIndirect : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsCallFarIndirect : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJkccShortOrNear : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJkccNear : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJkccShort : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsStringInstruction : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJcxShort : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsLoopCC : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsLoop : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsJccShortOrNear : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure NegateConditionCode; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure AsShortBranch; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure AsNearBranch; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function GetIsMvexEvictionHint : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetIsMvexEvictionHint( Value : Boolean ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property IsMvexEvictionHint : Boolean read GetIsMvexEvictionHint write SetIsMvexEvictionHint; + + function GetMvexRegMemConv : TMvexRegMemConv; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetMvexRegMemConv( Value : TMvexRegMemConv ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property MvexRegMemConv : TMvexRegMemConv read GetMvexRegMemConv write SetMvexRegMemConv; + + function GetOpMask : TRegister; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetOpMask( Value : TRegister ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property OpMask : TRegister read GetOpMask write SetOpMask; + + procedure SetDeclareDataLen( Value : NativeUInt ); {$IF CompilerVersion >= 23}inline;{$IFEND} + + function GetOp4Kind : TOpKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetOp4Kind( Value : TOpKind ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property Op4Kind : TOpKind read GetOp4Kind write SetOp4Kind; + + function GetOpKind( Operand : Cardinal ) : TOpKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetOpKind( Operand : Cardinal; Value : TOpKind ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property OpKind[ Operand : Cardinal ] : TOpKind read GetOpKind write SetOpKind; + + function TryGetImmediate( Operand : Cardinal ) : UInt64; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure TrySetImmediate( Operand : Cardinal; Value : UInt64 ); {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure TrySetImmediate_( Operand : Cardinal; Value : Int64 ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure TrySetImmediate_( Operand : Cardinal; Value : Cardinal ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure TrySetImmediate_( Operand : Cardinal; Value : Integer ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + property TryImmediate[ Operand : Cardinal ] : UInt64 read TryGetImmediate write TrySetImmediate; + + function GetDeclareByteValue( index: NativeUInt ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetDeclareByteValue( index: NativeUInt; Value: Byte ); {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetDeclareByteValue_( index: NativeUInt; Value: ShortInt ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property DeclareByteValue[ index : NativeUInt ] : Byte read GetDeclareByteValue write SetDeclareByteValue; + + function GetDeclareWordValue( index: NativeUInt ) : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetDeclareWordValue( index: NativeUInt; Value: Word ); {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetDeclareWordValue_( index: NativeUInt; Value: SmallInt ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property DeclareWordValue[ index : NativeUInt ] : Word read GetDeclareWordValue write SetDeclareWordValue; + + function GetDeclareDWordValue( index: NativeUInt ) : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetDeclareDWordValue( index: NativeUInt; Value: Cardinal ); {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetDeclareDWordValue_( index: NativeUInt; Value: Integer ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property DeclareDWordValue[ index : NativeUInt ] : Cardinal read GetDeclareDWordValue write SetDeclareDWordValue; + + function GetDeclareQWordValue( index: NativeUInt ) : UInt64; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetDeclareQWordValue( index: NativeUInt; Value: UInt64 ); {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure SetDeclareQWordValue_( index: NativeUInt; Value: Int64 ); {$IF CompilerVersion >= 23}inline;{$IFEND} + property DeclareQWordValue[ index : NativeUInt ] : UInt64 read GetDeclareQWordValue write SetDeclareQWordValue; + + // OpCodeInfo + function OpCodeInfo : TOpCodeInfo; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsInstruction : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Mode16 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Mode32 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Mode64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Fwait : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OperandSize : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AddressSize : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + function L : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + function W : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsLig : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsWig : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsWig32 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TupleType : TTupleType; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexEhBit : TMvexEHBit; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexCanUseEvictionHint : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexCanUseImmRoundingControl : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexIgnoresOpMaskRegister : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexNoSaeRc : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexTupleTypeLutKind : TMvexTupleTypeLutKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexConversionFunc : TMvexConvFn; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexValidConversionFuncsMask : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MvexValidSwizzleFuncsMask : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OpCodeInfo_MemorySize : TMemorySize; {$IF CompilerVersion >= 23}inline;{$IFEND} + function BroadcastMemorySize : TMemorySize; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanBroadcast : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseRoundingControl : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanSuppressAllExceptions : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseOpMaskRegister : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RequireOpMaskRegister : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseZeroingMasking : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseLockPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseXacquirePrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseXreleasePrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseRepPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseRepnePrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseBndPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseHintTakenPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CanUseNotrackPrefix : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IgnoresRoundingControl : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdLockRegBit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function DefaultOpSize64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ForceOpSize64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelForceOpSize64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MustBeCpl0 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Cpl0 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Cpl1 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Cpl2 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Cpl3 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsInputOutput : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsNop : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsReservedNop : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsSerializingIntel : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsSerializingAmd : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MayRequireCpl0 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsCetTracked : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsNonTemporal : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsFpuNoWait : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IgnoresModBits : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function No66 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Nfx : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RequiresUniqueRegNums : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RequiresUniqueDestRegNum : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OpCodeInfo_IsPrivileged : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsSaveRestore : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OpCodeInfo_IsStackInstruction : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IgnoresSegment : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsOpMaskReadWrite : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RealMode : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function ProtectedMode : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Virtual8086Mode : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function CompatibilityMode : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function LongMode : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseOutsideSmm : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInSmm : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseOutsideEnclaveSgx : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInEnclaveSgx1 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInEnclaveSgx2 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseOutsideVmxOp : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInVmxRootOp : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInVmxNonRootOp : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseOutsideSeam : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function UseInSeam : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TdxNonRootGenUd : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TdxNonRootGenVe : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TdxNonRootMayGenEx : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelVMExit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelMayVMExit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelSmmVMExit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdVMExit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdMayVMExit : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TsxAbort : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TsxImplAbort : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function TsxMayAbort : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelDecoder16 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelDecoder32 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IntelDecoder64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdDecoder16 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdDecoder32 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function AmdDecoder64 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function DecoderOption : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + function Table : TOpCodeTableKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + function MandatoryPrefix : TMandatoryPrefix; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OpCode : Word; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OpCodeLen : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsGroup : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function GroupIndex : Integer; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsRMGroup : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function RMGroupIndex : Integer; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OpCodeInfo_OPCount : Cardinal; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsAvailableInMode( Bitness : Cardinal ) : Boolean; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + function IsAvailableInMode( Bitness : TIcedBitness ) : Boolean; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + function OpCodeString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + function InstructionString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + + function VirtualAddress( Callback : TVirtualAddressResolverCallback; Operand : Cardinal = 0; Index : NativeUInt = 0; UserData : Pointer = nil ) : UInt64; {$IF CompilerVersion >= 23}inline;{$IFEND} + + {$IFDEF UNICODE} + class operator Implicit( Instruction : TInstruction ) : AnsiString; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + function Format( AType : TIcedFormatterType = DEFAULT_FORMATTER ) : AnsiString; {$IF CompilerVersion >= 23}inline;{$IFEND} + + class function With_( ACode : TCodeType ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With1( ACode : TCodeType; ARegister_ : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With1( ACode : TCodeType; AImmediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With1( ACode : TCodeType; AImmediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With1( ACode : TCodeType; AMemory : TMemoryOperand ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Int64 ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : UInt64 ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; ARegister_ : TRegisterType; AMemory : TMemoryOperand ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; AImmediate : Integer; ARegister_ : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; AImmediate : Cardinal; ARegister_ : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; AImmediate1 : Integer; AImmediate2 : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; AMemory : TMemoryOperand; AImmediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With2( ACode : TCodeType; AMemory : TMemoryOperand; AImmediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate1 : Integer; AImmediate2 : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; ARegister1 : TRegisterType; AMemory : TMemoryOperand; ARegister2 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; ARegister1 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; ARegister_ : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister1 : TRegisterType; ARegister2 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType; AImmediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType; AImmediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AImmediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AImmediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate1 : Integer; AImmediate2 : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType; AImmediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType; AImmediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType; AImmediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType; AImmediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Branch( ACode : TCodeType; Target : UInt64 ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Far_Branch( ACode : TCodeType; Selector : Word; Offset : Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_xbegin( Bitness : Cardinal; Target : UInt64 ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_outsb( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_outsb( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_outsw( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_outsw( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_outsd( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_outsd( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_lodsb( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_lodsb( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_lodsw( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_lodsw( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_lodsd( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_lodsd( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_lodsq( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_lodsq( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_scasb( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repe_scasb( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repne_scasb( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_scasw( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repe_scasw( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repne_scasw( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_scasd( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repe_scasd( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repne_scasd( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_scasq( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repe_scasq( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repne_scasq( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_insb( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_insb( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_insw( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_insw( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_insd( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_insd( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_stosb( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_stosb( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_stosw( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_stosw( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_stosd( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_stosd( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_stosq( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_cmpsb( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repe_cmpsb( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repne_cmpsb( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_cmpsw( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repe_cmpsw( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repne_cmpsw( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_cmpsd( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repe_cmpsd( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repne_cmpsd( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_cmpsq( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repe_cmpsq( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Repne_cmpsq( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_movsb( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_movsb( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_movsw( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_movsw( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_movsd( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_movsd( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_movsq( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Rep_movsq( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_maskmovq( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_maskmovdqu( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_vmaskmovdqu( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + class function With_Declare_Byte( Bytes : Array of Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}static;{$IFEND} // {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( Bytes : PByte; Count : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte; B15 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Word( Words : Array of Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}static;{$IFEND} // {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Word( Words : PWord; Count : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Word( W0 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Word( W0 : Word; W1 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Word( W0 : Word; W1 : Word; W2 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word; W7 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_DWord( DWords : Array of Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}static;{$IFEND} // {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_DWord( DWords : PCardinal; Count : Byte ) : TInstruction; overload;{$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_DWord( D0 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_DWord( D0 : Cardinal; D1 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_DWord( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_DWord( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal; D3 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_QWord( QWords : Array of UInt64 ) : TInstruction; overload; {$IF CompilerVersion >= 23}static;{$IFEND} // {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_QWord( QWords : PUInt64; Count : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_QWord( Q0 : UInt64 ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + class function With_Declare_QWord( Q0 : UInt64; Q1 : UInt64 ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline; static;{$IFEND} + + constructor From( ACode : TCodeType ); + constructor From1( ACode : TCodeType; ARegister_ : TRegisterType ); overload; + constructor From1( ACode : TCodeType; AImmediate : Integer ); overload; + constructor From1( ACode : TCodeType; AImmediate : Cardinal ); overload; + constructor From1( ACode : TCodeType; AMemory : TMemoryOperand ); overload; + constructor From2( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType ); overload; + constructor From2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Integer ); overload; + constructor From2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Cardinal ); overload; + constructor From2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Int64 ); overload; + constructor From2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : UInt64 ); overload; + constructor From2( ACode : TCodeType; ARegister_ : TRegisterType; AMemory : TMemoryOperand ); overload; + constructor From2( ACode : TCodeType; AImmediate : Integer; ARegister_ : TRegisterType ); overload; + constructor From2( ACode : TCodeType; AImmediate : Cardinal; ARegister_ : TRegisterType ); overload; + constructor From2( ACode : TCodeType; AImmediate1 : Integer; AImmediate2 : Integer ); overload; + constructor From2( ACode : TCodeType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ); overload; + constructor From2( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType ); overload; + constructor From2( ACode : TCodeType; AMemory : TMemoryOperand; AImmediate : Integer ); overload; + constructor From2( ACode : TCodeType; AMemory : TMemoryOperand; AImmediate : Cardinal ); overload; + constructor From3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType ); overload; + constructor From3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate : Integer ); overload; + constructor From3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate : Cardinal ); overload; + constructor From3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand ); overload; + constructor From3( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate1 : Integer; AImmediate2 : Integer ); overload; + constructor From3( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ); overload; + constructor From3( ACode : TCodeType; ARegister1 : TRegisterType; AMemory : TMemoryOperand; ARegister2 : TRegisterType ); overload; + constructor From3( ACode : TCodeType; ARegister1 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ); overload; + constructor From3( ACode : TCodeType; ARegister_ : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ); overload; + constructor From3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister1 : TRegisterType; ARegister2 : TRegisterType ); overload; + constructor From3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType; AImmediate : Integer ); overload; + constructor From3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType; AImmediate : Cardinal ); overload; + constructor From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType ); overload; + constructor From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AImmediate : Integer ); overload; + constructor From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AImmediate : Cardinal ); overload; + constructor From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand ); overload; + constructor From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate1 : Integer; AImmediate2 : Integer ); overload; + constructor From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ); overload; + constructor From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType ); overload; + constructor From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ); overload; + constructor From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ); overload; + constructor From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType; AImmediate : Integer ); overload; + constructor From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType; AImmediate : Cardinal ); overload; + constructor From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ); overload; + constructor From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ); overload; + constructor From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType; AImmediate : Integer ); overload; + constructor From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType; AImmediate : Cardinal ); overload; + constructor From_Branch( ACode : TCodeType; Target : UInt64 ); + constructor From_Far_Branch( ACode : TCodeType; Selector : Word; Offset : Cardinal ); + constructor From_xbegin( Bitness : Cardinal; Target : UInt64 ); + constructor From_outsb( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_outsb( AAddressSize: Cardinal ); + constructor From_outsw( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_outsw( AAddressSize: Cardinal ); + constructor From_outsd( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_outsd( AAddressSize: Cardinal ); + constructor From_lodsb( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_lodsb( AAddressSize: Cardinal ); + constructor From_lodsw( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_lodsw( AAddressSize: Cardinal ); + constructor From_lodsd( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_lodsd( AAddressSize: Cardinal ); + constructor From_lodsq( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_lodsq( AAddressSize: Cardinal ); + constructor From_scasb( AAddressSize: Cardinal; RepPrefix: Cardinal ); + constructor From_Repe_scasb( AAddressSize: Cardinal ); + constructor From_Repne_scasb( AAddressSize: Cardinal ); + constructor From_scasw( AAddressSize: Cardinal; RepPrefix: Cardinal ); + constructor From_Repe_scasw( AAddressSize: Cardinal ); + constructor From_Repne_scasw( AAddressSize: Cardinal ); + constructor From_scasd( AAddressSize: Cardinal; RepPrefix: Cardinal ); + constructor From_Repe_scasd( AAddressSize: Cardinal ); + constructor From_Repne_scasd( AAddressSize: Cardinal ); + constructor From_scasq( AAddressSize: Cardinal; RepPrefix: Cardinal ); + constructor From_Repe_scasq( AAddressSize: Cardinal ); + constructor From_Repne_scasq( AAddressSize: Cardinal ); + constructor From_insb( AAddressSize: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_insb( AAddressSize: Cardinal ); + constructor From_insw( AAddressSize: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_insw( AAddressSize: Cardinal ); + constructor From_insd( AAddressSize: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_insd( AAddressSize: Cardinal ); + constructor From_stosb( AAddressSize: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_stosb( AAddressSize: Cardinal ); + constructor From_stosw( AAddressSize: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_stosw( AAddressSize: Cardinal ); + constructor From_stosd( AAddressSize: Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_stosd( AAddressSize: Cardinal ); + constructor From_Rep_stosq( AAddressSize: Cardinal ); + constructor From_cmpsb( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); + constructor From_Repe_cmpsb( AAddressSize: Cardinal ); + constructor From_Repne_cmpsb( AAddressSize: Cardinal ); + constructor From_cmpsw( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); + constructor From_Repe_cmpsw( AAddressSize: Cardinal ); + constructor From_Repne_cmpsw( AAddressSize: Cardinal ); + constructor From_cmpsd( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); + constructor From_Repe_cmpsd( AAddressSize: Cardinal ); + constructor From_Repne_cmpsd( AAddressSize: Cardinal ); + constructor From_cmpsq( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); + constructor From_Repe_cmpsq( AAddressSize: Cardinal ); + constructor From_Repne_cmpsq( AAddressSize: Cardinal ); + constructor From_movsb( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_movsb( AAddressSize: Cardinal ); + constructor From_movsw( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_movsw( AAddressSize: Cardinal ); + constructor From_movsd( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_movsd( AAddressSize: Cardinal ); + constructor From_movsq( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); + constructor From_Rep_movsq( AAddressSize: Cardinal ); + constructor From_maskmovq( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ); + constructor From_maskmovdqu( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ); + constructor From_vmaskmovdqu( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ); + + constructor From_Declare_Byte( Bytes : Array of Byte ); overload; + constructor From_Declare_Byte( Bytes : PByte; Count : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte ); overload; + constructor From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte; B15 : Byte ); overload; + constructor From_Declare_Word( Words : Array of Word ); overload; + constructor From_Declare_Word( Words : PWord; Count : Byte ); overload; + constructor From_Declare_Word( W0 : Word ); overload; + constructor From_Declare_Word( W0 : Word; W1 : Word ); overload; + constructor From_Declare_Word( W0 : Word; W1 : Word; W2 : Word ); overload; + constructor From_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word ); overload; + constructor From_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word ); overload; + constructor From_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word ); overload; + constructor From_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word ); overload; + constructor From_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word; W7 : Word ); overload; + constructor From_Declare_DWord( DWords : Array of Cardinal ); overload; + constructor From_Declare_DWord( DWords : PCardinal; Count : Byte ); overload; + constructor From_Declare_DWord( D0 : Cardinal ); overload; + constructor From_Declare_DWord( D0 : Cardinal; D1 : Cardinal ); overload; + constructor From_Declare_DWord( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal ); overload; + constructor From_Declare_DWord( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal; D3 : Cardinal ); overload; + constructor From_Declare_QWord( QWords : Array of UInt64 ); overload; + constructor From_Declare_QWord( QWords : PUInt64; Count : Byte ); overload; + constructor From_Declare_QWord( Q0 : UInt64 ); overload; + constructor From_Declare_QWord( Q0 : UInt64; Q1 : UInt64 ); overload; + end; + PInstruction = ^TInstruction; + TInstructionArray = Array of TInstruction; +//{$IF CompilerVersion >= 22} // XE +// TInstructionList = TList; +//{$ELSE} + TInstructionList = class(TObject) + private + fItems : Array of TInstruction; + fID : UInt64; + function GetCount : Integer; + function GetItems( Index : Integer ) : TInstruction; + function GetPointer : PInstruction; + public + constructor Create; + destructor Destroy; override; + procedure Add( AItem : TInstruction ); overload; + procedure Add( AItem : TInstruction; RIP : UInt64 ); overload; + procedure AddWithCurrentLabel( AItem : TInstruction ); + procedure Push( AItem : TInstruction ); overload; + procedure Push( AItem : TInstruction; RIP : UInt64 ); overload; + procedure Remove( const Index : Integer ); + function CreateLabel : UInt64; + procedure Clear; + property Count : Integer read GetCount; + property Items[ Index: Integer ] : TInstruction read GetItems; default; + property Pointer : PInstruction read GetPointer; + end; +//{$IFEND} + + TConstantOffsets = {$IFDEF UNICODE}record{$ELSE}object{$ENDIF} + displacement_offset : Byte; + displacement_size : Byte; + immediate_offset : Byte; + immediate_size : Byte; + immediate_offset2 : Byte; + immediate_size2 : Byte; + pad : Array [ 0..1 ] of Byte; + + function HasDisplacement : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function HasImmediate : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + function HasImmediate2 : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TFormatterOperandOptions = packed record + flags: Cardinal; // FormatterOperandOptionsFlags + end; + + TNumberBaseType = ( + // Hex numbers (base 16) + nbHexadecimal = 0, + // Decimal numbers (base 10) + nbDecimal = 1, + // Octal numbers (base 8) + nbOctal = 2, + // Binary numbers (base 2) + nbBinary = 3 + ); + + TNumberBase = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + NumberBase : TNumberBaseType; + {$IFDEF UNICODE} + class operator Equal( const self, ANumberBase : TNumberBase ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, ANumberBase : TNumberBase ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TNumberBase; const ANumberBase : array of TNumberBaseType ) : Boolean; + class operator GreaterThan( const self, ANumberBase : TNumberBase ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, ANumberBase : TNumberBase ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, ANumberBase : TNumberBase ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, ANumberBase : TNumberBase ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ANumberBase : TNumberBase ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ANumberBase : TNumberBase ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ANumberBase : Byte ) : TNumberBase; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ANumberBase : TNumberBase ) : TNumberBaseType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ANumberBase : TNumberBaseType ) : TNumberBase; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TNumberFormattingOptions = packed record + // Number prefix or an empty string + prefix : PAnsiChar; + // Number suffix or an empty string + suffix : PAnsiChar; + // Digit separator or an empty string to not use a digit separator + digit_separator : PAnsiChar; + // Size of a digit group or 0 to not use a digit separator + digit_group_size : Byte; + // Number base + number_base : TNumberBase; + // Use uppercase hex digits + uppercase_hex : Boolean; + // Small hex numbers (-9 .. 9) are shown in decimal + small_hex_numbers_in_decimal : Boolean; + // Add a leading zero to hex numbers if there's no prefix and the number starts with hex digits `A-F` + add_leading_zero_to_hex_numbers : Boolean; + // If `true`, add leading zeros to numbers, eg. `1h` vs `00000001h` + leading_zeros : Boolean; + // If `true`, the number is signed, and if `false` it's an unsigned number + signed_number : Boolean; + // Add leading zeros to displacements + displacement_leading_zeros : Boolean; + end; + + TRelocKind = ( + // 64-bit offset. Only used if it's 64-bit code. + rkOffset64 = 0 + ); + + TRelocInfo = packed record + // Address + address: UInt64; + + // Relocation kind + kind: TRelocKind; + end; + + // Dummy-Arrays + TBlockEncoderResult_Byte = Array [ 0..0 ] of Byte; + pBlockEncoderResult_Byte = ^TBlockEncoderResult_Byte; + TBlockEncoderResult_RelocInfo = Array [ 0..0 ] of TRelocInfo; + pBlockEncoderResult_RelocInfo = ^TBlockEncoderResult_RelocInfo; + TBlockEncoderResult_Cardinal = Array [ 0..0 ] of Cardinal; + pBlockEncoderResult_Cardinal = ^TBlockEncoderResult_Cardinal; + TBlockEncoderResult_ConstantOffsets = Array [ 0..0 ] of TConstantOffsets; + pBlockEncoderResult_ConstantOffsets = ^TBlockEncoderResult_ConstantOffsets; + + TBlockEncoderResult = packed record + // Base IP of all encoded instructions + rip: UInt64; + + // The bytes of all encoded instructions + code_buffer : pBlockEncoderResult_Byte; + code_buffer_len : NativeUInt; + + // If [`BlockEncoderOptions::RETURN_RELOC_INFOS`] option was enabled + reloc_infos : pBlockEncoderResult_RelocInfo; + reloc_infos_len : NativeUInt; + + // If [`BlockEncoderOptions::RETURN_NEW_INSTRUCTION_OFFSETS`] option was enabled: + // + // Offsets of the instructions relative to the base IP. If the instruction was rewritten to a new instruction + // (eg. `JE TARGET_TOO_FAR_AWAY` -> `JNE SHORT SKIP ; JMP QWORD PTR [MEM]`), the value `u32::MAX` is stored in that element. + new_instruction_offsets : pBlockEncoderResult_Cardinal; + new_instruction_offsets_len : NativeUInt; + + // If [`BlockEncoderOptions::RETURN_CONSTANT_OFFSETS`] option was enabled: + // + // Offsets of all constants in the new encoded instructions. If the instruction was rewritten, + // the `default()` value is stored in the corresponding element. + constant_offsets : pBlockEncoderResult_ConstantOffsets; + constant_offsets_len : NativeUInt; + end; + +//type +// RflagsBits = ( +const + // No bit is set + rfNONE = $00000000{,}; + // `RFLAGS.OF` + rfOF = $00000001{,}; + // `RFLAGS.SF` + rfSF = $00000002{,}; + // `RFLAGS.ZF` + rfZF = $00000004{,}; + // `RFLAGS.AF` + rfAF = $00000008{,}; + // `RFLAGS.CF` + rfCF = $00000010{,}; + // `RFLAGS.PF` + rfPF = $00000020{,}; + // `RFLAGS.DF` + rfDF = $00000040{,}; + // `RFLAGS.IF` + rfIF = $00000080{,}; + // `RFLAGS.AC` + rfAC = $00000100{,}; + // `UIF` + rfUIF = $00000200{,}; + // FPU status word bit `C0` + rfC0 = $00000400{,}; + // FPU status word bit `C1` + rfC1 = $00000800{,}; + // FPU status word bit `C2` + rfC2 = $00001000{,}; + // FPU status word bit `C3` + rfC3 = $00002000; +// ); + +type + TOpAccessType = ( + // Nothing is read and nothing is written + oaNone = 0, + // The value is read + oaRead = 1, + // The value is sometimes read and sometimes not + oaCondRead = 2, + // The value is completely overwritten + oaWrite = 3, + // Conditional write, sometimes it's written and sometimes it's not modified + oaCondWrite = 4, + // The value is read and written + oaReadWrite = 5, + // The value is read and sometimes written + oaReadCondWrite = 6, + // The memory operand doesn't refer to memory (eg. `LEA` instruction) or it's an instruction that doesn't read the data to a register or doesn't write to the memory location, it just prefetches/invalidates it, eg. `INVLPG`, `PREFETCHNTA`, `VGATHERPF0DPS`, etc. Some of those instructions still check if the code can access the memory location. + oaNoMemAccess = 7 + ); + + TOpAccess = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + OpAccess : TOpAccessType; + {$IFDEF UNICODE} + class operator Equal( const self, AOpAccess : TOpAccess ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AOpAccess : TOpAccess ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TOpAccess; const AOpAccess : array of TOpAccessType ) : Boolean; + class operator GreaterThan( const self, AOpAccess : TOpAccess ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AOpAccess : TOpAccess ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AOpAccess : TOpAccess ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AOpAccess : TOpAccess ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpAccess : TOpAccess ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpAccess : TOpAccess ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpAccess : Byte ) : TOpAccess; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpAccess : TOpAccess ) : TOpAccessType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AOpAccess : TOpAccessType ) : TOpAccess; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TUsedMemory = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + displacement : UInt64; + segment : TRegister; + base : TRegister; + index : TRegister; + scale : Byte; + memory_size : TMemorySize; + access : TOpAccess; + address_size : TCodeSize; + vsib_size : Byte; + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + +const + UsedMemoryMaxEntries = 255; +type + TUsedMemoryArray = packed record + Entries : Array [ 0..UsedMemoryMaxEntries-1 ] of TUsedMemory; + Count : Byte; + end; + + TUsedRegister = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + register_ : TRegister; + access : TOpAccess; + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + +const + MAX_OP_COUNT = 5; + UsedRegisterMaxEntries = 100; +type + TUsedRegisterArray = packed record + Entries : Array [ 0..UsedRegisterMaxEntries-1 ] of TUsedRegister; + Count : Byte; + end; + + TInstructionInfo = packed record + used_registers : TUsedRegisterArray; + used_memory_locations : TUsedMemoryArray; + op_accesses : packed Array [ 0..MAX_OP_COUNT-1 ] of TOpAccess; + end; + +const +// InstructionInfoOptions = ( + // No option is enabled + iioNONE = 0{,}; + // Don't include memory usage, i.e., [`InstructionInfo::used_memory()`] will return an empty vector. All + // registers that are used by memory operands are still returned by [`InstructionInfo::used_registers()`]. + // + // [`InstructionInfo::used_memory()`]: struct.InstructionInfo.html#method.used_memory + // [`InstructionInfo::used_registers()`]: struct.InstructionInfo.html#method.used_registers + iioNO_MEMORY_USAGE = $00000001{,}; + // Don't include register usage, i.e., [`InstructionInfo::used_registers()`] will return an empty vector + // + // [`InstructionInfo::used_registers()`]: struct.InstructionInfo.html#method.used_registers + iioNO_REGISTER_USAGE = $00000002; +// ); + +type + TFormatterTextKindType = ( + // Normal text + ftkText = 0, + // Assembler directive + ftkDirective = 1, + // Any prefix + ftkPrefix = 2, + // Any mnemonic + ftkMnemonic = 3, + // Any keyword + ftkKeyword = 4, + // Any operator + ftkOperator = 5, + // Any punctuation + ftkPunctuation = 6, + // Number + ftkNumber = 7, + // Any register + ftkRegister = 8, + // A decorator, eg. `sae` in `{sae}` + ftkDecorator = 9, + // Selector value (eg. far `JMP`/`CALL`) + ftkSelectorValue = 10, + // Label address (eg. `JE XXXXXX`) + ftkLabelAddress = 11, + // Function address (eg. `CALL XXXXXX`) + ftkFunctionAddress = 12, + // Data symbol + ftkData = 13, + // Label symbol + ftkLabel = 14, + // Function symbol + ftkFunction = 15 + ); + + TFormatterTextKind = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + FormatterTextKind : TFormatterTextKindType; + {$IFDEF UNICODE} + class operator Equal( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TFormatterTextKind; const AFormatterTextKind : array of TFormatterTextKindType ) : Boolean; + class operator GreaterThan( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AFormatterTextKind : TFormatterTextKind ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AFormatterTextKind : TFormatterTextKind ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AFormatterTextKind : Byte ) : TFormatterTextKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AFormatterTextKind : TFormatterTextKind ) : TFormatterTextKindType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AFormatterTextKind : TFormatterTextKindType ) : TFormatterTextKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + TRepPrefixKindType = ( + // No `REP`/`REPE`/`REPNE` prefix + rpkNone = 0, + // `REP`/`REPE` prefix + rpkRepe = 1, + // `REPNE` prefix + rpkRepne = 2 + ); + + TRepPrefixKind = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + RepPrefixKind : TRepPrefixKindType; + {$IFDEF UNICODE} + class operator Equal( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TRepPrefixKind; const ARepPrefixKind : array of TRepPrefixKindType ) : Boolean; + class operator GreaterThan( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARepPrefixKind : TRepPrefixKind ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARepPrefixKind : TRepPrefixKind ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARepPrefixKind : Byte ) : TRepPrefixKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARepPrefixKind : TRepPrefixKind ) : TRepPrefixKindType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const ARepPrefixKind : TRepPrefixKindType ) : TRepPrefixKind; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + // Options that control if the memory size ( eg. `DWORD PTR` ) is shown or not. + // This is ignored by the gas ( AT&T ) formatter. + // + // - Default: [`Default`] + // + // [`Default`]: enum.MemorySizeOptions.html#variant.Default + TMemorySizeOptionsType = ( + // Show memory size if the assembler requires it, else don't show anything + msoDefault = 0, + // Always show the memory size, even if the assembler doesn't need it + msoAlways = 1, + // Show memory size if a human can't figure out the size of the operand + msoMinimal = 2, + // Never show memory size + msoNever = 3 + ); + + TMemorySizeOptions = {$IFDEF UNICODE}packed record{$ELSE}object{$ENDIF} + MemorySizeOptions : TMemorySizeOptionsType; + {$IFDEF UNICODE} + class operator Equal( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Equal( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator NotEqual( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator In( const self : TMemorySizeOptions; const AMemorySizeOptions : array of TMemorySizeOptionsType ) : Boolean; + class operator GreaterThan( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThan( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator GreaterThanOrEqual( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThan( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator LessThanOrEqual( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMemorySizeOptions : TMemorySizeOptions ) : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMemorySizeOptions : TMemorySizeOptions ) : Byte; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMemorySizeOptions : Byte ) : TMemorySizeOptions; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMemorySizeOptions : TMemorySizeOptions ) : TMemorySizeOptionsType; {$IF CompilerVersion >= 23}inline;{$IFEND} + class operator Implicit( const AMemorySizeOptions : TMemorySizeOptionsType ) : TMemorySizeOptions; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF UNICODE} + + function AsString : String; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + + // Mnemonic condition code selector ( eg. `JB` / `JC` / `JNAE` ) + // + // Default: `JB`, `CMOVB`, `SETB` + TCC_b = ( + // `JB`, `CMOVB`, `SETB` + b = 0, + // `JC`, `CMOVC`, `SETC` + c = 1, + // `JNAE`, `CMOVNAE`, `SETNAE` + nae = 2 + ); + + // Mnemonic condition code selector ( eg. `JAE` / `JNB` / `JNC` ) + // + // Default: `JAE`, `CMOVAE`, `SETAE` + TCC_ae = ( + // `JAE`, `CMOVAE`, `SETAE` + ae = 0, + // `JNB`, `CMOVNB`, `SETNB` + nb = 1, + // `JNC`, `CMOVNC`, `SETNC` + nc = 2 + ); + + // Mnemonic condition code selector ( eg. `JE` / `JZ` ) + // + // Default: `JE`, `CMOVE`, `SETE`, `LOOPE`, `REPE` + TCC_e = ( + // `JE`, `CMOVE`, `SETE`, `LOOPE`, `REPE` + e = 0, + // `JZ`, `CMOVZ`, `SETZ`, `LOOPZ`, `REPZ` + z = 1 + ); + + // Mnemonic condition code selector ( eg. `JNE` / `JNZ` ) + // + // Default: `JNE`, `CMOVNE`, `SETNE`, `LOOPNE`, `REPNE` + TCC_ne = ( + // `JNE`, `CMOVNE`, `SETNE`, `LOOPNE`, `REPNE` + ne = 0, + // `JNZ`, `CMOVNZ`, `SETNZ`, `LOOPNZ`, `REPNZ` + nz = 1 + ); + + // Mnemonic condition code selector ( eg. `JBE` / `JNA` ) + // + // Default: `JBE`, `CMOVBE`, `SETBE` + TCC_be = ( + // `JBE`, `CMOVBE`, `SETBE` + be = 0, + // `JNA`, `CMOVNA`, `SETNA` + na = 1 + ); + + // Mnemonic condition code selector ( eg. `JA` / `JNBE` ) + // + // Default: `JA`, `CMOVA`, `SETA` + TCC_a = ( + // `JA`, `CMOVA`, `SETA` + a = 0, + // `JNBE`, `CMOVNBE`, `SETNBE` + nbe = 1 + ); + + // Mnemonic condition code selector ( eg. `JP` / `JPE` ) + // + // Default: `JP`, `CMOVP`, `SETP` + TCC_p = ( + // `JP`, `CMOVP`, `SETP` + p = 0, + // `JPE`, `CMOVPE`, `SETPE` + pe = 1 + ); + + // Mnemonic condition code selector ( eg. `JNP` / `JPO` ) + // + // Default: `JNP`, `CMOVNP`, `SETNP` + TCC_np = ( + // `JNP`, `CMOVNP`, `SETNP` + np = 0, + // `JPO`, `CMOVPO`, `SETPO` + po = 1 + ); + + // Mnemonic condition code selector ( eg. `JL` / `JNGE` ) + // + // Default: `JL`, `CMOVL`, `SETL` + TCC_l = ( + // `JL`, `CMOVL`, `SETL` + l = 0, + // `JNGE`, `CMOVNGE`, `SETNGE` + nge = 1 + ); + + // Mnemonic condition code selector ( eg. `JGE` / `JNL` ) + // + // Default: `JGE`, `CMOVGE`, `SETGE` + TCC_ge = ( + // `JGE`, `CMOVGE`, `SETGE` + ge = 0, + // `JNL`, `CMOVNL`, `SETNL` + nl = 1 + ); + + // Mnemonic condition code selector ( eg. `JLE` / `JNG` ) + // + // Default: `JLE`, `CMOVLE`, `SETLE` + TCC_le = ( + // `JLE`, `CMOVLE`, `SETLE` + le = 0, + // `JNG`, `CMOVNG`, `SETNG` + ng = 1 + ); + + // Mnemonic condition code selector ( eg. `JG` / `JNLE` ) + // + // Default: `JG`, `CMOVG`, `SETG` + TCC_g = ( + // `JG`, `CMOVG`, `SETG` + g = 0, + // `JNLE`, `CMOVNLE`, `SETNLE` + nle = 1 + ); + + TDecoderCallback = procedure( const Instruction: TInstruction; var Stop : Boolean; UserData : Pointer ); cdecl; + TDecoderFormatCallback = procedure( const Instruction: TInstruction; Formatted : PAnsiChar; Size : NativeUInt; var Stop : Boolean; UserData : Pointer ); cdecl; + TSymbolResolverCallback = function( const Instruction: TInstruction; Operand: Cardinal; InstructionOperand : Cardinal; Address: UInt64; Size: Cardinal; UserData : Pointer = nil ) : PAnsiChar; cdecl; + TFormatterOptionsProviderCallback = procedure( const Instruction: TInstruction; Operand: Cardinal; InstructionOperand : Cardinal; var Options: TFormatterOperandOptions; var NumberOptions: TNumberFormattingOptions; UserData : Pointer = nil ); cdecl; + TFormatterOutputCallback = procedure( Text : PAnsiChar; Kind : TFormatterTextKind; UserData : Pointer = nil ); cdecl; + +const + CODE_SIZE_MASK : Cardinal = $00000003; + CODE_SIZE_SHIFT : Cardinal = $00000012; + EQUALS_IGNORE_MASK : Cardinal = $000C0000; + LOCK_PREFIX : Cardinal = $80000000; + REPNE_PREFIX : Cardinal = $40000000; + REPE_PREFIX : Cardinal = $20000000; + SEGMENT_PREFIX_MASK : Cardinal = $00000007; + SEGMENT_PREFIX_SHIFT : Cardinal = $00000005; + BROADCAST : Cardinal = $04000000; + OP_MASK_MASK : Cardinal = $00000007; + OP_MASK_SHIFT : Cardinal = $0000000F; + ZEROING_MASKING : Cardinal = $10000000; + ROUNDING_CONTROL_MASK : Cardinal = $00000007; + ROUNDING_CONTROL_SHIFT : Cardinal = $0000000C; + SUPPRESS_ALL_EXCEPTIONS : Cardinal = $08000000; + EVICTION_HINT : Cardinal = $80000000; + MVEX_REG_MEM_CONV_SHIFT : Cardinal = $00000010; + MVEX_REG_MEM_CONV_MASK : Cardinal = $0000001F; + DATA_LENGTH_MASK : Cardinal = $0000000F; + DATA_LENGTH_SHIFT : Cardinal = $00000008; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +function MemoryOperand_New( Base: TRegisterType; Index: TRegisterType; Scale: Cardinal; Displacement: Int64; DisplSize : Cardinal; IsBroadcast : Boolean; SegmentPrefix : TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Base_Index_Scale_Bcst_Seg( Base: TRegisterType; Index: TRegisterType; Scale: Cardinal; IsBroadcast : Boolean; SegmentPrefix : TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Base_Displ_Size_Bcst_Seg( Base: TRegisterType; Displacement: Int64; DisplSize : Cardinal; IsBroadcast : Boolean; SegmentPrefix : TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Index_Scale_Displ_Size_Bcst_Seg( Index: TRegisterType; Scale: Cardinal; Displacement: Int64; DisplSize : Cardinal; IsBroadcast : Boolean; SegmentPrefix : TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Base_Displ_Bcst_Seg( Base: TRegisterType; Displacement: Int64; IsBroadcast : Boolean; SegmentPrefix : TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Base_Index_Scale_DisplSize( Base: TRegisterType; Index: TRegisterType; Scale: Cardinal; Displacement: Int64; DisplSize : Cardinal ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Base_Index_Scale( Base: TRegisterType; Index: TRegisterType; Scale: Cardinal ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Base_Index( Base: TRegisterType; Index: TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Base_Displ_Size( Base: TRegisterType; Displacement: Int64; DisplSize : Cardinal ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Index_Scale_Displ_Size( Index: TRegisterType; Scale: Cardinal; Displacement: Int64; DisplSize : Cardinal ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Base_Displ( Base: TRegisterType; Displacement: Int64 ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Base( Base: TRegisterType ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} +function MemoryOperand_With_Displ( Displacement: Int64; DisplSize : Cardinal ) : TMemoryOperand; {$IF CompilerVersion >= 23}inline;{$IFEND} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Instruction 'WITH' +// Creates an instruction with no operands +function Instruction_With_( Code : TCodeType ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} + +// Creates an instruction with 1 operand +// +// # Errors +// Fails if one of the operands is invalid (basic checks) +function Instruction_With1( Code : TCodeType; Register_ : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With1( Code : TCodeType; Immediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With1( Code : TCodeType; Immediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With1( Code : TCodeType; Memory : TMemoryOperand ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Register_ : TRegisterType; Immediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Register_ : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Register_ : TRegisterType; Immediate : Int64 ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Register_ : TRegisterType; Immediate : UInt64 ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Register_ : TRegisterType; Memory : TMemoryOperand ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Immediate : Integer; Register_ : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Immediate : Cardinal; Register_ : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Immediate1 : Integer; Immediate2 : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Memory : TMemoryOperand; Register_ : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Memory : TMemoryOperand; Immediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With2( Code : TCodeType; Memory : TMemoryOperand; Immediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Register_ : TRegisterType; Immediate1 : Integer; Immediate2 : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Register_ : TRegisterType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Memory : TMemoryOperand; Register2 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Register_ : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Memory : TMemoryOperand; Register1 : TRegisterType; Register2 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Memory : TMemoryOperand; Register_ : TRegisterType; Immediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With3( Code : TCodeType; Memory : TMemoryOperand; Register_ : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Immediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Memory : TMemoryOperand ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate1 : Integer; Immediate2 : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType; Immediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType; Immediate : Integer ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Branch_( Code : TCodeType; Target : UInt64 ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Far_Branch_( Code : TCodeType; Selector : Word; Offset : Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_xbegin_( Bitness : Cardinal; Target : UInt64 ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_outsb_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_outsb_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_outsw_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_outsw_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_outsd_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_outsd_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_lodsb_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_lodsb_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_lodsw_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_lodsw_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_lodsd_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_lodsd_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_lodsq_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_lodsq_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_scasb_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repe_scasb_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repne_scasb_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_scasw_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repe_scasw_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repne_scasw_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_scasd_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repe_scasd_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repne_scasd_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_scasq_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repe_scasq_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repne_scasq_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_insb_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_insb_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_insw_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_insw_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_insd_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_insd_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_stosb_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_stosb_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_stosw_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_stosw_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_stosd_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_stosd_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_stosq_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_cmpsb_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repe_cmpsb_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repne_cmpsb_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_cmpsw_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repe_cmpsw_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repne_cmpsw_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_cmpsd_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repe_cmpsd_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repne_cmpsd_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_cmpsq_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repe_cmpsq_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Repne_cmpsq_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_movsb_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_movsb_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_movsw_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_movsw_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_movsd_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_movsd_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_movsq_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Rep_movsq_( AAddressSize: Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_maskmovq_( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_maskmovdqu_( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_vmaskmovdqu_( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( Bytes : Array of Byte ) : TInstruction; overload; +function Instruction_With_Declare_Byte_( Bytes : PByte; Count : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte; B15 : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Word_( Words : Array of Word ) : TInstruction; overload; +function Instruction_With_Declare_Word_( Words : PWord; Count : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Word_( W0 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word; W3 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word; W7 : Word ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_DWord_( DWords : Array of Cardinal ) : TInstruction; overload; +function Instruction_With_Declare_DWord_( DWords : PCardinal; Count : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_DWord_( D0 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_DWord_( D0 : Cardinal; D1 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_DWord_( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_DWord_( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal; D3 : Cardinal ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_QWord_( QWords : Array of UInt64 ) : TInstruction; overload; +function Instruction_With_Declare_QWord_( QWords : PUInt64; Count : Byte ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_QWord_( Q0 : UInt64 ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} +function Instruction_With_Declare_QWord_( Q0 : UInt64; Q1 : UInt64 ) : TInstruction; overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +implementation + +uses + SysUtils, + uIced.Imports; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TDecoderError (Record) +{$IFDEF UNICODE} +class operator TDecoderError.Equal( const self, ADecoderError : TDecoderError ) : Boolean; +begin + Result := ( self.DecoderError = ADecoderError.DecoderError ); +end; + +class operator TDecoderError.Equal( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; +begin + Result := ( self.DecoderError = ADecoderError ); +end; + +class operator TDecoderError.NotEqual( const self, ADecoderError : TDecoderError ) : Boolean; +begin + Result := ( self.DecoderError <> ADecoderError.DecoderError ); +end; + +class operator TDecoderError.NotEqual( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; +begin + Result := ( self.DecoderError <> ADecoderError ); +end; + +class operator TDecoderError.In( const self : TDecoderError; const ADecoderError : array of TDecoderErrorType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( ADecoderError ) to High( ADecoderError ) do + begin + if ( self.DecoderError = ADecoderError[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TDecoderError.GreaterThan( const self, ADecoderError : TDecoderError ) : Boolean; +begin + Result := ( self.DecoderError > ADecoderError.DecoderError ); +end; + +class operator TDecoderError.GreaterThan( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; +begin + Result := ( self.DecoderError > ADecoderError ); +end; + +class operator TDecoderError.GreaterThanOrEqual( const self, ADecoderError : TDecoderError ) : Boolean; +begin + Result := ( self.DecoderError >= ADecoderError.DecoderError ); +end; + +class operator TDecoderError.GreaterThanOrEqual( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; +begin + Result := ( self.DecoderError >= ADecoderError ); +end; + +class operator TDecoderError.LessThan( const self, ADecoderError : TDecoderError ) : Boolean; +begin + Result := ( self.DecoderError < ADecoderError.DecoderError ); +end; + +class operator TDecoderError.LessThan( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; +begin + Result := ( self.DecoderError < ADecoderError ); +end; + +class operator TDecoderError.LessThanOrEqual( const self, ADecoderError : TDecoderError ) : Boolean; +begin + Result := ( self.DecoderError <= ADecoderError.DecoderError ); +end; + +class operator TDecoderError.LessThanOrEqual( const self : TDecoderError; const ADecoderError : TDecoderErrorType ) : Boolean; +begin + Result := ( self.DecoderError <= ADecoderError ); +end; + +class operator TDecoderError.Implicit( const ADecoderError : TDecoderError ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + DecoderError_AsString( ADecoderError.DecoderError, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TDecoderError.Implicit( const ADecoderError : TDecoderError ) : Byte; +begin + result := Byte( ADecoderError.DecoderError ); +end; + +class operator TDecoderError.Implicit( const ADecoderError : Byte ) : TDecoderError; +begin + result.DecoderError := TDecoderError( ADecoderError ); +end; + +class operator TDecoderError.Implicit( const ADecoderError : TDecoderError ) : TDecoderErrorType; +begin + result := ADecoderError.DecoderError; +end; + +class operator TDecoderError.Implicit( const ADecoderError : TDecoderErrorType ) : TDecoderError; +begin + result.DecoderError := ADecoderError; +end; +{$ENDIF UNICODE} + +function TDecoderError.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + DecoderError_AsString( self.DecoderError, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TNumberBase (Record) +{$IFDEF UNICODE} +class operator TNumberBase.Equal( const self, ANumberBase : TNumberBase ) : Boolean; +begin + Result := ( self.NumberBase = ANumberBase.NumberBase ); +end; + +class operator TNumberBase.Equal( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; +begin + Result := ( self.NumberBase = ANumberBase ); +end; + +class operator TNumberBase.NotEqual( const self, ANumberBase : TNumberBase ) : Boolean; +begin + Result := ( self.NumberBase <> ANumberBase.NumberBase ); +end; + +class operator TNumberBase.NotEqual( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; +begin + Result := ( self.NumberBase <> ANumberBase ); +end; + +class operator TNumberBase.In( const self : TNumberBase; const ANumberBase : array of TNumberBaseType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( ANumberBase ) to High( ANumberBase ) do + begin + if ( self.NumberBase = ANumberBase[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TNumberBase.GreaterThan( const self, ANumberBase : TNumberBase ) : Boolean; +begin + Result := ( self.NumberBase > ANumberBase.NumberBase ); +end; + +class operator TNumberBase.GreaterThan( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; +begin + Result := ( self.NumberBase > ANumberBase ); +end; + +class operator TNumberBase.GreaterThanOrEqual( const self, ANumberBase : TNumberBase ) : Boolean; +begin + Result := ( self.NumberBase >= ANumberBase.NumberBase ); +end; + +class operator TNumberBase.GreaterThanOrEqual( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; +begin + Result := ( self.NumberBase >= ANumberBase ); +end; + +class operator TNumberBase.LessThan( const self, ANumberBase : TNumberBase ) : Boolean; +begin + Result := ( self.NumberBase < ANumberBase.NumberBase ); +end; + +class operator TNumberBase.LessThan( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; +begin + Result := ( self.NumberBase < ANumberBase ); +end; + +class operator TNumberBase.LessThanOrEqual( const self, ANumberBase : TNumberBase ) : Boolean; +begin + Result := ( self.NumberBase <= ANumberBase.NumberBase ); +end; + +class operator TNumberBase.LessThanOrEqual( const self : TNumberBase; const ANumberBase : TNumberBaseType ) : Boolean; +begin + Result := ( self.NumberBase <= ANumberBase ); +end; + +class operator TNumberBase.Implicit( const ANumberBase : TNumberBase ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + NumberBase_AsString( ANumberBase.NumberBase, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TNumberBase.Implicit( const ANumberBase : TNumberBase ) : Byte; +begin + result := Byte( ANumberBase.NumberBase ); +end; + +class operator TNumberBase.Implicit( const ANumberBase : Byte ) : TNumberBase; +begin + result.NumberBase := TNumberBase( ANumberBase ); +end; + +class operator TNumberBase.Implicit( const ANumberBase : TNumberBase ) : TNumberBaseType; +begin + result := ANumberBase.NumberBase; +end; + +class operator TNumberBase.Implicit( const ANumberBase : TNumberBaseType ) : TNumberBase; +begin + result.NumberBase := ANumberBase; +end; +{$ENDIF UNICODE} + +function TNumberBase.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + NumberBase_AsString( self.NumberBase, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TIcedSpecializedFormatterOptions (Record) +function TIcedSpecializedFormatterOptions.Options : Byte; +begin + result := 0; + if ENABLE_SYMBOL_RESOLVER then + result := result OR 4; + if ENABLE_DB_DW_DD_DQ then + result := result OR 2; + if verify_output_has_enough_bytes_left then + result := result OR 1; +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// RFlag (Record) +function TRFlag.IsNone : Boolean; +begin + result := ( Value = rfNone ); +end; + +function TRFlag.OF_ : Boolean; +begin + result := ( ( Value AND rfOF ) <> 0 ); +end; + +function TRFlag.SF : Boolean; +begin + result := ( ( Value AND rfSF ) <> 0 ); +end; + +function TRFlag.ZF : Boolean; +begin + result := ( ( Value AND rfZF ) <> 0 ); +end; + +function TRFlag.AF : Boolean; +begin + result := ( ( Value AND rfAF ) <> 0 ); +end; + +function TRFlag.CF : Boolean; +begin + result := ( ( Value AND rfCF ) <> 0 ); +end; + +function TRFlag.PF : Boolean; +begin + result := ( ( Value AND rfPF ) <> 0 ); +end; + +function TRFlag.DF : Boolean; +begin + result := ( ( Value AND rfDF ) <> 0 ); +end; + +function TRFlag.IF_ : Boolean; +begin + result := ( ( Value AND rfIF ) <> 0 ); +end; + +function TRFlag.AC : Boolean; +begin + result := ( ( Value AND rfAC ) <> 0 ); +end; + +function TRFlag.UIF : Boolean; +begin + result := ( ( Value AND rfUIF ) <> 0 ); +end; + +function TRFlag.AsString : String; +begin + result := ''; + + if ( ( Value AND rfOF ) <> 0 ) then + result := result + ', OF'; + if ( ( Value AND rfSF ) <> 0 ) then + result := result + ', SF'; + if ( ( Value AND rfZF ) <> 0 ) then + result := result + ', ZF'; + if ( ( Value AND rfAF ) <> 0 ) then + result := result + ', AF'; + if ( ( Value AND rfCF ) <> 0 ) then + result := result + ', CF'; + if ( ( Value AND rfPF ) <> 0 ) then + result := result + ', PF'; + if ( ( Value AND rfDF ) <> 0 ) then + result := result + ', DF'; + if ( ( Value AND rfIF ) <> 0 ) then + result := result + ', IF'; + if ( ( Value AND rfAC ) <> 0 ) then + result := result + ', AC'; + if ( ( Value AND rfUIF ) <> 0 ) then + result := result + ', UIF'; + + if ( Result <> '' ) then + result := Copy( Result, 3, Length( result )-2 ) + else + result := '---'; +end; + +// RFlags (Record) +function TRFlags.ReadAsString : String; +begin + if ( Read.Value <> rfNONE ) then + result := Read.AsString + else + result := ''; +end; + +function TRFlags.WrittenAsString : String; +begin + if ( Written.Value <> rfNONE ) then + result := Written.AsString + else + result := ''; +end; + +function TRFlags.ClearedAsString : String; +begin + if ( Cleared.Value <> rfNONE ) then + result := Cleared.AsString + else + result := ''; +end; + +function TRFlags.SetAsString : String; +begin + if ( Set_.Value <> rfNONE ) then + result := Set_.AsString + else + result := ''; +end; + +function TRFlags.UndefinedAsString : String; +begin + if ( Undefined.Value <> rfNONE ) then + result := Undefined.AsString + else + result := ''; +end; + +function TRFlags.ModifiedAsString : String; +begin + if ( Modified.Value <> rfNONE ) then + result := Modified.AsString + else + result := ''; +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TOpCodeInfo (Record) +function TOpCodeInfo.OpCodeString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + OpCodeInfo_OpCodeString( Code, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); + +// result := string( op_code_string ); +end; + +function TOpCodeInfo.InstructionString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + OpCodeInfo_InstructionString( Code, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); + +// result := string( InstructionString ); +end; + +function TOpCodeInfo.Mnemonic : TMnemonic; +begin + result := TCode( Code ).Mnemonic; +end; + +function TOpCodeInfo.Mode16 : Boolean; +begin + result := OpCodeInfo_Mode16( Code ); +end; + +function TOpCodeInfo.Mode32 : Boolean; +begin + result := OpCodeInfo_Mode32( Code ); +end; + +function TOpCodeInfo.Mode64 : Boolean; +begin + result := OpCodeInfo_Mode64( Code ); +end; + +function TOpCodeInfo.IsAvailableInMode( Bitness : Cardinal ) : Boolean; +begin + case Bitness of + 16 : result := Mode16; + 32 : result := Mode32; + 64 : result := Mode64; + else + result := False; + end; +end; + +function TOpCodeInfo.IsAvailableInMode( Bitness : TIcedBitness ) : Boolean; +begin + case Bitness of + bt16 : result := Mode16; + bt32 : result := Mode32; + bt64 : result := Mode64; + else + result := False; + end; +end; + +function TOpCodeInfo.IsInstruction : Boolean; +begin + result := NOT ( ( Code <= DeclareQword ) OR ( Code = Zero_bytes ) ); +end; + +function TOpCodeInfo.Fwait : Boolean; +begin + result := OpCodeInfo_Fwait( Code ); +end; + +function TOpCodeInfo.W : Cardinal; +begin + result := OpCodeInfo_W( Code ); +end; + +function TOpCodeInfo.IsLig : Boolean; +begin + result := OpCodeInfo_IsLig( Code ); +end; + +function TOpCodeInfo.IsWig : Boolean; +begin + result := OpCodeInfo_IsWig( Code ); +end; + +function TOpCodeInfo.IsWig32 : Boolean; +begin + result := OpCodeInfo_IsWig32( Code ); +end; + +function TOpCodeInfo.IsRmGroup : Boolean; +begin + result := ( rm_group_index >= 0 ); +end; + +function TOpCodeInfo.IsGroup : Boolean; +begin + result := ( group_index >= 0 ); +end; + +function TOpCodeInfo.MvexEhBit : TMvexEHBit; +begin + result := OpCodeInfo_MvexEhBit( Code ); +end; + +function TOpCodeInfo.MvexCanUseEvictionHint : Boolean; +begin + result := OpCodeInfo_MvexCanUseEvictionHint( Code ); +end; + +function TOpCodeInfo.MvexCanUseImmRoundingControl : Boolean; +begin + result := OpCodeInfo_MvexCanUseImmRoundingControl( Code ); +end; + +function TOpCodeInfo.MvexIgnoresOpMaskRegister : Boolean; +begin + result := OpCodeInfo_MvexIgnoresOpMaskRegister( Code ); +end; + +function TOpCodeInfo.MvexNoSaeRc : Boolean; +begin + result := OpCodeInfo_MvexNoSaeRc( Code ); +end; + +function TOpCodeInfo.MvexTupleTypeLutKind : TMvexTupleTypeLutKind; +begin + result := OpCodeInfo_MvexTupleTypeLutKind( Code ); +end; + +function TOpCodeInfo.MvexConversionFunc : TMvexConvFn; +begin + result := OpCodeInfo_MvexConversionFunc( Code ); +end; + +function TOpCodeInfo.MvexValidConversionFuncsMask : Byte; +begin + result := OpCodeInfo_MvexValidConversionFuncsMask( Code ); +end; + +function TOpCodeInfo.MvexValidSwizzleFuncsMask : Byte; +begin + result := OpCodeInfo_MvexValidSwizzleFuncsMask( Code ); +end; + +function TOpCodeInfo.MemorySize : TMemorySize; +begin + result := OpCodeInfo_MemorySize( Code ); +end; + +function TOpCodeInfo.BroadcastMemorySize : TMemorySize; +begin + result := OpCodeInfo_BroadcastMemorySize( Code ); +end; + +function TOpCodeInfo.CanBroadcast : Boolean; +begin + result := OpCodeInfo_CanBroadcast( Code ); +end; + +function TOpCodeInfo.CanUseRoundingControl : Boolean; +begin + result := OpCodeInfo_CanUseRoundingControl( Code ); +end; + +function TOpCodeInfo.CanSuppressAllExceptions : Boolean; +begin + result := OpCodeInfo_CanSuppressAllExceptions( Code ); +end; + +function TOpCodeInfo.CanUseOpMaskRegister : Boolean; +begin + result := OpCodeInfo_CanUseOpMaskRegister( Code ); +end; + +function TOpCodeInfo.RequireOpMaskRegister : Boolean; +begin + result := OpCodeInfo_RequireOpMaskRegister( Code ); +end; + +function TOpCodeInfo.CanUseZeroingMasking : Boolean; +begin + result := OpCodeInfo_CanUseZeroingMasking( Code ); +end; + +function TOpCodeInfo.CanUseLockPrefix : Boolean; +begin + result := OpCodeInfo_CanUseLockPrefix( Code ); +end; + +function TOpCodeInfo.CanUseXacquirePrefix : Boolean; +begin + result := OpCodeInfo_CanUseXacquirePrefix( Code ); +end; + +function TOpCodeInfo.CanUseXreleasePrefix : Boolean; +begin + result := OpCodeInfo_CanUseXreleasePrefix( Code ); +end; + +function TOpCodeInfo.CanUseRepPrefix : Boolean; +begin + result := OpCodeInfo_CanUseRepPrefix( Code ); +end; + +function TOpCodeInfo.CanUseRepnePrefix : Boolean; +begin + result := OpCodeInfo_CanUseRepnePrefix( Code ); +end; + +function TOpCodeInfo.CanUseBndPrefix : Boolean; +begin + result := OpCodeInfo_CanUseBndPrefix( Code ); +end; + +function TOpCodeInfo.CanUseHintTakenPrefix : Boolean; +begin + result := OpCodeInfo_CanUseHintTakenPrefix( Code ); +end; + +function TOpCodeInfo.CanUseNotrackPrefix : Boolean; +begin + result := OpCodeInfo_CanUseNotrackPrefix( Code ); +end; + +function TOpCodeInfo.IgnoresRoundingControl : Boolean; +begin + result := OpCodeInfo_IgnoresRoundingControl( Code ); +end; + +function TOpCodeInfo.AmdLockRegBit : Boolean; +begin + result := OpCodeInfo_AmdLockRegBit( Code ); +end; + +function TOpCodeInfo.DefaultOpSize64 : Boolean; +begin + result := OpCodeInfo_DefaultOpSize64( Code ); +end; + +function TOpCodeInfo.ForceOpSize64 : Boolean; +begin + result := OpCodeInfo_ForceOpSize64( Code ); +end; + +function TOpCodeInfo.IntelForceOpSize64 : Boolean; +begin + result := OpCodeInfo_IntelForceOpSize64( Code ); +end; + +function TOpCodeInfo.MustBeCpl0 : Boolean; +begin + result := OpCodeInfo_MustBeCpl0( Code ); +end; + +function TOpCodeInfo.Cpl0 : Boolean; +begin + result := OpCodeInfo_Cpl0( Code ); +end; + +function TOpCodeInfo.Cpl1 : Boolean; +begin + result := OpCodeInfo_Cpl1( Code ); +end; + +function TOpCodeInfo.Cpl2 : Boolean; +begin + result := OpCodeInfo_Cpl2( Code ); +end; + +function TOpCodeInfo.Cpl3 : Boolean; +begin + result := OpCodeInfo_Cpl3( Code ); +end; + +function TOpCodeInfo.IsInputOutput : Boolean; +begin + result := OpCodeInfo_IsInputOutput( Code ); +end; + +function TOpCodeInfo.IsNop : Boolean; +begin + result := OpCodeInfo_IsNop( Code ); +end; + +function TOpCodeInfo.IsReservedNop : Boolean; +begin + result := OpCodeInfo_IsReservedNop( Code ); +end; + +function TOpCodeInfo.IsSerializingIntel : Boolean; +begin + result := OpCodeInfo_IsSerializingIntel( Code ); +end; + +function TOpCodeInfo.IsSerializingAmd : Boolean; +begin + result := OpCodeInfo_IsSerializingAmd( Code ); +end; + +function TOpCodeInfo.MayRequireCpl0 : Boolean; +begin + result := OpCodeInfo_MayRequireCpl0( Code ); +end; + +function TOpCodeInfo.IsCetTracked : Boolean; +begin + result := OpCodeInfo_IsCetTracked( Code ); +end; + +function TOpCodeInfo.IsNonTemporal : Boolean; +begin + result := OpCodeInfo_IsNonTemporal( Code ); +end; + +function TOpCodeInfo.IsFpuNoWait : Boolean; +begin + result := OpCodeInfo_IsFpuNoWait( Code ); +end; + +function TOpCodeInfo.IgnoresModBits : Boolean; +begin + result := OpCodeInfo_IgnoresModBits( Code ); +end; + +function TOpCodeInfo.No66 : Boolean; +begin + result := OpCodeInfo_No66( Code ); +end; + +function TOpCodeInfo.Nfx : Boolean; +begin + result := OpCodeInfo_Nfx( Code ); +end; + +function TOpCodeInfo.RequiresUniqueRegNums : Boolean; +begin + result := OpCodeInfo_RequiresUniqueRegNums( Code ); +end; + +function TOpCodeInfo.RequiresUniqueDestRegNum : Boolean; +begin + result := OpCodeInfo_RequiresUniqueDestRegNum( Code ); +end; + +function TOpCodeInfo.IsPrivileged : Boolean; +begin + result := OpCodeInfo_IsPrivileged( Code ); +end; + +function TOpCodeInfo.IsSaveRestore : Boolean; +begin + result := OpCodeInfo_IsSaveRestore( Code ); +end; + +function TOpCodeInfo.IsStackInstruction : Boolean; +begin + result := OpCodeInfo_IsStackInstruction( Code ); +end; + +function TOpCodeInfo.IgnoresSegment : Boolean; +begin + result := OpCodeInfo_IgnoresSegment( Code ); +end; + +function TOpCodeInfo.IsOpMaskReadWrite : Boolean; +begin + result := OpCodeInfo_IsOpMaskReadWrite( Code ); +end; + +function TOpCodeInfo.RealMode : Boolean; +begin + result := OpCodeInfo_RealMode( Code ); +end; + +function TOpCodeInfo.ProtectedMode : Boolean; +begin + result := OpCodeInfo_ProtectedMode( Code ); +end; + +function TOpCodeInfo.Virtual8086Mode : Boolean; +begin + result := OpCodeInfo_Virtual8086Mode( Code ); +end; + +function TOpCodeInfo.CompatibilityMode : Boolean; +begin + result := OpCodeInfo_CompatibilityMode( Code ); +end; + +function TOpCodeInfo.LongMode : Boolean; +begin + result := OpCodeInfo_LongMode( Code ); +end; + +function TOpCodeInfo.UseOutsideSmm : Boolean; +begin + result := OpCodeInfo_UseOutsideSmm( Code ); +end; + +function TOpCodeInfo.UseInSmm : Boolean; +begin + result := OpCodeInfo_UseInSmm( Code ); +end; + +function TOpCodeInfo.UseOutsideEnclaveSgx : Boolean; +begin + result := OpCodeInfo_UseOutsideEnclaveSgx( Code ); +end; + +function TOpCodeInfo.UseInEnclaveSgx1 : Boolean; +begin + result := OpCodeInfo_UseInEnclaveSgx1( Code ); +end; + +function TOpCodeInfo.UseInEnclaveSgx2 : Boolean; +begin + result := OpCodeInfo_UseInEnclaveSgx2( Code ); +end; + +function TOpCodeInfo.UseOutsideVmxOp : Boolean; +begin + result := OpCodeInfo_UseOutsideVmxOp( Code ); +end; + +function TOpCodeInfo.UseInVmxRootOp : Boolean; +begin + result := OpCodeInfo_UseInVmxRootOp( Code ); +end; + +function TOpCodeInfo.UseInVmxNonRootOp : Boolean; +begin + result := OpCodeInfo_UseInVmxNonRootOp( Code ); +end; + +function TOpCodeInfo.UseOutsideSeam : Boolean; +begin + result := OpCodeInfo_UseOutsideSeam( Code ); +end; + +function TOpCodeInfo.UseInSeam : Boolean; +begin + result := OpCodeInfo_UseInSeam( Code ); +end; + +function TOpCodeInfo.TdxNonRootGenUd : Boolean; +begin + result := OpCodeInfo_TdxNonRootGenUd( Code ); +end; + +function TOpCodeInfo.TdxNonRootGenVe : Boolean; +begin + result := OpCodeInfo_TdxNonRootGenVe( Code ); +end; + +function TOpCodeInfo.TdxNonRootMayGenEx : Boolean; +begin + result := OpCodeInfo_TdxNonRootMayGenEx( Code ); +end; + +function TOpCodeInfo.IntelVMExit : Boolean; +begin + result := OpCodeInfo_IntelVMExit( Code ); +end; + +function TOpCodeInfo.IntelMayVMExit : Boolean; +begin + result := OpCodeInfo_IntelMayVMExit( Code ); +end; + +function TOpCodeInfo.IntelSmmVMExit : Boolean; +begin + result := OpCodeInfo_IntelSmmVMExit( Code ); +end; + +function TOpCodeInfo.AmdVMExit : Boolean; +begin + result := OpCodeInfo_AmdVMExit( Code ); +end; + +function TOpCodeInfo.AmdMayVMExit : Boolean; +begin + result := OpCodeInfo_AmdMayVMExit( Code ); +end; + +function TOpCodeInfo.TsxAbort : Boolean; +begin + result := OpCodeInfo_TsxAbort( Code ); +end; + +function TOpCodeInfo.TsxImplAbort : Boolean; +begin + result := OpCodeInfo_TsxImplAbort( Code ); +end; + +function TOpCodeInfo.TsxMayAbort : Boolean; +begin + result := OpCodeInfo_TsxMayAbort( Code ); +end; + +function TOpCodeInfo.IntelDecoder16 : Boolean; +begin + result := OpCodeInfo_IntelDecoder16( Code ); +end; + +function TOpCodeInfo.IntelDecoder32 : Boolean; +begin + result := OpCodeInfo_IntelDecoder32( Code ); +end; + +function TOpCodeInfo.IntelDecoder64 : Boolean; +begin + result := OpCodeInfo_IntelDecoder64( Code ); +end; + +function TOpCodeInfo.AmdDecoder16 : Boolean; +begin + result := OpCodeInfo_AmdDecoder16( Code ); +end; + +function TOpCodeInfo.AmdDecoder32 : Boolean; +begin + result := OpCodeInfo_AmdDecoder32( Code ); +end; + +function TOpCodeInfo.AmdDecoder64 : Boolean; +begin + result := OpCodeInfo_AmdDecoder64( Code ); +end; + +function TOpCodeInfo.DecoderOption : Cardinal; +begin + result := OpCodeInfo_DecoderOption( Code ); +end; + +function TOpCodeInfo.OpCodeLen : Cardinal; +begin + result := OpCodeInfo_OpCodeLen( Code ); +end; + +function TOpCodeInfo.OPCount : Cardinal; +begin + result := OpCodeInfo_OPCount( Code ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TCode (Record) +{$IFDEF UNICODE} +class operator TCode.Equal( const self, ACode : TCode ) : Boolean; +begin + Result := ( self.Code = ACode.Code ); +end; + +class operator TCode.Equal( const self : TCode; const ACode : TCodeType ) : Boolean; +begin + Result := ( self.Code = ACode ); +end; + +class operator TCode.NotEqual( const self, ACode : TCode ) : Boolean; +begin + Result := ( self.Code <> ACode.Code ); +end; + +class operator TCode.NotEqual( const self : TCode; const ACode : TCodeType ) : Boolean; +begin + Result := ( self.Code <> ACode ); +end; + +class operator TCode.In( const self : TCode; const ACode : array of TCodeType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( ACode ) to High( ACode ) do + begin + if ( self.Code = ACode[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TCode.GreaterThan( const self, ACode : TCode ) : Boolean; +begin + Result := ( self.Code > ACode.Code ); +end; + +class operator TCode.GreaterThan( const self : TCode; const ACode : TCodeType ) : Boolean; +begin + Result := ( self.Code > ACode ); +end; + +class operator TCode.GreaterThanOrEqual( const self, ACode : TCode ) : Boolean; +begin + Result := ( self.Code >= ACode.Code ); +end; + +class operator TCode.GreaterThanOrEqual( const self : TCode; const ACode : TCodeType ) : Boolean; +begin + Result := ( self.Code >= ACode ); +end; + +class operator TCode.LessThan( const self, ACode : TCode ) : Boolean; +begin + Result := ( self.Code < ACode.Code ); +end; + +class operator TCode.LessThan( const self : TCode; const ACode : TCodeType ) : Boolean; +begin + Result := ( self.Code < ACode ); +end; + +class operator TCode.LessThanOrEqual( const self, ACode : TCode ) : Boolean; +begin + Result := ( self.Code <= ACode.Code ); +end; + +class operator TCode.LessThanOrEqual( const self : TCode; const ACode : TCodeType ) : Boolean; +begin + Result := ( self.Code <= ACode ); +end; + +class operator TCode.Implicit( const ACode : TCode ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + Code_AsString( ACode.Code, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TCode.Implicit( const ACode : TCode ) : Word; +begin + result := Byte( ACode.Code ); +end; + +class operator TCode.Implicit( const ACode : Word ) : TCode; +begin + result.Code := TCode( ACode ); +end; + +class operator TCode.Implicit( const ACode : TCode ) : TCodeType; +begin + result := ACode.Code; +end; + +class operator TCode.Implicit( const ACode : TCodeType ) : TCode; +begin + result.Code := ACode; +end; +{$ENDIF UNICODE} + +function TCode.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + Code_AsString( Code, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +function TCode.Mnemonic : TMnemonic; +begin + result := Code_Mnemonic( Code ); +end; + +function TCode.OPCode : TOpCodeInfo; +begin + Code_OPCode( Code, result ); +end; + +function TCode.Encoding : TEncodingKind; +begin + result := Code_Encoding( Code ); +end; + +function TCode.CPUidFeature : TCPUIDFeaturesArray; +begin + Code_CPUidFeature( Code, result ); +end; + +function TCode.FlowControl : TFlowControl; +begin + result := Code_FlowControl( Code ); +end; + +function TCode.IsPrivileged : Boolean; +begin + result := Code_IsPrivileged( Code ); +end; + +function TCode.IsStackInstruction : Boolean; +begin + result := Code_IsStackInstruction( Code ); +end; + +function TCode.IsSaveRestoreInstruction : Boolean; +begin + result := Code_IsSaveRestoreInstruction( Code ); +end; + +function TCode.IsJccShort : Boolean; +begin + result := Code_IsJccShort( Code ); +end; + +function TCode.IsJmpShort : Boolean; +begin + result := Code_IsJmpShort( Code ); +end; + +function TCode.IsJmpShortOrNear : Boolean; +begin + result := Code_IsJmpShortOrNear( Code ); +end; + +function TCode.IsJmpNear : Boolean; +begin + result := Code_IsJmpNear( Code ); +end; + +function TCode.IsJmpFar : Boolean; +begin + result := Code_IsJmpFar( Code ); +end; + +function TCode.IsCallNear : Boolean; +begin + result := Code_IsCallNear( Code ); +end; + +function TCode.IsCallFar : Boolean; +begin + result := Code_IsCallFar( Code ); +end; + +function TCode.IsJmpNearIndirect : Boolean; +begin + result := Code_IsJmpNearIndirect( Code ); +end; + +function TCode.IsJmpFarIndirect : Boolean; +begin + result := Code_IsJmpFarIndirect( Code ); +end; + +function TCode.IsCallNearIndirect : Boolean; +begin + result := Code_IsCallNearIndirect( Code ); +end; + +function TCode.IsCallFarIndirect : Boolean; +begin + result := Code_IsCallFarIndirect( Code ); +end; + +function TCode.IsJkccShortOrNear : Boolean; +begin + result := ( Code = VEX_KNC_Jkzd_kr_rel8_64 ) OR ( Code = VEX_KNC_Jknzd_kr_rel8_64 ) OR ( Code = VEX_KNC_Jkzd_kr_rel32_64 ) OR ( Code = VEX_KNC_Jknzd_kr_rel32_64 ); +end; + +function TCode.IsJkccNear : Boolean; +begin + result := ( Code = VEX_KNC_Jkzd_kr_rel32_64 ) OR ( Code = VEX_KNC_Jknzd_kr_rel32_64 ); +end; + +function TCode.IsJkccShort : Boolean; +begin + result := ( Code = VEX_KNC_Jkzd_kr_rel8_64 ) OR ( Code = VEX_KNC_Jknzd_kr_rel8_64 ); +end; + +function TCode.ConditionCode : TConditionCode; +begin + result := Code_ConditionCode( Code ); +end; + +function TCode.IsStringInstruction : Boolean; +begin + result := ( Code = Insb_m8_DX ) OR ( Code = Insw_m16_DX ) OR ( Code = Insd_m32_DX ) OR + ( Code = Outsb_DX_m8 ) OR ( Code = Outsw_DX_m16 ) OR ( Code = Outsd_DX_m32 ) OR + ( Code = Movsb_m8_m8 ) OR ( Code = Movsw_m16_m16 ) OR ( Code = Movsd_m32_m32 ) OR + ( Code = Movsq_m64_m64 ) OR ( Code = Cmpsb_m8_m8 ) OR ( Code = Cmpsw_m16_m16 ) OR + ( Code = Cmpsd_m32_m32 ) OR ( Code = Cmpsq_m64_m64 ) OR ( Code = Stosb_m8_AL ) OR + ( Code = Stosw_m16_AX ) OR ( Code = Stosd_m32_EAX ) OR ( Code = Stosq_m64_RAX ) OR + + ( Code = Lodsb_AL_m8 ) OR ( Code = Lodsw_AX_m16 ) OR ( Code = Lodsd_EAX_m32 ) OR + ( Code = Lodsq_RAX_m64 ) OR ( Code = Scasb_AL_m8 ) OR ( Code = Scasw_AX_m16 ) OR + ( Code = Scasd_EAX_m32 ) OR ( Code = Scasq_RAX_m64 ); +end; + +function TCode.IsJcxShort : Boolean; +begin + result := Code_IsJcxShort( Code ); +end; + +function TCode.IsLoopCC : Boolean; +begin + result := Code_IsLoopCC( Code ); +end; + +function TCode.IsLoop : Boolean; +begin + result := Code_IsLoop( Code ); +end; + +function TCode.IsJccShortOrNear : Boolean; +begin + result := Code_IsJccShortOrNear( Code ); +end; + +function TCode.NegateConditionCode : TCode; +begin + result := Code_NegateConditionCode( Code ); +end; + +function TCode.AsShortBranch : TCode; +begin + result := Code_AsShortBranch( Code ); +end; + +function TCode.AsNearBranch : TCode; +begin + result := Code_AsNearBranch( Code ); +end; + +function TCode.IgnoresSegment : Boolean; +begin + result := ( Code = Lea_r16_m ) OR ( Code = Lea_r32_m ) OR ( Code = Lea_r64_m ) OR + ( Code = Bndcl_bnd_rm32 ) OR ( Code = Bndcl_bnd_rm64 ) OR ( Code = Bndcu_bnd_rm32 ) OR + ( Code = Bndcu_bnd_rm64 ) OR ( Code = Bndmk_bnd_m32 ) OR ( Code = Bndmk_bnd_m64 ) OR + ( Code = Bndcn_bnd_rm32 ) OR ( Code = Bndcn_bnd_rm64 ); +end; + +function TCode.IgnoresIndex : Boolean; +begin + result := ( Code = Bndldx_bnd_mib ) OR ( Code = Bndstx_mib_bnd ); +end; + +function TCode.IsTileStrideIndex : Boolean; +begin + result := ( Code = VEX_Tileloaddt1_tmm_sibmem ) OR ( Code = VEX_Tilestored_sibmem_tmm ) OR ( Code = VEX_Tileloadd_tmm_sibmem ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TMnemonic (Record) +{$IFDEF UNICODE} +class operator TMnemonic.Equal( const self, AMnemonic : TMnemonic ) : Boolean; +begin + Result := ( self.Mnemonic = AMnemonic.Mnemonic ); +end; + +class operator TMnemonic.Equal( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; +begin + Result := ( self.Mnemonic = AMnemonic ); +end; + +class operator TMnemonic.NotEqual( const self, AMnemonic : TMnemonic ) : Boolean; +begin + Result := ( self.Mnemonic <> AMnemonic.Mnemonic ); +end; + +class operator TMnemonic.NotEqual( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; +begin + Result := ( self.Mnemonic <> AMnemonic ); +end; + +class operator TMnemonic.In( const self : TMnemonic; const AMnemonic : array of TMnemonicType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AMnemonic ) to High( AMnemonic ) do + begin + if ( self.Mnemonic = AMnemonic[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TMnemonic.GreaterThan( const self, AMnemonic : TMnemonic ) : Boolean; +begin + Result := ( self.Mnemonic > AMnemonic.Mnemonic ); +end; + +class operator TMnemonic.GreaterThan( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; +begin + Result := ( self.Mnemonic > AMnemonic ); +end; + +class operator TMnemonic.GreaterThanOrEqual( const self, AMnemonic : TMnemonic ) : Boolean; +begin + Result := ( self.Mnemonic >= AMnemonic.Mnemonic ); +end; + +class operator TMnemonic.GreaterThanOrEqual( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; +begin + Result := ( self.Mnemonic >= AMnemonic ); +end; + +class operator TMnemonic.LessThan( const self, AMnemonic : TMnemonic ) : Boolean; +begin + Result := ( self.Mnemonic < AMnemonic.Mnemonic ); +end; + +class operator TMnemonic.LessThan( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; +begin + Result := ( self.Mnemonic < AMnemonic ); +end; + +class operator TMnemonic.LessThanOrEqual( const self, AMnemonic : TMnemonic ) : Boolean; +begin + Result := ( self.Mnemonic <= AMnemonic.Mnemonic ); +end; + +class operator TMnemonic.LessThanOrEqual( const self : TMnemonic; const AMnemonic : TMnemonicType ) : Boolean; +begin + Result := ( self.Mnemonic <= AMnemonic ); +end; + +class operator TMnemonic.Implicit( const AMnemonic : TMnemonic ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + Mnemonic_AsString( AMnemonic.Mnemonic, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TMnemonic.Implicit( const AMnemonic : TMnemonic ) : Word; +begin + result := Byte( AMnemonic.Mnemonic ); +end; + +class operator TMnemonic.Implicit( const AMnemonic : Word ) : TMnemonic; +begin + result.Mnemonic := TMnemonic( AMnemonic ); +end; + +class operator TMnemonic.Implicit( const AMnemonic : TMnemonic ) : TMnemonicType; +begin + result := AMnemonic.Mnemonic; +end; + +class operator TMnemonic.Implicit( const AMnemonic : TMnemonicType ) : TMnemonic; +begin + result.Mnemonic := AMnemonic; +end; +{$ENDIF UNICODE} + +function TMnemonic.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + Mnemonic_AsString( Mnemonic, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TRegister (Record) +{$IFDEF UNICODE} +class operator TRegister.Equal( const self, ARegister : TRegister ) : Boolean; +begin + Result := ( self.Register = ARegister.Register ); +end; + +class operator TRegister.Equal( const self : TRegister; const ARegister : TRegisterType ) : Boolean; +begin + Result := ( self.Register = ARegister ); +end; + +class operator TRegister.NotEqual( const self, ARegister : TRegister ) : Boolean; +begin + Result := ( self.Register <> ARegister.Register ); +end; + +class operator TRegister.NotEqual( const self : TRegister; const ARegister : TRegisterType ) : Boolean; +begin + Result := ( self.Register <> ARegister ); +end; + +class operator TRegister.In( const self : TRegister; const ARegister : array of TRegisterType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( ARegister ) to High( ARegister ) do + begin + if ( self.Register = ARegister[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TRegister.GreaterThan( const self, ARegister : TRegister ) : Boolean; +begin + Result := ( self.Register > ARegister.Register ); +end; + +class operator TRegister.GreaterThan( const self : TRegister; const ARegister : TRegisterType ) : Boolean; +begin + Result := ( self.Register > ARegister ); +end; + +class operator TRegister.GreaterThanOrEqual( const self, ARegister : TRegister ) : Boolean; +begin + Result := ( self.Register >= ARegister.Register ); +end; + +class operator TRegister.GreaterThanOrEqual( const self : TRegister; const ARegister : TRegisterType ) : Boolean; +begin + Result := ( self.Register >= ARegister ); +end; + +class operator TRegister.LessThan( const self, ARegister : TRegister ) : Boolean; +begin + Result := ( self.Register < ARegister.Register ); +end; + +class operator TRegister.LessThan( const self : TRegister; const ARegister : TRegisterType ) : Boolean; +begin + Result := ( self.Register < ARegister ); +end; + +class operator TRegister.LessThanOrEqual( const self, ARegister : TRegister ) : Boolean; +begin + Result := ( self.Register <= ARegister.Register ); +end; + +class operator TRegister.LessThanOrEqual( const self : TRegister; const ARegister : TRegisterType ) : Boolean; +begin + Result := ( self.Register <= ARegister ); +end; + +class operator TRegister.Implicit( const ARegister : TRegister ) : Byte; +begin + result := Byte( ARegister.Register ); +end; + +class operator TRegister.Implicit( const ARegister : Byte ) : TRegister; +begin + result.Register := TRegister( ARegister ); +end; + +class operator TRegister.Implicit( const ARegister : TRegister ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + Register_AsString( ARegister.Register, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TRegister.Implicit( const ARegister : TRegister ) : TRegisterType; +begin + result := ARegister.Register; +end; + +class operator TRegister.Implicit( const ARegister : TRegisterType ) : TRegister; +begin + result.Register := ARegister; +end; +{$ENDIF UNICODE} + +function TRegister.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + Register_AsString( Register, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +function TRegister.Base : TRegister; +begin + result := Register_Base( Self.Register ); +end; + +function TRegister.Number : NativeUInt; +begin + result := Register_Number( Self.Register ); +end; + +function TRegister.FullRegister : TRegister; +begin + result := Register_FullRegister( Self.Register ); +end; + +function TRegister.FullRegister32 : TRegister; +begin + result := Register_FullRegister32( Self.Register ); +end; + +function TRegister.Size : NativeUInt; +begin + result := Register_Size( Self.Register ); +end; + +function TRegister.IsSegmentRegister : Boolean; +begin + result := ( ES <= self.Register ) AND ( self.Register <= GS ); +end; + +function TRegister.IsGPR : Boolean; +begin + result := ( AL <= self.Register ) AND ( self.Register <= R15 ); +end; + +function TRegister.IsGPR8 : Boolean; +begin + result := ( AL <= self.Register ) AND ( self.Register <= R15L ); +end; + +function TRegister.IsGPR16 : Boolean; +begin + result := ( AX <= self.Register ) AND ( self.Register <= R15W ); +end; + +function TRegister.IsGPR32 : Boolean; +begin + result := ( EAX <= self.Register ) AND ( self.Register <= R15D ); +end; + +function TRegister.IsGPR64 : Boolean; +begin + result := ( RAX <= self.Register ) AND ( self.Register <= R15 ); +end; + +function TRegister.IsXMM : Boolean; +begin + result := ( XMM0 <= self.Register ) AND ( self.Register <= XMM31 ); +end; + +function TRegister.IsYMM : Boolean; +begin + result := ( YMM0 <= self.Register ) AND ( self.Register <= YMM31 ); +end; + +function TRegister.IsZMM : Boolean; +begin + result := ( ZMM0 <= self.Register ) AND ( self.Register <= ZMM31 ); +end; + +function TRegister.IsVectorRegister : Boolean; +begin + result := ( XMM0 <= self.Register ) AND ( self.Register <= ZMM31 ); +end; + +function TRegister.IsIP : Boolean; +begin + result := ( self.Register = EIP ) OR ( self.Register = RIP ); +end; + +function TRegister.IsK : Boolean; +begin + result := ( K0 <= self.Register ) AND ( self.Register <= K7 ); +end; + +function TRegister.IsCR : Boolean; +begin + result := ( CR0 <= self.Register ) AND ( self.Register <= cR15 ); +end; + +function TRegister.IsDR : Boolean; +begin + result := ( DR0 <= self.Register ) AND ( self.Register <= DR15 ); +end; + +function TRegister.IsTR : Boolean; +begin + result := ( TR0 <= self.Register ) AND ( self.Register <= TR7 ); +end; + +function TRegister.IsST : Boolean; +begin + result := ( ST0 <= self.Register ) AND ( self.Register <= ST7 ); +end; + +function TRegister.IsBND : Boolean; +begin + result := ( BND0 <= self.Register ) AND ( self.Register <= BND3 ); +end; + +function TRegister.IsMM : Boolean; +begin + result := ( MM0 <= self.Register ) AND ( self.Register <= MM7 ); +end; + +function TRegister.IsTMM : Boolean; +begin + result := ( TMM0 <= self.Register ) AND ( self.Register <= TMM7 ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TOpKind (Record) +{$IFDEF UNICODE} +class operator TOpKind.Equal( const self, AOpKind : TOpKind ) : Boolean; +begin + Result := ( self.OpKind = AOpKind.OpKind ); +end; + +class operator TOpKind.Equal( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; +begin + Result := ( self.OpKind = AOpKind ); +end; + +class operator TOpKind.NotEqual( const self, AOpKind : TOpKind ) : Boolean; +begin + Result := ( self.OpKind <> AOpKind.OpKind ); +end; + +class operator TOpKind.NotEqual( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; +begin + Result := ( self.OpKind <> AOpKind ); +end; + +class operator TOpKind.In( const self : TOpKind; const AOpKind : array of TOpKindType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AOpKind ) to High( AOpKind ) do + begin + if ( self.OpKind = AOpKind[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TOpKind.GreaterThan( const self, AOpKind : TOpKind ) : Boolean; +begin + Result := ( self.OpKind > AOpKind.OpKind ); +end; + +class operator TOpKind.GreaterThan( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; +begin + Result := ( self.OpKind > AOpKind ); +end; + +class operator TOpKind.GreaterThanOrEqual( const self, AOpKind : TOpKind ) : Boolean; +begin + Result := ( self.OpKind >= AOpKind.OpKind ); +end; + +class operator TOpKind.GreaterThanOrEqual( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; +begin + Result := ( self.OpKind >= AOpKind ); +end; + +class operator TOpKind.LessThan( const self, AOpKind : TOpKind ) : Boolean; +begin + Result := ( self.OpKind < AOpKind.OpKind ); +end; + +class operator TOpKind.LessThan( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; +begin + Result := ( self.OpKind < AOpKind ); +end; + +class operator TOpKind.LessThanOrEqual( const self, AOpKind : TOpKind ) : Boolean; +begin + Result := ( self.OpKind <= AOpKind.OpKind ); +end; + +class operator TOpKind.LessThanOrEqual( const self : TOpKind; const AOpKind : TOpKindType ) : Boolean; +begin + Result := ( self.OpKind <= AOpKind ); +end; + +class operator TOpKind.Implicit( const AOpKind : TOpKind ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + OpKind_AsString( AOpKind.OpKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TOpKind.Implicit( const AOpKind : TOpKind ) : Byte; +begin + result := Byte( AOpKind.OpKind ); +end; + +class operator TOpKind.Implicit( const AOpKind : Byte ) : TOpKind; +begin + result.OpKind := TOpKind( AOpKind ); +end; + +class operator TOpKind.Implicit( const AOpKind : TOpKind ) : TOpKindType; +begin + result := AOpKind.OpKind; +end; + +class operator TOpKind.Implicit( const AOpKind : TOpKindType ) : TOpKind; +begin + result.OpKind := AOpKind; +end; +{$ENDIF UNICODE} + +function TOpKind.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + OpKind_AsString( OpKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TEncodingKind (Record) +{$IFDEF UNICODE} +class operator TEncodingKind.Equal( const self, AEncodingKind : TEncodingKind ) : Boolean; +begin + Result := ( self.EncodingKind = AEncodingKind.EncodingKind ); +end; + +class operator TEncodingKind.Equal( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; +begin + Result := ( self.EncodingKind = AEncodingKind ); +end; + +class operator TEncodingKind.NotEqual( const self, AEncodingKind : TEncodingKind ) : Boolean; +begin + Result := ( self.EncodingKind <> AEncodingKind.EncodingKind ); +end; + +class operator TEncodingKind.NotEqual( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; +begin + Result := ( self.EncodingKind <> AEncodingKind ); +end; + +class operator TEncodingKind.In( const self : TEncodingKind; const AEncodingKind : array of TEncodingKindType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AEncodingKind ) to High( AEncodingKind ) do + begin + if ( self.EncodingKind = AEncodingKind[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TEncodingKind.GreaterThan( const self, AEncodingKind : TEncodingKind ) : Boolean; +begin + Result := ( self.EncodingKind > AEncodingKind.EncodingKind ); +end; + +class operator TEncodingKind.GreaterThan( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; +begin + Result := ( self.EncodingKind > AEncodingKind ); +end; + +class operator TEncodingKind.GreaterThanOrEqual( const self, AEncodingKind : TEncodingKind ) : Boolean; +begin + Result := ( self.EncodingKind >= AEncodingKind.EncodingKind ); +end; + +class operator TEncodingKind.GreaterThanOrEqual( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; +begin + Result := ( self.EncodingKind >= AEncodingKind ); +end; + +class operator TEncodingKind.LessThan( const self, AEncodingKind : TEncodingKind ) : Boolean; +begin + Result := ( self.EncodingKind < AEncodingKind.EncodingKind ); +end; + +class operator TEncodingKind.LessThan( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; +begin + Result := ( self.EncodingKind < AEncodingKind ); +end; + +class operator TEncodingKind.LessThanOrEqual( const self, AEncodingKind : TEncodingKind ) : Boolean; +begin + Result := ( self.EncodingKind <= AEncodingKind.EncodingKind ); +end; + +class operator TEncodingKind.LessThanOrEqual( const self : TEncodingKind; const AEncodingKind : TEncodingKindType ) : Boolean; +begin + Result := ( self.EncodingKind <= AEncodingKind ); +end; + +class operator TEncodingKind.Implicit( const AEncodingKind : TEncodingKind ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + EncodingKind_AsString( AEncodingKind.EncodingKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TEncodingKind.Implicit( const AEncodingKind : TEncodingKind ) : Byte; +begin + result := Byte( AEncodingKind.EncodingKind ); +end; + +class operator TEncodingKind.Implicit( const AEncodingKind : Byte ) : TEncodingKind; +begin + result.EncodingKind := TEncodingKind( AEncodingKind ); +end; + +class operator TEncodingKind.Implicit( const AEncodingKind : TEncodingKind ) : TEncodingKindType; +begin + result := AEncodingKind.EncodingKind; +end; + +class operator TEncodingKind.Implicit( const AEncodingKind : TEncodingKindType ) : TEncodingKind; +begin + result.EncodingKind := AEncodingKind; +end; +{$ENDIF UNICODE} + +function TEncodingKind.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + EncodingKind_AsString( EncodingKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TCPUidFeature (Record) +{$IFDEF UNICODE} +class operator TCPUidFeature.Equal( const self, ACPUidFeature : TCPUidFeature ) : Boolean; +begin + Result := ( self.CPUidFeature = ACPUidFeature.CPUidFeature ); +end; + +class operator TCPUidFeature.Equal( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; +begin + Result := ( self.CPUidFeature = ACPUidFeature ); +end; + +class operator TCPUidFeature.NotEqual( const self, ACPUidFeature : TCPUidFeature ) : Boolean; +begin + Result := ( self.CPUidFeature <> ACPUidFeature.CPUidFeature ); +end; + +class operator TCPUidFeature.NotEqual( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; +begin + Result := ( self.CPUidFeature <> ACPUidFeature ); +end; + +class operator TCPUidFeature.In( const self : TCPUidFeature; const ACPUidFeature : array of TCPUidFeatureType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( ACPUidFeature ) to High( ACPUidFeature ) do + begin + if ( self.CPUidFeature = ACPUidFeature[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TCPUidFeature.GreaterThan( const self, ACPUidFeature : TCPUidFeature ) : Boolean; +begin + Result := ( self.CPUidFeature > ACPUidFeature.CPUidFeature ); +end; + +class operator TCPUidFeature.GreaterThan( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; +begin + Result := ( self.CPUidFeature > ACPUidFeature ); +end; + +class operator TCPUidFeature.GreaterThanOrEqual( const self, ACPUidFeature : TCPUidFeature ) : Boolean; +begin + Result := ( self.CPUidFeature >= ACPUidFeature.CPUidFeature ); +end; + +class operator TCPUidFeature.GreaterThanOrEqual( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; +begin + Result := ( self.CPUidFeature >= ACPUidFeature ); +end; + +class operator TCPUidFeature.LessThan( const self, ACPUidFeature : TCPUidFeature ) : Boolean; +begin + Result := ( self.CPUidFeature < ACPUidFeature.CPUidFeature ); +end; + +class operator TCPUidFeature.LessThan( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; +begin + Result := ( self.CPUidFeature < ACPUidFeature ); +end; + +class operator TCPUidFeature.LessThanOrEqual( const self, ACPUidFeature : TCPUidFeature ) : Boolean; +begin + Result := ( self.CPUidFeature <= ACPUidFeature.CPUidFeature ); +end; + +class operator TCPUidFeature.LessThanOrEqual( const self : TCPUidFeature; const ACPUidFeature : TCPUidFeatureType ) : Boolean; +begin + Result := ( self.CPUidFeature <= ACPUidFeature ); +end; + +class operator TCPUidFeature.Implicit( const ACPUidFeature : TCPUidFeature ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + CPUidFeature_AsString( ACPUidFeature.CPUidFeature, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TCPUidFeature.Implicit( const ACPUidFeature : TCPUidFeature ) : Byte; +begin + result := Byte( ACPUidFeature.CPUidFeature ); +end; + +class operator TCPUidFeature.Implicit( const ACPUidFeature : Byte ) : TCPUidFeature; +begin + result.CPUidFeature := TCPUidFeature( ACPUidFeature ); +end; + +class operator TCPUidFeature.Implicit( const ACPUidFeature : TCPUidFeature ) : TCPUidFeatureType; +begin + result := ACPUidFeature.CPUidFeature; +end; + +class operator TCPUidFeature.Implicit( const ACPUidFeature : TCPUidFeatureType ) : TCPUidFeature; +begin + result.CPUidFeature := ACPUidFeature; +end; +{$ENDIF UNICODE} + +function TCPUidFeature.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + CPUidFeature_AsString( CPUidFeature, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TConditionCode (Record) +{$IFDEF UNICODE} +class operator TConditionCode.Equal( const self, AConditionCode : TConditionCode ) : Boolean; +begin + Result := ( self.ConditionCode = AConditionCode.ConditionCode ); +end; + +class operator TConditionCode.Equal( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; +begin + Result := ( self.ConditionCode = AConditionCode ); +end; + +class operator TConditionCode.NotEqual( const self, AConditionCode : TConditionCode ) : Boolean; +begin + Result := ( self.ConditionCode <> AConditionCode.ConditionCode ); +end; + +class operator TConditionCode.NotEqual( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; +begin + Result := ( self.ConditionCode <> AConditionCode ); +end; + +class operator TConditionCode.In( const self : TConditionCode; const AConditionCode : array of TConditionCodeType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AConditionCode ) to High( AConditionCode ) do + begin + if ( self.ConditionCode = AConditionCode[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TConditionCode.GreaterThan( const self, AConditionCode : TConditionCode ) : Boolean; +begin + Result := ( self.ConditionCode > AConditionCode.ConditionCode ); +end; + +class operator TConditionCode.GreaterThan( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; +begin + Result := ( self.ConditionCode > AConditionCode ); +end; + +class operator TConditionCode.GreaterThanOrEqual( const self, AConditionCode : TConditionCode ) : Boolean; +begin + Result := ( self.ConditionCode >= AConditionCode.ConditionCode ); +end; + +class operator TConditionCode.GreaterThanOrEqual( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; +begin + Result := ( self.ConditionCode >= AConditionCode ); +end; + +class operator TConditionCode.LessThan( const self, AConditionCode : TConditionCode ) : Boolean; +begin + Result := ( self.ConditionCode < AConditionCode.ConditionCode ); +end; + +class operator TConditionCode.LessThan( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; +begin + Result := ( self.ConditionCode < AConditionCode ); +end; + +class operator TConditionCode.LessThanOrEqual( const self, AConditionCode : TConditionCode ) : Boolean; +begin + Result := ( self.ConditionCode <= AConditionCode.ConditionCode ); +end; + +class operator TConditionCode.LessThanOrEqual( const self : TConditionCode; const AConditionCode : TConditionCodeType ) : Boolean; +begin + Result := ( self.ConditionCode <= AConditionCode ); +end; + +class operator TConditionCode.Implicit( const AConditionCode : TConditionCode ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + ConditionCode_AsString( AConditionCode.ConditionCode, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TConditionCode.Implicit( const AConditionCode : TConditionCode ) : Byte; +begin + result := Byte( AConditionCode.ConditionCode ); +end; + +class operator TConditionCode.Implicit( const AConditionCode : Byte ) : TConditionCode; +begin + result.ConditionCode := TConditionCode( AConditionCode ); +end; + +class operator TConditionCode.Implicit( const AConditionCode : TConditionCode ) : TConditionCodeType; +begin + result := AConditionCode.ConditionCode; +end; + +class operator TConditionCode.Implicit( const AConditionCode : TConditionCodeType ) : TConditionCode; +begin + result.ConditionCode := AConditionCode; +end; +{$ENDIF UNICODE} + +function TConditionCode.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + ConditionCode_AsString( ConditionCode, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +function TConditionCode.Name : String; +begin + result := TConditionCode_Name[ Integer( ConditionCode ) ]; +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TFlowControl (Record) +{$IFDEF UNICODE} +class operator TFlowControl.Equal( const self, AFlowControl : TFlowControl ) : Boolean; +begin + Result := ( self.FlowControl = AFlowControl.FlowControl ); +end; + +class operator TFlowControl.Equal( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; +begin + Result := ( self.FlowControl = AFlowControl ); +end; + +class operator TFlowControl.NotEqual( const self, AFlowControl : TFlowControl ) : Boolean; +begin + Result := ( self.FlowControl <> AFlowControl.FlowControl ); +end; + +class operator TFlowControl.NotEqual( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; +begin + Result := ( self.FlowControl <> AFlowControl ); +end; + +class operator TFlowControl.In( const self : TFlowControl; const AFlowControl : array of TFlowControlType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AFlowControl ) to High( AFlowControl ) do + begin + if ( self.FlowControl = AFlowControl[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TFlowControl.GreaterThan( const self, AFlowControl : TFlowControl ) : Boolean; +begin + Result := ( self.FlowControl > AFlowControl.FlowControl ); +end; + +class operator TFlowControl.GreaterThan( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; +begin + Result := ( self.FlowControl > AFlowControl ); +end; + +class operator TFlowControl.GreaterThanOrEqual( const self, AFlowControl : TFlowControl ) : Boolean; +begin + Result := ( self.FlowControl >= AFlowControl.FlowControl ); +end; + +class operator TFlowControl.GreaterThanOrEqual( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; +begin + Result := ( self.FlowControl >= AFlowControl ); +end; + +class operator TFlowControl.LessThan( const self, AFlowControl : TFlowControl ) : Boolean; +begin + Result := ( self.FlowControl < AFlowControl.FlowControl ); +end; + +class operator TFlowControl.LessThan( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; +begin + Result := ( self.FlowControl < AFlowControl ); +end; + +class operator TFlowControl.LessThanOrEqual( const self, AFlowControl : TFlowControl ) : Boolean; +begin + Result := ( self.FlowControl <= AFlowControl.FlowControl ); +end; + +class operator TFlowControl.LessThanOrEqual( const self : TFlowControl; const AFlowControl : TFlowControlType ) : Boolean; +begin + Result := ( self.FlowControl <= AFlowControl ); +end; + +class operator TFlowControl.Implicit( const AFlowControl : TFlowControl ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + FlowControl_AsString( AFlowControl.FlowControl, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TFlowControl.Implicit( const AFlowControl : TFlowControl ) : Byte; +begin + result := Byte( AFlowControl.FlowControl ); +end; + +class operator TFlowControl.Implicit( const AFlowControl : Byte ) : TFlowControl; +begin + result.FlowControl := TFlowControl( AFlowControl ); +end; + +class operator TFlowControl.Implicit( const AFlowControl : TFlowControl ) : TFlowControlType; +begin + result := AFlowControl.FlowControl; +end; + +class operator TFlowControl.Implicit( const AFlowControl : TFlowControlType ) : TFlowControl; +begin + result.FlowControl := AFlowControl; +end; +{$ENDIF UNICODE} + +function TFlowControl.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + FlowControl_AsString( self.FlowControl, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TTupleType (Record) +{$IFDEF UNICODE} +class operator TTupleType.Equal( const self, ATupleType : TTupleType ) : Boolean; +begin + Result := ( self.TupleType = ATupleType.TupleType ); +end; + +class operator TTupleType.Equal( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; +begin + Result := ( self.TupleType = ATupleType ); +end; + +class operator TTupleType.NotEqual( const self, ATupleType : TTupleType ) : Boolean; +begin + Result := ( self.TupleType <> ATupleType.TupleType ); +end; + +class operator TTupleType.NotEqual( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; +begin + Result := ( self.TupleType <> ATupleType ); +end; + +class operator TTupleType.In( const self : TTupleType; const ATupleType : array of TTupleTypeType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( ATupleType ) to High( ATupleType ) do + begin + if ( self.TupleType = ATupleType[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TTupleType.GreaterThan( const self, ATupleType : TTupleType ) : Boolean; +begin + Result := ( self.TupleType > ATupleType.TupleType ); +end; + +class operator TTupleType.GreaterThan( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; +begin + Result := ( self.TupleType > ATupleType ); +end; + +class operator TTupleType.GreaterThanOrEqual( const self, ATupleType : TTupleType ) : Boolean; +begin + Result := ( self.TupleType >= ATupleType.TupleType ); +end; + +class operator TTupleType.GreaterThanOrEqual( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; +begin + Result := ( self.TupleType >= ATupleType ); +end; + +class operator TTupleType.LessThan( const self, ATupleType : TTupleType ) : Boolean; +begin + Result := ( self.TupleType < ATupleType.TupleType ); +end; + +class operator TTupleType.LessThan( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; +begin + Result := ( self.TupleType < ATupleType ); +end; + +class operator TTupleType.LessThanOrEqual( const self, ATupleType : TTupleType ) : Boolean; +begin + Result := ( self.TupleType <= ATupleType.TupleType ); +end; + +class operator TTupleType.LessThanOrEqual( const self : TTupleType; const ATupleType : TTupleTypeType ) : Boolean; +begin + Result := ( self.TupleType <= ATupleType ); +end; + +class operator TTupleType.Implicit( const ATupleType : TTupleType ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + TupleType_AsString( ATupleType.TupleType, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TTupleType.Implicit( const ATupleType : TTupleType ) : Byte; +begin + result := Byte( ATupleType.TupleType ); +end; + +class operator TTupleType.Implicit( const ATupleType : Byte ) : TTupleType; +begin + result.TupleType := TTupleType( ATupleType ); +end; + +class operator TTupleType.Implicit( const ATupleType : TTupleType ) : TTupleTypeType; +begin + result := ATupleType.TupleType; +end; + +class operator TTupleType.Implicit( const ATupleType : TTupleTypeType ) : TTupleType; +begin + result.TupleType := ATupleType; +end; +{$ENDIF UNICODE} + +function TTupleType.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + TupleType_AsString( self.TupleType, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TMvexEHBit (Record) +{$IFDEF UNICODE} +class operator TMvexEHBit.Equal( const self, AMvexEHBit : TMvexEHBit ) : Boolean; +begin + Result := ( self.MvexEHBit = AMvexEHBit.MvexEHBit ); +end; + +class operator TMvexEHBit.Equal( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; +begin + Result := ( self.MvexEHBit = AMvexEHBit ); +end; + +class operator TMvexEHBit.NotEqual( const self, AMvexEHBit : TMvexEHBit ) : Boolean; +begin + Result := ( self.MvexEHBit <> AMvexEHBit.MvexEHBit ); +end; + +class operator TMvexEHBit.NotEqual( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; +begin + Result := ( self.MvexEHBit <> AMvexEHBit ); +end; + +class operator TMvexEHBit.In( const self : TMvexEHBit; const AMvexEHBit : array of TMvexEHBitType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AMvexEHBit ) to High( AMvexEHBit ) do + begin + if ( self.MvexEHBit = AMvexEHBit[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TMvexEHBit.GreaterThan( const self, AMvexEHBit : TMvexEHBit ) : Boolean; +begin + Result := ( self.MvexEHBit > AMvexEHBit.MvexEHBit ); +end; + +class operator TMvexEHBit.GreaterThan( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; +begin + Result := ( self.MvexEHBit > AMvexEHBit ); +end; + +class operator TMvexEHBit.GreaterThanOrEqual( const self, AMvexEHBit : TMvexEHBit ) : Boolean; +begin + Result := ( self.MvexEHBit >= AMvexEHBit.MvexEHBit ); +end; + +class operator TMvexEHBit.GreaterThanOrEqual( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; +begin + Result := ( self.MvexEHBit >= AMvexEHBit ); +end; + +class operator TMvexEHBit.LessThan( const self, AMvexEHBit : TMvexEHBit ) : Boolean; +begin + Result := ( self.MvexEHBit < AMvexEHBit.MvexEHBit ); +end; + +class operator TMvexEHBit.LessThan( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; +begin + Result := ( self.MvexEHBit < AMvexEHBit ); +end; + +class operator TMvexEHBit.LessThanOrEqual( const self, AMvexEHBit : TMvexEHBit ) : Boolean; +begin + Result := ( self.MvexEHBit <= AMvexEHBit.MvexEHBit ); +end; + +class operator TMvexEHBit.LessThanOrEqual( const self : TMvexEHBit; const AMvexEHBit : TMvexEHBitType ) : Boolean; +begin + Result := ( self.MvexEHBit <= AMvexEHBit ); +end; + +class operator TMvexEHBit.Implicit( const AMvexEHBit : TMvexEHBit ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MvexEHBit_AsString( AMvexEHBit.MvexEHBit, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TMvexEHBit.Implicit( const AMvexEHBit : TMvexEHBit ) : Byte; +begin + result := Byte( AMvexEHBit.MvexEHBit ); +end; + +class operator TMvexEHBit.Implicit( const AMvexEHBit : Byte ) : TMvexEHBit; +begin + result.MvexEHBit := TMvexEHBit( AMvexEHBit ); +end; + +class operator TMvexEHBit.Implicit( const AMvexEHBit : TMvexEHBit ) : TMvexEHBitType; +begin + result := AMvexEHBit.MvexEHBit; +end; + +class operator TMvexEHBit.Implicit( const AMvexEHBit : TMvexEHBitType ) : TMvexEHBit; +begin + result.MvexEHBit := AMvexEHBit; +end; +{$ENDIF UNICODE} + +function TMvexEHBit.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MvexEHBit_AsString( self.MvexEHBit, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TMvexTupleTypeLutKind (Record) +{$IFDEF UNICODE} +class operator TMvexTupleTypeLutKind.Equal( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind = AMvexTupleTypeLutKind.MvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.Equal( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind = AMvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.NotEqual( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind <> AMvexTupleTypeLutKind.MvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.NotEqual( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind <> AMvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.In( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : array of TMvexTupleTypeLutKindType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AMvexTupleTypeLutKind ) to High( AMvexTupleTypeLutKind ) do + begin + if ( self.MvexTupleTypeLutKind = AMvexTupleTypeLutKind[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TMvexTupleTypeLutKind.GreaterThan( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind > AMvexTupleTypeLutKind.MvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.GreaterThan( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind > AMvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.GreaterThanOrEqual( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind >= AMvexTupleTypeLutKind.MvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.GreaterThanOrEqual( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind >= AMvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.LessThan( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind < AMvexTupleTypeLutKind.MvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.LessThan( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind < AMvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.LessThanOrEqual( const self, AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind <= AMvexTupleTypeLutKind.MvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.LessThanOrEqual( const self : TMvexTupleTypeLutKind; const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : Boolean; +begin + Result := ( self.MvexTupleTypeLutKind <= AMvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.Implicit( const AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MvexTupleTypeLutKind_AsString( AMvexTupleTypeLutKind.MvexTupleTypeLutKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TMvexTupleTypeLutKind.Implicit( const AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : Byte; +begin + result := Byte( AMvexTupleTypeLutKind.MvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.Implicit( const AMvexTupleTypeLutKind : Byte ) : TMvexTupleTypeLutKind; +begin + result.MvexTupleTypeLutKind := TMvexTupleTypeLutKind( AMvexTupleTypeLutKind ); +end; + +class operator TMvexTupleTypeLutKind.Implicit( const AMvexTupleTypeLutKind : TMvexTupleTypeLutKind ) : TMvexTupleTypeLutKindType; +begin + result := AMvexTupleTypeLutKind.MvexTupleTypeLutKind; +end; + +class operator TMvexTupleTypeLutKind.Implicit( const AMvexTupleTypeLutKind : TMvexTupleTypeLutKindType ) : TMvexTupleTypeLutKind; +begin + result.MvexTupleTypeLutKind := AMvexTupleTypeLutKind; +end; +{$ENDIF UNICODE} + +function TMvexTupleTypeLutKind.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MvexTupleTypeLutKind_AsString( self.MvexTupleTypeLutKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TMvexConvFn (Record) +{$IFDEF UNICODE} +class operator TMvexConvFn.Equal( const self, AMvexConvFn : TMvexConvFn ) : Boolean; +begin + Result := ( self.MvexConvFn = AMvexConvFn.MvexConvFn ); +end; + +class operator TMvexConvFn.Equal( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; +begin + Result := ( self.MvexConvFn = AMvexConvFn ); +end; + +class operator TMvexConvFn.NotEqual( const self, AMvexConvFn : TMvexConvFn ) : Boolean; +begin + Result := ( self.MvexConvFn <> AMvexConvFn.MvexConvFn ); +end; + +class operator TMvexConvFn.NotEqual( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; +begin + Result := ( self.MvexConvFn <> AMvexConvFn ); +end; + +class operator TMvexConvFn.In( const self : TMvexConvFn; const AMvexConvFn : array of TMvexConvFnType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AMvexConvFn ) to High( AMvexConvFn ) do + begin + if ( self.MvexConvFn = AMvexConvFn[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TMvexConvFn.GreaterThan( const self, AMvexConvFn : TMvexConvFn ) : Boolean; +begin + Result := ( self.MvexConvFn > AMvexConvFn.MvexConvFn ); +end; + +class operator TMvexConvFn.GreaterThan( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; +begin + Result := ( self.MvexConvFn > AMvexConvFn ); +end; + +class operator TMvexConvFn.GreaterThanOrEqual( const self, AMvexConvFn : TMvexConvFn ) : Boolean; +begin + Result := ( self.MvexConvFn >= AMvexConvFn.MvexConvFn ); +end; + +class operator TMvexConvFn.GreaterThanOrEqual( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; +begin + Result := ( self.MvexConvFn >= AMvexConvFn ); +end; + +class operator TMvexConvFn.LessThan( const self, AMvexConvFn : TMvexConvFn ) : Boolean; +begin + Result := ( self.MvexConvFn < AMvexConvFn.MvexConvFn ); +end; + +class operator TMvexConvFn.LessThan( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; +begin + Result := ( self.MvexConvFn < AMvexConvFn ); +end; + +class operator TMvexConvFn.LessThanOrEqual( const self, AMvexConvFn : TMvexConvFn ) : Boolean; +begin + Result := ( self.MvexConvFn <= AMvexConvFn.MvexConvFn ); +end; + +class operator TMvexConvFn.LessThanOrEqual( const self : TMvexConvFn; const AMvexConvFn : TMvexConvFnType ) : Boolean; +begin + Result := ( self.MvexConvFn <= AMvexConvFn ); +end; + +class operator TMvexConvFn.Implicit( const AMvexConvFn : TMvexConvFn ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MvexConvFn_AsString( AMvexConvFn.MvexConvFn, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TMvexConvFn.Implicit( const AMvexConvFn : TMvexConvFn ) : Byte; +begin + result := Byte( AMvexConvFn.MvexConvFn ); +end; + +class operator TMvexConvFn.Implicit( const AMvexConvFn : Byte ) : TMvexConvFn; +begin + result.MvexConvFn := TMvexConvFn( AMvexConvFn ); +end; + +class operator TMvexConvFn.Implicit( const AMvexConvFn : TMvexConvFn ) : TMvexConvFnType; +begin + result := AMvexConvFn.MvexConvFn; +end; + +class operator TMvexConvFn.Implicit( const AMvexConvFn : TMvexConvFnType ) : TMvexConvFn; +begin + result.MvexConvFn := AMvexConvFn; +end; +{$ENDIF UNICODE} + +function TMvexConvFn.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MvexConvFn_AsString( self.MvexConvFn, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TMemorySizeInfo (Record) +function TMemorySizeInfo.ElementCount : Word; +begin + if ( ElementSize = size ) then + result := 1 + else + result := size div ElementSize; +end; + +function TMemorySizeInfo.IsPacked : Boolean; +begin + result := ( ElementSize < Size ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TMemorySize (Record) +{$IFDEF UNICODE} +class operator TMemorySize.Equal( const self, AMemorySize : TMemorySize ) : Boolean; +begin + Result := ( self.MemorySize = AMemorySize.MemorySize ); +end; + +class operator TMemorySize.Equal( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; +begin + Result := ( self.MemorySize = AMemorySize ); +end; + +class operator TMemorySize.NotEqual( const self, AMemorySize : TMemorySize ) : Boolean; +begin + Result := ( self.MemorySize <> AMemorySize.MemorySize ); +end; + +class operator TMemorySize.NotEqual( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; +begin + Result := ( self.MemorySize <> AMemorySize ); +end; + +class operator TMemorySize.In( const self : TMemorySize; const AMemorySize : array of TMemorySizeType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AMemorySize ) to High( AMemorySize ) do + begin + if ( self.MemorySize = AMemorySize[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TMemorySize.GreaterThan( const self, AMemorySize : TMemorySize ) : Boolean; +begin + Result := ( self.MemorySize > AMemorySize.MemorySize ); +end; + +class operator TMemorySize.GreaterThan( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; +begin + Result := ( self.MemorySize > AMemorySize ); +end; + +class operator TMemorySize.GreaterThanOrEqual( const self, AMemorySize : TMemorySize ) : Boolean; +begin + Result := ( self.MemorySize >= AMemorySize.MemorySize ); +end; + +class operator TMemorySize.GreaterThanOrEqual( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; +begin + Result := ( self.MemorySize >= AMemorySize ); +end; + +class operator TMemorySize.LessThan( const self, AMemorySize : TMemorySize ) : Boolean; +begin + Result := ( self.MemorySize < AMemorySize.MemorySize ); +end; + +class operator TMemorySize.LessThan( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; +begin + Result := ( self.MemorySize < AMemorySize ); +end; + +class operator TMemorySize.LessThanOrEqual( const self, AMemorySize : TMemorySize ) : Boolean; +begin + Result := ( self.MemorySize <= AMemorySize.MemorySize ); +end; + +class operator TMemorySize.LessThanOrEqual( const self : TMemorySize; const AMemorySize : TMemorySizeType ) : Boolean; +begin + Result := ( self.MemorySize <= AMemorySize ); +end; + +class operator TMemorySize.Implicit( const AMemorySize : TMemorySize ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MemorySize_AsString( AMemorySize.MemorySize, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TMemorySize.Implicit( const AMemorySize : TMemorySize ) : Byte; +begin + result := Byte( AMemorySize.MemorySize ); +end; + +class operator TMemorySize.Implicit( const AMemorySize : Byte ) : TMemorySize; +begin + result.MemorySize := TMemorySize( AMemorySize ); +end; + +class operator TMemorySize.Implicit( const AMemorySize : TMemorySize ) : TMemorySizeType; +begin + result := AMemorySize.MemorySize; +end; + +class operator TMemorySize.Implicit( const AMemorySize : TMemorySizeType ) : TMemorySize; +begin + result.MemorySize := AMemorySize; +end; +{$ENDIF UNICODE} + +function TMemorySize.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MemorySize_AsString( self.MemorySize, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +function TMemorySize.Info : TMemorySizeInfo; +begin + MemorySize_Info( MemorySize, result ); +end; + +function TMemorySize.Size : Word; +begin + result := Info.size; +end; + +function TMemorySize.ElementSize : Word; +begin + result := Info.ElementSize; +end; + +function TMemorySize.ElementType : TMemorySize; +begin + result.MemorySize := Info.ElementType; +end; + +function TMemorySize.ElementTypeInfo : TMemorySizeInfo; +var + M : TMemorySize; +begin + M := TMemorySize( Info.ElementType ); + result := M.Info; +end; + +function TMemorySize.IsSigned : Boolean; +begin + result := Info.IsSigned; +end; + +function TMemorySize.IsPacked : Boolean; +begin + result := Info.IsPacked; +end; + +function TMemorySize.ElementCount : NativeUInt; +begin + result := Info.ElementCount; +end; + +function TMemorySize.IsBroadcast : Boolean; +begin + result := ( MemorySize >= msBroadcast32_Float16 ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TOpCodeTableKind (Record) +{$IFDEF UNICODE} +class operator TOpCodeTableKind.Equal( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; +begin + Result := ( self.OpCodeTableKind = AOpCodeTableKind.OpCodeTableKind ); +end; + +class operator TOpCodeTableKind.Equal( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; +begin + Result := ( self.OpCodeTableKind = AOpCodeTableKind ); +end; + +class operator TOpCodeTableKind.NotEqual( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; +begin + Result := ( self.OpCodeTableKind <> AOpCodeTableKind.OpCodeTableKind ); +end; + +class operator TOpCodeTableKind.NotEqual( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; +begin + Result := ( self.OpCodeTableKind <> AOpCodeTableKind ); +end; + +class operator TOpCodeTableKind.In( const self : TOpCodeTableKind; const AOpCodeTableKind : array of TOpCodeTableKindType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AOpCodeTableKind ) to High( AOpCodeTableKind ) do + begin + if ( self.OpCodeTableKind = AOpCodeTableKind[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TOpCodeTableKind.GreaterThan( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; +begin + Result := ( self.OpCodeTableKind > AOpCodeTableKind.OpCodeTableKind ); +end; + +class operator TOpCodeTableKind.GreaterThan( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; +begin + Result := ( self.OpCodeTableKind > AOpCodeTableKind ); +end; + +class operator TOpCodeTableKind.GreaterThanOrEqual( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; +begin + Result := ( self.OpCodeTableKind >= AOpCodeTableKind.OpCodeTableKind ); +end; + +class operator TOpCodeTableKind.GreaterThanOrEqual( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; +begin + Result := ( self.OpCodeTableKind >= AOpCodeTableKind ); +end; + +class operator TOpCodeTableKind.LessThan( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; +begin + Result := ( self.OpCodeTableKind < AOpCodeTableKind.OpCodeTableKind ); +end; + +class operator TOpCodeTableKind.LessThan( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; +begin + Result := ( self.OpCodeTableKind < AOpCodeTableKind ); +end; + +class operator TOpCodeTableKind.LessThanOrEqual( const self, AOpCodeTableKind : TOpCodeTableKind ) : Boolean; +begin + Result := ( self.OpCodeTableKind <= AOpCodeTableKind.OpCodeTableKind ); +end; + +class operator TOpCodeTableKind.LessThanOrEqual( const self : TOpCodeTableKind; const AOpCodeTableKind : TOpCodeTableKindType ) : Boolean; +begin + Result := ( self.OpCodeTableKind <= AOpCodeTableKind ); +end; + +class operator TOpCodeTableKind.Implicit( const AOpCodeTableKind : TOpCodeTableKind ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + OpCodeTableKind_AsString( AOpCodeTableKind.OpCodeTableKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TOpCodeTableKind.Implicit( const AOpCodeTableKind : TOpCodeTableKind ) : Byte; +begin + result := Byte( AOpCodeTableKind.OpCodeTableKind ); +end; + +class operator TOpCodeTableKind.Implicit( const AOpCodeTableKind : Byte ) : TOpCodeTableKind; +begin + result.OpCodeTableKind := TOpCodeTableKind( AOpCodeTableKind ); +end; + +class operator TOpCodeTableKind.Implicit( const AOpCodeTableKind : TOpCodeTableKind ) : TOpCodeTableKindType; +begin + result := AOpCodeTableKind.OpCodeTableKind; +end; + +class operator TOpCodeTableKind.Implicit( const AOpCodeTableKind : TOpCodeTableKindType ) : TOpCodeTableKind; +begin + result.OpCodeTableKind := AOpCodeTableKind; +end; +{$ENDIF UNICODE} + +function TOpCodeTableKind.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + OpCodeTableKind_AsString( self.OpCodeTableKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TMandatoryPrefix (Record) +{$IFDEF UNICODE} +class operator TMandatoryPrefix.Equal( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; +begin + Result := ( self.MandatoryPrefix = AMandatoryPrefix.MandatoryPrefix ); +end; + +class operator TMandatoryPrefix.Equal( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; +begin + Result := ( self.MandatoryPrefix = AMandatoryPrefix ); +end; + +class operator TMandatoryPrefix.NotEqual( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; +begin + Result := ( self.MandatoryPrefix <> AMandatoryPrefix.MandatoryPrefix ); +end; + +class operator TMandatoryPrefix.NotEqual( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; +begin + Result := ( self.MandatoryPrefix <> AMandatoryPrefix ); +end; + +class operator TMandatoryPrefix.In( const self : TMandatoryPrefix; const AMandatoryPrefix : array of TMandatoryPrefixType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AMandatoryPrefix ) to High( AMandatoryPrefix ) do + begin + if ( self.MandatoryPrefix = AMandatoryPrefix[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TMandatoryPrefix.GreaterThan( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; +begin + Result := ( self.MandatoryPrefix > AMandatoryPrefix.MandatoryPrefix ); +end; + +class operator TMandatoryPrefix.GreaterThan( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; +begin + Result := ( self.MandatoryPrefix > AMandatoryPrefix ); +end; + +class operator TMandatoryPrefix.GreaterThanOrEqual( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; +begin + Result := ( self.MandatoryPrefix >= AMandatoryPrefix.MandatoryPrefix ); +end; + +class operator TMandatoryPrefix.GreaterThanOrEqual( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; +begin + Result := ( self.MandatoryPrefix >= AMandatoryPrefix ); +end; + +class operator TMandatoryPrefix.LessThan( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; +begin + Result := ( self.MandatoryPrefix < AMandatoryPrefix.MandatoryPrefix ); +end; + +class operator TMandatoryPrefix.LessThan( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; +begin + Result := ( self.MandatoryPrefix < AMandatoryPrefix ); +end; + +class operator TMandatoryPrefix.LessThanOrEqual( const self, AMandatoryPrefix : TMandatoryPrefix ) : Boolean; +begin + Result := ( self.MandatoryPrefix <= AMandatoryPrefix.MandatoryPrefix ); +end; + +class operator TMandatoryPrefix.LessThanOrEqual( const self : TMandatoryPrefix; const AMandatoryPrefix : TMandatoryPrefixType ) : Boolean; +begin + Result := ( self.MandatoryPrefix <= AMandatoryPrefix ); +end; + +class operator TMandatoryPrefix.Implicit( const AMandatoryPrefix : TMandatoryPrefix ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MandatoryPrefix_AsString( AMandatoryPrefix.MandatoryPrefix, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TMandatoryPrefix.Implicit( const AMandatoryPrefix : TMandatoryPrefix ) : Byte; +begin + result := Byte( AMandatoryPrefix.MandatoryPrefix ); +end; + +class operator TMandatoryPrefix.Implicit( const AMandatoryPrefix : Byte ) : TMandatoryPrefix; +begin + result.MandatoryPrefix := TMandatoryPrefix( AMandatoryPrefix ); +end; + +class operator TMandatoryPrefix.Implicit( const AMandatoryPrefix : TMandatoryPrefix ) : TMandatoryPrefixType; +begin + result := AMandatoryPrefix.MandatoryPrefix; +end; + +class operator TMandatoryPrefix.Implicit( const AMandatoryPrefix : TMandatoryPrefixType ) : TMandatoryPrefix; +begin + result.MandatoryPrefix := AMandatoryPrefix; +end; +{$ENDIF UNICODE} + +function TMandatoryPrefix.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MandatoryPrefix_AsString( self.MandatoryPrefix, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TOpCodeOperandKind (Record) +{$IFDEF UNICODE} +class operator TOpCodeOperandKind.Equal( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; +begin + Result := ( self.OpCodeOperandKind = AOpCodeOperandKind.OpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.Equal( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; +begin + Result := ( self.OpCodeOperandKind = AOpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.NotEqual( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; +begin + Result := ( self.OpCodeOperandKind <> AOpCodeOperandKind.OpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.NotEqual( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; +begin + Result := ( self.OpCodeOperandKind <> AOpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.In( const self : TOpCodeOperandKind; const AOpCodeOperandKind : array of TOpCodeOperandKindType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AOpCodeOperandKind ) to High( AOpCodeOperandKind ) do + begin + if ( self.OpCodeOperandKind = AOpCodeOperandKind[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TOpCodeOperandKind.GreaterThan( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; +begin + Result := ( self.OpCodeOperandKind > AOpCodeOperandKind.OpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.GreaterThan( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; +begin + Result := ( self.OpCodeOperandKind > AOpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.GreaterThanOrEqual( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; +begin + Result := ( self.OpCodeOperandKind >= AOpCodeOperandKind.OpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.GreaterThanOrEqual( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; +begin + Result := ( self.OpCodeOperandKind >= AOpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.LessThan( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; +begin + Result := ( self.OpCodeOperandKind < AOpCodeOperandKind.OpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.LessThan( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; +begin + Result := ( self.OpCodeOperandKind < AOpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.LessThanOrEqual( const self, AOpCodeOperandKind : TOpCodeOperandKind ) : Boolean; +begin + Result := ( self.OpCodeOperandKind <= AOpCodeOperandKind.OpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.LessThanOrEqual( const self : TOpCodeOperandKind; const AOpCodeOperandKind : TOpCodeOperandKindType ) : Boolean; +begin + Result := ( self.OpCodeOperandKind <= AOpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.Implicit( const AOpCodeOperandKind : TOpCodeOperandKind ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + OpCodeOperandKind_AsString( AOpCodeOperandKind.OpCodeOperandKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TOpCodeOperandKind.Implicit( const AOpCodeOperandKind : TOpCodeOperandKind ) : Byte; +begin + result := Byte( AOpCodeOperandKind.OpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.Implicit( const AOpCodeOperandKind : Byte ) : TOpCodeOperandKind; +begin + result.OpCodeOperandKind := TOpCodeOperandKind( AOpCodeOperandKind ); +end; + +class operator TOpCodeOperandKind.Implicit( const AOpCodeOperandKind : TOpCodeOperandKind ) : TOpCodeOperandKindType; +begin + result := AOpCodeOperandKind.OpCodeOperandKind; +end; + +class operator TOpCodeOperandKind.Implicit( const AOpCodeOperandKind : TOpCodeOperandKindType ) : TOpCodeOperandKind; +begin + result.OpCodeOperandKind := AOpCodeOperandKind; +end; +{$ENDIF UNICODE} + +function TOpCodeOperandKind.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + OpCodeOperandKind_AsString( self.OpCodeOperandKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Instruction (Record) +{$IFDEF UNICODE} +class operator TInstruction.Equal( const self : TInstruction; const Instruction : TInstruction ) : Boolean; +begin + result := self.IsEqual( Instruction ); +end; + +class operator TInstruction.NotEqual( const self : TInstruction; const Instruction : TInstruction ) : Boolean; +begin + result := NOT self.IsEqual( Instruction ); +end; +{$ENDIF UNICODE} + +function TInstruction.GetRIP : UInt64; +begin + if ( next_rip < len ) then + begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Exit; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := next_rip-len; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetRIP( Value : UInt64 ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + next_rip := Value+len; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.GetIP16 : Word; +begin + if ( next_rip < len ) then + begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Exit; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := next_rip-len; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetIP16( Value : Word ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + next_rip := Value + len; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.GetIP32 : Cardinal; +begin + if ( next_rip < len ) then + begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Exit; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := next_rip-len; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetIP32( Value : Cardinal ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + next_rip := Value + len; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.GetNextIP16 : Word; +begin + if ( next_rip < len ) then + begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Exit; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := next_rip-len; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetNextIP16( Value : Word ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + next_rip := Value; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.GetNextIP32 : Cardinal; +begin + if ( next_rip < len ) then + begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Exit; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := next_rip-len; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetNextIP32( Value : Cardinal ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + next_rip := Value; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.GetCodeSize : TCodeSize; +begin + result.CodeSize := TCodeSizeType( ( flags1 SHR CODE_SIZE_SHIFT ) AND CODE_SIZE_MASK ); +end; + +procedure TInstruction.SetCodeSize( Value : TCodeSize ); +begin + flags1 := ( flags1 AND NOT ( CODE_SIZE_MASK SHL CODE_SIZE_SHIFT ) ) OR ( ( Cardinal( Value.CodeSize ) AND CODE_SIZE_MASK ) SHL CODE_SIZE_SHIFT ); +end; + +function TInstruction.IsValid : Boolean; +begin + result := NOT ( Code.Code in [ INVALID_CODE{, Int3} ] ) AND NOT ( ( Code.Code = Add_rm8_r8 ) AND ( Regs[ 1 ].Register = AL ) AND ( mem_base_reg.Register = RAX ) ); +end; + +function TInstruction.IsData : Boolean; +begin + result := ( Code.Code in [ INVALID_CODE{, Int3}, DeclareByte, DeclareWord, DeclareDWord, DeclareQword ] ) OR ( ( Code.Code = Add_rm8_r8 ) AND ( Regs[ 1 ].Register = AL ) AND ( mem_base_reg.Register = RAX ) ); +end; + +function TInstruction.IsProcedureStart : Boolean; +begin + result := ( Code.Code in [ Push_r16, Push_r32, Push_r64 ] ) AND ( Regs[ 0 ].Register in [ EBP, RBP ] ); +end; + +function TInstruction.IsJump : Boolean; +begin + result := ( Code.Code = Jmp_rel16 ) OR + ( Code.Code = Jmp_rel32_32 ) OR ( Code.Code = Jmp_rel32_64 ) OR + ( Code.Code = Jmp_ptr1616 ) OR ( Code.Code = Jmp_ptr1632 ) OR + ( Code.Code = Jmp_rel8_16 ) OR ( Code.Code = Jmp_rel8_32 ) OR ( Code.Code = Jmp_rel8_64 ) OR + ( Code.Code = Jmp_rm16 ) OR ( Code.Code = Jmp_rm32 ) OR ( Code.Code = Jmp_rm64 ) OR + ( Code.Code = Jmp_m1616 ) OR ( Code.Code = Jmp_m1632 ) OR ( Code.Code = Jmp_m1664 ) OR + + IsConditionalJump OR IsCall; +end; + +function TInstruction.IsRegJump : Boolean; +begin + result := IsJump AND ( ( op_kinds[ 0 ].OpKind = okRegister_ ) OR ( mem_displ = 0 ) ); +end; + +function TInstruction.IsConditionalJump : Boolean; +begin + result := ( Code.Code = Je_rel8_64 ) OR ( Code.Code = Jp_rel8_16 ) OR ( Code.Code = Jg_rel8_32 ) OR ( Code.Code = Jle_rel16 ) OR ( Code.Code = Jle_rel32_32 ) OR ( Code.Code = Jle_rel32_64 ) OR ( Code.Code = Jnp_rel16 ) OR + ( Code.Code = Jne_rel8_16 ) OR ( Code.Code = Jp_rel8_32 ) OR ( Code.Code = Jg_rel8_64 ) OR ( Code.Code = Jg_rel16 ) OR ( Code.Code = Jg_rel32_32 ) OR ( Code.Code = Jg_rel32_64 ) OR ( Code.Code = Jl_rel16 ) OR + ( Code.Code = Jne_rel8_32 ) OR ( Code.Code = Jp_rel8_64 ) OR ( Code.Code = Jo_rel16 ) OR ( Code.Code = Jo_rel32_32 ) OR ( Code.Code = Jo_rel32_64 ) OR ( Code.Code = Jo_rel8_16 ) OR ( Code.Code = Jge_rel16 ) OR + ( Code.Code = Jne_rel8_64 ) OR ( Code.Code = Jnp_rel8_16 ) OR ( Code.Code = Jno_rel16 ) OR ( Code.Code = Jno_rel32_32 ) OR ( Code.Code = Jno_rel32_64 ) OR ( Code.Code = Jo_rel8_32 ) OR + ( Code.Code = Jbe_rel8_16 ) OR ( Code.Code = Jnp_rel8_32 ) OR ( Code.Code = Jb_rel16 ) OR ( Code.Code = Jb_rel32_32 ) OR ( Code.Code = Jb_rel32_64 ) OR ( Code.Code = Jo_rel8_64 ) OR + ( Code.Code = Jbe_rel8_32 ) OR ( Code.Code = Jnp_rel8_64 ) OR ( Code.Code = Jae_rel16 ) OR ( Code.Code = Jae_rel32_32 ) OR ( Code.Code = Jae_rel32_64 ) OR ( Code.Code = Jno_rel8_16 ) OR + ( Code.Code = Jbe_rel8_64 ) OR ( Code.Code = Jl_rel8_16 ) OR ( Code.Code = Je_rel16 ) OR ( Code.Code = Je_rel32_32 ) OR ( Code.Code = Je_rel32_64 ) OR ( Code.Code = Jno_rel8_32 ) OR + ( Code.Code = Ja_rel8_16 ) OR ( Code.Code = Jl_rel8_32 ) OR ( Code.Code = Jne_rel16 ) OR ( Code.Code = Jne_rel32_32 ) OR ( Code.Code = Jne_rel32_64 ) OR ( Code.Code = Jno_rel8_64 ) OR + ( Code.Code = Ja_rel8_32 ) OR ( Code.Code = Jl_rel8_64 ) OR ( Code.Code = Jbe_rel16 ) OR ( Code.Code = Jbe_rel32_32 ) OR ( Code.Code = Jbe_rel32_64 ) OR ( Code.Code = Jb_rel8_16 ) OR + ( Code.Code = Ja_rel8_64 ) OR ( Code.Code = Jge_rel8_16 ) OR ( Code.Code = Ja_rel16 ) OR ( Code.Code = Ja_rel32_32 ) OR ( Code.Code = Ja_rel32_64 ) OR ( Code.Code = Jb_rel8_32 ) OR + ( Code.Code = Js_rel8_16 ) OR ( Code.Code = Jge_rel8_32 ) OR ( Code.Code = Js_rel16 ) OR ( Code.Code = Js_rel32_32 ) OR ( Code.Code = Js_rel32_64 ) OR ( Code.Code = Jb_rel8_64 ) OR + ( Code.Code = Js_rel8_32 ) OR ( Code.Code = Jge_rel8_64 ) OR ( Code.Code = Jns_rel16 ) OR ( Code.Code = Jns_rel32_32 ) OR ( Code.Code = Jns_rel32_64 ) OR ( Code.Code = Jae_rel8_16 ) OR + ( Code.Code = Js_rel8_64 ) OR ( Code.Code = Jle_rel8_16 ) OR ( Code.Code = Jp_rel16 ) OR ( Code.Code = Jp_rel32_32 ) OR ( Code.Code = Jp_rel32_64 ) OR ( Code.Code = Jae_rel8_32 ) OR + ( Code.Code = Jns_rel8_16 ) OR ( Code.Code = Jle_rel8_32 ) OR ( Code.Code = Jnp_rel16 ) OR ( Code.Code = Jnp_rel32_32 ) OR ( Code.Code = Jnp_rel32_64 ) OR ( Code.Code = Jae_rel8_64 ) OR + ( Code.Code = Jns_rel8_32 ) OR ( Code.Code = Jle_rel8_64 ) OR ( Code.Code = Jl_rel16 ) OR ( Code.Code = Jl_rel32_32 ) OR ( Code.Code = Jl_rel32_64 ) OR ( Code.Code = Je_rel8_16 ) OR + ( Code.Code = Jns_rel8_64 ) OR ( Code.Code = Jg_rel8_16 ) OR ( Code.Code = Jge_rel16 ) OR ( Code.Code = Jge_rel32_32 ) OR ( Code.Code = Jge_rel32_64 ) OR ( Code.Code = Je_rel8_32 ); +end; + +function TInstruction.IsCall : Boolean; +begin + result := ( Code.Code = Call_ptr1616 ) OR ( Code.Code = Call_ptr1632 ) OR ( Code.Code = Call_rel16 ) OR + ( Code.Code = Call_rel32_32 ) OR ( Code.Code = Call_rel32_64 ) OR + ( Code.Code = Call_rm16 ) OR ( Code.Code = Call_rm32 ) OR ( Code.Code = Call_rm64 ) OR + ( Code.Code = Call_m1616 ) OR ( Code.Code = Call_m1632 ) OR ( Code.Code = Call_m1664 ); +end; + +function TInstruction.IsRet : Boolean; +begin + result := ( Code.Code = Retnw_imm16 ) OR ( Code.Code = Retnd_imm16 ) OR ( Code.Code = Retnq_imm16 ) OR + ( Code.Code = Retnw ) OR ( Code.Code = Retnd ) OR ( Code.Code = Retnq ); +end; + +function TInstruction.IsEqual( const Instruction : TInstruction; IgnoreRIP : Boolean = True ) : Boolean; +begin + result := ( IgnoreRIP OR ( NOT IgnoreRIP AND ( next_rip = Instruction.next_rip ) ) ) AND + ( mem_displ = Instruction.mem_displ ) AND + ( flags1 = Instruction.flags1 ) AND + ( immediate = Instruction.immediate ) AND +// ( Code.Code = Instruction.Code.Code ) AND + + ( ( ( Code.Code = Instruction.Code.Code ) AND + ( mem_base_reg.Register = Instruction.mem_base_reg.Register ) ) OR + + // Keystone compensation (mov rax, [] to movabs rax, []) + // mov [ ], rax + ( ( Regs[ 1 ].Register = RAX ) AND + ( ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_rm64_r64 ) AND ( Instruction.Code.Code = Mov_moffs64_RAX ) ) OR + ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_moffs64_RAX ) AND ( Instruction.Code.Code = Mov_rm64_r64 ) ) ) ) OR + + ( ( Regs[ 1 ].Register = EAX ) AND + ( ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_rm32_r32 ) AND ( Instruction.Code.Code = Mov_moffs32_EAX ) ) OR + ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_moffs32_EAX ) AND ( Instruction.Code.Code = Mov_rm32_r32 ) ) ) ) OR + + ( ( Regs[ 1 ].Register = AX ) AND + ( ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_rm16_r16 ) AND ( Instruction.Code.Code = Mov_moffs16_AX ) ) OR + ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_moffs16_AX ) AND ( Instruction.Code.Code = Mov_rm16_r16 ) ) ) ) OR + + ( ( Regs[ 1 ].Register = AL ) AND + ( ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_rm8_r8 ) AND ( Instruction.Code.Code = Mov_moffs8_AL ) ) OR + ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_moffs8_AL ) AND ( Instruction.Code.Code = Mov_rm8_r8 ) ) ) ) OR + + // mov rax, [ ] + ( ( Regs[ 0 ].Register = RAX ) AND + ( ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_r64_rm64 ) AND ( Instruction.Code.Code = Mov_RAX_moffs64 ) ) OR + ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_RAX_moffs64 ) AND ( Instruction.Code.Code = Mov_r64_rm64 ) ) ) ) OR + + ( ( Regs[ 0 ].Register = EAX ) AND + ( ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_r32_rm32 ) AND ( Instruction.Code.Code = Mov_EAX_moffs32 ) ) OR + ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_EAX_moffs32 ) AND ( Instruction.Code.Code = Mov_r32_rm32 ) ) ) ) OR + + ( ( Regs[ 0 ].Register = AX ) AND + ( ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_r16_rm16 ) AND ( Instruction.Code.Code = Mov_AX_moffs16 ) ) OR + ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_AX_moffs16 ) AND ( Instruction.Code.Code = Mov_r16_rm16 ) ) ) ) OR + + ( ( Regs[ 0 ].Register = AL ) AND + ( ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_r8_rm8 ) AND ( Instruction.Code.Code = Mov_AL_moffs8 ) ) OR + ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_AL_moffs8 ) AND ( Instruction.Code.Code = Mov_r8_rm8 ) ) ) ) + ) AND + +// ( mem_base_reg.Register = Instruction.mem_base_reg.Register ) AND + ( mem_index_reg.Register = Instruction.mem_index_reg.Register ) AND + + ( regs[ 0 ].Register = Instruction.regs[ 0 ].Register ) AND + ( regs[ 1 ].Register = Instruction.regs[ 1 ].Register ) AND + ( regs[ 2 ].Register = Instruction.regs[ 2 ].Register ) AND + ( regs[ 3 ].Register = Instruction.regs[ 3 ].Register ) AND + + ( op_kinds[ 0 ].OpKind = Instruction.op_kinds[ 0 ].OpKind ) AND + ( op_kinds[ 1 ].OpKind = Instruction.op_kinds[ 1 ].OpKind ) AND + ( op_kinds[ 2 ].OpKind = Instruction.op_kinds[ 2 ].OpKind ) AND + ( op_kinds[ 3 ].OpKind = Instruction.op_kinds[ 3 ].OpKind ) AND + + ( scale = Instruction.scale ) AND + ( displ_size = Instruction.displ_size ) AND + ( len = Instruction.len ) AND + ( pad = Instruction.pad ); +end; + +function TInstruction.IsPartialEqual( const Instruction : TInstruction ) : Boolean; +begin + result := ( mem_displ = Instruction.mem_displ ) AND + ( ( ( flags1 XOR Instruction.flags1 ) AND NOT EQUALS_IGNORE_MASK ) = 0 ) AND + + ( immediate = Instruction.immediate ) AND +// ( Code.Code = Instruction.Code.Code ) AND + + ( ( ( Code.Code = Instruction.Code.Code ) AND + ( mem_base_reg.Register = Instruction.mem_base_reg.Register ) ) OR + + // Keystone compensation (mov rax, [] to movabs rax, []) + // mov [ ], rax + ( ( Regs[ 1 ].Register = RAX ) AND + ( ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_rm64_r64 ) AND ( Instruction.Code.Code = Mov_moffs64_RAX ) ) OR + ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_moffs64_RAX ) AND ( Instruction.Code.Code = Mov_rm64_r64 ) ) ) ) OR + + ( ( Regs[ 1 ].Register = EAX ) AND + ( ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_rm32_r32 ) AND ( Instruction.Code.Code = Mov_moffs32_EAX ) ) OR + ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_moffs32_EAX ) AND ( Instruction.Code.Code = Mov_rm32_r32 ) ) ) ) OR + + ( ( Regs[ 1 ].Register = AX ) AND + ( ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_rm16_r16 ) AND ( Instruction.Code.Code = Mov_moffs16_AX ) ) OR + ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_moffs16_AX ) AND ( Instruction.Code.Code = Mov_rm16_r16 ) ) ) ) OR + + ( ( Regs[ 1 ].Register = AL ) AND + ( ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_rm8_r8 ) AND ( Instruction.Code.Code = Mov_moffs8_AL ) ) OR + ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_moffs8_AL ) AND ( Instruction.Code.Code = Mov_rm8_r8 ) ) ) ) OR + + // mov rax, [ ] + ( ( Regs[ 0 ].Register = RAX ) AND + ( ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_r64_rm64 ) AND ( Instruction.Code.Code = Mov_RAX_moffs64 ) ) OR + ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_RAX_moffs64 ) AND ( Instruction.Code.Code = Mov_r64_rm64 ) ) ) ) OR + + ( ( Regs[ 0 ].Register = EAX ) AND + ( ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_r32_rm32 ) AND ( Instruction.Code.Code = Mov_EAX_moffs32 ) ) OR + ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_EAX_moffs32 ) AND ( Instruction.Code.Code = Mov_r32_rm32 ) ) ) ) OR + + ( ( Regs[ 0 ].Register = AX ) AND + ( ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_r16_rm16 ) AND ( Instruction.Code.Code = Mov_AX_moffs16 ) ) OR + ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_AX_moffs16 ) AND ( Instruction.Code.Code = Mov_r16_rm16 ) ) ) ) OR + + ( ( Regs[ 0 ].Register = AL ) AND + ( ( ( mem_base_reg.Register = None ) AND ( Instruction.mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Code.Code = Mov_r8_rm8 ) AND ( Instruction.Code.Code = Mov_AL_moffs8 ) ) OR + ( ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) AND ( Instruction.mem_base_reg.Register = None ) AND ( Code.Code = Mov_AL_moffs8 ) AND ( Instruction.Code.Code = Mov_r8_rm8 ) ) ) ) + ) AND + +// ( mem_base_reg.Register = Instruction.mem_base_reg.Register ) AND + ( mem_index_reg.Register = Instruction.mem_index_reg.Register ) AND + + ( regs[ 0 ].Register = Instruction.regs[ 0 ].Register ) AND + ( regs[ 1 ].Register = Instruction.regs[ 1 ].Register ) AND + ( regs[ 2 ].Register = Instruction.regs[ 2 ].Register ) AND + ( regs[ 3 ].Register = Instruction.regs[ 3 ].Register ) AND + + ( op_kinds[ 0 ].OpKind = Instruction.op_kinds[ 0 ].OpKind ) AND + ( op_kinds[ 1 ].OpKind = Instruction.op_kinds[ 1 ].OpKind ) AND + ( op_kinds[ 2 ].OpKind = Instruction.op_kinds[ 2 ].OpKind ) AND + ( op_kinds[ 3 ].OpKind = Instruction.op_kinds[ 3 ].OpKind ) AND + + ( scale = Instruction.scale ) AND + ( displ_size = Instruction.displ_size ) AND + ( pad = Instruction.pad ); +end; + +function TInstruction.IsSimiliar( const Instruction : TInstruction; MaxDisplacement : Cardinal = 0 ) : Boolean; +const + MAX_DISPLACEMENT = $1000; +var + Cnt1, + Cnt2 : Byte; + i : Integer; + Dev : UInt64; +begin + Cnt1 := 0; + Cnt2 := 0; + for i := Low( regs ) to High( regs ) do + begin + if ( Regs[ i ].Register = None ) then + Inc( Cnt1 ); + if ( Instruction.Regs[ i ].Register = None ) then + Inc( Cnt2 ); + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( MaxDisplacement > 0 ) then + begin + if ( mem_displ > Instruction.mem_displ ) then + Dev := mem_displ - Instruction.mem_displ + else if ( mem_displ < Instruction.mem_displ ) then + Dev := Instruction.mem_displ - mem_displ + else //if ( mem_displ = Instruction.mem_displ ) then + Dev := 0; + end + else + Dev := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + result := //( next_rip = Instruction.next_rip ) AND +// ( mem_displ = Instruction.mem_displ ) AND + ( Dev <= MaxDisplacement ) AND + ( flags1 = Instruction.flags1 ) AND + ( immediate = Instruction.immediate ) AND +// ( Code.Code = Instruction.Code.Code ) AND + ( ( Code.Code = Instruction.Code.Code ) OR + // Keystone compensation (mov rax, [] to movabs rax, []) + // mov [ ], rax + ( ( Regs[ 1 ].Register = RAX ) AND + ( ( ( Code.Code = Mov_rm64_r64 ) AND ( Instruction.Code.Code = Mov_moffs64_RAX ) ) OR + ( ( Code.Code = Mov_moffs64_RAX ) AND ( Instruction.Code.Code = Mov_rm64_r64 ) ) ) ) OR + + ( ( Regs[ 1 ].Register = EAX ) AND + ( ( ( Code.Code = Mov_rm32_r32 ) AND ( Instruction.Code.Code = Mov_moffs32_EAX ) ) OR + ( ( Code.Code = Mov_moffs32_EAX ) AND ( Instruction.Code.Code = Mov_rm32_r32 ) ) ) ) OR + + ( ( Regs[ 1 ].Register = AX ) AND + ( ( ( Code.Code = Mov_rm16_r16 ) AND ( Instruction.Code.Code = Mov_moffs16_AX ) ) OR + ( ( Code.Code = Mov_moffs16_AX ) AND ( Instruction.Code.Code = Mov_rm16_r16 ) ) ) ) OR + + ( ( Regs[ 1 ].Register = AL ) AND + ( ( ( Code.Code = Mov_rm8_r8 ) AND ( Instruction.Code.Code = Mov_moffs8_AL ) ) OR + ( ( Code.Code = Mov_moffs8_AL ) AND ( Instruction.Code.Code = Mov_rm8_r8 ) ) ) ) OR + + // mov rax, [ ] + ( ( Regs[ 0 ].Register = RAX ) AND + ( ( ( Code.Code = Mov_r64_rm64 ) AND ( Instruction.Code.Code = Mov_RAX_moffs64 ) ) OR + ( ( Code.Code = Mov_RAX_moffs64 ) AND ( Instruction.Code.Code = Mov_r64_rm64 ) ) ) ) OR + + ( ( Regs[ 0 ].Register = EAX ) AND + ( ( ( Code.Code = Mov_r32_rm32 ) AND ( Instruction.Code.Code = Mov_EAX_moffs32 ) ) OR + ( ( Code.Code = Mov_EAX_moffs32 ) AND ( Instruction.Code.Code = Mov_r32_rm32 ) ) ) ) OR + + ( ( Regs[ 0 ].Register = AX ) AND + ( ( ( Code.Code = Mov_r16_rm16 ) AND ( Instruction.Code.Code = Mov_AX_moffs16 ) ) OR + ( ( Code.Code = Mov_AX_moffs16 ) AND ( Instruction.Code.Code = Mov_r16_rm16 ) ) ) ) OR + + ( ( Regs[ 0 ].Register = AL ) AND + ( ( ( Code.Code = Mov_r8_rm8 ) AND ( Instruction.Code.Code = Mov_AL_moffs8 ) ) OR + ( ( Code.Code = Mov_AL_moffs8 ) AND ( Instruction.Code.Code = Mov_r8_rm8 ) ) ) ) + ) AND + +// ( mem_base_reg.Register = Instruction.mem_base_reg ) AND +// ( mem_index_reg.Register = Instruction.mem_index_reg ) AND + +// ( regs[ 0 ].Register = Instruction.regs[ 0 ].Register ) AND +// ( regs[ 1 ].Register = Instruction.regs[ 1 ].Register ) AND +// ( regs[ 2 ].Register = Instruction.regs[ 2 ].Register ) AND +// ( regs[ 3 ].Register = Instruction.regs[ 3 ].Register ) AND + ( Cnt1 = Cnt2 ) AND + + ( op_kinds[ 0 ].OpKind = Instruction.op_kinds[ 0 ].OpKind ) AND + ( op_kinds[ 1 ].OpKind = Instruction.op_kinds[ 1 ].OpKind ) AND + ( op_kinds[ 2 ].OpKind = Instruction.op_kinds[ 2 ].OpKind ) AND + ( op_kinds[ 3 ].OpKind = Instruction.op_kinds[ 3 ].OpKind ) AND + + ( scale = Instruction.scale ) AND + ( displ_size = Instruction.displ_size ) AND +// ( len = Instruction.len ) AND + ( pad = Instruction.pad ); +end; + +function TInstruction.IsFloat : Boolean; +begin + if( Code.Code = Movups_xmm_xmmm128 ) OR ( Code.Code = VEX_Vmovups_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmovups_xmm_k1z_xmmm128 ) OR + ( Code.Code = Movupd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vmovupd_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmovupd_xmm_k1z_xmmm128 ) OR + ( Code.Code = Movss_xmm_xmmm32 ) OR ( Code.Code = VEX_Vmovss_xmm_xmm_xmm ) OR ( Code.Code = VEX_Vmovss_xmm_m32 ) OR + ( Code.Code = EVEX_Vmovss_xmm_k1z_xmm_xmm ) OR ( Code.Code = EVEX_Vmovss_xmm_k1z_m32 ) OR ( Code.Code = Movsd_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vmovsd_xmm_xmm_xmm ) OR ( Code.Code = VEX_Vmovsd_xmm_m64 ) OR ( Code.Code = EVEX_Vmovsd_xmm_k1z_xmm_xmm ) OR + ( Code.Code = EVEX_Vmovsd_xmm_k1z_m64 ) OR ( Code.Code = Movups_xmmm128_xmm ) OR ( Code.Code = VEX_Vmovups_xmmm128_xmm ) OR + ( Code.Code = EVEX_Vmovups_xmmm128_k1z_xmm ) OR ( Code.Code = Movupd_xmmm128_xmm ) OR ( Code.Code = VEX_Vmovupd_xmmm128_xmm ) OR + ( Code.Code = EVEX_Vmovupd_xmmm128_k1z_xmm ) OR ( Code.Code = Movss_xmmm32_xmm ) OR ( Code.Code = VEX_Vmovss_xmm_xmm_xmm_0F11 ) OR + ( Code.Code = VEX_Vmovss_m32_xmm ) OR ( Code.Code = EVEX_Vmovss_xmm_k1z_xmm_xmm_0F11 ) OR ( Code.Code = EVEX_Vmovss_m32_k1_xmm ) OR + ( Code.Code = Movsd_xmmm64_xmm ) OR ( Code.Code = VEX_Vmovsd_xmm_xmm_xmm_0F11 ) OR ( Code.Code = VEX_Vmovsd_m64_xmm ) OR + ( Code.Code = EVEX_Vmovsd_xmm_k1z_xmm_xmm_0F11 ) OR ( Code.Code = EVEX_Vmovsd_m64_k1_xmm ) OR ( Code.Code = Movhlps_xmm_xmm ) OR + ( Code.Code = Movlps_xmm_m64 ) OR ( Code.Code = VEX_Vmovhlps_xmm_xmm_xmm ) OR ( Code.Code = VEX_Vmovlps_xmm_xmm_m64 ) OR + ( Code.Code = EVEX_Vmovhlps_xmm_xmm_xmm ) OR ( Code.Code = EVEX_Vmovlps_xmm_xmm_m64 ) OR ( Code.Code = Movlpd_xmm_m64 ) OR + ( Code.Code = VEX_Vmovlpd_xmm_xmm_m64 ) OR ( Code.Code = EVEX_Vmovlpd_xmm_xmm_m64 ) OR ( Code.Code = Movsldup_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vmovsldup_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmovsldup_xmm_k1z_xmmm128 ) OR ( Code.Code = Movddup_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vmovddup_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vmovddup_xmm_k1z_xmmm64 ) OR ( Code.Code = Movlps_m64_xmm ) OR + ( Code.Code = VEX_Vmovlps_m64_xmm ) OR ( Code.Code = EVEX_Vmovlps_m64_xmm ) OR ( Code.Code = Movlpd_m64_xmm ) OR + ( Code.Code = VEX_Vmovlpd_m64_xmm ) OR ( Code.Code = EVEX_Vmovlpd_m64_xmm ) OR ( Code.Code = Unpcklps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vunpcklps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vunpcklps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Unpcklpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vunpcklpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vunpcklpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Unpckhps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vunpckhps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vunpckhps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Unpckhpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vunpckhpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vunpckhpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Movlhps_xmm_xmm ) OR + ( Code.Code = VEX_Vmovlhps_xmm_xmm_xmm ) OR ( Code.Code = EVEX_Vmovlhps_xmm_xmm_xmm ) OR ( Code.Code = Movhps_xmm_m64 ) OR + ( Code.Code = VEX_Vmovhps_xmm_xmm_m64 ) OR ( Code.Code = EVEX_Vmovhps_xmm_xmm_m64 ) OR ( Code.Code = Movhpd_xmm_m64 ) OR + ( Code.Code = VEX_Vmovhpd_xmm_xmm_m64 ) OR ( Code.Code = EVEX_Vmovhpd_xmm_xmm_m64 ) OR ( Code.Code = Movshdup_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vmovshdup_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmovshdup_xmm_k1z_xmmm128 ) OR ( Code.Code = Movhps_m64_xmm ) OR + ( Code.Code = VEX_Vmovhps_m64_xmm ) OR ( Code.Code = EVEX_Vmovhps_m64_xmm ) OR ( Code.Code = Movhpd_m64_xmm ) OR + ( Code.Code = VEX_Vmovhpd_m64_xmm ) OR ( Code.Code = EVEX_Vmovhpd_m64_xmm ) OR ( Code.Code = Movaps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vmovaps_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmovaps_xmm_k1z_xmmm128 ) OR ( Code.Code = Movapd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vmovapd_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmovapd_xmm_k1z_xmmm128 ) OR ( Code.Code = Movaps_xmmm128_xmm ) OR + ( Code.Code = VEX_Vmovaps_xmmm128_xmm ) OR ( Code.Code = EVEX_Vmovaps_xmmm128_k1z_xmm ) OR ( Code.Code = Movapd_xmmm128_xmm ) OR + ( Code.Code = VEX_Vmovapd_xmmm128_xmm ) OR ( Code.Code = EVEX_Vmovapd_xmmm128_k1z_xmm ) OR ( Code.Code = Cvtpi2ps_xmm_mmm64 ) OR + ( Code.Code = Cvtpi2pd_xmm_mmm64 ) OR ( Code.Code = Cvtsi2ss_xmm_rm32 ) OR ( Code.Code = Cvtsi2ss_xmm_rm64 ) OR + ( Code.Code = VEX_Vcvtsi2ss_xmm_xmm_rm32 ) OR ( Code.Code = VEX_Vcvtsi2ss_xmm_xmm_rm64 ) OR ( Code.Code = EVEX_Vcvtsi2ss_xmm_xmm_rm32_er ) OR + ( Code.Code = EVEX_Vcvtsi2ss_xmm_xmm_rm64_er ) OR ( Code.Code = Cvtsi2sd_xmm_rm32 ) OR ( Code.Code = Cvtsi2sd_xmm_rm64 ) OR + ( Code.Code = VEX_Vcvtsi2sd_xmm_xmm_rm32 ) OR ( Code.Code = VEX_Vcvtsi2sd_xmm_xmm_rm64 ) OR ( Code.Code = EVEX_Vcvtsi2sd_xmm_xmm_rm32_er ) OR + ( Code.Code = EVEX_Vcvtsi2sd_xmm_xmm_rm64_er ) OR ( Code.Code = Movntps_m128_xmm ) OR ( Code.Code = VEX_Vmovntps_m128_xmm ) OR + ( Code.Code = EVEX_Vmovntps_m128_xmm ) OR ( Code.Code = Movntpd_m128_xmm ) OR ( Code.Code = VEX_Vmovntpd_m128_xmm ) OR + ( Code.Code = EVEX_Vmovntpd_m128_xmm ) OR ( Code.Code = Movntss_m32_xmm ) OR ( Code.Code = Movntsd_m64_xmm ) OR + ( Code.Code = Cvttps2pi_mm_xmmm64 ) OR ( Code.Code = Cvttpd2pi_mm_xmmm128 ) OR ( Code.Code = Cvttss2si_r32_xmmm32 ) OR + ( Code.Code = Cvttss2si_r64_xmmm32 ) OR ( Code.Code = VEX_Vcvttss2si_r32_xmmm32 ) OR ( Code.Code = VEX_Vcvttss2si_r64_xmmm32 ) OR + ( Code.Code = EVEX_Vcvttss2si_r32_xmmm32_sae ) OR ( Code.Code = EVEX_Vcvttss2si_r64_xmmm32_sae ) OR ( Code.Code = Cvttsd2si_r32_xmmm64 ) OR + ( Code.Code = Cvttsd2si_r64_xmmm64 ) OR ( Code.Code = VEX_Vcvttsd2si_r32_xmmm64 ) OR ( Code.Code = VEX_Vcvttsd2si_r64_xmmm64 ) OR + ( Code.Code = EVEX_Vcvttsd2si_r32_xmmm64_sae ) OR ( Code.Code = EVEX_Vcvttsd2si_r64_xmmm64_sae ) OR ( Code.Code = Cvtps2pi_mm_xmmm64 ) OR + ( Code.Code = Cvtpd2pi_mm_xmmm128 ) OR ( Code.Code = Cvtss2si_r32_xmmm32 ) OR ( Code.Code = Cvtss2si_r64_xmmm32 ) OR + ( Code.Code = VEX_Vcvtss2si_r32_xmmm32 ) OR ( Code.Code = VEX_Vcvtss2si_r64_xmmm32 ) OR ( Code.Code = EVEX_Vcvtss2si_r32_xmmm32_er ) OR + ( Code.Code = EVEX_Vcvtss2si_r64_xmmm32_er ) OR ( Code.Code = Cvtsd2si_r32_xmmm64 ) OR ( Code.Code = Cvtsd2si_r64_xmmm64 ) OR + ( Code.Code = VEX_Vcvtsd2si_r32_xmmm64 ) OR ( Code.Code = VEX_Vcvtsd2si_r64_xmmm64 ) OR ( Code.Code = EVEX_Vcvtsd2si_r32_xmmm64_er ) OR + ( Code.Code = EVEX_Vcvtsd2si_r64_xmmm64_er ) OR ( Code.Code = Ucomiss_xmm_xmmm32 ) OR ( Code.Code = VEX_Vucomiss_xmm_xmmm32 ) OR + ( Code.Code = EVEX_Vucomiss_xmm_xmmm32_sae ) OR ( Code.Code = Ucomisd_xmm_xmmm64 ) OR ( Code.Code = VEX_Vucomisd_xmm_xmmm64 ) OR + ( Code.Code = EVEX_Vucomisd_xmm_xmmm64_sae ) OR ( Code.Code = Comiss_xmm_xmmm32 ) OR ( Code.Code = Comisd_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vcomiss_xmm_xmmm32 ) OR ( Code.Code = VEX_Vcomisd_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vcomiss_xmm_xmmm32_sae ) OR + ( Code.Code = EVEX_Vcomisd_xmm_xmmm64_sae ) OR ( Code.Code = Movmskps_r32_xmm ) OR ( Code.Code = Movmskps_r64_xmm ) OR + ( Code.Code = VEX_Vmovmskps_r32_xmm ) OR ( Code.Code = VEX_Vmovmskps_r64_xmm ) OR ( Code.Code = Movmskpd_r32_xmm ) OR + ( Code.Code = Movmskpd_r64_xmm ) OR ( Code.Code = VEX_Vmovmskpd_r32_xmm ) OR ( Code.Code = VEX_Vmovmskpd_r64_xmm ) OR + ( Code.Code = Sqrtps_xmm_xmmm128 ) OR ( Code.Code = VEX_Vsqrtps_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vsqrtps_xmm_k1z_xmmm128b32 ) OR + ( Code.Code = Sqrtpd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vsqrtpd_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vsqrtpd_xmm_k1z_xmmm128b64 ) OR + ( Code.Code = Sqrtss_xmm_xmmm32 ) OR ( Code.Code = VEX_Vsqrtss_xmm_xmm_xmmm32 ) OR ( Code.Code = EVEX_Vsqrtss_xmm_k1z_xmm_xmmm32_er ) OR + ( Code.Code = Sqrtsd_xmm_xmmm64 ) OR ( Code.Code = VEX_Vsqrtsd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vsqrtsd_xmm_k1z_xmm_xmmm64_er ) OR + ( Code.Code = Rsqrtps_xmm_xmmm128 ) OR ( Code.Code = VEX_Vrsqrtps_xmm_xmmm128 ) OR ( Code.Code = Rsqrtss_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vrsqrtss_xmm_xmm_xmmm32 ) OR ( Code.Code = Rcpps_xmm_xmmm128 ) OR ( Code.Code = VEX_Vrcpps_xmm_xmmm128 ) OR + ( Code.Code = Rcpss_xmm_xmmm32 ) OR ( Code.Code = VEX_Vrcpss_xmm_xmm_xmmm32 ) OR ( Code.Code = Andps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vandps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vandps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Andpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vandpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vandpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Andnps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vandnps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vandnps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Andnpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vandnpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vandnpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Orps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vorps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vorps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Orpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vorpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vorpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Xorps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vxorps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vxorps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Xorpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vxorpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vxorpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Addps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vaddps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vaddps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Addpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vaddpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vaddpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Addss_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vaddss_xmm_xmm_xmmm32 ) OR ( Code.Code = EVEX_Vaddss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = Addsd_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vaddsd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vaddsd_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = Mulps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vmulps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmulps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Mulpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vmulpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmulpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Mulss_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vmulss_xmm_xmm_xmmm32 ) OR ( Code.Code = EVEX_Vmulss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = Mulsd_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vmulsd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vmulsd_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = Cvtps2pd_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vcvtps2pd_xmm_xmmm64 ) OR ( Code.Code = VEX_Vcvtps2pd_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vcvtps2pd_xmm_k1z_xmmm64b32 ) OR + ( Code.Code = EVEX_Vcvtps2pd_ymm_k1z_xmmm128b32 ) OR ( Code.Code = Cvtpd2ps_xmm_xmmm128 ) OR ( Code.Code = VEX_Vcvtpd2ps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vcvtpd2ps_xmm_ymmm256 ) OR ( Code.Code = EVEX_Vcvtpd2ps_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vcvtpd2ps_xmm_k1z_ymmm256b64 ) OR + ( Code.Code = Cvtss2sd_xmm_xmmm32 ) OR ( Code.Code = VEX_Vcvtss2sd_xmm_xmm_xmmm32 ) OR ( Code.Code = EVEX_Vcvtss2sd_xmm_k1z_xmm_xmmm32_sae ) OR + ( Code.Code = Cvtsd2ss_xmm_xmmm64 ) OR ( Code.Code = VEX_Vcvtsd2ss_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vcvtsd2ss_xmm_k1z_xmm_xmmm64_er ) OR + ( Code.Code = Cvtdq2ps_xmm_xmmm128 ) OR ( Code.Code = VEX_Vcvtdq2ps_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vcvtdq2ps_xmm_k1z_xmmm128b32 ) OR + ( Code.Code = EVEX_Vcvtqq2ps_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vcvtqq2ps_xmm_k1z_ymmm256b64 ) OR ( Code.Code = Cvtps2dq_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vcvtps2dq_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vcvtps2dq_xmm_k1z_xmmm128b32 ) OR ( Code.Code = Cvttps2dq_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vcvttps2dq_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vcvttps2dq_xmm_k1z_xmmm128b32 ) OR ( Code.Code = Subps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vsubps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vsubps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Subpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vsubpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vsubpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Subss_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vsubss_xmm_xmm_xmmm32 ) OR ( Code.Code = EVEX_Vsubss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = Subsd_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vsubsd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vsubsd_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = Minps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vminps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vminps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Minpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vminpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vminpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Minss_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vminss_xmm_xmm_xmmm32 ) OR ( Code.Code = EVEX_Vminss_xmm_k1z_xmm_xmmm32_sae ) OR ( Code.Code = Minsd_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vminsd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vminsd_xmm_k1z_xmm_xmmm64_sae ) OR ( Code.Code = Divps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vdivps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vdivps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Divpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vdivpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vdivpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Divss_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vdivss_xmm_xmm_xmmm32 ) OR ( Code.Code = EVEX_Vdivss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = Divsd_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vdivsd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vdivsd_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = Maxps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vmaxps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmaxps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Maxpd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vmaxpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmaxpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Maxss_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vmaxss_xmm_xmm_xmmm32 ) OR ( Code.Code = EVEX_Vmaxss_xmm_k1z_xmm_xmmm32_sae ) OR ( Code.Code = Maxsd_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vmaxsd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vmaxsd_xmm_k1z_xmm_xmmm64_sae ) OR ( Code.Code = Punpcklbw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpunpcklbw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpunpcklbw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Punpcklwd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpunpcklwd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpunpcklwd_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Punpckldq_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpunpckldq_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpunpckldq_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Packsswb_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpacksswb_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpacksswb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Pcmpgtb_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpcmpgtb_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpcmpgtb_kr_k1_xmm_xmmm128 ) OR ( Code.Code = Pcmpgtw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpcmpgtw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpcmpgtw_kr_k1_xmm_xmmm128 ) OR ( Code.Code = Pcmpgtd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpcmpgtd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpcmpgtd_kr_k1_xmm_xmmm128b32 ) OR ( Code.Code = Packuswb_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpackuswb_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpackuswb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Punpckhbw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpunpckhbw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpunpckhbw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Punpckhwd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpunpckhwd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpunpckhwd_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Punpckhdq_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpunpckhdq_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpunpckhdq_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Packssdw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpackssdw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpackssdw_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Punpcklqdq_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpunpcklqdq_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpunpcklqdq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Punpckhqdq_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpunpckhqdq_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpunpckhqdq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Movd_xmm_rm32 ) OR + ( Code.Code = Movq_xmm_rm64 ) OR ( Code.Code = VEX_Vmovd_xmm_rm32 ) OR ( Code.Code = VEX_Vmovq_xmm_rm64 ) OR + ( Code.Code = EVEX_Vmovd_xmm_rm32 ) OR ( Code.Code = EVEX_Vmovq_xmm_rm64 ) OR ( Code.Code = Movdqa_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vmovdqa_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmovdqa32_xmm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vmovdqa64_xmm_k1z_xmmm128 ) OR + ( Code.Code = Movdqu_xmm_xmmm128 ) OR ( Code.Code = VEX_Vmovdqu_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vmovdqu32_xmm_k1z_xmmm128 ) OR + ( Code.Code = EVEX_Vmovdqu64_xmm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vmovdqu8_xmm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vmovdqu16_xmm_k1z_xmmm128 ) OR + ( Code.Code = Pshufd_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vpshufd_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vpshufd_xmm_k1z_xmmm128b32_imm8 ) OR + ( Code.Code = Pshufhw_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vpshufhw_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vpshufhw_xmm_k1z_xmmm128_imm8 ) OR + ( Code.Code = Pshuflw_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vpshuflw_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vpshuflw_xmm_k1z_xmmm128_imm8 ) OR + ( Code.Code = Psrlw_xmm_imm8 ) OR ( Code.Code = VEX_Vpsrlw_xmm_xmm_imm8 ) OR ( Code.Code = EVEX_Vpsrlw_xmm_k1z_xmmm128_imm8 ) OR + ( Code.Code = Psraw_xmm_imm8 ) OR ( Code.Code = VEX_Vpsraw_xmm_xmm_imm8 ) OR ( Code.Code = EVEX_Vpsraw_xmm_k1z_xmmm128_imm8 ) OR + ( Code.Code = Psllw_xmm_imm8 ) OR ( Code.Code = VEX_Vpsllw_xmm_xmm_imm8 ) OR ( Code.Code = EVEX_Vpsllw_xmm_k1z_xmmm128_imm8 ) OR + ( Code.Code = EVEX_Vprord_xmm_k1z_xmmm128b32_imm8 ) OR ( Code.Code = EVEX_Vprorq_xmm_k1z_xmmm128b64_imm8 ) OR ( Code.Code = EVEX_Vprold_xmm_k1z_xmmm128b32_imm8 ) OR + ( Code.Code = EVEX_Vprolq_xmm_k1z_xmmm128b64_imm8 ) OR ( Code.Code = Psrld_xmm_imm8 ) OR ( Code.Code = VEX_Vpsrld_xmm_xmm_imm8 ) OR + ( Code.Code = EVEX_Vpsrld_xmm_k1z_xmmm128b32_imm8 ) OR ( Code.Code = Psrad_xmm_imm8 ) OR ( Code.Code = VEX_Vpsrad_xmm_xmm_imm8 ) OR + ( Code.Code = EVEX_Vpsrad_xmm_k1z_xmmm128b32_imm8 ) OR ( Code.Code = EVEX_Vpsraq_xmm_k1z_xmmm128b64_imm8 ) OR ( Code.Code = Pslld_xmm_imm8 ) OR + ( Code.Code = VEX_Vpslld_xmm_xmm_imm8 ) OR ( Code.Code = EVEX_Vpslld_xmm_k1z_xmmm128b32_imm8 ) OR ( Code.Code = Psrlq_xmm_imm8 ) OR + ( Code.Code = VEX_Vpsrlq_xmm_xmm_imm8 ) OR ( Code.Code = EVEX_Vpsrlq_xmm_k1z_xmmm128b64_imm8 ) OR ( Code.Code = Psrldq_xmm_imm8 ) OR + ( Code.Code = VEX_Vpsrldq_xmm_xmm_imm8 ) OR ( Code.Code = EVEX_Vpsrldq_xmm_xmmm128_imm8 ) OR ( Code.Code = Psllq_xmm_imm8 ) OR + ( Code.Code = VEX_Vpsllq_xmm_xmm_imm8 ) OR ( Code.Code = EVEX_Vpsllq_xmm_k1z_xmmm128b64_imm8 ) OR ( Code.Code = Pslldq_xmm_imm8 ) OR + ( Code.Code = VEX_Vpslldq_xmm_xmm_imm8 ) OR ( Code.Code = EVEX_Vpslldq_xmm_xmmm128_imm8 ) OR ( Code.Code = Pcmpeqb_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpcmpeqb_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpcmpeqb_kr_k1_xmm_xmmm128 ) OR ( Code.Code = Pcmpeqw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpcmpeqw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpcmpeqw_kr_k1_xmm_xmmm128 ) OR ( Code.Code = Pcmpeqd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpcmpeqd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpcmpeqd_kr_k1_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vcvttps2udq_xmm_k1z_xmmm128b32 ) OR + ( Code.Code = EVEX_Vcvttpd2udq_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vcvttpd2udq_xmm_k1z_ymmm256b64 ) OR ( Code.Code = Extrq_xmm_imm8_imm8 ) OR + ( Code.Code = EVEX_Vcvttps2uqq_xmm_k1z_xmmm64b32 ) OR ( Code.Code = EVEX_Vcvttps2uqq_ymm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vcvttpd2uqq_xmm_k1z_xmmm128b64 ) OR + ( Code.Code = EVEX_Vcvttss2usi_r32_xmmm32_sae ) OR ( Code.Code = EVEX_Vcvttss2usi_r64_xmmm32_sae ) OR ( Code.Code = Insertq_xmm_xmm_imm8_imm8 ) OR + ( Code.Code = EVEX_Vcvttsd2usi_r32_xmmm64_sae ) OR ( Code.Code = EVEX_Vcvttsd2usi_r64_xmmm64_sae ) OR ( Code.Code = EVEX_Vcvtps2udq_xmm_k1z_xmmm128b32 ) OR + ( Code.Code = EVEX_Vcvtpd2udq_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vcvtpd2udq_xmm_k1z_ymmm256b64 ) OR ( Code.Code = Extrq_xmm_xmm ) OR + ( Code.Code = EVEX_Vcvtps2uqq_xmm_k1z_xmmm64b32 ) OR ( Code.Code = EVEX_Vcvtps2uqq_ymm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vcvtpd2uqq_xmm_k1z_xmmm128b64 ) OR + ( Code.Code = EVEX_Vcvtss2usi_r32_xmmm32_er ) OR ( Code.Code = EVEX_Vcvtss2usi_r64_xmmm32_er ) OR ( Code.Code = Insertq_xmm_xmm ) OR + ( Code.Code = EVEX_Vcvtsd2usi_r32_xmmm64_er ) OR ( Code.Code = EVEX_Vcvtsd2usi_r64_xmmm64_er ) OR ( Code.Code = EVEX_Vcvttps2qq_xmm_k1z_xmmm64b32 ) OR + ( Code.Code = EVEX_Vcvttps2qq_ymm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vcvttpd2qq_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vcvtudq2pd_xmm_k1z_xmmm64b32 ) OR + ( Code.Code = EVEX_Vcvtudq2pd_ymm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vcvtuqq2pd_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vcvtudq2ps_xmm_k1z_xmmm128b32 ) OR + ( Code.Code = EVEX_Vcvtuqq2ps_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vcvtuqq2ps_xmm_k1z_ymmm256b64 ) OR ( Code.Code = EVEX_Vcvtps2qq_xmm_k1z_xmmm64b32 ) OR + ( Code.Code = EVEX_Vcvtps2qq_ymm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vcvtpd2qq_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vcvtusi2ss_xmm_xmm_rm32_er ) OR + ( Code.Code = EVEX_Vcvtusi2ss_xmm_xmm_rm64_er ) OR ( Code.Code = EVEX_Vcvtusi2sd_xmm_xmm_rm32_er ) OR ( Code.Code = EVEX_Vcvtusi2sd_xmm_xmm_rm64_er ) OR + ( Code.Code = Haddpd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vhaddpd_xmm_xmm_xmmm128 ) OR ( Code.Code = Haddps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vhaddps_xmm_xmm_xmmm128 ) OR ( Code.Code = Hsubpd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vhsubpd_xmm_xmm_xmmm128 ) OR + ( Code.Code = Hsubps_xmm_xmmm128 ) OR ( Code.Code = VEX_Vhsubps_xmm_xmm_xmmm128 ) OR ( Code.Code = Movd_rm32_xmm ) OR + ( Code.Code = Movq_rm64_xmm ) OR ( Code.Code = VEX_Vmovd_rm32_xmm ) OR ( Code.Code = VEX_Vmovq_rm64_xmm ) OR + ( Code.Code = EVEX_Vmovd_rm32_xmm ) OR ( Code.Code = EVEX_Vmovq_rm64_xmm ) OR ( Code.Code = Movq_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vmovq_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vmovq_xmm_xmmm64 ) OR ( Code.Code = Movdqa_xmmm128_xmm ) OR + ( Code.Code = VEX_Vmovdqa_xmmm128_xmm ) OR ( Code.Code = EVEX_Vmovdqa32_xmmm128_k1z_xmm ) OR ( Code.Code = EVEX_Vmovdqa64_xmmm128_k1z_xmm ) OR + ( Code.Code = Movdqu_xmmm128_xmm ) OR ( Code.Code = VEX_Vmovdqu_xmmm128_xmm ) OR ( Code.Code = EVEX_Vmovdqu32_xmmm128_k1z_xmm ) OR + ( Code.Code = EVEX_Vmovdqu64_xmmm128_k1z_xmm ) OR ( Code.Code = EVEX_Vmovdqu8_xmmm128_k1z_xmm ) OR ( Code.Code = EVEX_Vmovdqu16_xmmm128_k1z_xmm ) OR + ( Code.Code = Cmpps_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vcmpps_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vcmpps_kr_k1_xmm_xmmm128b32_imm8 ) OR + ( Code.Code = Cmppd_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vcmppd_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vcmppd_kr_k1_xmm_xmmm128b64_imm8 ) OR + ( Code.Code = Cmpss_xmm_xmmm32_imm8 ) OR ( Code.Code = VEX_Vcmpss_xmm_xmm_xmmm32_imm8 ) OR ( Code.Code = EVEX_Vcmpss_kr_k1_xmm_xmmm32_imm8_sae ) OR + ( Code.Code = Cmpsd_xmm_xmmm64_imm8 ) OR ( Code.Code = VEX_Vcmpsd_xmm_xmm_xmmm64_imm8 ) OR ( Code.Code = EVEX_Vcmpsd_kr_k1_xmm_xmmm64_imm8_sae ) OR + ( Code.Code = Pinsrw_xmm_r32m16_imm8 ) OR ( Code.Code = Pinsrw_xmm_r64m16_imm8 ) OR ( Code.Code = VEX_Vpinsrw_xmm_xmm_r32m16_imm8 ) OR + ( Code.Code = VEX_Vpinsrw_xmm_xmm_r64m16_imm8 ) OR ( Code.Code = EVEX_Vpinsrw_xmm_xmm_r32m16_imm8 ) OR ( Code.Code = EVEX_Vpinsrw_xmm_xmm_r64m16_imm8 ) OR + ( Code.Code = Pextrw_r32_xmm_imm8 ) OR ( Code.Code = Pextrw_r64_xmm_imm8 ) OR ( Code.Code = VEX_Vpextrw_r32_xmm_imm8 ) OR + ( Code.Code = VEX_Vpextrw_r64_xmm_imm8 ) OR ( Code.Code = EVEX_Vpextrw_r32_xmm_imm8 ) OR ( Code.Code = EVEX_Vpextrw_r64_xmm_imm8 ) OR + ( Code.Code = Shufps_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vshufps_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vshufps_xmm_k1z_xmm_xmmm128b32_imm8 ) OR + ( Code.Code = Shufpd_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vshufpd_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vshufpd_xmm_k1z_xmm_xmmm128b64_imm8 ) OR + ( Code.Code = Addsubpd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vaddsubpd_xmm_xmm_xmmm128 ) OR ( Code.Code = Addsubps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vaddsubps_xmm_xmm_xmmm128 ) OR ( Code.Code = Psrlw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsrlw_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpsrlw_ymm_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpsrlw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpsrlw_ymm_k1z_ymm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsrlw_zmm_k1z_zmm_xmmm128 ) OR ( Code.Code = Psrld_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsrld_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpsrld_ymm_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpsrld_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpsrld_ymm_k1z_ymm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsrld_zmm_k1z_zmm_xmmm128 ) OR ( Code.Code = Psrlq_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsrlq_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpsrlq_ymm_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpsrlq_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpsrlq_ymm_k1z_ymm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsrlq_zmm_k1z_zmm_xmmm128 ) OR ( Code.Code = Paddq_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpaddq_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpaddq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Pmullw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpmullw_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpmullw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Movq_xmmm64_xmm ) OR ( Code.Code = VEX_Vmovq_xmmm64_xmm ) OR + ( Code.Code = EVEX_Vmovq_xmmm64_xmm ) OR ( Code.Code = Movq2dq_xmm_mm ) OR ( Code.Code = Movdq2q_mm_xmm ) OR + ( Code.Code = Pmovmskb_r32_xmm ) OR ( Code.Code = Pmovmskb_r64_xmm ) OR ( Code.Code = VEX_Vpmovmskb_r32_xmm ) OR + ( Code.Code = VEX_Vpmovmskb_r64_xmm ) OR ( Code.Code = Psubusb_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsubusb_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsubusb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Psubusw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsubusw_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsubusw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Pminub_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpminub_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpminub_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Pand_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpand_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpandd_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpandq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Paddusb_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpaddusb_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpaddusb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Paddusw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpaddusw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpaddusw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Pmaxub_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpmaxub_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpmaxub_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Pandn_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpandn_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpandnd_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpandnq_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = Pavgb_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpavgb_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpavgb_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = Psraw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsraw_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsraw_ymm_ymm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsraw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpsraw_ymm_k1z_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpsraw_zmm_k1z_zmm_xmmm128 ) OR + ( Code.Code = Psrad_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsrad_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsrad_ymm_ymm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsrad_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpsrad_ymm_k1z_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpsrad_zmm_k1z_zmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsraq_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpsraq_ymm_k1z_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpsraq_zmm_k1z_zmm_xmmm128 ) OR + ( Code.Code = Pavgw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpavgw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpavgw_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = Pmulhuw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpmulhuw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpmulhuw_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = Pmulhw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpmulhw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpmulhw_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = Cvttpd2dq_xmm_xmmm128 ) OR ( Code.Code = VEX_Vcvttpd2dq_xmm_xmmm128 ) OR ( Code.Code = VEX_Vcvttpd2dq_xmm_ymmm256 ) OR + ( Code.Code = EVEX_Vcvttpd2dq_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vcvttpd2dq_xmm_k1z_ymmm256b64 ) OR ( Code.Code = Cvtdq2pd_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vcvtdq2pd_xmm_xmmm64 ) OR ( Code.Code = VEX_Vcvtdq2pd_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vcvtdq2pd_xmm_k1z_xmmm64b32 ) OR + ( Code.Code = EVEX_Vcvtdq2pd_ymm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vcvtqq2pd_xmm_k1z_xmmm128b64 ) OR ( Code.Code = Cvtpd2dq_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vcvtpd2dq_xmm_xmmm128 ) OR ( Code.Code = VEX_Vcvtpd2dq_xmm_ymmm256 ) OR ( Code.Code = EVEX_Vcvtpd2dq_xmm_k1z_xmmm128b64 ) OR + ( Code.Code = EVEX_Vcvtpd2dq_xmm_k1z_ymmm256b64 ) OR ( Code.Code = Movntdq_m128_xmm ) OR ( Code.Code = VEX_Vmovntdq_m128_xmm ) OR + ( Code.Code = EVEX_Vmovntdq_m128_xmm ) OR ( Code.Code = Psubsb_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsubsb_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsubsb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Psubsw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsubsw_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsubsw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Pminsw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpminsw_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpminsw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Por_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpor_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpord_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vporq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Paddsb_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpaddsb_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpaddsb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Paddsw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpaddsw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpaddsw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Pmaxsw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpmaxsw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpmaxsw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Pxor_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpxor_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpxord_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpxorq_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = Lddqu_xmm_m128 ) OR ( Code.Code = VEX_Vlddqu_xmm_m128 ) OR ( Code.Code = Psllw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpsllw_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsllw_ymm_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpsllw_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsllw_ymm_k1z_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpsllw_zmm_k1z_zmm_xmmm128 ) OR ( Code.Code = Pslld_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpslld_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpslld_ymm_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpslld_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpslld_ymm_k1z_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpslld_zmm_k1z_zmm_xmmm128 ) OR ( Code.Code = Psllq_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpsllq_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsllq_ymm_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpsllq_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsllq_ymm_k1z_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpsllq_zmm_k1z_zmm_xmmm128 ) OR ( Code.Code = Pmuludq_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpmuludq_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpmuludq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Pmaddwd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpmaddwd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpmaddwd_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Psadbw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpsadbw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpsadbw_xmm_xmm_xmmm128 ) OR ( Code.Code = Maskmovdqu_rDI_xmm_xmm ) OR + ( Code.Code = VEX_Vmaskmovdqu_rDI_xmm_xmm ) OR ( Code.Code = Psubb_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsubb_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsubb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Psubw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsubw_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsubw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Psubd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsubd_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsubd_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Psubq_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsubq_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpsubq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Paddb_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpaddb_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpaddb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Paddw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpaddw_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpaddw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Paddd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpaddd_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpaddd_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = Pshufb_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpshufb_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpshufb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Phaddw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vphaddw_xmm_xmm_xmmm128 ) OR + ( Code.Code = Phaddd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vphaddd_xmm_xmm_xmmm128 ) OR ( Code.Code = Phaddsw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vphaddsw_xmm_xmm_xmmm128 ) OR ( Code.Code = Pmaddubsw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpmaddubsw_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpmaddubsw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Phsubw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vphsubw_xmm_xmm_xmmm128 ) OR + ( Code.Code = Phsubd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vphsubd_xmm_xmm_xmmm128 ) OR ( Code.Code = Phsubsw_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vphsubsw_xmm_xmm_xmmm128 ) OR ( Code.Code = Psignb_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsignb_xmm_xmm_xmmm128 ) OR + ( Code.Code = Psignw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsignw_xmm_xmm_xmmm128 ) OR ( Code.Code = Psignd_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpsignd_xmm_xmm_xmmm128 ) OR ( Code.Code = Pmulhrsw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpmulhrsw_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpmulhrsw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpermilps_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpermilps_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = VEX_Vpermilpd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpermilpd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vtestps_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vtestpd_xmm_xmmm128 ) OR ( Code.Code = Pblendvb_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpsrlvw_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpmovuswb_xmmm64_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovuswb_xmmm128_k1z_ymm ) OR ( Code.Code = EVEX_Vpsravw_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpmovusdb_xmmm32_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovusdb_xmmm64_k1z_ymm ) OR ( Code.Code = EVEX_Vpmovusdb_xmmm128_k1z_zmm ) OR + ( Code.Code = EVEX_Vpsllvw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpmovusqb_xmmm16_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovusqb_xmmm32_k1z_ymm ) OR + ( Code.Code = EVEX_Vpmovusqb_xmmm64_k1z_zmm ) OR ( Code.Code = VEX_Vcvtph2ps_xmm_xmmm64 ) OR ( Code.Code = VEX_Vcvtph2ps_ymm_xmmm128 ) OR + ( Code.Code = EVEX_Vcvtph2ps_xmm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vcvtph2ps_ymm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vpmovusdw_xmmm64_k1z_xmm ) OR + ( Code.Code = EVEX_Vpmovusdw_xmmm128_k1z_ymm ) OR ( Code.Code = Blendvps_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vprorvd_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vprorvq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vpmovusqw_xmmm32_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovusqw_xmmm64_k1z_ymm ) OR + ( Code.Code = EVEX_Vpmovusqw_xmmm128_k1z_zmm ) OR ( Code.Code = Blendvpd_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vprolvd_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vprolvq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vpmovusqd_xmmm64_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovusqd_xmmm128_k1z_ymm ) OR + ( Code.Code = Ptest_xmm_xmmm128 ) OR ( Code.Code = VEX_Vptest_xmm_xmmm128 ) OR ( Code.Code = VEX_Vbroadcastss_xmm_m32 ) OR + ( Code.Code = EVEX_Vbroadcastss_xmm_k1z_xmmm32 ) OR ( Code.Code = EVEX_Vbroadcastss_ymm_k1z_xmmm32 ) OR ( Code.Code = EVEX_Vbroadcastss_zmm_k1z_xmmm32 ) OR + ( Code.Code = EVEX_Vbroadcastf32x2_ymm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vbroadcastf32x2_zmm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vbroadcastsd_ymm_k1z_xmmm64 ) OR + ( Code.Code = EVEX_Vbroadcastsd_zmm_k1z_xmmm64 ) OR ( Code.Code = Pabsb_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpabsb_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpabsb_xmm_k1z_xmmm128 ) OR ( Code.Code = Pabsw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpabsw_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpabsw_xmm_k1z_xmmm128 ) OR ( Code.Code = Pabsd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpabsd_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpabsd_xmm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vpabsq_xmm_k1z_xmmm128b64 ) OR ( Code.Code = Pmovsxbw_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vpmovsxbw_xmm_xmmm64 ) OR ( Code.Code = VEX_Vpmovsxbw_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpmovsxbw_xmm_k1z_xmmm64 ) OR + ( Code.Code = EVEX_Vpmovsxbw_ymm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vpmovswb_xmmm64_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovswb_xmmm128_k1z_ymm ) OR + ( Code.Code = Pmovsxbd_xmm_xmmm32 ) OR ( Code.Code = VEX_Vpmovsxbd_xmm_xmmm32 ) OR ( Code.Code = VEX_Vpmovsxbd_ymm_xmmm64 ) OR + ( Code.Code = EVEX_Vpmovsxbd_xmm_k1z_xmmm32 ) OR ( Code.Code = EVEX_Vpmovsxbd_ymm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vpmovsxbd_zmm_k1z_xmmm128 ) OR + ( Code.Code = EVEX_Vpmovsdb_xmmm32_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovsdb_xmmm64_k1z_ymm ) OR ( Code.Code = EVEX_Vpmovsdb_xmmm128_k1z_zmm ) OR + ( Code.Code = Pmovsxbq_xmm_xmmm16 ) OR ( Code.Code = VEX_Vpmovsxbq_xmm_xmmm16 ) OR ( Code.Code = VEX_Vpmovsxbq_ymm_xmmm32 ) OR + ( Code.Code = EVEX_Vpmovsxbq_xmm_k1z_xmmm16 ) OR ( Code.Code = EVEX_Vpmovsxbq_ymm_k1z_xmmm32 ) OR ( Code.Code = EVEX_Vpmovsxbq_zmm_k1z_xmmm64 ) OR + ( Code.Code = EVEX_Vpmovsqb_xmmm16_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovsqb_xmmm32_k1z_ymm ) OR ( Code.Code = EVEX_Vpmovsqb_xmmm64_k1z_zmm ) OR + ( Code.Code = Pmovsxwd_xmm_xmmm64 ) OR ( Code.Code = VEX_Vpmovsxwd_xmm_xmmm64 ) OR ( Code.Code = VEX_Vpmovsxwd_ymm_xmmm128 ) OR + ( Code.Code = EVEX_Vpmovsxwd_xmm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vpmovsxwd_ymm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vpmovsdw_xmmm64_k1z_xmm ) OR + ( Code.Code = EVEX_Vpmovsdw_xmmm128_k1z_ymm ) OR ( Code.Code = Pmovsxwq_xmm_xmmm32 ) OR ( Code.Code = VEX_Vpmovsxwq_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vpmovsxwq_ymm_xmmm64 ) OR ( Code.Code = EVEX_Vpmovsxwq_xmm_k1z_xmmm32 ) OR ( Code.Code = EVEX_Vpmovsxwq_ymm_k1z_xmmm64 ) OR + ( Code.Code = EVEX_Vpmovsxwq_zmm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vpmovsqw_xmmm32_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovsqw_xmmm64_k1z_ymm ) OR + ( Code.Code = EVEX_Vpmovsqw_xmmm128_k1z_zmm ) OR ( Code.Code = Pmovsxdq_xmm_xmmm64 ) OR ( Code.Code = VEX_Vpmovsxdq_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vpmovsxdq_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpmovsxdq_xmm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vpmovsxdq_ymm_k1z_xmmm128 ) OR + ( Code.Code = EVEX_Vpmovsqd_xmmm64_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovsqd_xmmm128_k1z_ymm ) OR ( Code.Code = EVEX_Vptestmb_kr_k1_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vptestmw_kr_k1_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vptestnmb_kr_k1_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vptestnmw_kr_k1_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vptestmd_kr_k1_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vptestmq_kr_k1_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vptestnmd_kr_k1_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vptestnmq_kr_k1_xmm_xmmm128b64 ) OR ( Code.Code = Pmuldq_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpmuldq_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpmuldq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vpmovm2b_xmm_kr ) OR ( Code.Code = EVEX_Vpmovm2w_xmm_kr ) OR + ( Code.Code = Pcmpeqq_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpcmpeqq_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpcmpeqq_kr_k1_xmm_xmmm128b64 ) OR + ( Code.Code = EVEX_Vpmovb2m_kr_xmm ) OR ( Code.Code = EVEX_Vpmovw2m_kr_xmm ) OR ( Code.Code = Movntdqa_xmm_m128 ) OR + ( Code.Code = VEX_Vmovntdqa_xmm_m128 ) OR ( Code.Code = EVEX_Vmovntdqa_xmm_m128 ) OR ( Code.Code = EVEX_Vpbroadcastmb2q_xmm_kr ) OR + ( Code.Code = Packusdw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpackusdw_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpackusdw_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = VEX_Vmaskmovps_xmm_xmm_m128 ) OR ( Code.Code = EVEX_Vscalefps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vscalefpd_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = VEX_Vmaskmovpd_xmm_xmm_m128 ) OR ( Code.Code = EVEX_Vscalefss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vscalefsd_xmm_k1z_xmm_xmmm64_er ) OR + ( Code.Code = VEX_Vmaskmovps_m128_xmm_xmm ) OR ( Code.Code = VEX_Vmaskmovpd_m128_xmm_xmm ) OR ( Code.Code = Pmovzxbw_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vpmovzxbw_xmm_xmmm64 ) OR ( Code.Code = VEX_Vpmovzxbw_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpmovzxbw_xmm_k1z_xmmm64 ) OR + ( Code.Code = EVEX_Vpmovzxbw_ymm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vpmovwb_xmmm64_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovwb_xmmm128_k1z_ymm ) OR + ( Code.Code = Pmovzxbd_xmm_xmmm32 ) OR ( Code.Code = VEX_Vpmovzxbd_xmm_xmmm32 ) OR ( Code.Code = VEX_Vpmovzxbd_ymm_xmmm64 ) OR + ( Code.Code = EVEX_Vpmovzxbd_xmm_k1z_xmmm32 ) OR ( Code.Code = EVEX_Vpmovzxbd_ymm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vpmovzxbd_zmm_k1z_xmmm128 ) OR + ( Code.Code = EVEX_Vpmovdb_xmmm32_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovdb_xmmm64_k1z_ymm ) OR ( Code.Code = EVEX_Vpmovdb_xmmm128_k1z_zmm ) OR + ( Code.Code = Pmovzxbq_xmm_xmmm16 ) OR ( Code.Code = VEX_Vpmovzxbq_xmm_xmmm16 ) OR ( Code.Code = VEX_Vpmovzxbq_ymm_xmmm32 ) OR + ( Code.Code = EVEX_Vpmovzxbq_xmm_k1z_xmmm16 ) OR ( Code.Code = EVEX_Vpmovzxbq_ymm_k1z_xmmm32 ) OR ( Code.Code = EVEX_Vpmovzxbq_zmm_k1z_xmmm64 ) OR + ( Code.Code = EVEX_Vpmovqb_xmmm16_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovqb_xmmm32_k1z_ymm ) OR ( Code.Code = EVEX_Vpmovqb_xmmm64_k1z_zmm ) OR + ( Code.Code = Pmovzxwd_xmm_xmmm64 ) OR ( Code.Code = VEX_Vpmovzxwd_xmm_xmmm64 ) OR ( Code.Code = VEX_Vpmovzxwd_ymm_xmmm128 ) OR + ( Code.Code = EVEX_Vpmovzxwd_xmm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vpmovzxwd_ymm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vpmovdw_xmmm64_k1z_xmm ) OR + ( Code.Code = EVEX_Vpmovdw_xmmm128_k1z_ymm ) OR ( Code.Code = Pmovzxwq_xmm_xmmm32 ) OR ( Code.Code = VEX_Vpmovzxwq_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vpmovzxwq_ymm_xmmm64 ) OR ( Code.Code = EVEX_Vpmovzxwq_xmm_k1z_xmmm32 ) OR ( Code.Code = EVEX_Vpmovzxwq_ymm_k1z_xmmm64 ) OR + ( Code.Code = EVEX_Vpmovzxwq_zmm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vpmovqw_xmmm32_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovqw_xmmm64_k1z_ymm ) OR + ( Code.Code = EVEX_Vpmovqw_xmmm128_k1z_zmm ) OR ( Code.Code = Pmovzxdq_xmm_xmmm64 ) OR ( Code.Code = VEX_Vpmovzxdq_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vpmovzxdq_ymm_xmmm128 ) OR ( Code.Code = EVEX_Vpmovzxdq_xmm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vpmovzxdq_ymm_k1z_xmmm128 ) OR + ( Code.Code = EVEX_Vpmovqd_xmmm64_k1z_xmm ) OR ( Code.Code = EVEX_Vpmovqd_xmmm128_k1z_ymm ) OR ( Code.Code = Pcmpgtq_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpcmpgtq_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpcmpgtq_kr_k1_xmm_xmmm128b64 ) OR ( Code.Code = Pminsb_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpminsb_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpminsb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpmovm2d_xmm_kr ) OR + ( Code.Code = EVEX_Vpmovm2q_xmm_kr ) OR ( Code.Code = Pminsd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpminsd_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpminsd_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpminsq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vpmovd2m_kr_xmm ) OR + ( Code.Code = EVEX_Vpmovq2m_kr_xmm ) OR ( Code.Code = Pminuw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpminuw_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpminuw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpbroadcastmw2d_xmm_kr ) OR ( Code.Code = Pminud_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpminud_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpminud_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpminuq_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = Pmaxsb_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpmaxsb_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpmaxsb_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = Pmaxsd_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpmaxsd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpmaxsd_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vpmaxsq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Pmaxuw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpmaxuw_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpmaxuw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Pmaxud_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpmaxud_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpmaxud_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpmaxuq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = Pmulld_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpmulld_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpmulld_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpmullq_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = Phminposuw_xmm_xmmm128 ) OR ( Code.Code = VEX_Vphminposuw_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vgetexpps_xmm_k1z_xmmm128b32 ) OR + ( Code.Code = EVEX_Vgetexppd_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vgetexpss_xmm_k1z_xmm_xmmm32_sae ) OR ( Code.Code = EVEX_Vgetexpsd_xmm_k1z_xmm_xmmm64_sae ) OR + ( Code.Code = EVEX_Vplzcntd_xmm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vplzcntq_xmm_k1z_xmmm128b64 ) OR ( Code.Code = VEX_Vpsrlvd_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpsrlvq_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpsrlvd_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpsrlvq_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = VEX_Vpsravd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpsravd_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpsravq_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = VEX_Vpsllvd_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpsllvq_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpsllvd_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vpsllvq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vrcp14ps_xmm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vrcp14pd_xmm_k1z_xmmm128b64 ) OR + ( Code.Code = EVEX_Vrcp14ss_xmm_k1z_xmm_xmmm32 ) OR ( Code.Code = EVEX_Vrcp14sd_xmm_k1z_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vrsqrt14ps_xmm_k1z_xmmm128b32 ) OR + ( Code.Code = EVEX_Vrsqrt14pd_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vrsqrt14ss_xmm_k1z_xmm_xmmm32 ) OR ( Code.Code = EVEX_Vrsqrt14sd_xmm_k1z_xmm_xmmm64 ) OR + ( Code.Code = EVEX_Vpdpbusd_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpdpbusds_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpdpwssd_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vdpbf16ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpdpwssds_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpopcntb_xmm_k1z_xmmm128 ) OR + ( Code.Code = EVEX_Vpopcntw_xmm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vpopcntd_xmm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vpopcntq_xmm_k1z_xmmm128b64 ) OR + ( Code.Code = VEX_Vpbroadcastd_xmm_xmmm32 ) OR ( Code.Code = VEX_Vpbroadcastd_ymm_xmmm32 ) OR ( Code.Code = EVEX_Vpbroadcastd_xmm_k1z_xmmm32 ) OR + ( Code.Code = EVEX_Vpbroadcastd_ymm_k1z_xmmm32 ) OR ( Code.Code = EVEX_Vpbroadcastd_zmm_k1z_xmmm32 ) OR ( Code.Code = VEX_Vpbroadcastq_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vpbroadcastq_ymm_xmmm64 ) OR ( Code.Code = EVEX_Vbroadcasti32x2_xmm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vbroadcasti32x2_ymm_k1z_xmmm64 ) OR + ( Code.Code = EVEX_Vbroadcasti32x2_zmm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vpbroadcastq_xmm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vpbroadcastq_ymm_k1z_xmmm64 ) OR + ( Code.Code = EVEX_Vpbroadcastq_zmm_k1z_xmmm64 ) OR ( Code.Code = EVEX_Vpexpandb_xmm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vpexpandw_xmm_k1z_xmmm128 ) OR + ( Code.Code = EVEX_Vpcompressb_xmmm128_k1z_xmm ) OR ( Code.Code = EVEX_Vpcompressw_xmmm128_k1z_xmm ) OR ( Code.Code = EVEX_Vpblendmd_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vpblendmq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vblendmps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vblendmpd_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = EVEX_Vpblendmb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpblendmw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vp2intersectd_kp1_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vp2intersectq_kp1_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vpshldvw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpshldvd_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vpshldvq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vpshrdvw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vcvtneps2bf16_xmm_k1z_xmmm128b32 ) OR + ( Code.Code = EVEX_Vcvtneps2bf16_xmm_k1z_ymmm256b32 ) OR ( Code.Code = EVEX_Vcvtne2ps2bf16_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpshrdvd_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vpshrdvq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vpermi2b_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpermi2w_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpermi2d_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpermi2q_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vpermi2ps_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vpermi2pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vpbroadcastb_xmm_xmmm8 ) OR ( Code.Code = VEX_Vpbroadcastb_ymm_xmmm8 ) OR + ( Code.Code = EVEX_Vpbroadcastb_xmm_k1z_xmmm8 ) OR ( Code.Code = EVEX_Vpbroadcastb_ymm_k1z_xmmm8 ) OR ( Code.Code = EVEX_Vpbroadcastb_zmm_k1z_xmmm8 ) OR + ( Code.Code = VEX_Vpbroadcastw_xmm_xmmm16 ) OR ( Code.Code = VEX_Vpbroadcastw_ymm_xmmm16 ) OR ( Code.Code = EVEX_Vpbroadcastw_xmm_k1z_xmmm16 ) OR + ( Code.Code = EVEX_Vpbroadcastw_ymm_k1z_xmmm16 ) OR ( Code.Code = EVEX_Vpbroadcastw_zmm_k1z_xmmm16 ) OR ( Code.Code = EVEX_Vpbroadcastb_xmm_k1z_r32 ) OR + ( Code.Code = EVEX_Vpbroadcastw_xmm_k1z_r32 ) OR ( Code.Code = EVEX_Vpbroadcastd_xmm_k1z_r32 ) OR ( Code.Code = EVEX_Vpbroadcastq_xmm_k1z_r64 ) OR + ( Code.Code = EVEX_Vpermt2b_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpermt2w_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vpermt2d_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vpermt2q_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vpermt2ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vpermt2pd_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = EVEX_Vpmultishiftqb_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = EVEX_Vexpandps_xmm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vexpandpd_xmm_k1z_xmmm128 ) OR + ( Code.Code = EVEX_Vpexpandd_xmm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vpexpandq_xmm_k1z_xmmm128 ) OR ( Code.Code = EVEX_Vcompressps_xmmm128_k1z_xmm ) OR + ( Code.Code = EVEX_Vcompresspd_xmmm128_k1z_xmm ) OR ( Code.Code = EVEX_Vpcompressd_xmmm128_k1z_xmm ) OR ( Code.Code = EVEX_Vpcompressq_xmmm128_k1z_xmm ) OR + ( Code.Code = VEX_Vpmaskmovd_xmm_xmm_m128 ) OR ( Code.Code = VEX_Vpmaskmovq_xmm_xmm_m128 ) OR ( Code.Code = EVEX_Vpermb_xmm_k1z_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vpermw_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpmaskmovd_m128_xmm_xmm ) OR ( Code.Code = VEX_Vpmaskmovq_m128_xmm_xmm ) OR + ( Code.Code = EVEX_Vpshufbitqmb_kr_k1_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpgatherdd_xmm_vm32x_xmm ) OR ( Code.Code = VEX_Vpgatherdq_xmm_vm32x_xmm ) OR + ( Code.Code = EVEX_Vpgatherdd_xmm_k1_vm32x ) OR ( Code.Code = EVEX_Vpgatherdq_xmm_k1_vm32x ) OR ( Code.Code = VEX_Vpgatherqd_xmm_vm64x_xmm ) OR + ( Code.Code = VEX_Vpgatherqd_xmm_vm64y_xmm ) OR ( Code.Code = VEX_Vpgatherqq_xmm_vm64x_xmm ) OR ( Code.Code = EVEX_Vpgatherqd_xmm_k1_vm64x ) OR + ( Code.Code = EVEX_Vpgatherqd_xmm_k1_vm64y ) OR ( Code.Code = EVEX_Vpgatherqq_xmm_k1_vm64x ) OR ( Code.Code = VEX_Vgatherdps_xmm_vm32x_xmm ) OR + ( Code.Code = VEX_Vgatherdpd_xmm_vm32x_xmm ) OR ( Code.Code = EVEX_Vgatherdps_xmm_k1_vm32x ) OR ( Code.Code = EVEX_Vgatherdpd_xmm_k1_vm32x ) OR + ( Code.Code = VEX_Vgatherqps_xmm_vm64x_xmm ) OR ( Code.Code = VEX_Vgatherqps_xmm_vm64y_xmm ) OR ( Code.Code = VEX_Vgatherqpd_xmm_vm64x_xmm ) OR + ( Code.Code = EVEX_Vgatherqps_xmm_k1_vm64x ) OR ( Code.Code = EVEX_Vgatherqps_xmm_k1_vm64y ) OR ( Code.Code = EVEX_Vgatherqpd_xmm_k1_vm64x ) OR + ( Code.Code = VEX_Vfmaddsub132ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmaddsub132pd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vfmaddsub132ps_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vfmaddsub132pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfmsubadd132ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmsubadd132pd_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vfmsubadd132ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfmsubadd132pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfmadd132ps_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vfmadd132pd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vfmadd132ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfmadd132pd_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = VEX_Vfmadd132ss_xmm_xmm_xmmm32 ) OR ( Code.Code = VEX_Vfmadd132sd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vfmadd132ss_xmm_k1z_xmm_xmmm32_er ) OR + ( Code.Code = EVEX_Vfmadd132sd_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = VEX_Vfmsub132ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmsub132pd_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vfmsub132ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfmsub132pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfmsub132ss_xmm_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vfmsub132sd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vfmsub132ss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfmsub132sd_xmm_k1z_xmm_xmmm64_er ) OR + ( Code.Code = EVEX_V4fmaddss_xmm_k1z_xmmp3_m128 ) OR ( Code.Code = VEX_Vfnmadd132ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfnmadd132pd_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vfnmadd132ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfnmadd132pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfnmadd132ss_xmm_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vfnmadd132sd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vfnmadd132ss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfnmadd132sd_xmm_k1z_xmm_xmmm64_er ) OR + ( Code.Code = VEX_Vfnmsub132ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfnmsub132pd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vfnmsub132ps_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vfnmsub132pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfnmsub132ss_xmm_xmm_xmmm32 ) OR ( Code.Code = VEX_Vfnmsub132sd_xmm_xmm_xmmm64 ) OR + ( Code.Code = EVEX_Vfnmsub132ss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfnmsub132sd_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = EVEX_Vpscatterdd_vm32x_k1_xmm ) OR + ( Code.Code = EVEX_Vpscatterdq_vm32x_k1_xmm ) OR ( Code.Code = EVEX_Vpscatterqd_vm64x_k1_xmm ) OR ( Code.Code = EVEX_Vpscatterqd_vm64y_k1_xmm ) OR + ( Code.Code = EVEX_Vpscatterqq_vm64x_k1_xmm ) OR ( Code.Code = EVEX_Vscatterdps_vm32x_k1_xmm ) OR ( Code.Code = EVEX_Vscatterdpd_vm32x_k1_xmm ) OR + ( Code.Code = EVEX_Vscatterqps_vm64x_k1_xmm ) OR ( Code.Code = EVEX_Vscatterqps_vm64y_k1_xmm ) OR ( Code.Code = EVEX_Vscatterqpd_vm64x_k1_xmm ) OR + ( Code.Code = VEX_Vfmaddsub213ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmaddsub213pd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vfmaddsub213ps_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vfmaddsub213pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfmsubadd213ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmsubadd213pd_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vfmsubadd213ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfmsubadd213pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfmadd213ps_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vfmadd213pd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vfmadd213ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfmadd213pd_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = VEX_Vfmadd213ss_xmm_xmm_xmmm32 ) OR ( Code.Code = VEX_Vfmadd213sd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vfmadd213ss_xmm_k1z_xmm_xmmm32_er ) OR + ( Code.Code = EVEX_Vfmadd213sd_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = VEX_Vfmsub213ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmsub213pd_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vfmsub213ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfmsub213pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfmsub213ss_xmm_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vfmsub213sd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vfmsub213ss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfmsub213sd_xmm_k1z_xmm_xmmm64_er ) OR + ( Code.Code = EVEX_V4fnmaddss_xmm_k1z_xmmp3_m128 ) OR ( Code.Code = VEX_Vfnmadd213ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfnmadd213pd_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vfnmadd213ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfnmadd213pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfnmadd213ss_xmm_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vfnmadd213sd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vfnmadd213ss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfnmadd213sd_xmm_k1z_xmm_xmmm64_er ) OR + ( Code.Code = VEX_Vfnmsub213ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfnmsub213pd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vfnmsub213ps_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vfnmsub213pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfnmsub213ss_xmm_xmm_xmmm32 ) OR ( Code.Code = VEX_Vfnmsub213sd_xmm_xmm_xmmm64 ) OR + ( Code.Code = EVEX_Vfnmsub213ss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfnmsub213sd_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = EVEX_Vpmadd52luq_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = EVEX_Vpmadd52huq_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfmaddsub231ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmaddsub231pd_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vfmaddsub231ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfmaddsub231pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfmsubadd231ps_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vfmsubadd231pd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vfmsubadd231ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfmsubadd231pd_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = VEX_Vfmadd231ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmadd231pd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vfmadd231ps_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vfmadd231pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfmadd231ss_xmm_xmm_xmmm32 ) OR ( Code.Code = VEX_Vfmadd231sd_xmm_xmm_xmmm64 ) OR + ( Code.Code = EVEX_Vfmadd231ss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfmadd231sd_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = VEX_Vfmsub231ps_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vfmsub231pd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vfmsub231ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfmsub231pd_xmm_k1z_xmm_xmmm128b64 ) OR + ( Code.Code = VEX_Vfmsub231ss_xmm_xmm_xmmm32 ) OR ( Code.Code = VEX_Vfmsub231sd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vfmsub231ss_xmm_k1z_xmm_xmmm32_er ) OR + ( Code.Code = EVEX_Vfmsub231sd_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = VEX_Vfnmadd231ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfnmadd231pd_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vfnmadd231ps_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfnmadd231pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfnmadd231ss_xmm_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vfnmadd231sd_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vfnmadd231ss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfnmadd231sd_xmm_k1z_xmm_xmmm64_er ) OR + ( Code.Code = VEX_Vfnmsub231ps_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfnmsub231pd_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vfnmsub231ps_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vfnmsub231pd_xmm_k1z_xmm_xmmm128b64 ) OR ( Code.Code = VEX_Vfnmsub231ss_xmm_xmm_xmmm32 ) OR ( Code.Code = VEX_Vfnmsub231sd_xmm_xmm_xmmm64 ) OR + ( Code.Code = EVEX_Vfnmsub231ss_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfnmsub231sd_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = EVEX_Vpconflictd_xmm_k1z_xmmm128b32 ) OR + ( Code.Code = EVEX_Vpconflictq_xmm_k1z_xmmm128b64 ) OR ( Code.Code = Sha1nexte_xmm_xmmm128 ) OR ( Code.Code = Sha1msg1_xmm_xmmm128 ) OR + ( Code.Code = Sha1msg2_xmm_xmmm128 ) OR ( Code.Code = Sha256rnds2_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vrcp28ss_xmm_k1z_xmm_xmmm32_sae ) OR + ( Code.Code = EVEX_Vrcp28sd_xmm_k1z_xmm_xmmm64_sae ) OR ( Code.Code = Sha256msg1_xmm_xmmm128 ) OR ( Code.Code = Sha256msg2_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vrsqrt28ss_xmm_k1z_xmm_xmmm32_sae ) OR ( Code.Code = EVEX_Vrsqrt28sd_xmm_k1z_xmm_xmmm64_sae ) OR ( Code.Code = Gf2p8mulb_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vgf2p8mulb_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vgf2p8mulb_xmm_k1z_xmm_xmmm128 ) OR ( Code.Code = Aesimc_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vaesimc_xmm_xmmm128 ) OR ( Code.Code = Aesenc_xmm_xmmm128 ) OR ( Code.Code = VEX_Vaesenc_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vaesenc_xmm_xmm_xmmm128 ) OR ( Code.Code = Aesenclast_xmm_xmmm128 ) OR ( Code.Code = VEX_Vaesenclast_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vaesenclast_xmm_xmm_xmmm128 ) OR ( Code.Code = Aesdec_xmm_xmmm128 ) OR ( Code.Code = VEX_Vaesdec_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vaesdec_xmm_xmm_xmmm128 ) OR ( Code.Code = Aesdeclast_xmm_xmmm128 ) OR ( Code.Code = VEX_Vaesdeclast_xmm_xmm_xmmm128 ) OR + ( Code.Code = EVEX_Vaesdeclast_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpblendd_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Valignd_xmm_k1z_xmm_xmmm128b32_imm8 ) OR + ( Code.Code = EVEX_Valignq_xmm_k1z_xmm_xmmm128b64_imm8 ) OR ( Code.Code = VEX_Vpermilps_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vpermilps_xmm_k1z_xmmm128b32_imm8 ) OR + ( Code.Code = VEX_Vpermilpd_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vpermilpd_xmm_k1z_xmmm128b64_imm8 ) OR ( Code.Code = Roundps_xmm_xmmm128_imm8 ) OR + ( Code.Code = VEX_Vroundps_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vrndscaleps_xmm_k1z_xmmm128b32_imm8 ) OR ( Code.Code = Roundpd_xmm_xmmm128_imm8 ) OR + ( Code.Code = VEX_Vroundpd_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vrndscalepd_xmm_k1z_xmmm128b64_imm8 ) OR ( Code.Code = Roundss_xmm_xmmm32_imm8 ) OR + ( Code.Code = VEX_Vroundss_xmm_xmm_xmmm32_imm8 ) OR ( Code.Code = EVEX_Vrndscaless_xmm_k1z_xmm_xmmm32_imm8_sae ) OR ( Code.Code = Roundsd_xmm_xmmm64_imm8 ) OR + ( Code.Code = VEX_Vroundsd_xmm_xmm_xmmm64_imm8 ) OR ( Code.Code = EVEX_Vrndscalesd_xmm_k1z_xmm_xmmm64_imm8_sae ) OR ( Code.Code = Blendps_xmm_xmmm128_imm8 ) OR + ( Code.Code = VEX_Vblendps_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = Blendpd_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vblendpd_xmm_xmm_xmmm128_imm8 ) OR + ( Code.Code = Pblendw_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vpblendw_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = Palignr_xmm_xmmm128_imm8 ) OR + ( Code.Code = VEX_Vpalignr_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vpalignr_xmm_k1z_xmm_xmmm128_imm8 ) OR ( Code.Code = Pextrb_r32m8_xmm_imm8 ) OR + ( Code.Code = Pextrb_r64m8_xmm_imm8 ) OR ( Code.Code = VEX_Vpextrb_r32m8_xmm_imm8 ) OR ( Code.Code = VEX_Vpextrb_r64m8_xmm_imm8 ) OR + ( Code.Code = EVEX_Vpextrb_r32m8_xmm_imm8 ) OR ( Code.Code = EVEX_Vpextrb_r64m8_xmm_imm8 ) OR ( Code.Code = Pextrw_r32m16_xmm_imm8 ) OR + ( Code.Code = Pextrw_r64m16_xmm_imm8 ) OR ( Code.Code = VEX_Vpextrw_r32m16_xmm_imm8 ) OR ( Code.Code = VEX_Vpextrw_r64m16_xmm_imm8 ) OR + ( Code.Code = EVEX_Vpextrw_r32m16_xmm_imm8 ) OR ( Code.Code = EVEX_Vpextrw_r64m16_xmm_imm8 ) OR ( Code.Code = Pextrd_rm32_xmm_imm8 ) OR + ( Code.Code = Pextrq_rm64_xmm_imm8 ) OR ( Code.Code = VEX_Vpextrd_rm32_xmm_imm8 ) OR ( Code.Code = VEX_Vpextrq_rm64_xmm_imm8 ) OR + ( Code.Code = EVEX_Vpextrd_rm32_xmm_imm8 ) OR ( Code.Code = EVEX_Vpextrq_rm64_xmm_imm8 ) OR ( Code.Code = Extractps_rm32_xmm_imm8 ) OR + ( Code.Code = Extractps_r64m32_xmm_imm8 ) OR ( Code.Code = VEX_Vextractps_rm32_xmm_imm8 ) OR ( Code.Code = VEX_Vextractps_r64m32_xmm_imm8 ) OR + ( Code.Code = EVEX_Vextractps_rm32_xmm_imm8 ) OR ( Code.Code = EVEX_Vextractps_r64m32_xmm_imm8 ) OR ( Code.Code = VEX_Vinsertf128_ymm_ymm_xmmm128_imm8 ) OR + ( Code.Code = EVEX_Vinsertf32x4_ymm_k1z_ymm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vinsertf32x4_zmm_k1z_zmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vinsertf64x2_ymm_k1z_ymm_xmmm128_imm8 ) OR + ( Code.Code = EVEX_Vinsertf64x2_zmm_k1z_zmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vextractf128_xmmm128_ymm_imm8 ) OR ( Code.Code = EVEX_Vextractf32x4_xmmm128_k1z_ymm_imm8 ) OR + ( Code.Code = EVEX_Vextractf32x4_xmmm128_k1z_zmm_imm8 ) OR ( Code.Code = EVEX_Vextractf64x2_xmmm128_k1z_ymm_imm8 ) OR ( Code.Code = EVEX_Vextractf64x2_xmmm128_k1z_zmm_imm8 ) OR + ( Code.Code = VEX_Vcvtps2ph_xmmm64_xmm_imm8 ) OR ( Code.Code = VEX_Vcvtps2ph_xmmm128_ymm_imm8 ) OR ( Code.Code = EVEX_Vcvtps2ph_xmmm64_k1z_xmm_imm8 ) OR + ( Code.Code = EVEX_Vcvtps2ph_xmmm128_k1z_ymm_imm8 ) OR ( Code.Code = EVEX_Vpcmpud_kr_k1_xmm_xmmm128b32_imm8 ) OR ( Code.Code = EVEX_Vpcmpuq_kr_k1_xmm_xmmm128b64_imm8 ) OR + ( Code.Code = EVEX_Vpcmpd_kr_k1_xmm_xmmm128b32_imm8 ) OR ( Code.Code = EVEX_Vpcmpq_kr_k1_xmm_xmmm128b64_imm8 ) OR ( Code.Code = Pinsrb_xmm_r32m8_imm8 ) OR + ( Code.Code = Pinsrb_xmm_r64m8_imm8 ) OR ( Code.Code = VEX_Vpinsrb_xmm_xmm_r32m8_imm8 ) OR ( Code.Code = VEX_Vpinsrb_xmm_xmm_r64m8_imm8 ) OR + ( Code.Code = EVEX_Vpinsrb_xmm_xmm_r32m8_imm8 ) OR ( Code.Code = EVEX_Vpinsrb_xmm_xmm_r64m8_imm8 ) OR ( Code.Code = Insertps_xmm_xmmm32_imm8 ) OR + ( Code.Code = VEX_Vinsertps_xmm_xmm_xmmm32_imm8 ) OR ( Code.Code = EVEX_Vinsertps_xmm_xmm_xmmm32_imm8 ) OR ( Code.Code = Pinsrd_xmm_rm32_imm8 ) OR + ( Code.Code = Pinsrq_xmm_rm64_imm8 ) OR ( Code.Code = VEX_Vpinsrd_xmm_xmm_rm32_imm8 ) OR ( Code.Code = VEX_Vpinsrq_xmm_xmm_rm64_imm8 ) OR + ( Code.Code = EVEX_Vpinsrd_xmm_xmm_rm32_imm8 ) OR ( Code.Code = EVEX_Vpinsrq_xmm_xmm_rm64_imm8 ) OR ( Code.Code = EVEX_Vpternlogd_xmm_k1z_xmm_xmmm128b32_imm8 ) OR + ( Code.Code = EVEX_Vpternlogq_xmm_k1z_xmm_xmmm128b64_imm8 ) OR ( Code.Code = EVEX_Vgetmantps_xmm_k1z_xmmm128b32_imm8 ) OR ( Code.Code = EVEX_Vgetmantpd_xmm_k1z_xmmm128b64_imm8 ) OR + ( Code.Code = EVEX_Vgetmantss_xmm_k1z_xmm_xmmm32_imm8_sae ) OR ( Code.Code = EVEX_Vgetmantsd_xmm_k1z_xmm_xmmm64_imm8_sae ) OR ( Code.Code = VEX_Vinserti128_ymm_ymm_xmmm128_imm8 ) OR + ( Code.Code = EVEX_Vinserti32x4_ymm_k1z_ymm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vinserti32x4_zmm_k1z_zmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vinserti64x2_ymm_k1z_ymm_xmmm128_imm8 ) OR + ( Code.Code = EVEX_Vinserti64x2_zmm_k1z_zmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vextracti128_xmmm128_ymm_imm8 ) OR ( Code.Code = EVEX_Vextracti32x4_xmmm128_k1z_ymm_imm8 ) OR + ( Code.Code = EVEX_Vextracti32x4_xmmm128_k1z_zmm_imm8 ) OR ( Code.Code = EVEX_Vextracti64x2_xmmm128_k1z_ymm_imm8 ) OR ( Code.Code = EVEX_Vextracti64x2_xmmm128_k1z_zmm_imm8 ) OR + ( Code.Code = EVEX_Vpcmpub_kr_k1_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vpcmpuw_kr_k1_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vpcmpb_kr_k1_xmm_xmmm128_imm8 ) OR + ( Code.Code = EVEX_Vpcmpw_kr_k1_xmm_xmmm128_imm8 ) OR ( Code.Code = Dpps_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vdpps_xmm_xmm_xmmm128_imm8 ) OR + ( Code.Code = Dppd_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vdppd_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = Mpsadbw_xmm_xmmm128_imm8 ) OR + ( Code.Code = VEX_Vmpsadbw_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vdbpsadbw_xmm_k1z_xmm_xmmm128_imm8 ) OR ( Code.Code = Pclmulqdq_xmm_xmmm128_imm8 ) OR + ( Code.Code = VEX_Vpclmulqdq_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vpclmulqdq_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vpermil2ps_xmm_xmm_xmmm128_xmm_imm4 ) OR + ( Code.Code = VEX_Vpermil2ps_xmm_xmm_xmm_xmmm128_imm4 ) OR ( Code.Code = VEX_Vpermil2pd_xmm_xmm_xmmm128_xmm_imm4 ) OR ( Code.Code = VEX_Vpermil2pd_xmm_xmm_xmm_xmmm128_imm4 ) OR + ( Code.Code = VEX_Vblendvps_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = VEX_Vblendvpd_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = VEX_Vpblendvb_xmm_xmm_xmmm128_xmm ) OR + ( Code.Code = EVEX_Vrangeps_xmm_k1z_xmm_xmmm128b32_imm8 ) OR ( Code.Code = EVEX_Vrangepd_xmm_k1z_xmm_xmmm128b64_imm8 ) OR ( Code.Code = EVEX_Vrangess_xmm_k1z_xmm_xmmm32_imm8_sae ) OR + ( Code.Code = EVEX_Vrangesd_xmm_k1z_xmm_xmmm64_imm8_sae ) OR ( Code.Code = EVEX_Vfixupimmps_xmm_k1z_xmm_xmmm128b32_imm8 ) OR ( Code.Code = EVEX_Vfixupimmpd_xmm_k1z_xmm_xmmm128b64_imm8 ) OR + ( Code.Code = EVEX_Vfixupimmss_xmm_k1z_xmm_xmmm32_imm8_sae ) OR ( Code.Code = EVEX_Vfixupimmsd_xmm_k1z_xmm_xmmm64_imm8_sae ) OR ( Code.Code = EVEX_Vreduceps_xmm_k1z_xmmm128b32_imm8 ) OR + ( Code.Code = EVEX_Vreducepd_xmm_k1z_xmmm128b64_imm8 ) OR ( Code.Code = EVEX_Vreducess_xmm_k1z_xmm_xmmm32_imm8_sae ) OR ( Code.Code = EVEX_Vreducesd_xmm_k1z_xmm_xmmm64_imm8_sae ) OR + ( Code.Code = VEX_Vfmaddsubps_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = VEX_Vfmaddsubps_xmm_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmaddsubpd_xmm_xmm_xmmm128_xmm ) OR + ( Code.Code = VEX_Vfmaddsubpd_xmm_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmsubaddps_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = VEX_Vfmsubaddps_xmm_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vfmsubaddpd_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = VEX_Vfmsubaddpd_xmm_xmm_xmm_xmmm128 ) OR ( Code.Code = Pcmpestrm_xmm_xmmm128_imm8 ) OR + ( Code.Code = Pcmpestrm64_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vpcmpestrm_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vpcmpestrm64_xmm_xmmm128_imm8 ) OR + ( Code.Code = Pcmpestri_xmm_xmmm128_imm8 ) OR ( Code.Code = Pcmpestri64_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vpcmpestri_xmm_xmmm128_imm8 ) OR + ( Code.Code = VEX_Vpcmpestri64_xmm_xmmm128_imm8 ) OR ( Code.Code = Pcmpistrm_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vpcmpistrm_xmm_xmmm128_imm8 ) OR + ( Code.Code = Pcmpistri_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vpcmpistri_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vfpclassps_kr_k1_xmmm128b32_imm8 ) OR + ( Code.Code = EVEX_Vfpclasspd_kr_k1_xmmm128b64_imm8 ) OR ( Code.Code = EVEX_Vfpclassss_kr_k1_xmmm32_imm8 ) OR ( Code.Code = EVEX_Vfpclasssd_kr_k1_xmmm64_imm8 ) OR + ( Code.Code = VEX_Vfmaddps_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = VEX_Vfmaddps_xmm_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmaddpd_xmm_xmm_xmmm128_xmm ) OR + ( Code.Code = VEX_Vfmaddpd_xmm_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmaddss_xmm_xmm_xmmm32_xmm ) OR ( Code.Code = VEX_Vfmaddss_xmm_xmm_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vfmaddsd_xmm_xmm_xmmm64_xmm ) OR ( Code.Code = VEX_Vfmaddsd_xmm_xmm_xmm_xmmm64 ) OR ( Code.Code = VEX_Vfmsubps_xmm_xmm_xmmm128_xmm ) OR + ( Code.Code = VEX_Vfmsubps_xmm_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfmsubpd_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = VEX_Vfmsubpd_xmm_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vfmsubss_xmm_xmm_xmmm32_xmm ) OR ( Code.Code = VEX_Vfmsubss_xmm_xmm_xmm_xmmm32 ) OR ( Code.Code = VEX_Vfmsubsd_xmm_xmm_xmmm64_xmm ) OR + ( Code.Code = VEX_Vfmsubsd_xmm_xmm_xmm_xmmm64 ) OR ( Code.Code = EVEX_Vpshldw_xmm_k1z_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vpshldd_xmm_k1z_xmm_xmmm128b32_imm8 ) OR + ( Code.Code = EVEX_Vpshldq_xmm_k1z_xmm_xmmm128b64_imm8 ) OR ( Code.Code = EVEX_Vpshrdw_xmm_k1z_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vpshrdd_xmm_k1z_xmm_xmmm128b32_imm8 ) OR + ( Code.Code = EVEX_Vpshrdq_xmm_k1z_xmm_xmmm128b64_imm8 ) OR ( Code.Code = VEX_Vfnmaddps_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = VEX_Vfnmaddps_xmm_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vfnmaddpd_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = VEX_Vfnmaddpd_xmm_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfnmaddss_xmm_xmm_xmmm32_xmm ) OR + ( Code.Code = VEX_Vfnmaddss_xmm_xmm_xmm_xmmm32 ) OR ( Code.Code = VEX_Vfnmaddsd_xmm_xmm_xmmm64_xmm ) OR ( Code.Code = VEX_Vfnmaddsd_xmm_xmm_xmm_xmmm64 ) OR + ( Code.Code = VEX_Vfnmsubps_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = VEX_Vfnmsubps_xmm_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfnmsubpd_xmm_xmm_xmmm128_xmm ) OR + ( Code.Code = VEX_Vfnmsubpd_xmm_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vfnmsubss_xmm_xmm_xmmm32_xmm ) OR ( Code.Code = VEX_Vfnmsubss_xmm_xmm_xmm_xmmm32 ) OR + ( Code.Code = VEX_Vfnmsubsd_xmm_xmm_xmmm64_xmm ) OR ( Code.Code = VEX_Vfnmsubsd_xmm_xmm_xmm_xmmm64 ) OR ( Code.Code = Sha1rnds4_xmm_xmmm128_imm8 ) OR + ( Code.Code = Gf2p8affineqb_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vgf2p8affineqb_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vgf2p8affineqb_xmm_k1z_xmm_xmmm128b64_imm8 ) OR + ( Code.Code = Gf2p8affineinvqb_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vgf2p8affineinvqb_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = EVEX_Vgf2p8affineinvqb_xmm_k1z_xmm_xmmm128b64_imm8 ) OR + ( Code.Code = Aeskeygenassist_xmm_xmmm128_imm8 ) OR ( Code.Code = VEX_Vaeskeygenassist_xmm_xmmm128_imm8 ) OR ( Code.Code = XOP_Vpmacssww_xmm_xmm_xmmm128_xmm ) OR + ( Code.Code = XOP_Vpmacsswd_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpmacssdql_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpmacssdd_xmm_xmm_xmmm128_xmm ) OR + ( Code.Code = XOP_Vpmacssdqh_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpmacsww_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpmacswd_xmm_xmm_xmmm128_xmm ) OR + ( Code.Code = XOP_Vpmacsdql_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpmacsdd_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpmacsdqh_xmm_xmm_xmmm128_xmm ) OR + ( Code.Code = XOP_Vpcmov_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpcmov_xmm_xmm_xmm_xmmm128 ) OR ( Code.Code = XOP_Vpperm_xmm_xmm_xmmm128_xmm ) OR + ( Code.Code = XOP_Vpperm_xmm_xmm_xmm_xmmm128 ) OR ( Code.Code = XOP_Vpmadcsswd_xmm_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpmadcswd_xmm_xmm_xmmm128_xmm ) OR + ( Code.Code = XOP_Vprotb_xmm_xmmm128_imm8 ) OR ( Code.Code = XOP_Vprotw_xmm_xmmm128_imm8 ) OR ( Code.Code = XOP_Vprotd_xmm_xmmm128_imm8 ) OR + ( Code.Code = XOP_Vprotq_xmm_xmmm128_imm8 ) OR ( Code.Code = XOP_Vpcomb_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = XOP_Vpcomw_xmm_xmm_xmmm128_imm8 ) OR + ( Code.Code = XOP_Vpcomd_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = XOP_Vpcomq_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = XOP_Vpcomub_xmm_xmm_xmmm128_imm8 ) OR + ( Code.Code = XOP_Vpcomuw_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = XOP_Vpcomud_xmm_xmm_xmmm128_imm8 ) OR ( Code.Code = XOP_Vpcomuq_xmm_xmm_xmmm128_imm8 ) OR + ( Code.Code = XOP_Vfrczps_xmm_xmmm128 ) OR ( Code.Code = XOP_Vfrczpd_xmm_xmmm128 ) OR ( Code.Code = XOP_Vfrczss_xmm_xmmm32 ) OR + ( Code.Code = XOP_Vfrczsd_xmm_xmmm64 ) OR ( Code.Code = XOP_Vprotb_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vprotb_xmm_xmm_xmmm128 ) OR + ( Code.Code = XOP_Vprotw_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vprotw_xmm_xmm_xmmm128 ) OR ( Code.Code = XOP_Vprotd_xmm_xmmm128_xmm ) OR + ( Code.Code = XOP_Vprotd_xmm_xmm_xmmm128 ) OR ( Code.Code = XOP_Vprotq_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vprotq_xmm_xmm_xmmm128 ) OR + ( Code.Code = XOP_Vpshlb_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpshlb_xmm_xmm_xmmm128 ) OR ( Code.Code = XOP_Vpshlw_xmm_xmmm128_xmm ) OR + ( Code.Code = XOP_Vpshlw_xmm_xmm_xmmm128 ) OR ( Code.Code = XOP_Vpshld_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpshld_xmm_xmm_xmmm128 ) OR + ( Code.Code = XOP_Vpshlq_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpshlq_xmm_xmm_xmmm128 ) OR ( Code.Code = XOP_Vpshab_xmm_xmmm128_xmm ) OR + ( Code.Code = XOP_Vpshab_xmm_xmm_xmmm128 ) OR ( Code.Code = XOP_Vpshaw_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpshaw_xmm_xmm_xmmm128 ) OR + ( Code.Code = XOP_Vpshad_xmm_xmmm128_xmm ) OR ( Code.Code = XOP_Vpshad_xmm_xmm_xmmm128 ) OR ( Code.Code = XOP_Vpshaq_xmm_xmmm128_xmm ) OR + ( Code.Code = XOP_Vpshaq_xmm_xmm_xmmm128 ) OR ( Code.Code = XOP_Vphaddbw_xmm_xmmm128 ) OR ( Code.Code = XOP_Vphaddbd_xmm_xmmm128 ) OR + ( Code.Code = XOP_Vphaddbq_xmm_xmmm128 ) OR ( Code.Code = XOP_Vphaddwd_xmm_xmmm128 ) OR ( Code.Code = XOP_Vphaddwq_xmm_xmmm128 ) OR + ( Code.Code = XOP_Vphadddq_xmm_xmmm128 ) OR ( Code.Code = XOP_Vphaddubw_xmm_xmmm128 ) OR ( Code.Code = XOP_Vphaddubd_xmm_xmmm128 ) OR + ( Code.Code = XOP_Vphaddubq_xmm_xmmm128 ) OR ( Code.Code = XOP_Vphadduwd_xmm_xmmm128 ) OR ( Code.Code = XOP_Vphadduwq_xmm_xmmm128 ) OR + ( Code.Code = XOP_Vphaddudq_xmm_xmmm128 ) OR ( Code.Code = XOP_Vphsubbw_xmm_xmmm128 ) OR ( Code.Code = XOP_Vphsubwd_xmm_xmmm128 ) OR + ( Code.Code = XOP_Vphsubdq_xmm_xmmm128 ) OR ( Code.Code = Loadiwkey_xmm_xmm ) OR ( Code.Code = Aesenc128kl_xmm_m384 ) OR + ( Code.Code = Aesdec128kl_xmm_m384 ) OR ( Code.Code = Aesenc256kl_xmm_m512 ) OR ( Code.Code = Aesdec256kl_xmm_m512 ) OR + ( Code.Code = VEX_Vbroadcastss_xmm_xmm ) OR ( Code.Code = VEX_Vbroadcastss_ymm_xmm ) OR ( Code.Code = VEX_Vbroadcastsd_ymm_xmm ) OR + ( Code.Code = VEX_Vpdpbusd_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpdpbusds_xmm_xmm_xmmm128 ) OR ( Code.Code = VEX_Vpdpwssd_xmm_xmm_xmmm128 ) OR + ( Code.Code = VEX_Vpdpwssds_xmm_xmm_xmmm128 ) OR ( Code.Code = EVEX_Vaddph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vaddsh_xmm_k1z_xmm_xmmm16_er ) OR + ( Code.Code = EVEX_Vcmpph_kr_k1_xmm_xmmm128b16_imm8 ) OR ( Code.Code = EVEX_Vcmpsh_kr_k1_xmm_xmmm16_imm8_sae ) OR ( Code.Code = EVEX_Vcomish_xmm_xmmm16_sae ) OR + ( Code.Code = EVEX_Vcvtdq2ph_xmm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vcvtdq2ph_xmm_k1z_ymmm256b32 ) OR ( Code.Code = EVEX_Vcvtpd2ph_xmm_k1z_xmmm128b64 ) OR + ( Code.Code = EVEX_Vcvtpd2ph_xmm_k1z_ymmm256b64 ) OR ( Code.Code = EVEX_Vcvtpd2ph_xmm_k1z_zmmm512b64_er ) OR ( Code.Code = EVEX_Vcvtph2dq_xmm_k1z_xmmm64b16 ) OR + ( Code.Code = EVEX_Vcvtph2dq_ymm_k1z_xmmm128b16 ) OR ( Code.Code = EVEX_Vcvtph2pd_xmm_k1z_xmmm32b16 ) OR ( Code.Code = EVEX_Vcvtph2pd_ymm_k1z_xmmm64b16 ) OR + ( Code.Code = EVEX_Vcvtph2pd_zmm_k1z_xmmm128b16_sae ) OR ( Code.Code = EVEX_Vcvtph2psx_xmm_k1z_xmmm64b16 ) OR ( Code.Code = EVEX_Vcvtph2psx_ymm_k1z_xmmm128b16 ) OR + ( Code.Code = EVEX_Vcvtph2qq_xmm_k1z_xmmm32b16 ) OR ( Code.Code = EVEX_Vcvtph2qq_ymm_k1z_xmmm64b16 ) OR ( Code.Code = EVEX_Vcvtph2qq_zmm_k1z_xmmm128b16_er ) OR + ( Code.Code = EVEX_Vcvtph2udq_xmm_k1z_xmmm64b16 ) OR ( Code.Code = EVEX_Vcvtph2udq_ymm_k1z_xmmm128b16 ) OR ( Code.Code = EVEX_Vcvtph2uqq_xmm_k1z_xmmm32b16 ) OR + ( Code.Code = EVEX_Vcvtph2uqq_ymm_k1z_xmmm64b16 ) OR ( Code.Code = EVEX_Vcvtph2uqq_zmm_k1z_xmmm128b16_er ) OR ( Code.Code = EVEX_Vcvtph2uw_xmm_k1z_xmmm128b16 ) OR + ( Code.Code = EVEX_Vcvtph2w_xmm_k1z_xmmm128b16 ) OR ( Code.Code = EVEX_Vcvtps2phx_xmm_k1z_xmmm128b32 ) OR ( Code.Code = EVEX_Vcvtps2phx_xmm_k1z_ymmm256b32 ) OR + ( Code.Code = EVEX_Vcvtqq2ph_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vcvtqq2ph_xmm_k1z_ymmm256b64 ) OR ( Code.Code = EVEX_Vcvtqq2ph_xmm_k1z_zmmm512b64_er ) OR + ( Code.Code = EVEX_Vcvtsd2sh_xmm_k1z_xmm_xmmm64_er ) OR ( Code.Code = EVEX_Vcvtsh2sd_xmm_k1z_xmm_xmmm16_sae ) OR ( Code.Code = EVEX_Vcvtsh2si_r32_xmmm16_er ) OR + ( Code.Code = EVEX_Vcvtsh2si_r64_xmmm16_er ) OR ( Code.Code = EVEX_Vcvtsh2ss_xmm_k1z_xmm_xmmm16_sae ) OR ( Code.Code = EVEX_Vcvtsh2usi_r32_xmmm16_er ) OR + ( Code.Code = EVEX_Vcvtsh2usi_r64_xmmm16_er ) OR ( Code.Code = EVEX_Vcvtsi2sh_xmm_xmm_rm32_er ) OR ( Code.Code = EVEX_Vcvtsi2sh_xmm_xmm_rm64_er ) OR + ( Code.Code = EVEX_Vcvtss2sh_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vcvttph2dq_xmm_k1z_xmmm64b16 ) OR ( Code.Code = EVEX_Vcvttph2dq_ymm_k1z_xmmm128b16 ) OR + ( Code.Code = EVEX_Vcvttph2qq_xmm_k1z_xmmm32b16 ) OR ( Code.Code = EVEX_Vcvttph2qq_ymm_k1z_xmmm64b16 ) OR ( Code.Code = EVEX_Vcvttph2qq_zmm_k1z_xmmm128b16_sae ) OR + ( Code.Code = EVEX_Vcvttph2udq_xmm_k1z_xmmm64b16 ) OR ( Code.Code = EVEX_Vcvttph2udq_ymm_k1z_xmmm128b16 ) OR ( Code.Code = EVEX_Vcvttph2uqq_xmm_k1z_xmmm32b16 ) OR + ( Code.Code = EVEX_Vcvttph2uqq_ymm_k1z_xmmm64b16 ) OR ( Code.Code = EVEX_Vcvttph2uqq_zmm_k1z_xmmm128b16_sae ) OR ( Code.Code = EVEX_Vcvttph2uw_xmm_k1z_xmmm128b16 ) OR + ( Code.Code = EVEX_Vcvttph2w_xmm_k1z_xmmm128b16 ) OR ( Code.Code = EVEX_Vcvttsh2si_r32_xmmm16_sae ) OR ( Code.Code = EVEX_Vcvttsh2si_r64_xmmm16_sae ) OR + ( Code.Code = EVEX_Vcvttsh2usi_r32_xmmm16_sae ) OR ( Code.Code = EVEX_Vcvttsh2usi_r64_xmmm16_sae ) OR ( Code.Code = EVEX_Vcvtudq2ph_xmm_k1z_xmmm128b32 ) OR + ( Code.Code = EVEX_Vcvtudq2ph_xmm_k1z_ymmm256b32 ) OR ( Code.Code = EVEX_Vcvtuqq2ph_xmm_k1z_xmmm128b64 ) OR ( Code.Code = EVEX_Vcvtuqq2ph_xmm_k1z_ymmm256b64 ) OR + ( Code.Code = EVEX_Vcvtuqq2ph_xmm_k1z_zmmm512b64_er ) OR ( Code.Code = EVEX_Vcvtusi2sh_xmm_xmm_rm32_er ) OR ( Code.Code = EVEX_Vcvtusi2sh_xmm_xmm_rm64_er ) OR + ( Code.Code = EVEX_Vcvtuw2ph_xmm_k1z_xmmm128b16 ) OR ( Code.Code = EVEX_Vcvtw2ph_xmm_k1z_xmmm128b16 ) OR ( Code.Code = EVEX_Vdivph_xmm_k1z_xmm_xmmm128b16 ) OR + ( Code.Code = EVEX_Vdivsh_xmm_k1z_xmm_xmmm16_er ) OR ( Code.Code = EVEX_Vfcmaddcph_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfmaddcph_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vfcmaddcsh_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfmaddcsh_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfcmulcph_xmm_k1z_xmm_xmmm128b32 ) OR + ( Code.Code = EVEX_Vfmulcph_xmm_k1z_xmm_xmmm128b32 ) OR ( Code.Code = EVEX_Vfcmulcsh_xmm_k1z_xmm_xmmm32_er ) OR ( Code.Code = EVEX_Vfmulcsh_xmm_k1z_xmm_xmmm32_er ) OR + ( Code.Code = EVEX_Vfmaddsub132ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfmaddsub213ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfmaddsub231ph_xmm_k1z_xmm_xmmm128b16 ) OR + ( Code.Code = EVEX_Vfmsubadd132ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfmsubadd213ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfmsubadd231ph_xmm_k1z_xmm_xmmm128b16 ) OR + ( Code.Code = EVEX_Vfmadd132ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfmadd213ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfmadd231ph_xmm_k1z_xmm_xmmm128b16 ) OR + ( Code.Code = EVEX_Vfnmadd132ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfnmadd213ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfnmadd231ph_xmm_k1z_xmm_xmmm128b16 ) OR + ( Code.Code = EVEX_Vfmadd132sh_xmm_k1z_xmm_xmmm16_er ) OR ( Code.Code = EVEX_Vfmadd213sh_xmm_k1z_xmm_xmmm16_er ) OR ( Code.Code = EVEX_Vfmadd231sh_xmm_k1z_xmm_xmmm16_er ) OR + ( Code.Code = EVEX_Vfnmadd132sh_xmm_k1z_xmm_xmmm16_er ) OR ( Code.Code = EVEX_Vfnmadd213sh_xmm_k1z_xmm_xmmm16_er ) OR ( Code.Code = EVEX_Vfnmadd231sh_xmm_k1z_xmm_xmmm16_er ) OR + ( Code.Code = EVEX_Vfmsub132ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfmsub213ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfmsub231ph_xmm_k1z_xmm_xmmm128b16 ) OR + ( Code.Code = EVEX_Vfnmsub132ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfnmsub213ph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vfnmsub231ph_xmm_k1z_xmm_xmmm128b16 ) OR + ( Code.Code = EVEX_Vfmsub132sh_xmm_k1z_xmm_xmmm16_er ) OR ( Code.Code = EVEX_Vfmsub213sh_xmm_k1z_xmm_xmmm16_er ) OR ( Code.Code = EVEX_Vfmsub231sh_xmm_k1z_xmm_xmmm16_er ) OR + ( Code.Code = EVEX_Vfnmsub132sh_xmm_k1z_xmm_xmmm16_er ) OR ( Code.Code = EVEX_Vfnmsub213sh_xmm_k1z_xmm_xmmm16_er ) OR ( Code.Code = EVEX_Vfnmsub231sh_xmm_k1z_xmm_xmmm16_er ) OR + ( Code.Code = EVEX_Vfpclassph_kr_k1_xmmm128b16_imm8 ) OR ( Code.Code = EVEX_Vfpclasssh_kr_k1_xmmm16_imm8 ) OR ( Code.Code = EVEX_Vgetexpph_xmm_k1z_xmmm128b16 ) OR + ( Code.Code = EVEX_Vgetexpsh_xmm_k1z_xmm_xmmm16_sae ) OR ( Code.Code = EVEX_Vgetmantph_xmm_k1z_xmmm128b16_imm8 ) OR ( Code.Code = EVEX_Vgetmantsh_xmm_k1z_xmm_xmmm16_imm8_sae ) OR + ( Code.Code = EVEX_Vmaxph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vmaxsh_xmm_k1z_xmm_xmmm16_sae ) OR ( Code.Code = EVEX_Vminph_xmm_k1z_xmm_xmmm128b16 ) OR + ( Code.Code = EVEX_Vminsh_xmm_k1z_xmm_xmmm16_sae ) OR ( Code.Code = EVEX_Vmovsh_xmm_k1z_m16 ) OR ( Code.Code = EVEX_Vmovsh_m16_k1_xmm ) OR + ( Code.Code = EVEX_Vmovsh_xmm_k1z_xmm_xmm ) OR ( Code.Code = EVEX_Vmovsh_xmm_k1z_xmm_xmm_MAP5_11 ) OR ( Code.Code = EVEX_Vmovw_xmm_r32m16 ) OR + ( Code.Code = EVEX_Vmovw_xmm_r64m16 ) OR ( Code.Code = EVEX_Vmovw_r32m16_xmm ) OR ( Code.Code = EVEX_Vmovw_r64m16_xmm ) OR + ( Code.Code = EVEX_Vmulph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vmulsh_xmm_k1z_xmm_xmmm16_er ) OR ( Code.Code = EVEX_Vrcpph_xmm_k1z_xmmm128b16 ) OR + ( Code.Code = EVEX_Vrcpsh_xmm_k1z_xmm_xmmm16 ) OR ( Code.Code = EVEX_Vreduceph_xmm_k1z_xmmm128b16_imm8 ) OR ( Code.Code = EVEX_Vreducesh_xmm_k1z_xmm_xmmm16_imm8_sae ) OR + ( Code.Code = EVEX_Vrndscaleph_xmm_k1z_xmmm128b16_imm8 ) OR ( Code.Code = EVEX_Vrndscalesh_xmm_k1z_xmm_xmmm16_imm8_sae ) OR ( Code.Code = EVEX_Vrsqrtph_xmm_k1z_xmmm128b16 ) OR + ( Code.Code = EVEX_Vrsqrtsh_xmm_k1z_xmm_xmmm16 ) OR ( Code.Code = EVEX_Vscalefph_xmm_k1z_xmm_xmmm128b16 ) OR ( Code.Code = EVEX_Vscalefsh_xmm_k1z_xmm_xmmm16_er ) OR + ( Code.Code = EVEX_Vsqrtph_xmm_k1z_xmmm128b16 ) OR ( Code.Code = EVEX_Vsqrtsh_xmm_k1z_xmm_xmmm16_er ) OR ( Code.Code = EVEX_Vsubph_xmm_k1z_xmm_xmmm128b16 ) OR + ( Code.Code = EVEX_Vsubsh_xmm_k1z_xmm_xmmm16_er ) then + result := True + else + result := False; +end; + +function TInstruction.IsFloat64 : Boolean; +begin + if( Code.Code = Cvtsi2ss_xmm_rm64 ) OR + ( Code.Code = VEX_Vcvtsi2ss_xmm_xmm_rm64 ) OR + ( Code.Code = EVEX_Vcvtsi2ss_xmm_xmm_rm64_er ) OR + ( Code.Code = Cvtsi2sd_xmm_rm64 ) OR + ( Code.Code = VEX_Vcvtsi2sd_xmm_xmm_rm64 ) OR + ( Code.Code = EVEX_Vcvtsi2sd_xmm_xmm_rm64_er ) OR + ( Code.Code = Cvttss2si_r64_xmmm32 ) OR + ( Code.Code = VEX_Vcvttss2si_r64_xmmm32 ) OR + ( Code.Code = EVEX_Vcvttss2si_r64_xmmm32_sae ) OR + ( Code.Code = Cvttsd2si_r64_xmmm64 ) OR + ( Code.Code = VEX_Vcvttsd2si_r64_xmmm64 ) OR + ( Code.Code = EVEX_Vcvttsd2si_r64_xmmm64_sae ) OR + ( Code.Code = Cvtss2si_r64_xmmm32 ) OR + ( Code.Code = VEX_Vcvtss2si_r64_xmmm32 ) OR + ( Code.Code = EVEX_Vcvtss2si_r64_xmmm32_er ) OR + ( Code.Code = Cvtsd2si_r64_xmmm64 ) OR + ( Code.Code = VEX_Vcvtsd2si_r64_xmmm64 ) OR + ( Code.Code = EVEX_Vcvtsd2si_r64_xmmm64_er ) OR + ( Code.Code = Movmskps_r64_xmm ) OR + ( Code.Code = VEX_Vmovmskps_r64_xmm ) OR + ( Code.Code = Movmskpd_r64_xmm ) OR + ( Code.Code = VEX_Vmovmskpd_r64_xmm ) OR + ( Code.Code = Movq_xmm_rm64 ) OR + ( Code.Code = VEX_Vmovq_xmm_rm64 ) OR + ( Code.Code = EVEX_Vmovq_xmm_rm64 ) OR + ( Code.Code = EVEX_Vcvttss2usi_r64_xmmm32_sae ) OR + ( Code.Code = EVEX_Vcvttsd2usi_r64_xmmm64_sae ) OR + ( Code.Code = EVEX_Vcvtss2usi_r64_xmmm32_er ) OR + ( Code.Code = EVEX_Vcvtsd2usi_r64_xmmm64_er ) OR + ( Code.Code = EVEX_Vcvtusi2ss_xmm_xmm_rm64_er ) OR + ( Code.Code = EVEX_Vcvtusi2sd_xmm_xmm_rm64_er ) OR + ( Code.Code = Movq_rm64_xmm ) OR + ( Code.Code = VEX_Vmovq_rm64_xmm ) OR + ( Code.Code = EVEX_Vmovq_rm64_xmm ) OR + ( Code.Code = Pinsrw_xmm_r64m16_imm8 ) OR + ( Code.Code = VEX_Vpinsrw_xmm_xmm_r64m16_imm8 ) OR + ( Code.Code = EVEX_Vpinsrw_xmm_xmm_r64m16_imm8 ) OR + ( Code.Code = Pextrw_r64_xmm_imm8 ) OR + ( Code.Code = VEX_Vpextrw_r64_xmm_imm8 ) OR + ( Code.Code = EVEX_Vpextrw_r64_xmm_imm8 ) OR + ( Code.Code = Pmovmskb_r64_xmm ) OR + ( Code.Code = VEX_Vpmovmskb_r64_xmm ) OR + ( Code.Code = EVEX_Vpbroadcastq_xmm_k1z_r64 ) OR + ( Code.Code = Pextrb_r64m8_xmm_imm8 ) OR + ( Code.Code = VEX_Vpextrb_r64m8_xmm_imm8 ) OR + ( Code.Code = EVEX_Vpextrb_r64m8_xmm_imm8 ) OR + ( Code.Code = Pextrw_r64m16_xmm_imm8 ) OR + ( Code.Code = VEX_Vpextrw_r64m16_xmm_imm8 ) OR + ( Code.Code = EVEX_Vpextrw_r64m16_xmm_imm8 ) OR + ( Code.Code = Pextrq_rm64_xmm_imm8 ) OR + ( Code.Code = VEX_Vpextrq_rm64_xmm_imm8 ) OR + ( Code.Code = EVEX_Vpextrq_rm64_xmm_imm8 ) OR + ( Code.Code = Extractps_r64m32_xmm_imm8 ) OR + ( Code.Code = VEX_Vextractps_r64m32_xmm_imm8 ) OR + ( Code.Code = EVEX_Vextractps_r64m32_xmm_imm8 ) OR + ( Code.Code = Pinsrb_xmm_r64m8_imm8 ) OR + ( Code.Code = VEX_Vpinsrb_xmm_xmm_r64m8_imm8 ) OR + ( Code.Code = EVEX_Vpinsrb_xmm_xmm_r64m8_imm8 ) OR + ( Code.Code = Pinsrq_xmm_rm64_imm8 ) OR + ( Code.Code = VEX_Vpinsrq_xmm_xmm_rm64_imm8 ) OR + ( Code.Code = EVEX_Vpinsrq_xmm_xmm_rm64_imm8 ) OR + ( Code.Code = Pcmpestrm64_xmm_xmmm128_imm8 ) OR + ( Code.Code = VEX_Vpcmpestrm64_xmm_xmmm128_imm8 ) OR + ( Code.Code = Pcmpestri64_xmm_xmmm128_imm8 ) OR + ( Code.Code = VEX_Vpcmpestri64_xmm_xmmm128_imm8 ) OR + ( Code.Code = EVEX_Vcvtsh2si_r64_xmmm16_er ) OR + ( Code.Code = EVEX_Vcvtsh2usi_r64_xmmm16_er ) OR + ( Code.Code = EVEX_Vcvtsi2sh_xmm_xmm_rm64_er ) OR + ( Code.Code = EVEX_Vcvttsh2si_r64_xmmm16_sae ) OR + ( Code.Code = EVEX_Vcvttsh2usi_r64_xmmm16_sae ) OR + ( Code.Code = EVEX_Vcvtusi2sh_xmm_xmm_rm64_er ) OR + ( Code.Code = EVEX_Vmovw_xmm_r64m16 ) then + result := True + else + result := False; +end; + +function TInstruction.FPU_StackIncrementInfo : TFpuStackIncrementInfo; +begin + Instruction_FPU_StackIncrementInfo( self, result ); +end; + +function TInstruction.Encoding : TEncodingKind; +begin + result := Code.Encoding; +end; + +function TInstruction.Mnemonic : TMnemonic; +begin + result := Code.Mnemonic; +end; + +function TInstruction.CPUIDFeatures : TCPUIDFeaturesArray; +begin + result := Code.CPUidFeature +end; + +function TInstruction.IsStackInstruction : Boolean; +begin + result := Code.IsStackInstruction; +end; + +function TInstruction.StackPointerIncrement : Integer; +begin + result := Instruction_StackPointerIncrement( self ); +end; + +function TInstruction.ConditionCode : TConditionCode; +begin + result := Code.ConditionCode; +end; + +function TInstruction.RFlagsRead : TRFlag{Cardinal}; +begin + result := Instruction_RFlagsRead( self ); +end; + +function TInstruction.RFlagsWritten : TRFlag{Cardinal}; +begin + result := Instruction_RFlagsWritten( self ); +end; + +function TInstruction.RFlagsCleared : TRFlag{Cardinal}; +begin + result := Instruction_RFlagsCleared( self ); +end; + +function TInstruction.RFlagsSet : TRFlag{Cardinal}; +begin + result := Instruction_RFlagsSet( self ); +end; + +function TInstruction.RFlagsUndefined : TRFlag{Cardinal}; +begin + result := Instruction_RFlagsUndefined( self ); +end; + +function TInstruction.RFlagsModified : TRFlag{Cardinal}; +begin + result := Instruction_RFlagsModified( self ); +end; + +function TInstruction.RFlags : TRFlags; +begin + result.Read := RFlagsRead; + result.Written := RFlagsWritten; + result.Cleared := RFlagsCleared; + result.Set_ := RFlagsSet; + result.Undefined := RFlagsUndefined; + result.Modified := RFlagsModified; +end; + +function TInstruction.FlowControl : TFlowControl; +begin + result := Code.FlowControl; +end; + +function TInstruction.OPKinds( var OPKindsArray : TOPKindsArray ) : TFlowControl; +begin + result := Instruction_OPKinds( self, OPKindsArray ); +end; + +function TInstruction.MemorySize : TMemorySize; +begin + result := Instruction_MemorySize( self ); +end; + +function TInstruction.OPCount : Cardinal; +begin + result := Instruction_OPCount( self ); +end; + +function TInstruction.VSIB : Integer; +begin + if ( Code.Code = VEX_Vpgatherdd_xmm_vm32x_xmm ) OR + ( Code.Code = VEX_Vpgatherdd_ymm_vm32y_ymm ) OR + ( Code.Code = VEX_Vpgatherdq_xmm_vm32x_xmm ) OR + ( Code.Code = VEX_Vpgatherdq_ymm_vm32x_ymm ) OR + ( Code.Code = EVEX_Vpgatherdd_xmm_k1_vm32x ) OR + ( Code.Code = EVEX_Vpgatherdd_ymm_k1_vm32y ) OR + ( Code.Code = EVEX_Vpgatherdd_zmm_k1_vm32z ) OR + ( Code.Code = EVEX_Vpgatherdq_xmm_k1_vm32x ) OR + ( Code.Code = EVEX_Vpgatherdq_ymm_k1_vm32x ) OR + ( Code.Code = EVEX_Vpgatherdq_zmm_k1_vm32y ) OR + ( Code.Code = VEX_Vgatherdps_xmm_vm32x_xmm ) OR + ( Code.Code = VEX_Vgatherdps_ymm_vm32y_ymm ) OR + ( Code.Code = VEX_Vgatherdpd_xmm_vm32x_xmm ) OR + ( Code.Code = VEX_Vgatherdpd_ymm_vm32x_ymm ) OR + ( Code.Code = EVEX_Vgatherdps_xmm_k1_vm32x ) OR + ( Code.Code = EVEX_Vgatherdps_ymm_k1_vm32y ) OR + ( Code.Code = EVEX_Vgatherdps_zmm_k1_vm32z ) OR + ( Code.Code = EVEX_Vgatherdpd_xmm_k1_vm32x ) OR + ( Code.Code = EVEX_Vgatherdpd_ymm_k1_vm32x ) OR + ( Code.Code = EVEX_Vgatherdpd_zmm_k1_vm32y ) OR + ( Code.Code = EVEX_Vpscatterdd_vm32x_k1_xmm ) OR + ( Code.Code = EVEX_Vpscatterdd_vm32y_k1_ymm ) OR + ( Code.Code = EVEX_Vpscatterdd_vm32z_k1_zmm ) OR + ( Code.Code = EVEX_Vpscatterdq_vm32x_k1_xmm ) OR + ( Code.Code = EVEX_Vpscatterdq_vm32x_k1_ymm ) OR + ( Code.Code = EVEX_Vpscatterdq_vm32y_k1_zmm ) OR + ( Code.Code = EVEX_Vscatterdps_vm32x_k1_xmm ) OR + ( Code.Code = EVEX_Vscatterdps_vm32y_k1_ymm ) OR + ( Code.Code = EVEX_Vscatterdps_vm32z_k1_zmm ) OR + ( Code.Code = EVEX_Vscatterdpd_vm32x_k1_xmm ) OR + ( Code.Code = EVEX_Vscatterdpd_vm32x_k1_ymm ) OR + ( Code.Code = EVEX_Vscatterdpd_vm32y_k1_zmm ) OR + ( Code.Code = EVEX_Vgatherpf0dps_vm32z_k1 ) OR + ( Code.Code = EVEX_Vgatherpf0dpd_vm32y_k1 ) OR + ( Code.Code = EVEX_Vgatherpf1dps_vm32z_k1 ) OR + ( Code.Code = EVEX_Vgatherpf1dpd_vm32y_k1 ) OR + ( Code.Code = EVEX_Vscatterpf0dps_vm32z_k1 ) OR + ( Code.Code = EVEX_Vscatterpf0dpd_vm32y_k1 ) OR + ( Code.Code = EVEX_Vscatterpf1dps_vm32z_k1 ) OR + ( Code.Code = EVEX_Vscatterpf1dpd_vm32y_k1 ) OR + ( Code.Code = MVEX_Vpgatherdd_zmm_k1_mvt ) OR + ( Code.Code = MVEX_Vpgatherdq_zmm_k1_mvt ) OR + ( Code.Code = MVEX_Vgatherdps_zmm_k1_mvt ) OR + ( Code.Code = MVEX_Vgatherdpd_zmm_k1_mvt ) OR + ( Code.Code = MVEX_Vpscatterdd_mvt_k1_zmm ) OR + ( Code.Code = MVEX_Vpscatterdq_mvt_k1_zmm ) OR + ( Code.Code = MVEX_Vscatterdps_mvt_k1_zmm ) OR + ( Code.Code = MVEX_Vscatterdpd_mvt_k1_zmm ) OR + ( Code.Code = MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_B0 ) OR + ( Code.Code = MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_B2 ) OR + ( Code.Code = MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_C0 ) OR + ( Code.Code = MVEX_Vgatherpf0hintdps_mvt_k1 ) OR + ( Code.Code = MVEX_Vgatherpf0hintdpd_mvt_k1 ) OR + ( Code.Code = MVEX_Vgatherpf0dps_mvt_k1 ) OR + ( Code.Code = MVEX_Vgatherpf1dps_mvt_k1 ) OR + ( Code.Code = MVEX_Vscatterpf0hintdps_mvt_k1 ) OR + ( Code.Code = MVEX_Vscatterpf0hintdpd_mvt_k1 ) OR + ( Code.Code = MVEX_Vscatterpf0dps_mvt_k1 ) OR + ( Code.Code = MVEX_Vscatterpf1dps_mvt_k1 ) then + result := 0 + else if + ( Code.Code = VEX_Vpgatherqd_xmm_vm64x_xmm ) OR + ( Code.Code = VEX_Vpgatherqd_xmm_vm64y_xmm ) OR + ( Code.Code = VEX_Vpgatherqq_xmm_vm64x_xmm ) OR + ( Code.Code = VEX_Vpgatherqq_ymm_vm64y_ymm ) OR + ( Code.Code = EVEX_Vpgatherqd_xmm_k1_vm64x ) OR + ( Code.Code = EVEX_Vpgatherqd_xmm_k1_vm64y ) OR + ( Code.Code = EVEX_Vpgatherqd_ymm_k1_vm64z ) OR + ( Code.Code = EVEX_Vpgatherqq_xmm_k1_vm64x ) OR + ( Code.Code = EVEX_Vpgatherqq_ymm_k1_vm64y ) OR + ( Code.Code = EVEX_Vpgatherqq_zmm_k1_vm64z ) OR + ( Code.Code = VEX_Vgatherqps_xmm_vm64x_xmm ) OR + ( Code.Code = VEX_Vgatherqps_xmm_vm64y_xmm ) OR + ( Code.Code = VEX_Vgatherqpd_xmm_vm64x_xmm ) OR + ( Code.Code = VEX_Vgatherqpd_ymm_vm64y_ymm ) OR + ( Code.Code = EVEX_Vgatherqps_xmm_k1_vm64x ) OR + ( Code.Code = EVEX_Vgatherqps_xmm_k1_vm64y ) OR + ( Code.Code = EVEX_Vgatherqps_ymm_k1_vm64z ) OR + ( Code.Code = EVEX_Vgatherqpd_xmm_k1_vm64x ) OR + ( Code.Code = EVEX_Vgatherqpd_ymm_k1_vm64y ) OR + ( Code.Code = EVEX_Vgatherqpd_zmm_k1_vm64z ) OR + ( Code.Code = EVEX_Vpscatterqd_vm64x_k1_xmm ) OR + ( Code.Code = EVEX_Vpscatterqd_vm64y_k1_xmm ) OR + ( Code.Code = EVEX_Vpscatterqd_vm64z_k1_ymm ) OR + ( Code.Code = EVEX_Vpscatterqq_vm64x_k1_xmm ) OR + ( Code.Code = EVEX_Vpscatterqq_vm64y_k1_ymm ) OR + ( Code.Code = EVEX_Vpscatterqq_vm64z_k1_zmm ) OR + ( Code.Code = EVEX_Vscatterqps_vm64x_k1_xmm ) OR + ( Code.Code = EVEX_Vscatterqps_vm64y_k1_xmm ) OR + ( Code.Code = EVEX_Vscatterqps_vm64z_k1_ymm ) OR + ( Code.Code = EVEX_Vscatterqpd_vm64x_k1_xmm ) OR + ( Code.Code = EVEX_Vscatterqpd_vm64y_k1_ymm ) OR + ( Code.Code = EVEX_Vscatterqpd_vm64z_k1_zmm ) OR + ( Code.Code = EVEX_Vgatherpf0qps_vm64z_k1 ) OR + ( Code.Code = EVEX_Vgatherpf0qpd_vm64z_k1 ) OR + ( Code.Code = EVEX_Vgatherpf1qps_vm64z_k1 ) OR + ( Code.Code = EVEX_Vgatherpf1qpd_vm64z_k1 ) OR + ( Code.Code = EVEX_Vscatterpf0qps_vm64z_k1 ) OR + ( Code.Code = EVEX_Vscatterpf0qpd_vm64z_k1 ) OR + ( Code.Code = EVEX_Vscatterpf1qps_vm64z_k1 ) OR + ( Code.Code = EVEX_Vscatterpf1qpd_vm64z_k1 ) then + result := 1 + else + result := -1; +end; + +function TInstruction.GetLockPrefix : Boolean; +begin + result := ( flags1 AND LOCK_PREFIX ) <> 0; +end; + +procedure TInstruction.SetLockPrefix( Value : Boolean ); +begin + if Value then + flags1 := flags1 OR LOCK_PREFIX + else + flags1 := flags1 AND NOT LOCK_PREFIX; +end; + +function TInstruction.IsXacquireInstruction : Boolean; +begin + if ( op_kinds[ 0 ].OpKind <> okMemory ) then + result := false + else if HasLockPrefix then + result := Code.Code <> Cmpxchg16b_m128 + else + result := Mnemonic.Mnemonic = mnXchg; +end; + +function TInstruction.IsXreleaseInstruction : Boolean; +begin + if ( op_kinds[ 0 ].OpKind <> okMemory ) then + result := false + else if HasLockPrefix then + result := Code.Code <> Cmpxchg16b_m128 + else + result := ( Code.Code = Xchg_rm8_r8 ) OR + ( Code.Code = Xchg_rm16_r16 ) OR + ( Code.Code = Xchg_rm32_r32 ) OR + ( Code.Code = Xchg_rm64_r64 ) OR + ( Code.Code = Mov_rm8_r8 ) OR + ( Code.Code = Mov_rm16_r16 ) OR + ( Code.Code = Mov_rm32_r32 ) OR + ( Code.Code = Mov_rm64_r64 ) OR + ( Code.Code = Mov_rm8_imm8 ) OR + ( Code.Code = Mov_rm16_imm16 ) OR + ( Code.Code = Mov_rm32_imm32 ) OR + ( Code.Code = Mov_rm64_imm32 ); +end; + +function TInstruction.GetHasXacquirePrefix : Boolean; +begin + result := ( ( flags1 AND REPNE_PREFIX ) <> 0 ) AND IsXacquireInstruction; +end; + +procedure TInstruction.SetHasXacquirePrefix( Value : Boolean ); +begin + if Value then + flags1 := flags1 OR REPNE_PREFIX + else + flags1 := flags1 AND NOT REPNE_PREFIX; +end; + +function TInstruction.GetHasXreleasePrefix : Boolean; +begin + result := ( ( flags1 AND REPE_PREFIX ) <> 0 ) AND self.IsXreleaseInstruction; +end; + +procedure TInstruction.SetHasXreleasePrefix( Value : Boolean ); +begin + if Value then + flags1 := flags1 OR REPE_PREFIX + else + flags1 := flags1 AND NOT REPE_PREFIX; +end; + +function TInstruction.GetHasRepPrefix : Boolean; + +begin + result := ( flags1 AND REPE_PREFIX ) <> 0; +end; + +procedure TInstruction.SetHasRepPrefix( Value : Boolean ); +begin + if Value then + flags1 := flags1 OR REPE_PREFIX + else + flags1 := flags1 AND NOT REPE_PREFIX; +end; + +function TInstruction.GetHasRepePrefix : Boolean; +begin + result := ( flags1 AND REPE_PREFIX ) <> 0; +end; + +procedure TInstruction.SetHasRepePrefix( Value : Boolean ); +begin + if Value then + flags1 := flags1 OR REPE_PREFIX + else + flags1 := flags1 AND NOT REPE_PREFIX; +end; + +function TInstruction.GetHasRepnePrefix : Boolean; +begin + result := ( flags1 AND REPNE_PREFIX ) <> 0; +end; + +procedure TInstruction.SetHasRepnePrefix( Value : Boolean ); +begin + if Value then + flags1 := flags1 OR REPNE_PREFIX + else + flags1 := flags1 AND NOT REPNE_PREFIX; +end; + +function TInstruction.HasSegmentPrefix : Boolean; +begin + result := ( ( flags1 SHR SEGMENT_PREFIX_SHIFT ) AND SEGMENT_PREFIX_MASK )-1 < 6; +end; + +function TInstruction.GetSegmentPrefix : TRegister; +var + index : Cardinal; +begin + index := ( ( flags1 SHR SEGMENT_PREFIX_SHIFT ) AND SEGMENT_PREFIX_MASK )-1; + assert( Cardinal( ES )+1 = Cardinal( CS ) ); + assert( Cardinal( ES )+2 = Cardinal( SS ) ); + assert( Cardinal( ES )+3 = Cardinal( DS ) ); + assert( Cardinal( ES )+4 = Cardinal( FS ) ); + assert( Cardinal( ES )+5 = Cardinal( GS ) ); + if ( index < 6 ) then + // SAFETY: ES+index is a valid enum variant, see above const assert!()'s + result.Register := TRegisterType( Cardinal( ES ) + index ) + else + result.Register := None; +end; + +procedure TInstruction.SetSegmentPrefix( Value : TRegister ); +var + enc_value : Cardinal; +begin + assert( ( Value.Register = None ) OR ( ( ES <= Value.Register ) AND ( Value.Register <= GS ) ) ); + if ( Value.Register = None ) then + enc_value := 0 + else + enc_value := ( Cardinal( Value.Register ) - ( Cardinal( ES ) ) + 1 ) AND SEGMENT_PREFIX_MASK; + + flags1 := ( flags1 AND NOT ( SEGMENT_PREFIX_MASK SHL SEGMENT_PREFIX_SHIFT ) ) OR + ( enc_value SHL SEGMENT_PREFIX_SHIFT ); +end; + +function TInstruction.MemorySegment : TRegister; +var + seg_reg : TRegister; +begin + seg_reg := SegmentPrefix; + if seg_reg.Register <> None then + begin + result := seg_reg; + Exit; + end; + + if ( mem_base_reg.Register in [ BP, EBP, ESP, RBP, RSP ] ) then + result.Register := SS + else + result.Register := DS; +end; + +function TInstruction.GetMemoryDisplSize : Cardinal; +begin + result := displ_size; + if ( result <= 2 ) then + + else if ( result = 3 ) then + result := 4 + else + result := 8; +end; + +procedure TInstruction.SetMemoryDisplSize( Value : Cardinal ); +begin + case Value of + 0 : displ_size := 0; + 1 : displ_size := 1; + 2 : displ_size := 2; + 4 : displ_size := 3; + else + displ_size := 4; + end; +end; + +function TInstruction.GetIsBroadcast : Boolean; +begin + result := ( flags1 AND BROADCAST ) <> 0; +end; + +procedure TInstruction.SetIsBroadcast( Value : Boolean ); +begin + if Value then + flags1 := flags1 OR BROADCAST + else + flags1 := flags1 AND NOT BROADCAST; +end; + +function TInstruction.GetMemoryIndexScale : Cardinal; +begin + result := 1 SHL Byte( scale ) +end; + +procedure TInstruction.SetMemoryIndexScale( Value : Cardinal ); +begin + case Value of + 1 : scale := Scale1; + 2 : scale := Scale2; + 4 : scale := Scale4; + 8 : scale := Scale8; + end; +end; + +function TInstruction.GetImmediate8 : Byte; +begin + result := Byte( immediate ); +end; + +procedure TInstruction.SetImmediate8( Value : Byte ); +begin + // MVEX + immediate := ( immediate AND $FFFFFF00 ) OR Cardinal( Value ); + // !MVEX +// immediate := Value; +end; + +function TInstruction.GetImmediate8_2nd : Byte; +begin + result := mem_displ; +end; + +procedure TInstruction.SetImmediate8_2nd( Value : Byte ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + mem_displ := Value; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.GetImmediate16 : Word; +begin + result := immediate; +end; + +procedure TInstruction.SetImmediate16( Value : Word ); +begin + immediate := Value; +end; + +function TInstruction.GetImmediate32 : Cardinal; +begin + result := immediate; +end; + +procedure TInstruction.SetImmediate32( Value : Cardinal ); +begin + immediate := Value; +end; + +function TInstruction.GetImmediate64 : UInt64; +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := ( mem_displ SHL 32 ) OR UInt64( immediate ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetImmediate64( Value : UInt64 ); +begin + immediate := Value; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + mem_displ := Value SHR 32; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.GetImmediate8to16 : SmallInt; +begin + result := ShortInt( immediate ); +end; + +procedure TInstruction.SetImmediate8to16( Value : SmallInt ); +begin + immediate := Cardinal( ShortInt( Value ) ); +end; + +function TInstruction.GetImmediate8to32 : Integer; +begin + result := ShortInt( immediate ); +end; + +procedure TInstruction.SetImmediate8to32( Value : Integer ); +begin + immediate := Cardinal( ShortInt( Value ) ); +end; + +function TInstruction.GetImmediate8to64 : Int64; +begin + result := ShortInt( immediate ); +end; + +procedure TInstruction.SetImmediate8to64( Value : Int64 ); +begin + immediate := Cardinal( ShortInt( Value ) ); +end; + +function TInstruction.GetImmediate32to64 : Int64; +begin + result := Integer( immediate ); +end; + +procedure TInstruction.SetImmediate32to64( Value : Int64 ); +begin + immediate := Cardinal( Value ); +end; + +function TInstruction.GetNearBranch16 : Word; +begin + result := mem_displ; +end; + +procedure TInstruction.SetNearBranch16( Value : Word ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + mem_displ := Value; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.GetNearBranch32 : Cardinal; +begin + result := mem_displ; +end; + +procedure TInstruction.SetNearBranch32( Value : Cardinal ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + mem_displ := Value; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.GetNearBranch64 : UInt64; +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := mem_displ; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetNearBranch64( Value : UInt64 ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + mem_displ := Value; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.NearBranchTarget : UInt64; +var + op_kind : TOpKind; +begin + op_kind := op_kinds[ 0 ]; + // MVEX - Check if JKZD/JKNZD + if ( OPCount = 2 ) then + op_kind := op_kinds[ 1 ]; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + case op_kind.OpKind of + okNearBranch16 : result := NearBranch16; + okNearBranch32 : result := NearBranch32; + okNearBranch64 : result := NearBranch64; + else + result := 0; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.GetFarBranch16 : Word; +begin + result := immediate; +end; + +procedure TInstruction.SetFarBranch16( Value : Word ); +begin + immediate := Value; +end; + +function TInstruction.GetFarBranch32 : Cardinal; +begin + result := immediate; +end; + +procedure TInstruction.SetFarBranch32( Value : Cardinal ); +begin + immediate := Value; +end; + +function TInstruction.GetFarBranchSelector : Word; +begin + result := mem_displ; +end; + +procedure TInstruction.SetFarBranchSelector( Value : Word ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + mem_displ := Value; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.HasOpMask : Boolean; +begin + result := ( flags1 AND ( OP_MASK_MASK SHL OP_MASK_SHIFT ) ) <> 0; +end; + +function TInstruction.GetZeroingMasking : Boolean; +begin + result := ( flags1 AND ZEROING_MASKING ) <> 0; +end; + +procedure TInstruction.SetZeroingMasking( Value : Boolean ); +begin + if Value then + flags1 := flags1 OR ZEROING_MASKING + else + flags1 := flags1 AND NOT ZEROING_MASKING; +end; + +function TInstruction.GetMergingMasking : Boolean; +begin + result := ( flags1 AND ZEROING_MASKING ) = 0; +end; + +procedure TInstruction.SetMergingMasking( Value : Boolean ); +begin + if Value then + flags1 := flags1 AND NOT ZEROING_MASKING + else + flags1 := flags1 OR ZEROING_MASKING; +end; + +function TInstruction.GetRoundingControl : TRoundingControl; +begin + result.RoundingControl := TRoundingControlType( ( ( flags1 SHR ROUNDING_CONTROL_SHIFT ) AND ROUNDING_CONTROL_MASK ) ); +end; + +procedure TInstruction.SetRoundingControl( Value : TRoundingControl ); +begin + flags1 := ( flags1 AND NOT ( ROUNDING_CONTROL_MASK SHL ROUNDING_CONTROL_SHIFT ) ) OR + ( Cardinal( Value.RoundingControl ) SHL ROUNDING_CONTROL_SHIFT ); +end; + +function TInstruction.GetSuppressAllExceptions : Boolean; +begin + result := ( flags1 AND SUPPRESS_ALL_EXCEPTIONS ) <> 0; +end; + +procedure TInstruction.SetSuppressAllExceptions( Value : Boolean ); +begin + if Value then + flags1 := flags1 OR SUPPRESS_ALL_EXCEPTIONS + else + flags1 := flags1 AND NOT SUPPRESS_ALL_EXCEPTIONS; +end; + +function TInstruction.MemoryDisplacement32 : Cardinal; +begin + result := mem_displ; +end; + +function TInstruction.MemoryDisplacement64 : UInt64; +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := mem_displ; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.IsIP_RelMemoryOperand : Boolean; +begin + result := ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) OR ( mem_base_reg.Register = EIP ); +end; + +function TInstruction.IP_RelMemoryAddress : UInt64; +begin + if ( mem_base_reg.Register = {$IF CompilerVersion >= 23}TRegisterType.RIP{$ELSE}TRegisterType( 70{RIP} ){$IFEND} ) then + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := MemoryDisplacement64 + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + else + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := MemoryDisplacement32; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstruction.IsPrivileged : Boolean; +begin + result := Code.IsPrivileged; +end; + +function TInstruction.IsSaveRestoreInstruction : Boolean; +begin + result := Code.IsSaveRestoreInstruction; +end; + +function TInstruction.IsJccShort : Boolean; +begin + result := Code.IsJccShort; +end; + +function TInstruction.IsJmpShort : Boolean; +begin + result := Code.IsJmpShort; +end; + +function TInstruction.IsJmpShortOrNear : Boolean; +begin + result := Code.IsJmpShortOrNear; +end; + +function TInstruction.IsJmpNear : Boolean; +begin + result := Code.IsJmpNear; +end; + +function TInstruction.IsJmpFar : Boolean; +begin + result := Code.IsJmpFar; +end; + +function TInstruction.IsCallNear : Boolean; +begin + result := Code.IsCallNear; +end; + +function TInstruction.IsCallFar : Boolean; +begin + result := Code.IsCallFar; +end; + +function TInstruction.IsJmpNearIndirect : Boolean; +begin + result := Code.IsJmpNearIndirect; +end; + +function TInstruction.IsJmpFarIndirect : Boolean; +begin + result := Code.IsJmpFarIndirect; +end; + +function TInstruction.IsCallNearIndirect : Boolean; +begin + result := Code.IsCallNearIndirect; +end; + +function TInstruction.IsCallFarIndirect : Boolean; +begin + result := Code.IsCallFarIndirect; +end; + +function TInstruction.IsJkccShortOrNear : Boolean; +begin + result := Code.IsJkccShortOrNear; +end; + +function TInstruction.IsJkccNear : Boolean; +begin + result := Code.IsJkccNear; +end; + +function TInstruction.IsJkccShort : Boolean; +begin + result := Code.IsJkccShort; +end; + +function TInstruction.IsStringInstruction : Boolean; +begin + result := Code.IsStringInstruction; +end; + +function TInstruction.IsJcxShort : Boolean; +begin + result := Code.IsJcxShort; +end; + +function TInstruction.IsLoopCC : Boolean; +begin + result := Code.IsLoopCC; +end; + +function TInstruction.IsLoop : Boolean; +begin + result := Code.IsLoop; +end; + +function TInstruction.IsJccShortOrNear : Boolean; +begin + result := Code.IsJccShortOrNear; +end; + +procedure TInstruction.NegateConditionCode; +begin + Code := Code.NegateConditionCode; +end; + +procedure TInstruction.AsShortBranch; +begin + Code := Code.AsShortBranch; +end; + +procedure TInstruction.AsNearBranch; +begin + Code := Code.AsNearBranch; +end; + +function TInstruction.GetIsMvexEvictionHint : Boolean; +begin + result := Instruction_IsMvexEvictionHint( self ); +end; + +procedure TInstruction.SetIsMvexEvictionHint( Value : Boolean ); +begin + if Value then + immediate := immediate OR EVICTION_HINT + else + immediate := immediate AND NOT EVICTION_HINT; +end; + +function TInstruction.GetMvexRegMemConv : TMvexRegMemConv; +begin + result := Instruction_MvexRegMemConv( self ); +end; + +procedure TInstruction.SetMvexRegMemConv( Value : TMvexRegMemConv ); +begin + immediate := ( immediate AND NOT ( MVEX_REG_MEM_CONV_MASK SHL MVEX_REG_MEM_CONV_SHIFT ) ) OR + ( Cardinal( Value.MvexRegMemConv ) SHL MVEX_REG_MEM_CONV_SHIFT ); +end; + +function TInstruction.GetOpMask : TRegister; +var + r : Cardinal; +begin + r := ( flags1 SHR OP_MASK_SHIFT ) AND OP_MASK_MASK; + if ( r = 0 ) then + result.Register := None + else + begin + assert( OP_MASK_MASK = 7 ); + assert( Cardinal( K0 ) + 1 = Cardinal( K1 ) ); + assert( Cardinal( K0 ) + 2 = Cardinal( K2 ) ); + assert( Cardinal( K0 ) + 3 = Cardinal( K3 ) ); + assert( Cardinal( K0 ) + 4 = Cardinal( K4 ) ); + assert( Cardinal( K0 ) + 5 = Cardinal( K5 ) ); + assert( Cardinal( K0 ) + 6 = Cardinal( K6 ) ); + assert( Cardinal( K0 ) + 7 = Cardinal( K7 ) ); + // SAFETY: r+K0 is a valid TRegister variant since 1<=r<=7 + result.Register := TRegisterType( r + Cardinal( K0 ) ) + end; +end; + +procedure TInstruction.SetOpMask( Value : TRegister ); +var + r : Cardinal; +begin + assert( ( Value.Register = None ) OR ( ( K1 <= Value.Register ) AND ( Value.Register <= K7 ) ) ); + + if ( Value.Register = None ) then + r := 0 + else + r := ( Cardinal( Value.Register ) - Cardinal( K0 ) ) AND OP_MASK_MASK; + + flags1 := ( flags1 AND NOT ( OP_MASK_MASK SHL OP_MASK_SHIFT ) ) OR ( r SHL OP_MASK_SHIFT ); +end; + +procedure TInstruction.SetDeclareDataLen( Value : NativeUInt ); +begin + assert( ( 1 <= Value ) AND ( Value <= $10 ) ); + flags1 := ( flags1 AND NOT ( DATA_LENGTH_MASK SHL DATA_LENGTH_SHIFT ) ) OR + ( ( ( Cardinal( Value ) - 1 ) AND DATA_LENGTH_MASK ) SHL DATA_LENGTH_SHIFT ); +end; + +function TInstruction.GetOp4Kind : TOpKind; +begin + result.OpKind := okImmediate8; +end; + +procedure TInstruction.SetOp4Kind( Value : TOpKind ); +begin + assert( Value.OpKind = okImmediate8 ); +end; + +function TInstruction.GetOpKind( Operand : Cardinal ) : TOpKind; +begin + if ( Operand <= High( op_kinds ) ) then + result := op_kinds[ Operand ] + else // if ( Operand = Length( op_kinds ) ) then + result.OpKind := okImmediate8 // Op4Kind +end; + +procedure TInstruction.SetOpKind( Operand : Cardinal; Value : TOpKind ); +begin + if ( Operand <= High( op_kinds ) ) then + op_kinds[ Operand ] := Value + else + assert( Value.OpKind = okImmediate8 ); +end; + +function TInstruction.TryGetImmediate( Operand : Cardinal ) : UInt64; +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + case GetOpKind( Operand ).OpKind of + okImmediate8 : result := immediate8; + okImmediate8_2nd : result := immediate8_2nd; + okImmediate16 : result := immediate16; + okImmediate32 : result := immediate32; + okImmediate64 : result := immediate64; + okImmediate8to16 : result := immediate8to16; + okImmediate8to32 : result := immediate8to32; + okImmediate8to64 : result := immediate8to64; + okImmediate32to64 : result := immediate32to64; + else + result := 0; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.TrySetImmediate( Operand : Cardinal; Value : UInt64 ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + case GetOpKind( Operand ).OpKind of + okImmediate8 : immediate8 := Value; + okImmediate8_2nd : immediate8_2nd := Value; + okImmediate16 : immediate16 := Value; + okImmediate32 : immediate32 := Value; + okImmediate64 : immediate64 := Value; + okImmediate8to16 : immediate8to16 := Value; + okImmediate8to32 : immediate8to32 := Value; + okImmediate8to64 : immediate8to64 := Value; + okImmediate32to64 : immediate32to64 := Value; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.TrySetImmediate_( Operand : Cardinal; Value : Int64 ); +begin + TrySetImmediate( Operand, UInt64( Value ) ); +end; + +procedure TInstruction.TrySetImmediate_( Operand : Cardinal; Value : Cardinal ); +begin + TrySetImmediate( Operand, UInt64( Value ) ); +end; + +procedure TInstruction.TrySetImmediate_( Operand : Cardinal; Value : Integer ); +begin + TrySetImmediate( Operand, UInt64( Value ) ); +end; + +function TInstruction.GetDeclareByteValue( index: NativeUInt ) : Byte; +begin + case index of + 0 : result := Byte( regs[ 0 ].Register ); + 1 : result := Byte( regs[ 1 ].Register ); + 2 : result := Byte( regs[ 2 ].Register ); + 3 : result := Byte( regs[ 3 ].Register ); + 4 : result := immediate; + 5 : result := ( immediate SHR 8 ); + 6 : result := ( immediate SHR 16 ); + 7 : result := ( immediate SHR 24 ); + 8 : result := mem_displ; + 9 : result := ( Cardinal( mem_displ ) SHR 8 ); + 10 : result := ( Cardinal( mem_displ ) SHR 16 ); + 11 : result := ( Cardinal( mem_displ ) SHR 24 ); + 12 : result := ( mem_displ SHR 32 ); + 13 : result := ( mem_displ SHR 40 ); + 14 : result := ( mem_displ SHR 48 ); + 15 : result := ( mem_displ SHR 56 ); + else + result := 0; + end; +end; + +procedure TInstruction.SetDeclareByteValue( index: NativeUInt; Value: Byte ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + case index of + 0 : regs[ 0 ].Register := TRegisterType( Value ); + 1 : regs[ 1 ].Register := TRegisterType( Value ); + 2 : regs[ 2 ].Register := TRegisterType( Value ); + 3 : regs[ 3 ].Register := TRegisterType( Value ); + 4 : immediate := ( immediate AND $FFFFFF00 ) OR Cardinal( Value ); + 5 : immediate := ( immediate AND $FFFF00FF ) OR ( Cardinal( Value ) SHL 8 ); + 6 : immediate := ( immediate AND $FF00FFFF ) OR ( Cardinal( Value ) SHL 16 ); + 7 : immediate := ( immediate AND $00FFFFFF ) OR ( Cardinal( Value ) SHL 24 ); + 8 : mem_displ := ( mem_displ AND $FFFFFFFFFFFFFF00 ) OR UInt64( Value ); + 9 : mem_displ := ( mem_displ AND $FFFFFFFFFFFF00FF ) OR ( UInt64( Value ) SHL 8 ); + 10 : mem_displ := ( mem_displ AND $FFFFFFFFFF00FFFF ) OR ( UInt64( Value ) SHL 16 ); + 11 : mem_displ := ( mem_displ AND $FFFFFFFF00FFFFFF ) OR ( UInt64( Value ) SHL 24 ); + 12 : mem_displ := ( mem_displ AND $FFFFFF00FFFFFFFF ) OR ( UInt64( Value ) SHL 32 ); + 13 : mem_displ := ( mem_displ AND $FFFF00FFFFFFFFFF ) OR ( UInt64( Value ) SHL 40 ); + 14 : mem_displ := ( mem_displ AND $FF00FFFFFFFFFFFF ) OR ( UInt64( Value ) SHL 48 ); + 15 : mem_displ := ( mem_displ AND $00FFFFFFFFFFFFFF ) OR ( UInt64( Value ) SHL 56 ); + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetDeclareByteValue_( index: NativeUInt; Value: ShortInt ); +begin + SetDeclareByteValue( index, Byte( Value ) ); +end; + +function TInstruction.GetDeclareWordValue( index: NativeUInt ) : Word; +begin + case Index of + 0 : result := Word( regs[ 0 ].Register ) OR ( Word( regs[ 1 ].Register ) SHL 8 ); + 1 : result := Word( regs[ 2 ].Register ) OR ( Word( regs[ 3 ].Register ) SHL 8 ); + 2 : result := immediate; + 3 : result := ( immediate SHR 16 ); + 4 : result := mem_displ; + 5 : result := ( Cardinal( mem_displ ) SHR 16 ); + 6 : result := ( mem_displ SHR 32 ); + 7 : result := ( mem_displ SHR 48 ); + else + result := 0; + end; +end; + +procedure TInstruction.SetDeclareWordValue( index: NativeUInt; Value: Word ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + case index of + 0 : begin + regs[ 0 ].Register := TRegisterType( Value ); + regs[ 1 ].Register := TRegisterType( Value SHR 8 ); + end; + 1 : begin + regs[ 2 ].Register := TRegisterType( Value ); + regs[ 3 ].Register := TRegisterType( Value SHR 8 ); + end; + 2 : immediate := ( immediate AND $FFFF0000 ) OR Cardinal( Value ); + 3 : immediate := Cardinal( Word( immediate ) ) OR Cardinal( Value ) SHL 16; + 4 : mem_displ := ( mem_displ AND $FFFFFFFFFFFF0000 ) OR UInt64( Value ); + 5 : mem_displ := ( mem_displ AND $FFFFFFFF0000FFFF ) OR ( UInt64( Value ) SHL 16 ); + 6 : mem_displ := ( mem_displ AND $FFFF0000FFFFFFFF ) OR ( UInt64( Value ) SHL 32 ); + 7 : mem_displ := ( mem_displ AND $0000FFFFFFFFFFFF ) OR ( UInt64( Value ) SHL 48 ); + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetDeclareWordValue_( index: NativeUInt; Value: SmallInt ); +begin + SetDeclareWordValue( index, Word( Value ) ); +end; + +function TInstruction.GetDeclareDWordValue( index: NativeUInt ) : Cardinal; +begin + case Index of + 0 : result := Cardinal( regs[ 0 ].Register ) OR ( Cardinal( regs[ 1 ].Register ) SHL 8 ) OR ( Cardinal( regs[ 2 ].Register ) SHL 16 ) OR ( Cardinal( regs[ 3 ].Register ) SHL 24 ); + 1 : result := immediate; + 2 : result := mem_displ; + 3 : result := ( mem_displ SHR 32 ); + else + result := 0; + end; +end; + +procedure TInstruction.SetDeclareDWordValue( index: NativeUInt; Value: Cardinal ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + case Index of + 0 : begin + regs[ 0 ].Register := TRegisterType( Value ); + regs[ 1 ].Register := TRegisterType( Value SHR 8 ); + regs[ 2 ].Register := TRegisterType( Value SHR 16 ); + regs[ 3 ].Register := TRegisterType( Value SHR 24 ); + end; + 1 : immediate := Value; + 2 : mem_displ := ( mem_displ AND $FFFFFFFF00000000 ) OR UInt64( Value ); + 3 : mem_displ := ( mem_displ AND $00000000FFFFFFFF ) OR UInt64( Value ) SHL 32; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetDeclareDWordValue_( index: NativeUInt; Value: Integer ); +begin + SetDeclareDWordValue( index, Cardinal( Value ) ); +end; + +function TInstruction.GetDeclareQWordValue( index: NativeUInt ) : UInt64; +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + case Index of + 0 : result := UInt64( regs[ 0 ].Register ) OR +// ( UInt64( regs[ 1 ].Register ) SHL 8 ) OR +// ( UInt64( regs[ 2 ].Register ) SHL 16 ) OR +// ( UInt64( regs[ 3 ].Register ) SHL 24 ) OR + ( UInt64( immediate ) SHL 32 ); + 1 : result := mem_displ; + else + result := 0; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetDeclareQWordValue( index: NativeUInt; Value: UInt64 ); +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + case index of + 0 : begin + regs[ 0 ].Register := TRegisterType( Value ); + regs[ 1 ].Register := TRegisterType( Value SHR 8 ); + regs[ 2 ].Register := TRegisterType( Value SHR 16 ); + regs[ 3 ].Register := TRegisterType( Value SHR 24 ); + immediate := Cardinal( Value SHR 32 ); + end; + 1 : mem_displ := Value; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstruction.SetDeclareQWordValue_( index: NativeUInt; Value: Int64 ); +begin + SetDeclareQWordValue( index, UInt64( Value ) ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +function TInstruction.OpCodeInfo : TOpCodeInfo; +begin + result := Code.OPCode; +end; + +function TInstruction.IsInstruction : Boolean; +begin + result := OpCodeInfo.IsInstruction; +end; + +function TInstruction.Mode16 : Boolean; +begin + result := OpCodeInfo.Mode16; +end; + +function TInstruction.Mode32 : Boolean; +begin + result := OpCodeInfo.Mode32; +end; + +function TInstruction.Mode64 : Boolean; +begin + result := OpCodeInfo.Mode64; +end; + +function TInstruction.Fwait : Boolean; +begin + result := OpCodeInfo.Fwait; +end; + +function TInstruction.OperandSize : Cardinal; +begin + result := OpCodeInfo.operand_size; +end; + +function TInstruction.AddressSize : Cardinal; +begin + result := OpCodeInfo.address_size; +end; + +function TInstruction.L : Cardinal; +begin + result := OpCodeInfo.l; +end; + +function TInstruction.W : Cardinal; +begin + result := OpCodeInfo.w; +end; + +function TInstruction.IsLig : Boolean; +begin + result := OpCodeInfo.IsLig; +end; + +function TInstruction.IsWig : Boolean; +begin + result := OpCodeInfo.IsWig; +end; + +function TInstruction.IsWig32 : Boolean; +begin + result := OpCodeInfo.IsWig32; +end; + +function TInstruction.TupleType : TTupleType; +begin + result := OpCodeInfo.tuple_type; +end; + +function TInstruction.MvexEhBit : TMvexEHBit; +begin + result := OpCodeInfo.MvexEhBit; +end; + +function TInstruction.MvexCanUseEvictionHint : Boolean; +begin + result := OpCodeInfo.MvexCanUseEvictionHint; +end; + +function TInstruction.MvexCanUseImmRoundingControl : Boolean; +begin + result := OpCodeInfo.MvexCanUseImmRoundingControl; +end; + +function TInstruction.MvexIgnoresOpMaskRegister : Boolean; +begin + result := OpCodeInfo.MvexIgnoresOpMaskRegister; +end; + +function TInstruction.MvexNoSaeRc : Boolean; +begin + result := OpCodeInfo.MvexNoSaeRc; +end; + +function TInstruction.MvexTupleTypeLutKind : TMvexTupleTypeLutKind; +begin + result := OpCodeInfo.MvexTupleTypeLutKind; +end; + +function TInstruction.MvexConversionFunc : TMvexConvFn; +begin + result := OpCodeInfo.MvexConversionFunc; +end; + +function TInstruction.MvexValidConversionFuncsMask : Byte; +begin + result := OpCodeInfo.MvexValidConversionFuncsMask; +end; + +function TInstruction.MvexValidSwizzleFuncsMask : Byte; +begin + result := OpCodeInfo.MvexValidSwizzleFuncsMask; +end; + +function TInstruction.OpCodeInfo_MemorySize : TMemorySize; +begin + result := OpCodeInfo.MemorySize; +end; + +function TInstruction.BroadcastMemorySize : TMemorySize; +begin + result := OpCodeInfo.BroadcastMemorySize; +end; + +function TInstruction.CanBroadcast : Boolean; +begin + result := OpCodeInfo.CanBroadcast; +end; + +function TInstruction.CanUseRoundingControl : Boolean; +begin + result := OpCodeInfo.CanUseRoundingControl; +end; + +function TInstruction.CanSuppressAllExceptions : Boolean; +begin + result := OpCodeInfo.CanSuppressAllExceptions; +end; + +function TInstruction.CanUseOpMaskRegister : Boolean; +begin + result := OpCodeInfo.CanUseOpMaskRegister; +end; + +function TInstruction.RequireOpMaskRegister : Boolean; +begin + result := OpCodeInfo.RequireOpMaskRegister; +end; + +function TInstruction.CanUseZeroingMasking : Boolean; +begin + result := OpCodeInfo.CanUseZeroingMasking; +end; + +function TInstruction.CanUseLockPrefix : Boolean; +begin + result := OpCodeInfo.CanUseLockPrefix; +end; + +function TInstruction.CanUseXacquirePrefix : Boolean; +begin + result := OpCodeInfo.CanUseXacquirePrefix; +end; + +function TInstruction.CanUseXreleasePrefix : Boolean; +begin + result := OpCodeInfo.CanUseXreleasePrefix; +end; + +function TInstruction.CanUseRepPrefix : Boolean; +begin + result := OpCodeInfo.CanUseRepPrefix; +end; + +function TInstruction.CanUseRepnePrefix : Boolean; +begin + result := OpCodeInfo.CanUseRepnePrefix; +end; + +function TInstruction.CanUseBndPrefix : Boolean; +begin + result := OpCodeInfo.CanUseBndPrefix; +end; + +function TInstruction.CanUseHintTakenPrefix : Boolean; +begin + result := OpCodeInfo.CanUseHintTakenPrefix; +end; + +function TInstruction.CanUseNotrackPrefix : Boolean; +begin + result := OpCodeInfo.CanUseNotrackPrefix; +end; + +function TInstruction.IgnoresRoundingControl : Boolean; +begin + result := OpCodeInfo.IgnoresRoundingControl; +end; + +function TInstruction.AmdLockRegBit : Boolean; +begin + result := OpCodeInfo.AmdLockRegBit; +end; + +function TInstruction.DefaultOpSize64 : Boolean; +begin + result := OpCodeInfo.DefaultOpSize64; +end; + +function TInstruction.ForceOpSize64 : Boolean; +begin + result := OpCodeInfo.ForceOpSize64; +end; + +function TInstruction.IntelForceOpSize64 : Boolean; +begin + result := OpCodeInfo.IntelForceOpSize64; +end; + +function TInstruction.MustBeCpl0 : Boolean; +begin + result := OpCodeInfo.MustBeCpl0; +end; + +function TInstruction.Cpl0 : Boolean; +begin + result := OpCodeInfo.Cpl0; +end; + +function TInstruction.Cpl1 : Boolean; +begin + result := OpCodeInfo.Cpl1; +end; + +function TInstruction.Cpl2 : Boolean; +begin + result := OpCodeInfo.Cpl2; +end; + +function TInstruction.Cpl3 : Boolean; +begin + result := OpCodeInfo.Cpl3; +end; + +function TInstruction.IsInputOutput : Boolean; +begin + result := OpCodeInfo.IsInputOutput; +end; + +function TInstruction.IsNop : Boolean; +begin + result := OpCodeInfo.IsNop; +end; + +function TInstruction.IsReservedNop : Boolean; +begin + result := OpCodeInfo.IsReservedNop; +end; + +function TInstruction.IsSerializingIntel : Boolean; +begin + result := OpCodeInfo.IsSerializingIntel; +end; + +function TInstruction.IsSerializingAmd : Boolean; +begin + result := OpCodeInfo.IsSerializingAmd; +end; + +function TInstruction.MayRequireCpl0 : Boolean; +begin + result := OpCodeInfo.MayRequireCpl0; +end; + +function TInstruction.IsCetTracked : Boolean; +begin + result := OpCodeInfo.IsCetTracked; +end; + +function TInstruction.IsNonTemporal : Boolean; +begin + result := OpCodeInfo.IsNonTemporal; +end; + +function TInstruction.IsFpuNoWait : Boolean; +begin + result := OpCodeInfo.IsFpuNoWait; +end; + +function TInstruction.IgnoresModBits : Boolean; +begin + result := OpCodeInfo.IgnoresModBits; +end; + +function TInstruction.No66 : Boolean; +begin + result := OpCodeInfo.No66; +end; + +function TInstruction.Nfx : Boolean; +begin + result := OpCodeInfo.Nfx; +end; + +function TInstruction.RequiresUniqueRegNums : Boolean; +begin + result := OpCodeInfo.RequiresUniqueRegNums; +end; + +function TInstruction.RequiresUniqueDestRegNum : Boolean; +begin + result := OpCodeInfo.RequiresUniqueDestRegNum; +end; + +function TInstruction.OpCodeInfo_IsPrivileged : Boolean; +begin + result := OpCodeInfo.IsPrivileged; +end; + +function TInstruction.IsSaveRestore : Boolean; +begin + result := OpCodeInfo.IsSaveRestore; +end; + +function TInstruction.OpCodeInfo_IsStackInstruction : Boolean; +begin + result := OpCodeInfo.IsStackInstruction; +end; + +function TInstruction.IgnoresSegment : Boolean; +begin + result := OpCodeInfo.IgnoresSegment; +end; + +function TInstruction.IsOpMaskReadWrite : Boolean; +begin + result := OpCodeInfo.IsOpMaskReadWrite; +end; + +function TInstruction.RealMode : Boolean; +begin + result := OpCodeInfo.RealMode; +end; + +function TInstruction.ProtectedMode : Boolean; +begin + result := OpCodeInfo.ProtectedMode; +end; + +function TInstruction.Virtual8086Mode : Boolean; +begin + result := OpCodeInfo.Virtual8086Mode; +end; + +function TInstruction.CompatibilityMode : Boolean; +begin + result := OpCodeInfo.CompatibilityMode; +end; + +function TInstruction.LongMode : Boolean; +begin + result := OpCodeInfo.LongMode; +end; + +function TInstruction.UseOutsideSmm : Boolean; +begin + result := OpCodeInfo.UseOutsideSmm; +end; + +function TInstruction.UseInSmm : Boolean; +begin + result := OpCodeInfo.UseInSmm; +end; + +function TInstruction.UseOutsideEnclaveSgx : Boolean; +begin + result := OpCodeInfo.UseOutsideEnclaveSgx; +end; + +function TInstruction.UseInEnclaveSgx1 : Boolean; +begin + result := OpCodeInfo.UseInEnclaveSgx1; +end; + +function TInstruction.UseInEnclaveSgx2 : Boolean; +begin + result := OpCodeInfo.UseInEnclaveSgx2; +end; + +function TInstruction.UseOutsideVmxOp : Boolean; +begin + result := OpCodeInfo.UseOutsideVmxOp; +end; + +function TInstruction.UseInVmxRootOp : Boolean; +begin + result := OpCodeInfo.UseInVmxRootOp; +end; + +function TInstruction.UseInVmxNonRootOp : Boolean; +begin + result := OpCodeInfo.UseInVmxNonRootOp; +end; + +function TInstruction.UseOutsideSeam : Boolean; +begin + result := OpCodeInfo.UseOutsideSeam; +end; + +function TInstruction.UseInSeam : Boolean; +begin + result := OpCodeInfo.UseInSeam; +end; + +function TInstruction.TdxNonRootGenUd : Boolean; +begin + result := OpCodeInfo.TdxNonRootGenUd; +end; + +function TInstruction.TdxNonRootGenVe : Boolean; +begin + result := OpCodeInfo.TdxNonRootGenVe; +end; + +function TInstruction.TdxNonRootMayGenEx : Boolean; +begin + result := OpCodeInfo.TdxNonRootMayGenEx; +end; + +function TInstruction.IntelVMExit : Boolean; +begin + result := OpCodeInfo.IntelVMExit; +end; + +function TInstruction.IntelMayVMExit : Boolean; +begin + result := OpCodeInfo.IntelMayVMExit; +end; + +function TInstruction.IntelSmmVMExit : Boolean; +begin + result := OpCodeInfo.IntelSmmVMExit; +end; + +function TInstruction.AmdVMExit : Boolean; +begin + result := OpCodeInfo.AmdVMExit; +end; + +function TInstruction.AmdMayVMExit : Boolean; +begin + result := OpCodeInfo.AmdMayVMExit; +end; + +function TInstruction.TsxAbort : Boolean; +begin + result := OpCodeInfo.TsxAbort; +end; + +function TInstruction.TsxImplAbort : Boolean; +begin + result := OpCodeInfo.TsxImplAbort; +end; + +function TInstruction.TsxMayAbort : Boolean; +begin + result := OpCodeInfo.TsxMayAbort; +end; + +function TInstruction.IntelDecoder16 : Boolean; +begin + result := OpCodeInfo.IntelDecoder16; +end; + +function TInstruction.IntelDecoder32 : Boolean; +begin + result := OpCodeInfo.IntelDecoder32; +end; + +function TInstruction.IntelDecoder64 : Boolean; +begin + result := OpCodeInfo.IntelDecoder64; +end; + +function TInstruction.AmdDecoder16 : Boolean; +begin + result := OpCodeInfo.AmdDecoder16; +end; + +function TInstruction.AmdDecoder32 : Boolean; +begin + result := OpCodeInfo.AmdDecoder32; +end; + +function TInstruction.AmdDecoder64 : Boolean; +begin + result := OpCodeInfo.AmdDecoder64; +end; + +function TInstruction.DecoderOption : Cardinal; +begin + result := OpCodeInfo.DecoderOption; +end; + +function TInstruction.Table : TOpCodeTableKind; +begin + result := OpCodeInfo.Table; +end; + +function TInstruction.MandatoryPrefix : TMandatoryPrefix; +begin + result := OpCodeInfo.Mandatory_Prefix; +end; + +function TInstruction.OpCode : Word; +begin + result := OpCodeInfo.op_code; +end; + +function TInstruction.OpCodeLen : Cardinal; +begin + result := OpCodeInfo.OpCodeLen; +end; + +function TInstruction.IsGroup : Boolean; +begin + result := OpCodeInfo.IsGroup; +end; + +function TInstruction.GroupIndex : Integer; +begin + result := OpCodeInfo.group_index; +end; + +function TInstruction.IsRMGroup : Boolean; +begin + result := OpCodeInfo.IsRMGroup; +end; + +function TInstruction.RMGroupIndex : Integer; +begin + result := OpCodeInfo.rm_group_index; +end; + +function TInstruction.OpCodeInfo_OPCount : Cardinal; +begin + result := OpCodeInfo.OPCount; +end; + +function TInstruction.IsAvailableInMode( Bitness : Cardinal ) : Boolean; +begin + result := OpCodeInfo.IsAvailableInMode( Bitness ); +end; + +function TInstruction.IsAvailableInMode( Bitness : TIcedBitness ) : Boolean; +begin + result := OpCodeInfo.IsAvailableInMode( Cardinal( Bitness ) ); +end; + +function TInstruction.OpCodeString : String; +begin + result := Code.OPCode.OpCodeString; +end; + +function TInstruction.InstructionString : String; +begin + result := Code.OPCode.InstructionString; +end; + +function TInstruction.VirtualAddress( Callback : TVirtualAddressResolverCallback; Operand : Cardinal = 0; Index : NativeUInt = 0; UserData : Pointer = nil ) : UInt64; +begin + result := Instruction_VirtualAddress( self, Callback, Operand, Index, UserData ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +{$IFDEF UNICODE} +class operator TInstruction.Implicit( Instruction : TInstruction ) : AnsiString; +begin + result := Instruction.Format; +end; +{$ENDIF UNICODE} + +function TInstruction.Format( AType : TIcedFormatterType = DEFAULT_FORMATTER ) : AnsiString; +var + Handle : Pointer; + P : PAnsiChar; + Size : NativeUInt; +begin + P := nil; + Size := 0; + case AType of +// ftMasm : begin +// Handle := MasmFormatter_Create( nil{SymbolResolver}, nil{OptionsProvider}, nil{UserData} ); +// MasmFormatter_Format( Handle, self, P, Size ); +// end; + ftNasm : begin + Handle := NasmFormatter_Create( nil{SymbolResolver}, nil{OptionsProvider}, nil{UserData} ); + NasmFormatter_Format( Handle, self, P, Size ); + end; + ftGas : begin + Handle := GasFormatter_Create( nil{SymbolResolver}, nil{OptionsProvider}, nil{UserData} ); + GasFormatter_Format( Handle, self, P, Size ); + end; + ftIntel : begin + Handle := IntelFormatter_Create( nil{SymbolResolver}, nil{OptionsProvider}, nil{UserData} ); + IntelFormatter_Format( Handle, self, P, Size ); + end; + ftFast : begin + Handle := FastFormatter_Create( nil{SymbolResolver}, nil{UserData} ); + FastFormatter_Format( Handle, self, P, Size ); + end; + ftSpecialized : begin + Handle := SpecializedFormatter_Create( nil{SymbolResolver}, nil{UserData} ); + SpecializedFormatter_Format( Handle, 0, self, P, Size ); + end; + else + begin + Handle := MasmFormatter_Create( nil{SymbolResolver}, nil{OptionsProvider}, nil{UserData} ); + MasmFormatter_Format( Handle, self, P, Size ); + end; + end; + result := P; + IcedFreeMemory( Handle ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// ConstantOffsets +function TConstantOffsets.HasDisplacement : Boolean; +begin + result := ( displacement_size <> 0 ); +end; + +function TConstantOffsets.HasImmediate : Boolean; +begin + result := ( immediate_size <> 0 ); +end; + +function TConstantOffsets.HasImmediate2 : Boolean; +begin + result := ( immediate_size2 <> 0 ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TOpAccess (Record) +{$IFDEF UNICODE} +class operator TOpAccess.Equal( const self, AOpAccess : TOpAccess ) : Boolean; +begin + Result := ( self.OpAccess = AOpAccess.OpAccess ); +end; + +class operator TOpAccess.Equal( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; +begin + Result := ( self.OpAccess = AOpAccess ); +end; + +class operator TOpAccess.NotEqual( const self, AOpAccess : TOpAccess ) : Boolean; +begin + Result := ( self.OpAccess <> AOpAccess.OpAccess ); +end; + +class operator TOpAccess.NotEqual( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; +begin + Result := ( self.OpAccess <> AOpAccess ); +end; + +class operator TOpAccess.In( const self : TOpAccess; const AOpAccess : array of TOpAccessType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AOpAccess ) to High( AOpAccess ) do + begin + if ( self.OpAccess = AOpAccess[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TOpAccess.GreaterThan( const self, AOpAccess : TOpAccess ) : Boolean; +begin + Result := ( self.OpAccess > AOpAccess.OpAccess ); +end; + +class operator TOpAccess.GreaterThan( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; +begin + Result := ( self.OpAccess > AOpAccess ); +end; + +class operator TOpAccess.GreaterThanOrEqual( const self, AOpAccess : TOpAccess ) : Boolean; +begin + Result := ( self.OpAccess >= AOpAccess.OpAccess ); +end; + +class operator TOpAccess.GreaterThanOrEqual( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; +begin + Result := ( self.OpAccess >= AOpAccess ); +end; + +class operator TOpAccess.LessThan( const self, AOpAccess : TOpAccess ) : Boolean; +begin + Result := ( self.OpAccess < AOpAccess.OpAccess ); +end; + +class operator TOpAccess.LessThan( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; +begin + Result := ( self.OpAccess < AOpAccess ); +end; + +class operator TOpAccess.LessThanOrEqual( const self, AOpAccess : TOpAccess ) : Boolean; +begin + Result := ( self.OpAccess <= AOpAccess.OpAccess ); +end; + +class operator TOpAccess.LessThanOrEqual( const self : TOpAccess; const AOpAccess : TOpAccessType ) : Boolean; +begin + Result := ( self.OpAccess <= AOpAccess ); +end; + +class operator TOpAccess.Implicit( const AOpAccess : TOpAccess ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + OpAccess_AsString( AOpAccess.OpAccess, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TOpAccess.Implicit( const AOpAccess : TOpAccess ) : Byte; +begin + result := Byte( AOpAccess.OpAccess ); +end; + +class operator TOpAccess.Implicit( const AOpAccess : Byte ) : TOpAccess; +begin + result.OpAccess := TOpAccess( AOpAccess ); +end; + +class operator TOpAccess.Implicit( const AOpAccess : TOpAccess ) : TOpAccessType; +begin + result := AOpAccess.OpAccess; +end; + +class operator TOpAccess.Implicit( const AOpAccess : TOpAccessType ) : TOpAccess; +begin + result.OpAccess := AOpAccess; +end; +{$ENDIF UNICODE} + +function TOpAccess.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + OpAccess_AsString( self.OpAccess, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TUsedRegister (Record) +function TUsedMemory.AsString : String; +begin + result := segment.AsString + ';'; + + if ( Base.Register <> None ) then + result := result + base.AsString + '+'; + + result := Format( '%s0x%.2x', [ result, displacement ] ); + + if ( index.Register <> None ) then + result := result + ';' + index.AsString + '+' + IntToStr( scale ); + + result := result + ';' + memory_size.AsString + ';' + access.AsString + ';' + address_size.AsString + ';' + IntToStr( vsib_size ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TUsedRegister (Record) +function TUsedRegister.AsString : String; +begin + result := register_.AsString + ':' + access.AsString +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TCodeSize (Record) +{$IFDEF UNICODE} +class operator TCodeSize.Equal( const self, ACodeSize : TCodeSize ) : Boolean; +begin + Result := ( self.CodeSize = ACodeSize.CodeSize ); +end; + +class operator TCodeSize.Equal( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; +begin + Result := ( self.CodeSize = ACodeSize ); +end; + +class operator TCodeSize.NotEqual( const self, ACodeSize : TCodeSize ) : Boolean; +begin + Result := ( self.CodeSize <> ACodeSize.CodeSize ); +end; + +class operator TCodeSize.NotEqual( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; +begin + Result := ( self.CodeSize <> ACodeSize ); +end; + +class operator TCodeSize.In( const self : TCodeSize; const ACodeSize : array of TCodeSizeType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( ACodeSize ) to High( ACodeSize ) do + begin + if ( self.CodeSize = ACodeSize[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TCodeSize.GreaterThan( const self, ACodeSize : TCodeSize ) : Boolean; +begin + Result := ( self.CodeSize > ACodeSize.CodeSize ); +end; + +class operator TCodeSize.GreaterThan( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; +begin + Result := ( self.CodeSize > ACodeSize ); +end; + +class operator TCodeSize.GreaterThanOrEqual( const self, ACodeSize : TCodeSize ) : Boolean; +begin + Result := ( self.CodeSize >= ACodeSize.CodeSize ); +end; + +class operator TCodeSize.GreaterThanOrEqual( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; +begin + Result := ( self.CodeSize >= ACodeSize ); +end; + +class operator TCodeSize.LessThan( const self, ACodeSize : TCodeSize ) : Boolean; +begin + Result := ( self.CodeSize < ACodeSize.CodeSize ); +end; + +class operator TCodeSize.LessThan( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; +begin + Result := ( self.CodeSize < ACodeSize ); +end; + +class operator TCodeSize.LessThanOrEqual( const self, ACodeSize : TCodeSize ) : Boolean; +begin + Result := ( self.CodeSize <= ACodeSize.CodeSize ); +end; + +class operator TCodeSize.LessThanOrEqual( const self : TCodeSize; const ACodeSize : TCodeSizeType ) : Boolean; +begin + Result := ( self.CodeSize <= ACodeSize ); +end; + +class operator TCodeSize.Implicit( const ACodeSize : TCodeSize ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + CodeSize_AsString( ACodeSize.CodeSize, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TCodeSize.Implicit( const ACodeSize : TCodeSize ) : Byte; +begin + result := Byte( ACodeSize.CodeSize ); +end; + +class operator TCodeSize.Implicit( const ACodeSize : Byte ) : TCodeSize; +begin + result.CodeSize := TCodeSize( ACodeSize ); +end; + +class operator TCodeSize.Implicit( const ACodeSize : TCodeSize ) : TCodeSizeType; +begin + result := ACodeSize.CodeSize; +end; + +class operator TCodeSize.Implicit( const ACodeSize : TCodeSizeType ) : TCodeSize; +begin + result.CodeSize := ACodeSize; +end; +{$ENDIF UNICODE} + +function TCodeSize.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + CodeSize_AsString( self.CodeSize, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TRoundingControl (Record) +{$IFDEF UNICODE} +class operator TRoundingControl.Equal( const self, ARoundingControl : TRoundingControl ) : Boolean; +begin + Result := ( self.RoundingControl = ARoundingControl.RoundingControl ); +end; + +class operator TRoundingControl.Equal( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; +begin + Result := ( self.RoundingControl = ARoundingControl ); +end; + +class operator TRoundingControl.NotEqual( const self, ARoundingControl : TRoundingControl ) : Boolean; +begin + Result := ( self.RoundingControl <> ARoundingControl.RoundingControl ); +end; + +class operator TRoundingControl.NotEqual( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; +begin + Result := ( self.RoundingControl <> ARoundingControl ); +end; + +class operator TRoundingControl.In( const self : TRoundingControl; const ARoundingControl : array of TRoundingControlType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( ARoundingControl ) to High( ARoundingControl ) do + begin + if ( self.RoundingControl = ARoundingControl[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TRoundingControl.GreaterThan( const self, ARoundingControl : TRoundingControl ) : Boolean; +begin + Result := ( self.RoundingControl > ARoundingControl.RoundingControl ); +end; + +class operator TRoundingControl.GreaterThan( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; +begin + Result := ( self.RoundingControl > ARoundingControl ); +end; + +class operator TRoundingControl.GreaterThanOrEqual( const self, ARoundingControl : TRoundingControl ) : Boolean; +begin + Result := ( self.RoundingControl >= ARoundingControl.RoundingControl ); +end; + +class operator TRoundingControl.GreaterThanOrEqual( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; +begin + Result := ( self.RoundingControl >= ARoundingControl ); +end; + +class operator TRoundingControl.LessThan( const self, ARoundingControl : TRoundingControl ) : Boolean; +begin + Result := ( self.RoundingControl < ARoundingControl.RoundingControl ); +end; + +class operator TRoundingControl.LessThan( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; +begin + Result := ( self.RoundingControl < ARoundingControl ); +end; + +class operator TRoundingControl.LessThanOrEqual( const self, ARoundingControl : TRoundingControl ) : Boolean; +begin + Result := ( self.RoundingControl <= ARoundingControl.RoundingControl ); +end; + +class operator TRoundingControl.LessThanOrEqual( const self : TRoundingControl; const ARoundingControl : TRoundingControlType ) : Boolean; +begin + Result := ( self.RoundingControl <= ARoundingControl ); +end; + +class operator TRoundingControl.Implicit( const ARoundingControl : TRoundingControl ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + RoundingControl_AsString( ARoundingControl.RoundingControl, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TRoundingControl.Implicit( const ARoundingControl : TRoundingControl ) : Byte; +begin + result := Byte( ARoundingControl.RoundingControl ); +end; + +class operator TRoundingControl.Implicit( const ARoundingControl : Byte ) : TRoundingControl; +begin + result.RoundingControl := TRoundingControl( ARoundingControl ); +end; + +class operator TRoundingControl.Implicit( const ARoundingControl : TRoundingControl ) : TRoundingControlType; +begin + result := ARoundingControl.RoundingControl; +end; + +class operator TRoundingControl.Implicit( const ARoundingControl : TRoundingControlType ) : TRoundingControl; +begin + result.RoundingControl := ARoundingControl; +end; +{$ENDIF UNICODE} + +function TRoundingControl.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + RoundingControl_AsString( self.RoundingControl, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TMvexRegMemConv (Record) +{$IFDEF UNICODE} +class operator TMvexRegMemConv.Equal( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; +begin + Result := ( self.MvexRegMemConv = AMvexRegMemConv.MvexRegMemConv ); +end; + +class operator TMvexRegMemConv.Equal( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; +begin + Result := ( self.MvexRegMemConv = AMvexRegMemConv ); +end; + +class operator TMvexRegMemConv.NotEqual( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; +begin + Result := ( self.MvexRegMemConv <> AMvexRegMemConv.MvexRegMemConv ); +end; + +class operator TMvexRegMemConv.NotEqual( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; +begin + Result := ( self.MvexRegMemConv <> AMvexRegMemConv ); +end; + +class operator TMvexRegMemConv.In( const self : TMvexRegMemConv; const AMvexRegMemConv : array of TMvexRegMemConvType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AMvexRegMemConv ) to High( AMvexRegMemConv ) do + begin + if ( self.MvexRegMemConv = AMvexRegMemConv[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TMvexRegMemConv.GreaterThan( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; +begin + Result := ( self.MvexRegMemConv > AMvexRegMemConv.MvexRegMemConv ); +end; + +class operator TMvexRegMemConv.GreaterThan( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; +begin + Result := ( self.MvexRegMemConv > AMvexRegMemConv ); +end; + +class operator TMvexRegMemConv.GreaterThanOrEqual( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; +begin + Result := ( self.MvexRegMemConv >= AMvexRegMemConv.MvexRegMemConv ); +end; + +class operator TMvexRegMemConv.GreaterThanOrEqual( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; +begin + Result := ( self.MvexRegMemConv >= AMvexRegMemConv ); +end; + +class operator TMvexRegMemConv.LessThan( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; +begin + Result := ( self.MvexRegMemConv < AMvexRegMemConv.MvexRegMemConv ); +end; + +class operator TMvexRegMemConv.LessThan( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; +begin + Result := ( self.MvexRegMemConv < AMvexRegMemConv ); +end; + +class operator TMvexRegMemConv.LessThanOrEqual( const self, AMvexRegMemConv : TMvexRegMemConv ) : Boolean; +begin + Result := ( self.MvexRegMemConv <= AMvexRegMemConv.MvexRegMemConv ); +end; + +class operator TMvexRegMemConv.LessThanOrEqual( const self : TMvexRegMemConv; const AMvexRegMemConv : TMvexRegMemConvType ) : Boolean; +begin + Result := ( self.MvexRegMemConv <= AMvexRegMemConv ); +end; + +class operator TMvexRegMemConv.Implicit( const AMvexRegMemConv : TMvexRegMemConv ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MvexRegMemConv_AsString( AMvexRegMemConv.MvexRegMemConv, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TMvexRegMemConv.Implicit( const AMvexRegMemConv : TMvexRegMemConv ) : Byte; +begin + result := Byte( AMvexRegMemConv.MvexRegMemConv ); +end; + +class operator TMvexRegMemConv.Implicit( const AMvexRegMemConv : Byte ) : TMvexRegMemConv; +begin + result.MvexRegMemConv := TMvexRegMemConv( AMvexRegMemConv ); +end; + +class operator TMvexRegMemConv.Implicit( const AMvexRegMemConv : TMvexRegMemConv ) : TMvexRegMemConvType; +begin + result := AMvexRegMemConv.MvexRegMemConv; +end; + +class operator TMvexRegMemConv.Implicit( const AMvexRegMemConv : TMvexRegMemConvType ) : TMvexRegMemConv; +begin + result.MvexRegMemConv := AMvexRegMemConv; +end; +{$ENDIF UNICODE} + +function TMvexRegMemConv.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MvexRegMemConv_AsString( self.MvexRegMemConv, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TFormatterTextKind (Record) +{$IFDEF UNICODE} +class operator TFormatterTextKind.Equal( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; +begin + Result := ( self.FormatterTextKind = AFormatterTextKind.FormatterTextKind ); +end; + +class operator TFormatterTextKind.Equal( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; +begin + Result := ( self.FormatterTextKind = AFormatterTextKind ); +end; + +class operator TFormatterTextKind.NotEqual( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; +begin + Result := ( self.FormatterTextKind <> AFormatterTextKind.FormatterTextKind ); +end; + +class operator TFormatterTextKind.NotEqual( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; +begin + Result := ( self.FormatterTextKind <> AFormatterTextKind ); +end; + +class operator TFormatterTextKind.In( const self : TFormatterTextKind; const AFormatterTextKind : array of TFormatterTextKindType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AFormatterTextKind ) to High( AFormatterTextKind ) do + begin + if ( self.FormatterTextKind = AFormatterTextKind[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TFormatterTextKind.GreaterThan( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; +begin + Result := ( self.FormatterTextKind > AFormatterTextKind.FormatterTextKind ); +end; + +class operator TFormatterTextKind.GreaterThan( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; +begin + Result := ( self.FormatterTextKind > AFormatterTextKind ); +end; + +class operator TFormatterTextKind.GreaterThanOrEqual( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; +begin + Result := ( self.FormatterTextKind >= AFormatterTextKind.FormatterTextKind ); +end; + +class operator TFormatterTextKind.GreaterThanOrEqual( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; +begin + Result := ( self.FormatterTextKind >= AFormatterTextKind ); +end; + +class operator TFormatterTextKind.LessThan( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; +begin + Result := ( self.FormatterTextKind < AFormatterTextKind.FormatterTextKind ); +end; + +class operator TFormatterTextKind.LessThan( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; +begin + Result := ( self.FormatterTextKind < AFormatterTextKind ); +end; + +class operator TFormatterTextKind.LessThanOrEqual( const self, AFormatterTextKind : TFormatterTextKind ) : Boolean; +begin + Result := ( self.FormatterTextKind <= AFormatterTextKind.FormatterTextKind ); +end; + +class operator TFormatterTextKind.LessThanOrEqual( const self : TFormatterTextKind; const AFormatterTextKind : TFormatterTextKindType ) : Boolean; +begin + Result := ( self.FormatterTextKind <= AFormatterTextKind ); +end; + +class operator TFormatterTextKind.Implicit( const AFormatterTextKind : TFormatterTextKind ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + FormatterTextKind_AsString( AFormatterTextKind.FormatterTextKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TFormatterTextKind.Implicit( const AFormatterTextKind : TFormatterTextKind ) : Byte; +begin + result := Byte( AFormatterTextKind.FormatterTextKind ); +end; + +class operator TFormatterTextKind.Implicit( const AFormatterTextKind : Byte ) : TFormatterTextKind; +begin + result.FormatterTextKind := TFormatterTextKind( AFormatterTextKind ); +end; + +class operator TFormatterTextKind.Implicit( const AFormatterTextKind : TFormatterTextKind ) : TFormatterTextKindType; +begin + result := AFormatterTextKind.FormatterTextKind; +end; + +class operator TFormatterTextKind.Implicit( const AFormatterTextKind : TFormatterTextKindType ) : TFormatterTextKind; +begin + result.FormatterTextKind := AFormatterTextKind; +end; +{$ENDIF UNICODE} + +function TFormatterTextKind.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + FormatterTextKind_AsString( self.FormatterTextKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TRepPrefixKind (Record) +{$IFDEF UNICODE} +class operator TRepPrefixKind.Equal( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; +begin + Result := ( self.RepPrefixKind = ARepPrefixKind.RepPrefixKind ); +end; + +class operator TRepPrefixKind.Equal( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; +begin + Result := ( self.RepPrefixKind = ARepPrefixKind ); +end; + +class operator TRepPrefixKind.NotEqual( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; +begin + Result := ( self.RepPrefixKind <> ARepPrefixKind.RepPrefixKind ); +end; + +class operator TRepPrefixKind.NotEqual( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; +begin + Result := ( self.RepPrefixKind <> ARepPrefixKind ); +end; + +class operator TRepPrefixKind.In( const self : TRepPrefixKind; const ARepPrefixKind : array of TRepPrefixKindType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( ARepPrefixKind ) to High( ARepPrefixKind ) do + begin + if ( self.RepPrefixKind = ARepPrefixKind[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TRepPrefixKind.GreaterThan( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; +begin + Result := ( self.RepPrefixKind > ARepPrefixKind.RepPrefixKind ); +end; + +class operator TRepPrefixKind.GreaterThan( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; +begin + Result := ( self.RepPrefixKind > ARepPrefixKind ); +end; + +class operator TRepPrefixKind.GreaterThanOrEqual( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; +begin + Result := ( self.RepPrefixKind >= ARepPrefixKind.RepPrefixKind ); +end; + +class operator TRepPrefixKind.GreaterThanOrEqual( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; +begin + Result := ( self.RepPrefixKind >= ARepPrefixKind ); +end; + +class operator TRepPrefixKind.LessThan( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; +begin + Result := ( self.RepPrefixKind < ARepPrefixKind.RepPrefixKind ); +end; + +class operator TRepPrefixKind.LessThan( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; +begin + Result := ( self.RepPrefixKind < ARepPrefixKind ); +end; + +class operator TRepPrefixKind.LessThanOrEqual( const self, ARepPrefixKind : TRepPrefixKind ) : Boolean; +begin + Result := ( self.RepPrefixKind <= ARepPrefixKind.RepPrefixKind ); +end; + +class operator TRepPrefixKind.LessThanOrEqual( const self : TRepPrefixKind; const ARepPrefixKind : TRepPrefixKindType ) : Boolean; +begin + Result := ( self.RepPrefixKind <= ARepPrefixKind ); +end; + +class operator TRepPrefixKind.Implicit( const ARepPrefixKind : TRepPrefixKind ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + RepPrefixKind_AsString( ARepPrefixKind.RepPrefixKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TRepPrefixKind.Implicit( const ARepPrefixKind : TRepPrefixKind ) : Byte; +begin + result := Byte( ARepPrefixKind.RepPrefixKind ); +end; + +class operator TRepPrefixKind.Implicit( const ARepPrefixKind : Byte ) : TRepPrefixKind; +begin + result.RepPrefixKind := TRepPrefixKind( ARepPrefixKind ); +end; + +class operator TRepPrefixKind.Implicit( const ARepPrefixKind : TRepPrefixKind ) : TRepPrefixKindType; +begin + result := ARepPrefixKind.RepPrefixKind; +end; + +class operator TRepPrefixKind.Implicit( const ARepPrefixKind : TRepPrefixKindType ) : TRepPrefixKind; +begin + result.RepPrefixKind := ARepPrefixKind; +end; +{$ENDIF UNICODE} + +function TRepPrefixKind.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + RepPrefixKind_AsString( self.RepPrefixKind, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// TMemorySizeOptions (Record) +{$IFDEF UNICODE} +class operator TMemorySizeOptions.Equal( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; +begin + Result := ( self.MemorySizeOptions = AMemorySizeOptions.MemorySizeOptions ); +end; + +class operator TMemorySizeOptions.Equal( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; +begin + Result := ( self.MemorySizeOptions = AMemorySizeOptions ); +end; + +class operator TMemorySizeOptions.NotEqual( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; +begin + Result := ( self.MemorySizeOptions <> AMemorySizeOptions.MemorySizeOptions ); +end; + +class operator TMemorySizeOptions.NotEqual( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; +begin + Result := ( self.MemorySizeOptions <> AMemorySizeOptions ); +end; + +class operator TMemorySizeOptions.In( const self : TMemorySizeOptions; const AMemorySizeOptions : array of TMemorySizeOptionsType ) : Boolean; +var + i : Integer; +begin + result := False; + for i := Low( AMemorySizeOptions ) to High( AMemorySizeOptions ) do + begin + if ( self.MemorySizeOptions = AMemorySizeOptions[ i ] ) then + begin + result := True; + Break; + end; + end; +end; + +class operator TMemorySizeOptions.GreaterThan( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; +begin + Result := ( self.MemorySizeOptions > AMemorySizeOptions.MemorySizeOptions ); +end; + +class operator TMemorySizeOptions.GreaterThan( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; +begin + Result := ( self.MemorySizeOptions > AMemorySizeOptions ); +end; + +class operator TMemorySizeOptions.GreaterThanOrEqual( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; +begin + Result := ( self.MemorySizeOptions >= AMemorySizeOptions.MemorySizeOptions ); +end; + +class operator TMemorySizeOptions.GreaterThanOrEqual( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; +begin + Result := ( self.MemorySizeOptions >= AMemorySizeOptions ); +end; + +class operator TMemorySizeOptions.LessThan( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; +begin + Result := ( self.MemorySizeOptions < AMemorySizeOptions.MemorySizeOptions ); +end; + +class operator TMemorySizeOptions.LessThan( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; +begin + Result := ( self.MemorySizeOptions < AMemorySizeOptions ); +end; + +class operator TMemorySizeOptions.LessThanOrEqual( const self, AMemorySizeOptions : TMemorySizeOptions ) : Boolean; +begin + Result := ( self.MemorySizeOptions <= AMemorySizeOptions.MemorySizeOptions ); +end; + +class operator TMemorySizeOptions.LessThanOrEqual( const self : TMemorySizeOptions; const AMemorySizeOptions : TMemorySizeOptionsType ) : Boolean; +begin + Result := ( self.MemorySizeOptions <= AMemorySizeOptions ); +end; + +class operator TMemorySizeOptions.Implicit( const AMemorySizeOptions : TMemorySizeOptions ) : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MemorySizeOptions_AsString( AMemorySizeOptions.MemorySizeOptions, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +class operator TMemorySizeOptions.Implicit( const AMemorySizeOptions : TMemorySizeOptions ) : Byte; +begin + result := Byte( AMemorySizeOptions.MemorySizeOptions ); +end; + +class operator TMemorySizeOptions.Implicit( const AMemorySizeOptions : Byte ) : TMemorySizeOptions; +begin + result.MemorySizeOptions := TMemorySizeOptions( AMemorySizeOptions ); +end; + +class operator TMemorySizeOptions.Implicit( const AMemorySizeOptions : TMemorySizeOptions ) : TMemorySizeOptionsType; +begin + result := AMemorySizeOptions.MemorySizeOptions; +end; + +class operator TMemorySizeOptions.Implicit( const AMemorySizeOptions : TMemorySizeOptionsType ) : TMemorySizeOptions; +begin + result.MemorySizeOptions := AMemorySizeOptions; +end; +{$ENDIF UNICODE} + +function TMemorySizeOptions.AsString : String; +var + tOutput : Array [ 0..255 ] of AnsiChar; +begin + FillChar( tOutput[ 0 ], Length( tOutput ), 0 ); + MemorySizeOptions_AsString( self.MemorySizeOptions, @tOutput[ 0 ], Length( tOutput ) ); + result := String( tOutput ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// MemoryOperand (Record) +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +class function TMemoryOperand.New( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := ABase; + result.Index.Register := AIndex; + result.Scale := AScale; + result.Displacement := ADisplacement; + result.displ_size := ADisplSize; + result.is_broadcast := AIsBroadcast; + result.segment_prefix.Register := ASegmentPrefix; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +class function TMemoryOperand.With_Base_Index_Scale_Bcst_Seg( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := ABase; + result.Index.Register := AIndex; + result.Scale := AScale; + result.Displacement := 0; + result.displ_size := 0; + result.is_broadcast := AIsBroadcast; + result.segment_prefix.Register := ASegmentPrefix; +end; + +// # Arguments +// +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +class function TMemoryOperand.With_Base_Displ_Size_Bcst_Seg( ABase: TRegisterType; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := ABase; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := ADisplacement; + result.displ_size := ADisplSize; + result.is_broadcast := AIsBroadcast; + result.segment_prefix.Register := ASegmentPrefix; +end; + +// # Arguments +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +class function TMemoryOperand.With_Index_Scale_Displ_Size_Bcst_Seg( AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := None; + result.Index.Register := AIndex; + result.Scale := AScale; + result.Displacement := ADisplacement; + result.displ_size := ADisplSize; + result.is_broadcast := AIsBroadcast; + result.segment_prefix.Register := ASegmentPrefix; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +class function TMemoryOperand.With_Base_Displ_Bcst_Seg( ABase: TRegisterType; ADisplacement: Int64; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := ABase; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := ADisplacement; + result.displ_size := 1; + result.is_broadcast := AIsBroadcast; + result.segment_prefix.Register := ASegmentPrefix; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +class function TMemoryOperand.With_Base_Index_Scale_DisplSize( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal ) : TMemoryOperand; +begin + result.Base.Register := ABase; + result.Index.Register := AIndex; + result.Scale := AScale; + result.Displacement := ADisplacement; + result.displ_size := ADisplSize; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +class function TMemoryOperand.With_Base_Index_Scale( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal ) : TMemoryOperand; +begin + result.Base.Register := ABase; + result.Index.Register := AIndex; + result.Scale := AScale; + result.Displacement := 0; + result.displ_size := 0; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +class function TMemoryOperand.With_Base_Index( ABase: TRegisterType; AIndex: TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := ABase; + result.Index.Register := AIndex; + result.Scale := 1; + result.Displacement := 0; + result.displ_size := 0; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +class function TMemoryOperand.With_Base_Displ_Size( ABase: TRegisterType; ADisplacement: Int64; ADisplSize : Cardinal ) : TMemoryOperand; +begin + result.Base.Register := ABase; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := ADisplacement; + result.displ_size := ADisplSize; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +class function TMemoryOperand.With_Index_Scale_Displ_Size( AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal ) : TMemoryOperand; +begin + result.Base.Register := None; + result.Index.Register := AIndex; + result.Scale := AScale; + result.Displacement := ADisplacement; + result.displ_size := ADisplSize; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +class function TMemoryOperand.With_Base_Displ( ABase: TRegisterType; ADisplacement: Int64 ) : TMemoryOperand; +begin + result.Base.Register := ABase; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := ADisplacement; + result.displ_size := 1; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +class function TMemoryOperand.With_Base( ABase: TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := ABase; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := 0; + result.displ_size := 0; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `displacement`: Memory displacement +// * `displ_size`: 2 (16-bit), 4 (32-bit) or 8 (64-bit) +class function TMemoryOperand.With_Displ( ADisplacement: Int64; ADisplSize : Cardinal ) : TMemoryOperand; +begin + result.Base.Register := None; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := ADisplacement; + result.displ_size := ADisplSize; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +constructor TMemoryOperand.From( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ); +begin + inherited; + + self.Base.Register := ABase; + self.Index.Register := AIndex; + self.Scale := AScale; + self.Displacement := ADisplacement; + self.displ_size := ADisplSize; + self.is_broadcast := AIsBroadcast; + self.segment_prefix.Register := ASegmentPrefix; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +constructor TMemoryOperand.From_Base_Index_Scale_Bcst_Seg( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ); +begin + inherited; + + self.Base.Register := ABase; + self.Index.Register := AIndex; + self.Scale := AScale; + self.Displacement := 0; + self.displ_size := 0; + self.is_broadcast := AIsBroadcast; + self.segment_prefix.Register := ASegmentPrefix; +end; + +// # Arguments +// +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +constructor TMemoryOperand.From_Base_Displ_Size_Bcst_Seg( ABase: TRegisterType; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ); +begin + inherited; + + self.Base.Register := ABase; + self.Index.Register := None; + self.Scale := 1; + self.Displacement := ADisplacement; + self.displ_size := ADisplSize; + self.is_broadcast := AIsBroadcast; + self.segment_prefix.Register := ASegmentPrefix; +end; + +// # Arguments +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +constructor TMemoryOperand.From_Index_Scale_Displ_Size_Bcst_Seg( AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ); +begin + inherited; + + self.Base.Register := None; + self.Index.Register := AIndex; + self.Scale := AScale; + self.Displacement := ADisplacement; + self.displ_size := ADisplSize; + self.is_broadcast := AIsBroadcast; + self.segment_prefix.Register := ASegmentPrefix; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +constructor TMemoryOperand.From_Base_Displ_Bcst_Seg( ABase: TRegisterType; ADisplacement: Int64; AIsBroadcast : Boolean; ASegmentPrefix : TRegisterType ); +begin + inherited; + + self.Base.Register := ABase; + self.Index.Register := None; + self.Scale := 1; + self.Displacement := ADisplacement; + self.displ_size := 1; + self.is_broadcast := AIsBroadcast; + self.segment_prefix.Register := ASegmentPrefix; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +constructor TMemoryOperand.From_Base_Index_Scale_DisplSize( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal ); +begin + inherited; + + self.Base.Register := ABase; + self.Index.Register := AIndex; + self.Scale := AScale; + self.Displacement := ADisplacement; + self.displ_size := ADisplSize; + self.is_broadcast := False; + self.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +constructor TMemoryOperand.From_Base_Index_Scale( ABase: TRegisterType; AIndex: TRegisterType; AScale: Cardinal ); +begin + inherited; + + self.Base.Register := ABase; + self.Index.Register := AIndex; + self.Scale := AScale; + self.Displacement := 0; + self.displ_size := 0; + self.is_broadcast := False; + self.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +constructor TMemoryOperand.From_Base_Index( ABase: TRegisterType; AIndex: TRegisterType ); +begin + inherited; + + self.Base.Register := ABase; + self.Index.Register := AIndex; + self.Scale := 1; + self.Displacement := 0; + self.displ_size := 0; + self.is_broadcast := False; + self.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +constructor TMemoryOperand.From_Base_Displ_Size( ABase: TRegisterType; ADisplacement: Int64; ADisplSize : Cardinal ); +begin + inherited; + + self.Base.Register := ABase; + self.Index.Register := None; + self.Scale := 1; + self.Displacement := ADisplacement; + self.displ_size := ADisplSize; + self.is_broadcast := False; + self.segment_prefix.Register := None; +end; + +// # Arguments +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +constructor TMemoryOperand.From_Index_Scale_Displ_Size( AIndex: TRegisterType; AScale: Cardinal; ADisplacement: Int64; ADisplSize : Cardinal ); +begin + inherited; + + self.Base.Register := None; + self.Index.Register := AIndex; + self.Scale := AScale; + self.Displacement := ADisplacement; + self.displ_size := ADisplSize; + self.is_broadcast := False; + self.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +constructor TMemoryOperand.From_Base_Displ( ABase: TRegisterType; ADisplacement: Int64 ); +begin + inherited; + + self.Base.Register := ABase; + self.Index.Register := None; + self.Scale := 1; + self.Displacement := ADisplacement; + self.displ_size := 1; + self.is_broadcast := False; + self.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +constructor TMemoryOperand.From_Base( ABase: TRegisterType ); +begin + inherited; + + self.Base.Register := ABase; + self.Index.Register := None; + self.Scale := 1; + self.Displacement := 0; + self.displ_size := 0; + self.is_broadcast := False; + self.segment_prefix.Register := None; +end; + +// # Arguments +// * `displacement`: Memory displacement +// * `displ_size`: 2 (16-bit), 4 (32-bit) or 8 (64-bit) +constructor TMemoryOperand.From_Displ( ADisplacement: Int64; ADisplSize : Cardinal ); +begin + inherited; + + self.Base.Register := None; + self.Index.Register := None; + self.Scale := 1; + self.Displacement := ADisplacement; + self.displ_size := ADisplSize; + self.is_broadcast := False; + self.segment_prefix.Register := None; +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// MemoryOperand +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +function MemoryOperand_New( Base: TRegisterType; Index: TRegisterType; Scale: Cardinal; Displacement: Int64; DisplSize : Cardinal; IsBroadcast : Boolean; SegmentPrefix : TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := Base; + result.Index.Register := Index; + result.Scale := Scale; + result.Displacement := Displacement; + result.displ_size := DisplSize; + result.is_broadcast := IsBroadcast; + result.segment_prefix.Register := SegmentPrefix; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +function MemoryOperand_With_Base_Index_Scale_Bcst_Seg( Base: TRegisterType; Index: TRegisterType; Scale: Cardinal; IsBroadcast : Boolean; SegmentPrefix : TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := Base; + result.Index.Register := Index; + result.Scale := Scale; + result.Displacement := 0; + result.displ_size := 0; + result.is_broadcast := IsBroadcast; + result.segment_prefix.Register := SegmentPrefix; +end; + +// # Arguments +// +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +function MemoryOperand_With_Base_Displ_Size_Bcst_Seg( Base: TRegisterType; Displacement: Int64; DisplSize : Cardinal; IsBroadcast : Boolean; SegmentPrefix : TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := Base; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := Displacement; + result.displ_size := DisplSize; + result.is_broadcast := IsBroadcast; + result.segment_prefix.Register := SegmentPrefix; +end; + +// # Arguments +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +function MemoryOperand_With_Index_Scale_Displ_Size_Bcst_Seg( Index: TRegisterType; Scale: Cardinal; Displacement: Int64; DisplSize : Cardinal; IsBroadcast : Boolean; SegmentPrefix : TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := None; + result.Index.Register := Index; + result.Scale := Scale; + result.Displacement := Displacement; + result.displ_size := DisplSize; + result.is_broadcast := IsBroadcast; + result.segment_prefix.Register := SegmentPrefix; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +// * `is_broadcast`: `true` if it's broadcast memory (EVEX instructions) +// * `segment_prefix`: Segment override or [`Register::None`] +function MemoryOperand_With_Base_Displ_Bcst_Seg( Base: TRegisterType; Displacement: Int64; IsBroadcast : Boolean; SegmentPrefix : TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := Base; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := Displacement; + result.displ_size := 1; + result.is_broadcast := IsBroadcast; + result.segment_prefix.Register := SegmentPrefix; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +function MemoryOperand_With_Base_Index_Scale_DisplSize( Base: TRegisterType; Index: TRegisterType; Scale: Cardinal; Displacement: Int64; DisplSize : Cardinal ) : TMemoryOperand; +begin + result.Base.Register := Base; + result.Index.Register := Index; + result.Scale := Scale; + result.Displacement := Displacement; + result.displ_size := DisplSize; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +function MemoryOperand_With_Base_Index_Scale( Base: TRegisterType; Index: TRegisterType; Scale: Cardinal ) : TMemoryOperand; +begin + result.Base.Register := Base; + result.Index.Register := Index; + result.Scale := Scale; + result.Displacement := 0; + result.displ_size := 0; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `index`: Index register or [`Register::None`] +function MemoryOperand_With_Base_Index( Base: TRegisterType; Index: TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := Base; + result.Index.Register := Index; + result.Scale := 1; + result.Displacement := 0; + result.displ_size := 0; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +function MemoryOperand_With_Base_Displ_Size( Base: TRegisterType; Displacement: Int64; DisplSize : Cardinal ) : TMemoryOperand; +begin + result.Base.Register := Base; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := Displacement; + result.displ_size := DisplSize; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `index`: Index register or [`Register::None`] +// * `scale`: Index register scale (1, 2, 4, or 8) +// * `displacement`: Memory displacement +// * `displ_size`: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) +function MemoryOperand_With_Index_Scale_Displ_Size( Index: TRegisterType; Scale: Cardinal; Displacement: Int64; DisplSize : Cardinal ) : TMemoryOperand; +begin + result.Base.Register := None; + result.Index.Register := Index; + result.Scale := Scale; + result.Displacement := Displacement; + result.displ_size := DisplSize; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +// * `displacement`: Memory displacement +function MemoryOperand_With_Base_Displ( Base: TRegisterType; Displacement: Int64 ) : TMemoryOperand; +begin + result.Base.Register := Base; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := Displacement; + result.displ_size := 1; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `base`: Base register or [`Register::None`] +function MemoryOperand_With_Base( Base: TRegisterType ) : TMemoryOperand; +begin + result.Base.Register := Base; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := 0; + result.displ_size := 0; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// # Arguments +// * `displacement`: Memory displacement +// * `displ_size`: 2 (16-bit), 4 (32-bit) or 8 (64-bit) +function MemoryOperand_With_Displ( Displacement: Int64; DisplSize : Cardinal ) : TMemoryOperand; +begin + result.Base.Register := None; + result.Index.Register := None; + result.Scale := 1; + result.Displacement := Displacement; + result.displ_size := DisplSize; + result.is_broadcast := False; + result.segment_prefix.Register := None; +end; + +// Instruction 'WITH' +// Creates an instruction with no operands +class function TInstruction.With_( ACode : TCodeType ) : TInstruction; +begin + if NOT Instruction_With( result, ACode ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +// Creates an instruction with 1 operand +// +// # Errors +// Fails if one of the operands is invalid (basic checks) +class function TInstruction.With1( ACode : TCodeType; ARegister_ : TRegisterType ) : TInstruction; +begin + if NOT Instruction_With1_Register( result, ACode, ARegister_ ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With1( ACode : TCodeType; AImmediate : Integer ) : TInstruction; +begin + if NOT Instruction_With1_i32( result, ACode, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With1( ACode : TCodeType; AImmediate : Cardinal ) : TInstruction; +begin + if NOT Instruction_With1_u32( result, ACode, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With1( ACode : TCodeType; AMemory : TMemoryOperand ) : TInstruction; +begin + if NOT Instruction_With1_Memory( result, ACode, AMemory ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType ) : TInstruction; +begin + if NOT Instruction_With2_Register_Register( result, ACode, ARegister1, ARegister2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Integer ) : TInstruction; +begin + if NOT Instruction_With2_Register_i32( result, ACode, ARegister_, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Cardinal ) : TInstruction; +begin + if NOT Instruction_With2_Register_u32( result, ACode, ARegister_, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Int64 ) : TInstruction; +begin + if NOT Instruction_With2_Register_i64( result, ACode, ARegister_, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : UInt64 ) : TInstruction; +begin + if NOT Instruction_With2_Register_u64( result, ACode, ARegister_, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; ARegister_ : TRegisterType; AMemory : TMemoryOperand ) : TInstruction; +begin + if NOT Instruction_With2_Register_MemoryOperand( result, ACode, ARegister_, AMemory ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; AImmediate : Integer; ARegister_ : TRegisterType ) : TInstruction; +begin + if NOT Instruction_With2_i32_Register( result, ACode, AImmediate, ARegister_ ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; AImmediate : Cardinal; ARegister_ : TRegisterType ) : TInstruction; +begin + if NOT Instruction_With2_u32_Register( result, ACode, AImmediate, ARegister_ ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; AImmediate1 : Integer; AImmediate2 : Integer ) : TInstruction; +begin + if NOT Instruction_With2_i32_i32( result, ACode, AImmediate1, AImmediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ) : TInstruction; +begin + if NOT Instruction_With2_u32_u32( result, ACode, AImmediate1, AImmediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType ) : TInstruction; +begin + if NOT Instruction_With2_MemoryOperand_Register( result, ACode, AMemory, ARegister_ ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; AMemory : TMemoryOperand; AImmediate : Integer ) : TInstruction; +begin + if NOT Instruction_With2_MemoryOperand_i32( result, ACode, AMemory, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With2( ACode : TCodeType; AMemory : TMemoryOperand; AImmediate : Cardinal ) : TInstruction; +begin + if NOT Instruction_With2_MemoryOperand_u32( result, ACode, AMemory, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType ) : TInstruction; +begin + if NOT Instruction_With3_Register_Register_Register( result, ACode, ARegister1, ARegister2, ARegister3 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate : Integer ) : TInstruction; +begin + if NOT Instruction_With3_Register_Register_i32( result, ACode, ARegister1, ARegister2, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate : Cardinal ) : TInstruction; +begin + if NOT Instruction_With3_Register_Register_u32( result, ACode, ARegister1, ARegister2, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand ) : TInstruction; +begin + if NOT Instruction_With3_Register_Register_MemoryOperand( result, ACode, ARegister1, ARegister2, AMemory ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate1 : Integer; AImmediate2 : Integer ) : TInstruction; +begin + if NOT Instruction_With3_Register_i32_i32( result, ACode, ARegister_, AImmediate1, AImmediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ) : TInstruction; +begin + if NOT Instruction_With3_Register_u32_u32( result, ACode, ARegister_, AImmediate1, AImmediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; ARegister1 : TRegisterType; AMemory : TMemoryOperand; ARegister2 : TRegisterType ) : TInstruction; +begin + if NOT Instruction_With3_Register_MemoryOperand_Register( result, ACode, ARegister1, AMemory, ARegister2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; ARegister1 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ) : TInstruction; +begin + if NOT Instruction_With3_Register_MemoryOperand_i32( result, ACode, ARegister1, AMemory, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; ARegister_ : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ) : TInstruction; +begin + if NOT Instruction_With3_Register_MemoryOperand_u32( result, ACode, ARegister_, AMemory, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister1 : TRegisterType; ARegister2 : TRegisterType ) : TInstruction; +begin + if NOT Instruction_With3_MemoryOperand_Register_Register( result, ACode, AMemory, ARegister1, ARegister2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType; AImmediate : Integer ) : TInstruction; +begin + if NOT Instruction_With3_MemoryOperand_Register_i32( result, ACode, AMemory, ARegister_, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType; AImmediate : Cardinal ) : TInstruction; +begin + if NOT Instruction_With3_MemoryOperand_Register_u32( result, ACode, AMemory, ARegister_, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType ) : TInstruction; +begin + if NOT Instruction_With4_Register_Register_Register_Register( result, ACode, ARegister1, ARegister2, ARegister3, ARegister4 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AImmediate : Integer ) : TInstruction; +begin + if NOT Instruction_With4_Register_Register_Register_i32( result, ACode, ARegister1, ARegister2, ARegister3, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AImmediate : Cardinal ) : TInstruction; +begin + if NOT Instruction_With4_Register_Register_Register_u32( result, ACode, ARegister1, ARegister2, ARegister3, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand ) : TInstruction; +begin + if NOT Instruction_With4_Register_Register_Register_MemoryOperand( result, ACode, ARegister1, ARegister2, ARegister3, AMemory ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate1 : Integer; AImmediate2 : Integer ) : TInstruction; +begin + if NOT Instruction_With4_Register_Register_i32_i32( result, ACode, ARegister1, ARegister2, AImmediate1, AImmediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ) : TInstruction; +begin + if NOT Instruction_With4_Register_Register_u32_u32( result, ACode, ARegister1, ARegister2, AImmediate1, AImmediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType ) : TInstruction; +begin + if NOT Instruction_With4_Register_Register_MemoryOperand_Register( result, ACode, ARegister1, ARegister2, AMemory, ARegister3 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ) : TInstruction; +begin + if NOT Instruction_With4_Register_Register_MemoryOperand_i32( result, ACode, ARegister1, ARegister2, AMemory, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ) : TInstruction; +begin + if NOT Instruction_With4_Register_Register_MemoryOperand_u32( result, ACode, ARegister1, ARegister2, AMemory, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType; AImmediate : Integer ) : TInstruction; +begin + if NOT Instruction_With5_Register_Register_Register_Register_i32( result, ACode, ARegister1, ARegister2, ARegister3, ARegister4, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType; AImmediate : Cardinal ) : TInstruction; +begin + if NOT Instruction_With5_Register_Register_Register_Register_u32( result, ACode, ARegister1, ARegister2, ARegister3, ARegister4, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ) : TInstruction; +begin + if NOT Instruction_With5_Register_Register_Register_MemoryOperand_i32( result, ACode, ARegister1, ARegister2, ARegister3, AMemory, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ) : TInstruction; +begin + if NOT Instruction_With5_Register_Register_Register_MemoryOperand_u32( result, ACode, ARegister1, ARegister2, ARegister3, AMemory, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType; AImmediate : Integer ) : TInstruction; +begin + if NOT Instruction_With5_Register_Register_MemoryOperand_Register_i32( result, ACode, ARegister1, ARegister2, AMemory, ARegister3, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType; AImmediate : Cardinal ) : TInstruction; +begin + if NOT Instruction_With5_Register_Register_MemoryOperand_Register_u32( result, ACode, ARegister1, ARegister2, AMemory, ARegister3, AImmediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Branch( ACode : TCodeType; Target : UInt64 ) : TInstruction; +begin + if NOT Instruction_With_Branch( result, ACode, Target ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Far_Branch( ACode : TCodeType; Selector : Word; Offset : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Far_Branch( result, ACode, Selector, Offset ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_xbegin( Bitness : Cardinal; Target : UInt64 ) : TInstruction; +begin + if NOT Instruction_With_xbegin( result, Bitness, Target ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_outsb( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_outsb( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_outsb( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_outsb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_outsw( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_outsw( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_outsw( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_outsw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_outsd( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_outsd( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_outsd( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_outsd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_lodsb( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_lodsb( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_lodsb( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_lodsb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_lodsw( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_lodsw( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_lodsw( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_lodsw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_lodsd( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_lodsd( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_lodsd( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_lodsd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_lodsq( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_lodsq( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_lodsq( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_lodsq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_scasb( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_scasb( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repe_scasb( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_scasb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repne_scasb( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_scasb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_scasw( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_scasw( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repe_scasw( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_scasw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repne_scasw( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_scasw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_scasd( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_scasd( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repe_scasd( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_scasd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repne_scasd( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_scasd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_scasq( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_scasq( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repe_scasq( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_scasq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repne_scasq( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_scasq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_insb( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_insb( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_insb( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_insb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_insw( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_insw( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_insw( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_insw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_insd( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_insd( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_insd( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_insd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_stosb( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_stosb( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_stosb( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_stosb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_stosw( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_stosw( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_stosw( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_stosw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_stosd( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_stosd( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_stosd( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_stosd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_stosq( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_stosq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_cmpsb( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_cmpsb( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repe_cmpsb( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_cmpsb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repne_cmpsb( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_cmpsb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_cmpsw( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_cmpsw( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repe_cmpsw( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_cmpsw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repne_cmpsw( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_cmpsw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_cmpsd( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_cmpsd( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repe_cmpsd( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_cmpsd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repne_cmpsd( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_cmpsd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_cmpsq( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_cmpsq( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repe_cmpsq( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_cmpsq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Repne_cmpsq( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_cmpsq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_movsb( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_movsb( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_movsb( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_movsb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_movsw( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_movsw( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_movsw( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_movsw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_movsd( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_movsd( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_movsd( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_movsd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_movsq( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_movsq( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Rep_movsq( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_movsq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_maskmovq( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_maskmovq( result, AAddressSize, Register1, Register2, ASegmentPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_maskmovdqu( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_maskmovdqu( result, AAddressSize, Register1, Register2, ASegmentPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_vmaskmovdqu( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_vmaskmovdqu( result, AAddressSize, Register1, Register2, ASegmentPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( Bytes : Array of Byte ) : TInstruction; +begin + case Length( Bytes ) of + 1 : begin + if NOT Instruction_With_Declare_Byte_1( result, Bytes[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Byte_2( result, Bytes[ 0 ], Bytes[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Byte_3( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Byte_4( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Byte_5( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Byte_6( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Byte_7( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Byte_8( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 9 : begin + if NOT Instruction_With_Declare_Byte_9( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 10 : begin + if NOT Instruction_With_Declare_Byte_10( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 11 : begin + if NOT Instruction_With_Declare_Byte_11( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 12 : begin + if NOT Instruction_With_Declare_Byte_12( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 13 : begin + if NOT Instruction_With_Declare_Byte_13( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 14 : begin + if NOT Instruction_With_Declare_Byte_14( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ], Bytes[ 13 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 15 : begin + if NOT Instruction_With_Declare_Byte_15( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ], Bytes[ 13 ], Bytes[ 14 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 16 : begin + if NOT Instruction_With_Declare_Byte_16( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ], Bytes[ 13 ], Bytes[ 14 ], Bytes[ 14 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +class function TInstruction.With_Declare_Byte( Bytes : PByte; Count : Byte ) : TInstruction; +type + TByteArray = Array [ 0..15 ] of Byte; + PByteArray = ^TByteArray; +var + ByteArray : PByteArray absolute Bytes; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_Byte_1( result, ByteArray^[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Byte_2( result, ByteArray^[ 0 ], ByteArray^[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Byte_3( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Byte_4( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Byte_5( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Byte_6( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Byte_7( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Byte_8( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 9 : begin + if NOT Instruction_With_Declare_Byte_9( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 10 : begin + if NOT Instruction_With_Declare_Byte_10( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 11 : begin + if NOT Instruction_With_Declare_Byte_11( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 12 : begin + if NOT Instruction_With_Declare_Byte_12( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 13 : begin + if NOT Instruction_With_Declare_Byte_13( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 14 : begin + if NOT Instruction_With_Declare_Byte_14( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ], ByteArray^[ 13 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 15 : begin + if NOT Instruction_With_Declare_Byte_15( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ], ByteArray^[ 13 ], ByteArray^[ 14 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 16 : begin + if NOT Instruction_With_Declare_Byte_16( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ], ByteArray^[ 13 ], ByteArray^[ 14 ], ByteArray^[ 14 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_1( result, B0 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_2( result, B0, B1 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_3( result, B0, B1, B2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_4( result, B0, B1, B2, B3 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_5( result, B0, B1, B2, B3 , B4 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_6( result, B0, B1, B2, B3 , B4, B5 ) then + FillChar( result, SizeOf( result ), 0 ); +end; +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_7( result, B0, B1, B2, B3 , B4, B5, B6 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_8( result, B0, B1, B2, B3 , B4, B5, B6, B7 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_9( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_10( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9 ) then + FillChar( result, SizeOf( result ), 0 ); +end; +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_11( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_12( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_13( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_14( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12, B13 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_15( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte; B15 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_16( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Word( Words : Array of Word ) : TInstruction; +begin + case Length( Words ) of + 1 : begin + if NOT Instruction_With_Declare_Word_1( result, Words[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Word_2( result, Words[ 0 ], Words[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Word_3( result, Words[ 0 ], Words[ 1 ], Words[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Word_4( result, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Word_5( result, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Word_6( result, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ], Words[ 5 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Word_7( result, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ], Words[ 5 ], Words[ 6 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Word_8( result, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ], Words[ 5 ], Words[ 6 ], Words[ 7 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +class function TInstruction.With_Declare_Word( Words : PWord; Count : Byte ) : TInstruction; +type + TWordArray = Array [ 0..7 ] of Word; + PWordArray = ^TWordArray; +var + WordArray : PWordArray absolute Words; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_Word_1( result, WordArray^[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Word_2( result, WordArray^[ 0 ], WordArray^[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Word_3( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Word_4( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Word_5( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Word_6( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ], WordArray^[ 5 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Word_7( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ], WordArray^[ 5 ], WordArray^[ 6 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Word_8( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ], WordArray^[ 5 ], WordArray^[ 6 ], WordArray^[ 7 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +class function TInstruction.With_Declare_Word( W0 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_1( result, W0 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Word( W0 : Word; W1 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_2( result, W0, W1 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Word( W0 : Word; W1 : Word; W2 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_3( result, W0, W1, W2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_4( result, W0, W1, W2, W3 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_5( result, W0, W1, W2, W3, W4 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_6( result, W0, W1, W2, W3, W4, W5 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_7( result, W0, W1, W2, W3, W4, W5, W6 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word; W7 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_8( result, W0, W1, W2, W3, W4, W5, W6, W7 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_DWord( DWords : Array of Cardinal ) : TInstruction; +begin + case Length( DWords ) of + 1 : begin + if NOT Instruction_With_Declare_DWord_1( result, DWords[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_DWord_2( result, DWords[ 0 ], DWords[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_DWord_3( result, DWords[ 0 ], DWords[ 1 ], DWords[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_DWord_4( result, DWords[ 0 ], DWords[ 1 ], DWords[ 2 ], DWords[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +class function TInstruction.With_Declare_DWord( DWords : PCardinal; Count : Byte ) : TInstruction; +type + TDWordArray = Array [ 0..3 ] of Cardinal; + PDWordArray = ^TDWordArray; +var + DWordArray : PDWordArray absolute DWords; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_DWord_1( result, DWordArray^[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_DWord_2( result, DWordArray^[ 0 ], DWordArray^[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_DWord_3( result, DWordArray^[ 0 ], DWordArray^[ 1 ], DWordArray^[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_DWord_4( result, DWordArray^[ 0 ], DWordArray^[ 1 ], DWordArray^[ 2 ], DWordArray^[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +class function TInstruction.With_Declare_DWord( D0 : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Declare_DWord_1( result, D0 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_DWord( D0 : Cardinal; D1 : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Declare_DWord_2( result, D0, D1 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_DWord( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Declare_DWord_3( result, D0, D1, D2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_DWord( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal; D3 : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Declare_DWord_4( result, D0, D1, D2, D3 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_QWord( QWords : Array of UInt64 ) : TInstruction; +begin + case Length( QWords ) of + 1 : begin + if NOT Instruction_With_Declare_QWord_1( result, QWords[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_QWord_2( result, QWords[ 0 ], QWords[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +class function TInstruction.With_Declare_QWord( QWords : PUInt64; Count : Byte ) : TInstruction; +type + TQWordArray = Array [ 0..1 ] of UInt64; + PQWordArray = ^TQWordArray; +var + QWordArray : PQWordArray absolute QWords; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_QWord_1( result, QWordArray^[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_QWord_2( result, QWordArray^[ 0 ], QWordArray^[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +class function TInstruction.With_Declare_QWord( Q0 : UInt64 ) : TInstruction; +begin + if NOT Instruction_With_Declare_QWord_1( result, Q0 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +class function TInstruction.With_Declare_QWord( Q0 : UInt64; Q1 : UInt64 ) : TInstruction; +begin + if NOT Instruction_With_Declare_QWord_2( result, Q0, Q1 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +// Instruction 'WITH' +// Creates an instruction with no operands +constructor TInstruction.From( ACode : TCodeType ); +begin + if NOT Instruction_With( self, ACode ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +// Creates an instruction with 1 operand +// +// # Errors +// Fails if one of the operands is invalid (basic checks) +constructor TInstruction.From1( ACode : TCodeType; ARegister_ : TRegisterType ); +begin + if NOT Instruction_With1_Register( self, ACode, ARegister_ ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From1( ACode : TCodeType; AImmediate : Integer ); +begin + if NOT Instruction_With1_i32( self, ACode, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From1( ACode : TCodeType; AImmediate : Cardinal ); +begin + if NOT Instruction_With1_u32( self, ACode, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From1( ACode : TCodeType; AMemory : TMemoryOperand ); +begin + if NOT Instruction_With1_Memory( self, ACode, AMemory ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType ); +begin + if NOT Instruction_With2_Register_Register( self, ACode, ARegister1, ARegister2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Integer ); +begin + if NOT Instruction_With2_Register_i32( self, ACode, ARegister_, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Cardinal ); +begin + if NOT Instruction_With2_Register_u32( self, ACode, ARegister_, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : Int64 ); +begin + if NOT Instruction_With2_Register_i64( self, ACode, ARegister_, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate : UInt64 ); +begin + if NOT Instruction_With2_Register_u64( self, ACode, ARegister_, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; ARegister_ : TRegisterType; AMemory : TMemoryOperand ); +begin + if NOT Instruction_With2_Register_MemoryOperand( self, ACode, ARegister_, AMemory ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; AImmediate : Integer; ARegister_ : TRegisterType ); +begin + if NOT Instruction_With2_i32_Register( self, ACode, AImmediate, ARegister_ ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; AImmediate : Cardinal; ARegister_ : TRegisterType ); +begin + if NOT Instruction_With2_u32_Register( self, ACode, AImmediate, ARegister_ ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; AImmediate1 : Integer; AImmediate2 : Integer ); +begin + if NOT Instruction_With2_i32_i32( self, ACode, AImmediate1, AImmediate2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ); +begin + if NOT Instruction_With2_u32_u32( self, ACode, AImmediate1, AImmediate2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType ); +begin + if NOT Instruction_With2_MemoryOperand_Register( self, ACode, AMemory, ARegister_ ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; AMemory : TMemoryOperand; AImmediate : Integer ); +begin + if NOT Instruction_With2_MemoryOperand_i32( self, ACode, AMemory, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From2( ACode : TCodeType; AMemory : TMemoryOperand; AImmediate : Cardinal ); +begin + if NOT Instruction_With2_MemoryOperand_u32( self, ACode, AMemory, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType ); +begin + if NOT Instruction_With3_Register_Register_Register( self, ACode, ARegister1, ARegister2, ARegister3 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate : Integer ); +begin + if NOT Instruction_With3_Register_Register_i32( self, ACode, ARegister1, ARegister2, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate : Cardinal ); +begin + if NOT Instruction_With3_Register_Register_u32( self, ACode, ARegister1, ARegister2, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand ); +begin + if NOT Instruction_With3_Register_Register_MemoryOperand( self, ACode, ARegister1, ARegister2, AMemory ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate1 : Integer; AImmediate2 : Integer ); +begin + if NOT Instruction_With3_Register_i32_i32( self, ACode, ARegister_, AImmediate1, AImmediate2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; ARegister_ : TRegisterType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ); +begin + if NOT Instruction_With3_Register_u32_u32( self, ACode, ARegister_, AImmediate1, AImmediate2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; ARegister1 : TRegisterType; AMemory : TMemoryOperand; ARegister2 : TRegisterType ); +begin + if NOT Instruction_With3_Register_MemoryOperand_Register( self, ACode, ARegister1, AMemory, ARegister2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; ARegister1 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ); +begin + if NOT Instruction_With3_Register_MemoryOperand_i32( self, ACode, ARegister1, AMemory, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; ARegister_ : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ); +begin + if NOT Instruction_With3_Register_MemoryOperand_u32( self, ACode, ARegister_, AMemory, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister1 : TRegisterType; ARegister2 : TRegisterType ); +begin + if NOT Instruction_With3_MemoryOperand_Register_Register( self, ACode, AMemory, ARegister1, ARegister2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType; AImmediate : Integer ); +begin + if NOT Instruction_With3_MemoryOperand_Register_i32( self, ACode, AMemory, ARegister_, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From3( ACode : TCodeType; AMemory : TMemoryOperand; ARegister_ : TRegisterType; AImmediate : Cardinal ); +begin + if NOT Instruction_With3_MemoryOperand_Register_u32( self, ACode, AMemory, ARegister_, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType ); +begin + if NOT Instruction_With4_Register_Register_Register_Register( self, ACode, ARegister1, ARegister2, ARegister3, ARegister4 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AImmediate : Integer ); +begin + if NOT Instruction_With4_Register_Register_Register_i32( self, ACode, ARegister1, ARegister2, ARegister3, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AImmediate : Cardinal ); +begin + if NOT Instruction_With4_Register_Register_Register_u32( self, ACode, ARegister1, ARegister2, ARegister3, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand ); +begin + if NOT Instruction_With4_Register_Register_Register_MemoryOperand( self, ACode, ARegister1, ARegister2, ARegister3, AMemory ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate1 : Integer; AImmediate2 : Integer ); +begin + if NOT Instruction_With4_Register_Register_i32_i32( self, ACode, ARegister1, ARegister2, AImmediate1, AImmediate2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AImmediate1 : Cardinal; AImmediate2 : Cardinal ); +begin + if NOT Instruction_With4_Register_Register_u32_u32( self, ACode, ARegister1, ARegister2, AImmediate1, AImmediate2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType ); +begin + if NOT Instruction_With4_Register_Register_MemoryOperand_Register( self, ACode, ARegister1, ARegister2, AMemory, ARegister3 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ); +begin + if NOT Instruction_With4_Register_Register_MemoryOperand_i32( self, ACode, ARegister1, ARegister2, AMemory, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From4( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ); +begin + if NOT Instruction_With4_Register_Register_MemoryOperand_u32( self, ACode, ARegister1, ARegister2, AMemory, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType; AImmediate : Integer ); +begin + if NOT Instruction_With5_Register_Register_Register_Register_i32( self, ACode, ARegister1, ARegister2, ARegister3, ARegister4, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; ARegister4 : TRegisterType; AImmediate : Cardinal ); +begin + if NOT Instruction_With5_Register_Register_Register_Register_u32( self, ACode, ARegister1, ARegister2, ARegister3, ARegister4, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Integer ); +begin + if NOT Instruction_With5_Register_Register_Register_MemoryOperand_i32( self, ACode, ARegister1, ARegister2, ARegister3, AMemory, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; ARegister3 : TRegisterType; AMemory : TMemoryOperand; AImmediate : Cardinal ); +begin + if NOT Instruction_With5_Register_Register_Register_MemoryOperand_u32( self, ACode, ARegister1, ARegister2, ARegister3, AMemory, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType; AImmediate : Integer ); +begin + if NOT Instruction_With5_Register_Register_MemoryOperand_Register_i32( self, ACode, ARegister1, ARegister2, AMemory, ARegister3, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From5( ACode : TCodeType; ARegister1 : TRegisterType; ARegister2 : TRegisterType; AMemory : TMemoryOperand; ARegister3 : TRegisterType; AImmediate : Cardinal ); +begin + if NOT Instruction_With5_Register_Register_MemoryOperand_Register_u32( self, ACode, ARegister1, ARegister2, AMemory, ARegister3, AImmediate ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Branch( ACode : TCodeType; Target : UInt64 ); +begin + if NOT Instruction_With_Branch( self, ACode, Target ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Far_Branch( ACode : TCodeType; Selector : Word; Offset : Cardinal ); +begin + if NOT Instruction_With_Far_Branch( self, ACode, Selector, Offset ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_xbegin( Bitness : Cardinal; Target : UInt64 ); +begin + if NOT Instruction_With_xbegin( self, Bitness, Target ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_outsb( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_outsb( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_outsb( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_outsb( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_outsw( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_outsw( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_outsw( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_outsw( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_outsd( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_outsd( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_outsd( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_outsd( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_lodsb( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_lodsb( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_lodsb( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_lodsb( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_lodsw( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_lodsw( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_lodsw( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_lodsw( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_lodsd( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_lodsd( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_lodsd( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_lodsd( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_lodsq( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_lodsq( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_lodsq( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_lodsq( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_scasb( AAddressSize: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_scasb( self, AAddressSize, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repe_scasb( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repe_scasb( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repne_scasb( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repne_scasb( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_scasw( AAddressSize: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_scasw( self, AAddressSize, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repe_scasw( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repe_scasw( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repne_scasw( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repne_scasw( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_scasd( AAddressSize: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_scasd( self, AAddressSize, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repe_scasd( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repe_scasd( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repne_scasd( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repne_scasd( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_scasq( AAddressSize: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_scasq( self, AAddressSize, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repe_scasq( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repe_scasq( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repne_scasq( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repne_scasq( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_insb( AAddressSize: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_insb( self, AAddressSize, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_insb( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_insb( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_insw( AAddressSize: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_insw( self, AAddressSize, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_insw( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_insw( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_insd( AAddressSize: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_insd( self, AAddressSize, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_insd( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_insd( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_stosb( AAddressSize: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_stosb( self, AAddressSize, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_stosb( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_stosb( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_stosw( AAddressSize: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_stosw( self, AAddressSize, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_stosw( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_stosw( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_stosd( AAddressSize: Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_stosd( self, AAddressSize, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_stosd( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_stosd( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_stosq( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_stosq( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_cmpsb( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_cmpsb( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repe_cmpsb( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repe_cmpsb( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repne_cmpsb( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repne_cmpsb( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_cmpsw( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_cmpsw( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repe_cmpsw( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repe_cmpsw( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repne_cmpsw( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repne_cmpsw( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_cmpsd( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_cmpsd( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repe_cmpsd( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repe_cmpsd( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repne_cmpsd( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repne_cmpsd( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_cmpsq( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_cmpsq( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repe_cmpsq( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repe_cmpsq( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Repne_cmpsq( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Repne_cmpsq( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_movsb( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_movsb( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_movsb( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_movsb( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_movsw( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_movsw( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_movsw( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_movsw( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_movsd( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_movsd( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_movsd( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_movsd( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_movsq( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ); +begin + if NOT Instruction_With_movsq( self, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Rep_movsq( AAddressSize: Cardinal ); +begin + if NOT Instruction_With_Rep_movsq( self, AAddressSize ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_maskmovq( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ); +begin + if NOT Instruction_With_maskmovq( self, AAddressSize, Register1, Register2, ASegmentPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_maskmovdqu( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ); +begin + if NOT Instruction_With_maskmovdqu( self, AAddressSize, Register1, Register2, ASegmentPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_vmaskmovdqu( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ); +begin + if NOT Instruction_With_vmaskmovdqu( self, AAddressSize, Register1, Register2, ASegmentPrefix ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( Bytes : Array of Byte ); +begin + case Length( Bytes ) of + 1 : begin + if NOT Instruction_With_Declare_Byte_1( self, Bytes[ 0 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Byte_2( self, Bytes[ 0 ], Bytes[ 1 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Byte_3( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Byte_4( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Byte_5( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Byte_6( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Byte_7( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Byte_8( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 9 : begin + if NOT Instruction_With_Declare_Byte_9( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 10 : begin + if NOT Instruction_With_Declare_Byte_10( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 11 : begin + if NOT Instruction_With_Declare_Byte_11( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 12 : begin + if NOT Instruction_With_Declare_Byte_12( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 13 : begin + if NOT Instruction_With_Declare_Byte_13( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 14 : begin + if NOT Instruction_With_Declare_Byte_14( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ], Bytes[ 13 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 15 : begin + if NOT Instruction_With_Declare_Byte_15( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ], Bytes[ 13 ], Bytes[ 14 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 16 : begin + if NOT Instruction_With_Declare_Byte_16( self, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ], Bytes[ 13 ], Bytes[ 14 ], Bytes[ 14 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + else + FillChar( self, SizeOf( self ), 0 ); + end; +end; + +constructor TInstruction.From_Declare_Byte( Bytes : PByte; Count : Byte ); +type + TByteArray = Array [ 0..15 ] of Byte; + PByteArray = ^TByteArray; +var + ByteArray : PByteArray absolute Bytes; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_Byte_1( self, ByteArray^[ 0 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Byte_2( self, ByteArray^[ 0 ], ByteArray^[ 1 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Byte_3( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Byte_4( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Byte_5( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Byte_6( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Byte_7( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Byte_8( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 9 : begin + if NOT Instruction_With_Declare_Byte_9( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 10 : begin + if NOT Instruction_With_Declare_Byte_10( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 11 : begin + if NOT Instruction_With_Declare_Byte_11( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 12 : begin + if NOT Instruction_With_Declare_Byte_12( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 13 : begin + if NOT Instruction_With_Declare_Byte_13( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 14 : begin + if NOT Instruction_With_Declare_Byte_14( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ], ByteArray^[ 13 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 15 : begin + if NOT Instruction_With_Declare_Byte_15( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ], ByteArray^[ 13 ], ByteArray^[ 14 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 16 : begin + if NOT Instruction_With_Declare_Byte_16( self, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ], ByteArray^[ 13 ], ByteArray^[ 14 ], ByteArray^[ 14 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + else + FillChar( self, SizeOf( self ), 0 ); + end; +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_1( self, B0 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_2( self, B0, B1 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_3( self, B0, B1, B2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_4( self, B0, B1, B2, B3 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_5( self, B0, B1, B2, B3 , B4 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_6( self, B0, B1, B2, B3 , B4, B5 ) then + FillChar( self, SizeOf( self ), 0 ); +end; +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_7( self, B0, B1, B2, B3 , B4, B5, B6 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_8( self, B0, B1, B2, B3 , B4, B5, B6, B7 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_9( self, B0, B1, B2, B3 , B4, B5, B6, B7, B8 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_10( self, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9 ) then + FillChar( self, SizeOf( self ), 0 ); +end; +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_11( self, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_12( self, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_13( self, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_14( self, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12, B13 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_15( self, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Byte( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte; B15 : Byte ); +begin + if NOT Instruction_With_Declare_Byte_16( self, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Word( Words : Array of Word ); +begin + case Length( Words ) of + 1 : begin + if NOT Instruction_With_Declare_Word_1( self, Words[ 0 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Word_2( self, Words[ 0 ], Words[ 1 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Word_3( self, Words[ 0 ], Words[ 1 ], Words[ 2 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Word_4( self, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Word_5( self, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Word_6( self, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ], Words[ 5 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Word_7( self, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ], Words[ 5 ], Words[ 6 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Word_8( self, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ], Words[ 5 ], Words[ 6 ], Words[ 7 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + else + FillChar( self, SizeOf( self ), 0 ); + end; +end; + +constructor TInstruction.From_Declare_Word( Words : PWord; Count : Byte ); +type + TWordArray = Array [ 0..7 ] of Word; + PWordArray = ^TWordArray; +var + WordArray : PWordArray absolute Words; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_Word_1( self, WordArray^[ 0 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Word_2( self, WordArray^[ 0 ], WordArray^[ 1 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Word_3( self, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Word_4( self, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Word_5( self, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Word_6( self, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ], WordArray^[ 5 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Word_7( self, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ], WordArray^[ 5 ], WordArray^[ 6 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Word_8( self, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ], WordArray^[ 5 ], WordArray^[ 6 ], WordArray^[ 7 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + else + FillChar( self, SizeOf( self ), 0 ); + end; +end; + +constructor TInstruction.From_Declare_Word( W0 : Word ); +begin + if NOT Instruction_With_Declare_Word_1( self, W0 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Word( W0 : Word; W1 : Word ); +begin + if NOT Instruction_With_Declare_Word_2( self, W0, W1 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Word( W0 : Word; W1 : Word; W2 : Word ); +begin + if NOT Instruction_With_Declare_Word_3( self, W0, W1, W2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word ); +begin + if NOT Instruction_With_Declare_Word_4( self, W0, W1, W2, W3 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word ); +begin + if NOT Instruction_With_Declare_Word_5( self, W0, W1, W2, W3, W4 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word ); +begin + if NOT Instruction_With_Declare_Word_6( self, W0, W1, W2, W3, W4, W5 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word ); +begin + if NOT Instruction_With_Declare_Word_7( self, W0, W1, W2, W3, W4, W5, W6 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_Word( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word; W7 : Word ); +begin + if NOT Instruction_With_Declare_Word_8( self, W0, W1, W2, W3, W4, W5, W6, W7 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_DWord( DWords : Array of Cardinal ); +begin + case Length( DWords ) of + 1 : begin + if NOT Instruction_With_Declare_DWord_1( self, DWords[ 0 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_DWord_2( self, DWords[ 0 ], DWords[ 1 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_DWord_3( self, DWords[ 0 ], DWords[ 1 ], DWords[ 2 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_DWord_4( self, DWords[ 0 ], DWords[ 1 ], DWords[ 2 ], DWords[ 3 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + else + FillChar( self, SizeOf( self ), 0 ); + end; +end; + +constructor TInstruction.From_Declare_DWord( DWords : PCardinal; Count : Byte ); +type + TDWordArray = Array [ 0..3 ] of Cardinal; + PDWordArray = ^TDWordArray; +var + DWordArray : PDWordArray absolute DWords; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_DWord_1( self, DWordArray^[ 0 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_DWord_2( self, DWordArray^[ 0 ], DWordArray^[ 1 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_DWord_3( self, DWordArray^[ 0 ], DWordArray^[ 1 ], DWordArray^[ 2 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_DWord_4( self, DWordArray^[ 0 ], DWordArray^[ 1 ], DWordArray^[ 2 ], DWordArray^[ 3 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + else + FillChar( self, SizeOf( self ), 0 ); + end; +end; + +constructor TInstruction.From_Declare_DWord( D0 : Cardinal ); +begin + if NOT Instruction_With_Declare_DWord_1( self, D0 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_DWord( D0 : Cardinal; D1 : Cardinal ); +begin + if NOT Instruction_With_Declare_DWord_2( self, D0, D1 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_DWord( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal ); +begin + if NOT Instruction_With_Declare_DWord_3( self, D0, D1, D2 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_DWord( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal; D3 : Cardinal ); +begin + if NOT Instruction_With_Declare_DWord_4( self, D0, D1, D2, D3 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_QWord( QWords : Array of UInt64 ); +begin + case Length( QWords ) of + 1 : begin + if NOT Instruction_With_Declare_QWord_1( self, QWords[ 0 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_QWord_2( self, QWords[ 0 ], QWords[ 1 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + else + FillChar( self, SizeOf( self ), 0 ); + end; +end; + +constructor TInstruction.From_Declare_QWord( QWords : PUInt64; Count : Byte ); +type + TQWordArray = Array [ 0..1 ] of UInt64; + PQWordArray = ^TQWordArray; +var + QWordArray : PQWordArray absolute QWords; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_QWord_1( self, QWordArray^[ 0 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_QWord_2( self, QWordArray^[ 0 ], QWordArray^[ 1 ] ) then + FillChar( self, SizeOf( self ), 0 ); + end; + else + FillChar( self, SizeOf( self ), 0 ); + end; +end; + +constructor TInstruction.From_Declare_QWord( Q0 : UInt64 ); +begin + if NOT Instruction_With_Declare_QWord_1( self, Q0 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +constructor TInstruction.From_Declare_QWord( Q0 : UInt64; Q1 : UInt64 ); +begin + if NOT Instruction_With_Declare_QWord_2( self, Q0, Q1 ) then + FillChar( self, SizeOf( self ), 0 ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +//{$IF CompilerVersion < 22} // XE +constructor TInstructionList.Create; +begin + inherited; + Clear; +end; + +destructor TInstructionList.Destroy; +begin + Clear; + inherited; +end; + +procedure TInstructionList.Add( AItem : TInstruction ); +begin + SetLength( fItems, Length( fItems )+1 ); + fItems[ High( fItems ) ] := AItem; +end; + +procedure TInstructionList.Add( AItem : TInstruction; RIP : UInt64 ); +begin + SetLength( fItems, Length( fItems )+1 ); + fItems[ High( fItems ) ] := AItem; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + fItems[ High( fItems ) ].RIP := RIP; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstructionList.AddWithCurrentLabel( AItem : TInstruction ); +begin + SetLength( fItems, Length( fItems )+1 ); + fItems[ High( fItems ) ] := AItem; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + fItems[ High( fItems ) ].RIP := fID; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstructionList.Push( AItem : TInstruction ); +begin + SetLength( fItems, Length( fItems )+1 ); + fItems[ High( fItems ) ] := AItem; +end; + +procedure TInstructionList.Push( AItem : TInstruction; RIP : UInt64 ); +begin + SetLength( fItems, Length( fItems )+1 ); + fItems[ High( fItems ) ] := AItem; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + fItems[ High( fItems ) ].RIP := RIP; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TInstructionList.Clear; +begin + if ( self = nil ) then + Exit; + SetLength( fItems, 0 ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + fID := 1; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TInstructionList.GetCount : Integer; +begin + result := 0; + if ( self = nil ) then + Exit; + + result := Length( fItems ); +end; + +procedure TInstructionList.Remove( const Index : Integer ); +var + i : Integer; +begin + if ( Index > High( fItems ) ) then + Exit; + for i := Index to High( fItems )-1 do + fItems[ i ] := fItems[ i+1 ]; + SetLength( fItems, Length( fItems )-1 ); +end; + +function TInstructionList.GetItems( Index : Integer ) : TInstruction; +begin + if ( self = nil ) then + begin + FillChar( result, SizeOf( result ), 0 ); + Exit; + end; + Result := fItems[ Index ]; +end; + +function TInstructionList.GetPointer : PInstruction; +begin + result := nil; + if ( self = nil ) then + Exit; + if ( Length( fItems ) < 1 ) then + Exit; + Result := @fItems[ 0 ]; +end; + +function TInstructionList.CreateLabel : UInt64; +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := fID; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Inc( fID ); +end; +//{$IFEND} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Instruction 'WITH' +// Creates an instruction with no operands +function Instruction_With_( Code : TCodeType ) : TInstruction; +begin + if NOT Instruction_With( result, Code ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +// Creates an instruction with 1 operand +// +// # Errors +// Fails if one of the operands is invalid (basic checks) +function Instruction_With1( Code : TCodeType; Register_ : TRegisterType ) : TInstruction; overload; +begin + if NOT Instruction_With1_Register( result, Code, Register_ ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With1( Code : TCodeType; Immediate : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With1_i32( result, Code, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With1( Code : TCodeType; Immediate : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With1_u32( result, Code, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With1( Code : TCodeType; Memory : TMemoryOperand ) : TInstruction; overload; +begin + if NOT Instruction_With1_Memory( result, Code, Memory ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType ) : TInstruction; overload; +begin + if NOT Instruction_With2_Register_Register( result, Code, Register1, Register2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Register_ : TRegisterType; Immediate : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With2_Register_i32( result, Code, Register_, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Register_ : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With2_Register_u32( result, Code, Register_, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Register_ : TRegisterType; Immediate : Int64 ) : TInstruction; overload; +begin + if NOT Instruction_With2_Register_i64( result, Code, Register_, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Register_ : TRegisterType; Immediate : UInt64 ) : TInstruction; overload; +begin + if NOT Instruction_With2_Register_u64( result, Code, Register_, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Register_ : TRegisterType; Memory : TMemoryOperand ) : TInstruction; overload; +begin + if NOT Instruction_With2_Register_MemoryOperand( result, Code, Register_, Memory ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Immediate : Integer; Register_ : TRegisterType ) : TInstruction; overload; +begin + if NOT Instruction_With2_i32_Register( result, Code, Immediate, Register_ ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Immediate : Cardinal; Register_ : TRegisterType ) : TInstruction; overload; +begin + if NOT Instruction_With2_u32_Register( result, Code, Immediate, Register_ ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Immediate1 : Integer; Immediate2 : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With2_i32_i32( result, Code, Immediate1, Immediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With2_u32_u32( result, Code, Immediate1, Immediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Memory : TMemoryOperand; Register_ : TRegisterType ) : TInstruction; overload; +begin + if NOT Instruction_With2_MemoryOperand_Register( result, Code, Memory, Register_ ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Memory : TMemoryOperand; Immediate : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With2_MemoryOperand_i32( result, Code, Memory, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With2( Code : TCodeType; Memory : TMemoryOperand; Immediate : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With2_MemoryOperand_u32( result, Code, Memory, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType ) : TInstruction; overload; +begin + if NOT Instruction_With3_Register_Register_Register( result, Code, Register1, Register2, Register3 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With3_Register_Register_i32( result, Code, Register1, Register2, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With3_Register_Register_u32( result, Code, Register1, Register2, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand ) : TInstruction; overload; +begin + if NOT Instruction_With3_Register_Register_MemoryOperand( result, Code, Register1, Register2, Memory ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Register_ : TRegisterType; Immediate1 : Integer; Immediate2 : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With3_Register_i32_i32( result, Code, Register_, Immediate1, Immediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Register_ : TRegisterType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With3_Register_u32_u32( result, Code, Register_, Immediate1, Immediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Memory : TMemoryOperand; Register2 : TRegisterType ) : TInstruction; overload; +begin + if NOT Instruction_With3_Register_MemoryOperand_Register( result, Code, Register1, Memory, Register2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Register1 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With3_Register_MemoryOperand_i32( result, Code, Register1, Memory, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Register_ : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With3_Register_MemoryOperand_u32( result, Code, Register_, Memory, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Memory : TMemoryOperand; Register1 : TRegisterType; Register2 : TRegisterType ) : TInstruction; overload; +begin + if NOT Instruction_With3_MemoryOperand_Register_Register( result, Code, Memory, Register1, Register2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Memory : TMemoryOperand; Register_ : TRegisterType; Immediate : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With3_MemoryOperand_Register_i32( result, Code, Memory, Register_, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With3( Code : TCodeType; Memory : TMemoryOperand; Register_ : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With3_MemoryOperand_Register_u32( result, Code, Memory, Register_, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType ) : TInstruction; overload; +begin + if NOT Instruction_With4_Register_Register_Register_Register( result, Code, Register1, Register2, Register3, Register4 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Immediate : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With4_Register_Register_Register_i32( result, Code, Register1, Register2, Register3, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With4_Register_Register_Register_u32( result, Code, Register1, Register2, Register3, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Memory : TMemoryOperand ) : TInstruction; overload; +begin + if NOT Instruction_With4_Register_Register_Register_MemoryOperand( result, Code, Register1, Register2, Register3, Memory ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate1 : Integer; Immediate2 : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With4_Register_Register_i32_i32( result, Code, Register1, Register2, Immediate1, Immediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Immediate1 : Cardinal; Immediate2 : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With4_Register_Register_u32_u32( result, Code, Register1, Register2, Immediate1, Immediate2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType ) : TInstruction; overload; +begin + if NOT Instruction_With4_Register_Register_MemoryOperand_Register( result, Code, Register1, Register2, Memory, Register3 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With4_Register_Register_MemoryOperand_i32( result, Code, Register1, Register2, Memory, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With4( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With4_Register_Register_MemoryOperand_u32( result, Code, Register1, Register2, Memory, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType; Immediate : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With5_Register_Register_Register_Register_i32( result, Code, Register1, Register2, Register3, Register4, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Register4 : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With5_Register_Register_Register_Register_u32( result, Code, Register1, Register2, Register3, Register4, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Memory : TMemoryOperand; Immediate : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With5_Register_Register_Register_MemoryOperand_i32( result, Code, Register1, Register2, Register3, Memory, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Register3 : TRegisterType; Memory : TMemoryOperand; Immediate : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With5_Register_Register_Register_MemoryOperand_u32( result, Code, Register1, Register2, Register3, Memory, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType; Immediate : Integer ) : TInstruction; overload; +begin + if NOT Instruction_With5_Register_Register_MemoryOperand_Register_i32( result, Code, Register1, Register2, Memory, Register3, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With5( Code : TCodeType; Register1 : TRegisterType; Register2 : TRegisterType; Memory : TMemoryOperand; Register3 : TRegisterType; Immediate : Cardinal ) : TInstruction; overload; +begin + if NOT Instruction_With5_Register_Register_MemoryOperand_Register_u32( result, Code, Register1, Register2, Memory, Register3, Immediate ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Branch_( Code : TCodeType; Target : UInt64 ) : TInstruction; +begin + if NOT Instruction_With_Branch( result, Code, Target ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Far_Branch_( Code : TCodeType; Selector : Word; Offset : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Far_Branch( result, Code, Selector, Offset ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_xbegin_( Bitness : Cardinal; Target : UInt64 ) : TInstruction; +begin + if NOT Instruction_With_xbegin( result, Bitness, Target ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_outsb_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_outsb( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_outsb_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_outsb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_outsw_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_outsw( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_outsw_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_outsw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_outsd_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_outsd( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_outsd_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_outsd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_lodsb_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_lodsb( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_lodsb_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_lodsb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_lodsw_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_lodsw( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_lodsw_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_lodsw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_lodsd_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_lodsd( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_lodsd_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_lodsd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_lodsq_( AAddressSize: Cardinal; ASegmentPrefix: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_lodsq( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_lodsq_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_lodsq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_scasb_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_scasb( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repe_scasb_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_scasb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repne_scasb_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_scasb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_scasw_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_scasw( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repe_scasw_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_scasw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repne_scasw_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_scasw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_scasd_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_scasd( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repe_scasd_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_scasd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repne_scasd_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_scasd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_scasq_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_scasq( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repe_scasq_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_scasq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repne_scasq_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_scasq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_insb_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_insb( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_insb_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_insb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_insw_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_insw( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_insw_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_insw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_insd_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_insd( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_insd_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_insd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_stosb_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_stosb( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_stosb_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_stosb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_stosw_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_stosw( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_stosw_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_stosw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_stosd_( AAddressSize: Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_stosd( result, AAddressSize, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_stosd_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_stosd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_stosq_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_stosq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_cmpsb_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_cmpsb( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repe_cmpsb_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_cmpsb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repne_cmpsb_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_cmpsb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_cmpsw_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_cmpsw( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repe_cmpsw_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_cmpsw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repne_cmpsw_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_cmpsw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_cmpsd_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_cmpsd( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repe_cmpsd_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_cmpsd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repne_cmpsd_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_cmpsd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_cmpsq_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_cmpsq( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repe_cmpsq_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repe_cmpsq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Repne_cmpsq_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Repne_cmpsq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_movsb_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_movsb( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_movsb_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_movsb( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_movsw_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_movsw( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_movsw_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_movsw( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_movsd_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_movsd( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_movsd_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_movsd( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_movsq_( AAddressSize: Cardinal; ASegmentPrefix : Cardinal; RepPrefix: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_movsq( result, AAddressSize, ASegmentPrefix, RepPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Rep_movsq_( AAddressSize: Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Rep_movsq( result, AAddressSize ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_maskmovq_( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_maskmovq( result, AAddressSize, Register1, Register2, ASegmentPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_maskmovdqu_( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_maskmovdqu( result, AAddressSize, Register1, Register2, ASegmentPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_vmaskmovdqu_( AAddressSize: Cardinal; Register1 : TRegisterType; Register2 : TRegisterType; ASegmentPrefix : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_vmaskmovdqu( result, AAddressSize, Register1, Register2, ASegmentPrefix ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( Bytes : Array of Byte ) : TInstruction; +begin + case Length( Bytes ) of + 1 : begin + if NOT Instruction_With_Declare_Byte_1( result, Bytes[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Byte_2( result, Bytes[ 0 ], Bytes[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Byte_3( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Byte_4( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Byte_5( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Byte_6( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Byte_7( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Byte_8( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 9 : begin + if NOT Instruction_With_Declare_Byte_9( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 10 : begin + if NOT Instruction_With_Declare_Byte_10( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 11 : begin + if NOT Instruction_With_Declare_Byte_11( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 12 : begin + if NOT Instruction_With_Declare_Byte_12( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 13 : begin + if NOT Instruction_With_Declare_Byte_13( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 14 : begin + if NOT Instruction_With_Declare_Byte_14( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ], Bytes[ 13 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 15 : begin + if NOT Instruction_With_Declare_Byte_15( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ], Bytes[ 13 ], Bytes[ 14 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 16 : begin + if NOT Instruction_With_Declare_Byte_16( result, Bytes[ 0 ], Bytes[ 1 ], Bytes[ 2 ], Bytes[ 3 ], Bytes[ 4 ], Bytes[ 5 ], Bytes[ 6 ], Bytes[ 7 ], Bytes[ 8 ], Bytes[ 9 ], Bytes[ 10 ], Bytes[ 11 ], Bytes[ 12 ], Bytes[ 13 ], Bytes[ 14 ], Bytes[ 14 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +function Instruction_With_Declare_Byte_( Bytes : PByte; Count : Byte ) : TInstruction; +type + TByteArray = Array [ 0..15 ] of Byte; + PByteArray = ^TByteArray; +var + ByteArray : PByteArray absolute Bytes; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_Byte_1( result, ByteArray^[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Byte_2( result, ByteArray^[ 0 ], ByteArray^[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Byte_3( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Byte_4( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Byte_5( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Byte_6( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Byte_7( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Byte_8( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 9 : begin + if NOT Instruction_With_Declare_Byte_9( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 10 : begin + if NOT Instruction_With_Declare_Byte_10( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 11 : begin + if NOT Instruction_With_Declare_Byte_11( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 12 : begin + if NOT Instruction_With_Declare_Byte_12( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 13 : begin + if NOT Instruction_With_Declare_Byte_13( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 14 : begin + if NOT Instruction_With_Declare_Byte_14( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ], ByteArray^[ 13 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 15 : begin + if NOT Instruction_With_Declare_Byte_15( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ], ByteArray^[ 13 ], ByteArray^[ 14 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 16 : begin + if NOT Instruction_With_Declare_Byte_16( result, ByteArray^[ 0 ], ByteArray^[ 1 ], ByteArray^[ 2 ], ByteArray^[ 3 ], ByteArray^[ 4 ], ByteArray^[ 5 ], ByteArray^[ 6 ], ByteArray^[ 7 ], ByteArray^[ 8 ], ByteArray^[ 9 ], ByteArray^[ 10 ], ByteArray^[ 11 ], ByteArray^[ 12 ], ByteArray^[ 13 ], ByteArray^[ 14 ], ByteArray^[ 14 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +function Instruction_With_Declare_Byte_( B0 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_1( result, B0 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_2( result, B0, B1 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_3( result, B0, B1, B2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_4( result, B0, B1, B2, B3 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_5( result, B0, B1, B2, B3 , B4 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_6( result, B0, B1, B2, B3 , B4, B5 ) then + FillChar( result, SizeOf( result ), 0 ); +end; +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_7( result, B0, B1, B2, B3 , B4, B5, B6 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_8( result, B0, B1, B2, B3 , B4, B5, B6, B7 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_9( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_10( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9 ) then + FillChar( result, SizeOf( result ), 0 ); +end; +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_11( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_12( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_13( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_14( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12, B13 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_15( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Byte_( B0 : Byte; B1 : Byte; B2 : Byte; B3 : Byte; B4 : Byte; B5 : Byte; B6 : Byte; B7 : Byte; B8 : Byte; B9 : Byte; B10 : Byte; B11 : Byte; B12 : Byte; B13 : Byte; B14 : Byte; B15 : Byte ) : TInstruction; +begin + if NOT Instruction_With_Declare_Byte_16( result, B0, B1, B2, B3 , B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Word_( Words : Array of Word ) : TInstruction; +begin + case Length( Words ) of + 1 : begin + if NOT Instruction_With_Declare_Word_1( result, Words[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Word_2( result, Words[ 0 ], Words[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Word_3( result, Words[ 0 ], Words[ 1 ], Words[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Word_4( result, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Word_5( result, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Word_6( result, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ], Words[ 5 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Word_7( result, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ], Words[ 5 ], Words[ 6 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Word_8( result, Words[ 0 ], Words[ 1 ], Words[ 2 ], Words[ 3 ], Words[ 4 ], Words[ 5 ], Words[ 6 ], Words[ 7 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +function Instruction_With_Declare_Word_( Words : PWord; Count : Byte ) : TInstruction; +type + TWordArray = Array [ 0..7 ] of Word; + PWordArray = ^TWordArray; +var + WordArray : PWordArray absolute Words; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_Word_1( result, WordArray^[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_Word_2( result, WordArray^[ 0 ], WordArray^[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_Word_3( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_Word_4( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 5 : begin + if NOT Instruction_With_Declare_Word_5( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 6 : begin + if NOT Instruction_With_Declare_Word_6( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ], WordArray^[ 5 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 7 : begin + if NOT Instruction_With_Declare_Word_7( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ], WordArray^[ 5 ], WordArray^[ 6 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 8 : begin + if NOT Instruction_With_Declare_Word_8( result, WordArray^[ 0 ], WordArray^[ 1 ], WordArray^[ 2 ], WordArray^[ 3 ], WordArray^[ 4 ], WordArray^[ 5 ], WordArray^[ 6 ], WordArray^[ 7 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +function Instruction_With_Declare_Word_( W0 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_1( result, W0 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_2( result, W0, W1 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_3( result, W0, W1, W2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word; W3 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_4( result, W0, W1, W2, W3 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_5( result, W0, W1, W2, W3, W4 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_6( result, W0, W1, W2, W3, W4, W5 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_7( result, W0, W1, W2, W3, W4, W5, W6 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_Word_( W0 : Word; W1 : Word; W2 : Word; W3 : Word; W4 : Word; W5 : Word; W6 : Word; W7 : Word ) : TInstruction; +begin + if NOT Instruction_With_Declare_Word_8( result, W0, W1, W2, W3, W4, W5, W6, W7 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_DWord_( DWords : Array of Cardinal ) : TInstruction; +begin + case Length( DWords ) of + 1 : begin + if NOT Instruction_With_Declare_DWord_1( result, DWords[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_DWord_2( result, DWords[ 0 ], DWords[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_DWord_3( result, DWords[ 0 ], DWords[ 1 ], DWords[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_DWord_4( result, DWords[ 0 ], DWords[ 1 ], DWords[ 2 ], DWords[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +function Instruction_With_Declare_DWord_( DWords : PCardinal; Count : Byte ) : TInstruction; +type + TDWordArray = Array [ 0..3 ] of Cardinal; + PDWordArray = ^TDWordArray; +var + DWordArray : PDWordArray absolute DWords; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_DWord_1( result, DWordArray^[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_DWord_2( result, DWordArray^[ 0 ], DWordArray^[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 3 : begin + if NOT Instruction_With_Declare_DWord_3( result, DWordArray^[ 0 ], DWordArray^[ 1 ], DWordArray^[ 2 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 4 : begin + if NOT Instruction_With_Declare_DWord_4( result, DWordArray^[ 0 ], DWordArray^[ 1 ], DWordArray^[ 2 ], DWordArray^[ 3 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +function Instruction_With_Declare_DWord_( D0 : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Declare_DWord_1( result, D0 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_DWord_( D0 : Cardinal; D1 : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Declare_DWord_2( result, D0, D1 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_DWord_( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Declare_DWord_3( result, D0, D1, D2 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_DWord_( D0 : Cardinal; D1 : Cardinal; D2 : Cardinal; D3 : Cardinal ) : TInstruction; +begin + if NOT Instruction_With_Declare_DWord_4( result, D0, D1, D2, D3 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_QWord_( QWords : Array of UInt64 ) : TInstruction; +begin + case Length( QWords ) of + 1 : begin + if NOT Instruction_With_Declare_QWord_1( result, QWords[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_QWord_2( result, QWords[ 0 ], QWords[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +function Instruction_With_Declare_QWord_( QWords : PUInt64; Count : Byte ) : TInstruction; +type + TQWordArray = Array [ 0..1 ] of UInt64; + PQWordArray = ^TQWordArray; +var + QWordArray : PQWordArray absolute QWords; +begin + case Count of + 1 : begin + if NOT Instruction_With_Declare_QWord_1( result, QWordArray^[ 0 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + 2 : begin + if NOT Instruction_With_Declare_QWord_2( result, QWordArray^[ 0 ], QWordArray^[ 1 ] ) then + FillChar( result, SizeOf( result ), 0 ); + end; + else + FillChar( result, SizeOf( result ), 0 ); + end; +end; + +function Instruction_With_Declare_QWord_( Q0 : UInt64 ) : TInstruction; +begin + if NOT Instruction_With_Declare_QWord_1( result, Q0 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +function Instruction_With_Declare_QWord_( Q0 : UInt64; Q1 : UInt64 ) : TInstruction; +begin + if NOT Instruction_With_Declare_QWord_2( result, Q0, Q1 ) then + FillChar( result, SizeOf( result ), 0 ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +end. \ No newline at end of file diff --git a/src/Delphi/uIced.pas b/src/Delphi/uIced.pas new file mode 100644 index 000000000..8fd035a1d --- /dev/null +++ b/src/Delphi/uIced.pas @@ -0,0 +1,7688 @@ +unit uIced; + +{ + Iced (Dis)Assembler + + TetzkatLipHoka 2022-2024 +} + +// MS Finish details .. + +interface + +{$WARN UNSAFE_CODE OFF} +{$WARN COMPARING_SIGNED_UNSIGNED OFF} + +{$IF CompilerVersion >= 22} + {$LEGACYIFEND ON} +{$IFEND} + +{$WARN UNSAFE_TYPE OFF} +{$WARN UNSAFE_CAST OFF} + +{.$DEFINE DECODER_LOCAL_POSITION} // Buffer-Position is saved in Local-Variable, updated each Decode + +{.$DEFINE SynUnicode} +{.$DEFINE AssemblyTools} // MS test again in the end +{.$DEFINE TEST_FUNCTIONS} + +uses + Classes, SysUtils, + {$IFDEF TEST_FUNCTIONS}Windows,{$ENDIF} + {$IF NOT Defined( UNICODE ) AND Defined( SynUnicode )}SynUnicode,{$IFEND} + {$IFDEF AssemblyTools}uAssemblyTools,{$ENDIF} + uIced.Imports, uIced.Types; + +type + TIcedDecoder = class + private + fHandle : Pointer; + fBitness : TIcedBitness; + fData : PByte; + fSize : NativeUInt; + fIPosition: NativeUInt; + {$IFDEF DECODER_LOCAL_POSITION} + fPosition : NativeUInt; + {$ENDIF DECODER_LOCAL_POSITION} + function GetHandle : Pointer; + function GetBitness : TIcedBitness; + procedure SetBitness( Value : TIcedBitness ); + function GetIP : UInt64; + procedure SetIP( Value : UInt64 ); + function GetPosition : NativeUInt; + procedure SetPosition( Value : NativeUInt ); + function GetMaxPosition : NativeUInt; + function GetInstructionFirstByte : PByte; + function GetCurrentByte : PByte; + function GetLastError : TDecoderError; + public + constructor Create( Bitness : TIcedBitness = bt64 ); reintroduce; + destructor Destroy; override; + procedure SetData( Data : PByte; Size : NativeUInt; IP : UInt64 = UInt64( 0 ); Options : Cardinal = doNONE ); {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure Decode( var Instruction : TInstruction ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$IFDEF AssemblyTools} + procedure GenerateDetails( const Instruction : TInstruction; var Details : TIcedDetails ); {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure Decode( var Instruction : TInstruction; var Details : TIcedDetails ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF AssemblyTools} + procedure DecodeToEnd( Callback : TDecoderCallback; UserData : Pointer = nil ); {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure GetConstantOffsets( const Instruction : TInstruction; var ConstantOffsets : TConstantOffsets ); {$IF CompilerVersion >= 23}inline;{$IFEND} + + property Handle : Pointer read GetHandle; + property Bitness : TIcedBitness read GetBitness write SetBitness; + function CanDecode : Boolean; + property IP : UInt64 read GetIP write SetIP; + property Position : NativeUInt read GetPosition write SetPosition; + property MaxPosition : NativeUInt read GetMaxPosition; + + property InstructionFirstByte : PByte read GetInstructionFirstByte; + property CurrentByte : PByte read GetCurrentByte; + + property LastError : TDecoderError read GetLastError; + end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + TIcedEncoder = class + private + fHandle : Pointer; + fBitness : TIcedBitness; + fCapacity : NativeUInt; + function GetHandle : Pointer; + function GetBitness : TIcedBitness; + procedure SetBitness( Value : TIcedBitness ); + function GetCapacity : NativeUInt; + procedure SetCapacity( Value : NativeUInt ); + function GetPreventVex2 : Boolean; + procedure SetPreventVex2( Value : Boolean ); + function GetVexWig : Cardinal; + procedure SetVexWig( Value : Cardinal ); + function GetVexLig : Cardinal; + procedure SetVexLig( Value : Cardinal ); + function GetEvexWig : Cardinal; + procedure SetEvexWig( Value : Cardinal ); + function GetEvexLig : Cardinal; + procedure SetEvexLig( Value : Cardinal ); + function GetMvexWig : Cardinal; + procedure SetMvexWig( Value : Cardinal ); + public + constructor Create( Bitness : TIcedBitness = bt64; Capacity : NativeUInt = 0 ); reintroduce; + destructor Destroy; override; + procedure Encode( var Instruction : TInstruction ); {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure Write( Byte : Byte ); {$IF CompilerVersion >= 23}inline;{$IFEND} + + function GetBuffer( Buffer : PByte; Size : NativeUInt ) : Boolean; +// function SetBuffer( Buffer : PByte; Size : NativeUInt ) : Boolean; + + procedure GetConstantOffsets( var ConstantOffsets : TConstantOffsets ); {$IF CompilerVersion >= 23}inline;{$IFEND} + + property Handle : Pointer read GetHandle; + property Bitness : TIcedBitness read GetBitness write SetBitness; + property Capacity : NativeUInt read GetCapacity write SetCapacity; + + property PreventVex2 : Boolean read GetPreventVex2 write SetPreventVex2; + property VexWig : Cardinal read GetVexWig write SetVexWig; + property VexLig : Cardinal read GetVexLig write SetVexLig; + property EvexWig : Cardinal read GetEvexWig write SetEvexWig; + property EvexLig : Cardinal read GetEvexLig write SetEvexLig; + property MvexWig : Cardinal read GetMvexWig write SetMvexWig; + end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + TIcedBlockEncoder = class + private + fBitness : TIcedBitness; + fOptions : Cardinal; + fMemory : Pointer; + function GetBitness : TIcedBitness; + procedure SetBitness( Value : TIcedBitness ); + + function GetOptions : Cardinal; + procedure SetOptions( Value : Cardinal ); + public + constructor Create( Bitness : TIcedBitness = bt64; Options : Cardinal = beoNONE ); reintroduce; + destructor Destroy; override; + + property Bitness : TIcedBitness read GetBitness write SetBitness; + property Options : Cardinal read GetOptions write SetOptions; + procedure Encode( RIP : UInt64; var Instructions : TInstruction; Count : NativeUInt; var Results : TBlockEncoderResult ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure Encode( RIP : UInt64; var Instructions : TInstructionArray; var Results : TBlockEncoderResult ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure Encode( RIP : UInt64; var Instructions : TInstructionList; var Results : TBlockEncoderResult ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure Clear; {$IF CompilerVersion >= 23}inline;{$IFEND} + end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + TInstructionInfoFactory = class + private + fHandle : Pointer; + fOptions : Cardinal; + function GetHandle : Pointer; + function GetOptions : Cardinal; + procedure SetOptions( Value : Cardinal ); + public + constructor Create( Options : Cardinal = iioNone ); reintroduce; + destructor Destroy; override; + procedure Info( const Instruction: TInstruction; var InstructionInfo : TInstructionInfo ); {$IF CompilerVersion >= 23}inline;{$IFEND} + + property Handle : Pointer read GetHandle; + property Options : Cardinal read GetOptions write SetOptions; + end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + TIcedFormatterSettings = record + // Options + // Masm + AddDsPrefix32 : Boolean; + SymbolDisplacementInBrackets : Boolean; + DisplacementInBrackets : Boolean; + // Nasm + ShowSignExtendedImmediateSize : Boolean; + // Gas + NakedRegisters : Boolean; + ShowMnemonicSizeSuffix : Boolean; + SpaceAfterMemoryOperandComma : Boolean; + // Specialized + UseHexPrefix : Boolean; + AlwaysShowMemorySize : Boolean; + // Common + SpaceAfterOperandSeparator : Boolean; + AlwaysShowSegmentRegister : Boolean; + UsePseudoOps : Boolean; + RipRelativeAddresses : Boolean; + ShowSymbolAddress : Boolean; + UpperCaseHex : Boolean; + // Common (All but Fast/Specialized) + UpperCasePrefixes : Boolean; + UpperCaseMnemonics : Boolean; + UpperCaseRegisters : Boolean; + UpperCaseKeyWords : Boolean; + UpperCaseDecorators : Boolean; + UpperCaseEverything : Boolean; + FirstOperandCharIndex : Cardinal; + TabSize : Cardinal; + SpaceAfterMemoryBracket : Boolean; + SpaceBetweenMemoryAddOperators : Boolean; + SpaceBetweenMemoryMulOperators : Boolean; + ScaleBeforeIndex : Boolean; + AlwaysShowScale : Boolean; + ShowZeroDisplacements : Boolean; + HexPrefix : AnsiString; + HexSuffix : AnsiString; + HexDigitGroupSize : Cardinal; + DecimalPrefix : AnsiString; + DecimalSuffix : AnsiString; + DecimalDigitGroupSize : Cardinal; + OctalPrefix : AnsiString; + OctalSuffix : AnsiString; + OctalDigitGroupSize : Cardinal; + BinaryPrefix : AnsiString; + BinarySuffix : AnsiString; + BinaryDigitGroupSize : Cardinal; + DigitSeparator : AnsiString; + LeadingZeros : Boolean; + SmallHexNumbersInDecimal : Boolean; + AddLeadingZeroToHexNumbers : Boolean; + NumberBase : TNumberBase; + BranchLeadingZeros : Boolean; + SignedImmediateOperands : Boolean; + SignedMemoryDisplacements : Boolean; + DisplacementLeadingZeros : Boolean; + MemorySizeOptions : TMemorySizeOptions; + ShowBranchSize : Boolean; + PreferST0 : Boolean; + ShowUselessPrefixes : Boolean; + CC_b : TCC_b; + CC_ae : TCC_ae; + CC_e : TCC_e; + CC_ne : TCC_ne; + CC_be : TCC_be; + CC_a : TCC_a; + CC_p : TCC_p; + CC_np : TCC_np; + CC_l : TCC_l; + CC_ge : TCC_ge; + CC_le : TCC_le; + CC_g : TCC_g; + end; + PIcedFormatterSettings = ^TIcedFormatterSettings; + + TIcedFormatter = class + private + fType : TIcedFormatterType; + fHandle : Pointer; + fOptions : TIcedFormatterSettings; + fSpecialized : TIcedSpecializedFormatterOptions; + fSymbolResolver : TSymbolResolverCallback; + fOptionsProvider : TFormatterOptionsProviderCallback; + fFormatterOutput : TFormatterOutputCallback; + fOutputHandle : Pointer; + fShowSymbols : Boolean; + {$IFDEF AssemblyTools} + fSymbolHandler : TSymbolHandler; + {$ENDIF AssemblyTools} + procedure CreateHandle( KeepConfiguration : Boolean = False ); + function GetHandle : Pointer; + procedure SetType( Value : TIcedFormatterType ); + function GetSymbolResolver : TSymbolResolverCallback; + procedure SetSymbolResolver( Value : TSymbolResolverCallback ); + function GetOptionsProvider : TFormatterOptionsProviderCallback; + procedure SetOptionsProvider( Value : TFormatterOptionsProviderCallback ); + function GetFormatterOutput : TFormatterOutputCallback; + procedure SetFormatterOutput( Value : TFormatterOutputCallback ); + + procedure SetShowSymbols( Value : Boolean ); + {$IFDEF AssemblyTools} + procedure SetSymbolHandler( Value : TSymbolHandler ); + {$ENDIF AssemblyTools} + + // Options + function GetOptions : TIcedFormatterSettings; + procedure SetOptions( Value : TIcedFormatterSettings ); + procedure SetCapstoneOptions; + + // Masm + function GetAddDsPrefix32 : Boolean; + procedure SetAddDsPrefix32( Value : Boolean ); + function GetSymbolDisplacementInBrackets : Boolean; + procedure SetSymbolDisplacementInBrackets( Value : Boolean ); + function GetDisplacementInBrackets : Boolean; + procedure SetDisplacementInBrackets( Value : Boolean ); + // Nasm + function GetShowSignExtendedImmediateSize : Boolean; + procedure SetShowSignExtendedImmediateSize( Value : Boolean ); + // Gas + function GetNakedRegisters : Boolean; + procedure SetNakedRegisters( Value : Boolean ); + function GetShowMnemonicSizeSuffix : Boolean; + procedure SetShowMnemonicSizeSuffix( Value : Boolean ); + function GetSpaceAfterMemoryOperandComma : Boolean; + procedure SetSpaceAfterMemoryOperandComma( Value : Boolean ); + // Specialized + function GetUseHexPrefix : Boolean; + procedure SetUseHexPrefix( Value : Boolean ); + function GetAlwaysShowMemorySize : Boolean; + procedure SetAlwaysShowMemorySize( Value : Boolean ); + function GetEnable_DB_DW_DD_DQ : Boolean; + procedure SetEnable_DB_DW_DD_DQ( Value : Boolean ); + function GetVerifyOutputHasEnoughBytesLeft : Boolean; + procedure SetVerifyOutputHasEnoughBytesLeft( Value : Boolean ); + + // Common + function GetSpaceAfterOperandSeparator : Boolean; + procedure SetSpaceAfterOperandSeparator( Value : Boolean ); + function GetAlwaysShowSegmentRegister : Boolean; + procedure SetAlwaysShowSegmentRegister( Value : Boolean ); + function GetUsePseudoOps : Boolean; + procedure SetUsePseudoOps( Value : Boolean ); + function GetRipRelativeAddresses : Boolean; + procedure SetRipRelativeAddresses( Value : Boolean ); + function GetShowSymbolAddress : Boolean; + procedure SetShowSymbolAddress( Value : Boolean ); + function GetUpperCaseHex : Boolean; + procedure SetUpperCaseHex( Value : Boolean ); + // Common (All but Fast/Specialized) + function GetUpperCasePrefixes : Boolean; + procedure SetUpperCasePrefixes( Value : Boolean ); + function GetUpperCaseMnemonics : Boolean; + procedure SetUpperCaseMnemonics( Value : Boolean ); + function GetUpperCaseRegisters : Boolean; + procedure SetUpperCaseRegisters( Value : Boolean ); + function GetUpperCaseKeyWords : Boolean; + procedure SetUpperCaseKeyWords( Value : Boolean ); + function GetUpperCaseDecorators : Boolean; + procedure SetUpperCaseDecorators( Value : Boolean ); + function GetUpperCaseEverything : Boolean; + procedure SetUpperCaseEverything( Value : Boolean ); + function GetFirstOperandCharIndex : Cardinal; + procedure SetFirstOperandCharIndex( Value : Cardinal ); + function GetTabSize : Cardinal; + procedure SetTabSize( Value : Cardinal ); + function GetSpaceAfterMemoryBracket : Boolean; + procedure SetSpaceAfterMemoryBracket( Value : Boolean ); + function GetSpaceBetweenMemoryAddOperators : Boolean; + procedure SetSpaceBetweenMemoryAddOperators( Value : Boolean ); + function GetSpaceBetweenMemoryMulOperators : Boolean; + procedure SetSpaceBetweenMemoryMulOperators( Value : Boolean ); + function GetScaleBeforeIndex : Boolean; + procedure SetScaleBeforeIndex( Value : Boolean ); + function GetAlwaysShowScale : Boolean; + procedure SetAlwaysShowScale( Value : Boolean ); + function GetShowZeroDisplacements : Boolean; + procedure SetShowZeroDisplacements( Value : Boolean ); + function GetHexPrefix : AnsiString; + procedure SetHexPrefix( Value : AnsiString ); + function GetHexSuffix : AnsiString; + procedure SetHexSuffix( Value : AnsiString ); + function GetHexDigitGroupSize : Cardinal; + procedure SetHexDigitGroupSize( Value : Cardinal ); + function GetDecimalPrefix : AnsiString; + procedure SetDecimalPrefix( Value : AnsiString ); + function GetDecimalSuffix : AnsiString; + procedure SetDecimalSuffix( Value : AnsiString ); + function GetDecimalDigitGroupSize : Cardinal; + procedure SetDecimalDigitGroupSize( Value : Cardinal ); + function GetOctalPrefix : AnsiString; + procedure SetOctalPrefix( Value : AnsiString ); + function GetOctalSuffix : AnsiString; + procedure SetOctalSuffix( Value : AnsiString ); + function GetOctalDigitGroupSize : Cardinal; + procedure SetOctalDigitGroupSize( Value : Cardinal ); + function GetBinaryPrefix : AnsiString; + procedure SetBinaryPrefix( Value : AnsiString ); + function GetBinarySuffix : AnsiString; + procedure SetBinarySuffix( Value : AnsiString ); + function GetBinaryDigitGroupSize : Cardinal; + procedure SetBinaryDigitGroupSize( Value : Cardinal ); + function GetDigitSeparator : AnsiString; + procedure SetDigitSeparator( Value : AnsiString ); + function GetLeadingZeros : Boolean; + procedure SetLeadingZeros( Value : Boolean ); + function GetSmallHexNumbersInDecimal : Boolean; + procedure SetSmallHexNumbersInDecimal( Value : Boolean ); + function GetAddLeadingZeroToHexNumbers : Boolean; + procedure SetAddLeadingZeroToHexNumbers( Value : Boolean ); + function GetNumberBase : TNumberBase; + procedure SetNumberBase( Value : TNumberBase ); + function GetBranchLeadingZeros : Boolean; + procedure SetBranchLeadingZeros( Value : Boolean ); + function GetSignedImmediateOperands : Boolean; + procedure SetSignedImmediateOperands( Value : Boolean ); + function GetSignedMemoryDisplacements : Boolean; + procedure SetSignedMemoryDisplacements( Value : Boolean ); + function GetDisplacementLeadingZeros : Boolean; + procedure SetDisplacementLeadingZeros( Value : Boolean ); + function GetMemorySizeOptions : TMemorySizeOptions; + procedure SetMemorySizeOptions( Value : TMemorySizeOptions ); + function GetShowBranchSize : Boolean; + procedure SetShowBranchSize( Value : Boolean ); + function GetPreferST0 : Boolean; + procedure SetPreferST0( Value : Boolean ); + function GetShowUselessPrefixes : Boolean; + procedure SetShowUselessPrefixes( Value : Boolean ); + function GetCC_b : TCC_b; + procedure SetCC_b( Value : TCC_b ); + function GetCC_ae : TCC_ae; + procedure SetCC_ae( Value : TCC_ae ); + function GetCC_e : TCC_e; + procedure SetCC_e( Value : TCC_e ); + function GetCC_ne : TCC_ne; + procedure SetCC_ne( Value : TCC_ne ); + function GetCC_be : TCC_be; + procedure SetCC_be( Value : TCC_be ); + function GetCC_a : TCC_a; + procedure SetCC_a( Value : TCC_a ); + function GetCC_p : TCC_p; + procedure SetCC_p( Value : TCC_p ); + function GetCC_np : TCC_np; + procedure SetCC_np( Value : TCC_np ); + function GetCC_l : TCC_l; + procedure SetCC_l( Value : TCC_l ); + function GetCC_ge : TCC_ge; + procedure SetCC_ge( Value : TCC_ge ); + function GetCC_le : TCC_le; + procedure SetCC_le( Value : TCC_le ); + function GetCC_g : TCC_g; + procedure SetCC_g( Value : TCC_g ); + public + constructor Create( FormatterType : TIcedFormatterType = DEFAULT_FORMATTER; SymbolResolver : TSymbolResolverCallback = nil; OptionsProvider : TFormatterOptionsProviderCallback = nil ); reintroduce; + destructor Destroy; override; + procedure DefaultSettings; + + function FormatToString( const Instruction: TInstruction ) : PAnsiChar; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure Format( const Instruction: TInstruction; var AOutput: PAnsiChar; Size : PNativeUInt = nil ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + procedure Format( const Instruction: TInstruction ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} // TFormatterOutputCallback + + property Handle : Pointer read GetHandle; + property FormatterType : TIcedFormatterType read fType write SetType; + property SymbolResolver : TSymbolResolverCallback read GetSymbolResolver write SetSymbolResolver; + property OptionsProvider : TFormatterOptionsProviderCallback read GetOptionsProvider write SetOptionsProvider; + property Callback : TFormatterOutputCallback read GetFormatterOutput write SetFormatterOutput; + + property ShowSymbols : Boolean read fShowSymbols write SetShowSymbols; + {$IFDEF AssemblyTools} + property SymbolHandler : TSymbolHandler read fSymbolHandler write SetSymbolHandler; + {$ENDIF AssemblyTools} + + // Options + property Options : TIcedFormatterSettings read GetOptions write SetOptions; + procedure SettingsToStringList( Settings : TIcedFormatterSettings; var StrL : TStringList ); + function StringListToSettings( StrL : TStringList; Settings : PIcedFormatterSettings = nil ) : boolean; + + // Masm + property AddDsPrefix32 : Boolean read GetAddDsPrefix32 write SetAddDsPrefix32; + property SymbolDisplacementInBrackets : Boolean read GetSymbolDisplacementInBrackets write SetSymbolDisplacementInBrackets; + property DisplacementInBrackets : Boolean read GetDisplacementInBrackets write SetDisplacementInBrackets; + // Nasm + property ShowSignExtendedImmediateSize : Boolean read GetShowSignExtendedImmediateSize write SetShowSignExtendedImmediateSize; + // Gas + property NakedRegisters : Boolean read GetNakedRegisters write SetNakedRegisters; + property ShowMnemonicSizeSuffix : Boolean read GetShowMnemonicSizeSuffix write SetShowMnemonicSizeSuffix; + property SpaceAfterMemoryOperandComma : Boolean read GetSpaceAfterMemoryOperandComma write SetSpaceAfterMemoryOperandComma; + // Specialized + property UseHexPrefix : Boolean read GetUseHexPrefix write SetUseHexPrefix; + property AlwaysShowMemorySize : Boolean read GetAlwaysShowMemorySize write SetAlwaysShowMemorySize; + property Enable_DB_DW_DD_DQ : Boolean read GetEnable_DB_DW_DD_DQ write SetEnable_DB_DW_DD_DQ; + property VerifyOutputHasEnoughBytesLeft : Boolean read GetVerifyOutputHasEnoughBytesLeft write SetVerifyOutputHasEnoughBytesLeft; + + // Common + property SpaceAfterOperandSeparator : Boolean read GetSpaceAfterOperandSeparator write SetSpaceAfterOperandSeparator; + property AlwaysShowSegmentRegister : Boolean read GetAlwaysShowSegmentRegister write SetAlwaysShowSegmentRegister; + property UsePseudoOps : Boolean read GetUsePseudoOps write SetUsePseudoOps; + property RipRelativeAddresses : Boolean read GetRipRelativeAddresses write SetRipRelativeAddresses; + property ShowSymbolAddress : Boolean read GetShowSymbolAddress write SetShowSymbolAddress; + property UpperCaseHex : Boolean read GetUpperCaseHex write SetUpperCaseHex; + // Common (All but Fast/Specialized) + property UpperCasePrefixes : Boolean read GetUpperCasePrefixes write SetUpperCasePrefixes; + property UpperCaseMnemonics : Boolean read GetUpperCaseMnemonics write SetUpperCaseMnemonics; + property UpperCaseRegisters : Boolean read GetUpperCaseRegisters write SetUpperCaseRegisters; + property UpperCaseKeyWords : Boolean read GetUpperCaseKeyWords write SetUpperCaseKeyWords; + property UpperCaseDecorators : Boolean read GetUpperCaseDecorators write SetUpperCaseDecorators; + property UpperCaseEverything : Boolean read GetUpperCaseEverything write SetUpperCaseEverything; + property FirstOperandCharIndex : Cardinal read GetFirstOperandCharIndex write SetFirstOperandCharIndex; + property TabSize : Cardinal read GetTabSize write SetTabSize; + property SpaceAfterMemoryBracket : Boolean read GetSpaceAfterMemoryBracket write SetSpaceAfterMemoryBracket; + property SpaceBetweenMemoryAddOperators : Boolean read GetSpaceBetweenMemoryAddOperators write SetSpaceBetweenMemoryAddOperators; + property SpaceBetweenMemoryMulOperators : Boolean read GetSpaceBetweenMemoryMulOperators write SetSpaceBetweenMemoryMulOperators; + property ScaleBeforeIndex : Boolean read GetScaleBeforeIndex write SetScaleBeforeIndex; + property AlwaysShowScale : Boolean read GetAlwaysShowScale write SetAlwaysShowScale; + property ShowZeroDisplacements : Boolean read GetShowZeroDisplacements write SetShowZeroDisplacements; + property HexPrefix : AnsiString read GetHexPrefix write SetHexPrefix; + property HexSuffix : AnsiString read GetHexSuffix write SetHexSuffix; + property HexDigitGroupSize : Cardinal read GetHexDigitGroupSize write SetHexDigitGroupSize; + property DecimalPrefix : AnsiString read GetDecimalPrefix write SetDecimalPrefix; + property DecimalSuffix : AnsiString read GetDecimalSuffix write SetDecimalSuffix; + property DecimalDigitGroupSize : Cardinal read GetDecimalDigitGroupSize write SetDecimalDigitGroupSize; + property OctalPrefix : AnsiString read GetOctalPrefix write SetOctalPrefix; + property OctalSuffix : AnsiString read GetOctalSuffix write SetOctalSuffix; + property OctalDigitGroupSize : Cardinal read GetOctalDigitGroupSize write SetOctalDigitGroupSize; + property BinaryPrefix : AnsiString read GetBinaryPrefix write SetBinaryPrefix; + property BinarySuffix : AnsiString read GetBinarySuffix write SetBinarySuffix; + property BinaryDigitGroupSize : Cardinal read GetBinaryDigitGroupSize write SetBinaryDigitGroupSize; + property DigitSeparator : AnsiString read GetDigitSeparator write SetDigitSeparator; + property LeadingZeros : Boolean read GetLeadingZeros write SetLeadingZeros; + property SmallHexNumbersInDecimal : Boolean read GetSmallHexNumbersInDecimal write SetSmallHexNumbersInDecimal; + property AddLeadingZeroToHexNumbers : Boolean read GetAddLeadingZeroToHexNumbers write SetAddLeadingZeroToHexNumbers; + property NumberBase : TNumberBase read GetNumberBase write SetNumberBase; + property BranchLeadingZeros : Boolean read GetBranchLeadingZeros write SetBranchLeadingZeros; + property SignedImmediateOperands : Boolean read GetSignedImmediateOperands write SetSignedImmediateOperands; + property SignedMemoryDisplacements : Boolean read GetSignedMemoryDisplacements write SetSignedMemoryDisplacements; + property DisplacementLeadingZeros : Boolean read GetDisplacementLeadingZeros write SetDisplacementLeadingZeros; + property MemorySizeOptions : TMemorySizeOptions read GetMemorySizeOptions write SetMemorySizeOptions; + property ShowBranchSize : Boolean read GetShowBranchSize write SetShowBranchSize; + property PreferST0 : Boolean read GetPreferST0 write SetPreferST0; + property ShowUselessPrefixes : Boolean read GetShowUselessPrefixes write SetShowUselessPrefixes; + property CC_b : TCC_b read GetCC_b write SetCC_b; + property CC_ae : TCC_ae read GetCC_ae write SetCC_ae; + property CC_e : TCC_e read GetCC_e write SetCC_e; + property CC_ne : TCC_ne read GetCC_ne write SetCC_ne; + property CC_be : TCC_be read GetCC_be write SetCC_be; + property CC_a : TCC_a read GetCC_a write SetCC_a; + property CC_p : TCC_p read GetCC_p write SetCC_p; + property CC_np : TCC_np read GetCC_np write SetCC_np; + property CC_l : TCC_l read GetCC_l write SetCC_l; + property CC_ge : TCC_ge read GetCC_ge write SetCC_ge; + property CC_le : TCC_le read GetCC_le write SetCC_le; + property CC_g : TCC_g read GetCC_g write SetCC_g; + end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + tIcedPointerScanResult = record + Origin : UInt64; + Instruction : string; + vPointer : UInt64; + Count : Word; + end; + tIcedPointerScanResults = Array of tIcedPointerScanResult; + PIcedPointerScanResults = ^tIcedPointerScanResults; + + tIcedReferenceScanResult = record + Origin : UInt64; + Instruction : string; + end; + tIcedReferenceScanResults = Array of tIcedReferenceScanResult; + PIcedReferenceScanResults = ^tIcedReferenceScanResults; + + tIcedAssemblyScanMode = ( + asmEqual, asmSimiliar, asmWildcard + {$IF CompilerVersion >= 22}, asmRegExp{$IFEND} // XE + ); + + tIcedPointerScanProcessEvent = procedure( Current, Total : Cardinal; var Cancel : Boolean ) of object; + + tIcedAssemblyCompareMode = ( acmCenter, acmForward, acmBackward ); + +{$IF NOT Declared( TByteInstruction )} // IFNDEF AssemblyTools +const + MAX_INSTRUCTION_LEN_ = 15; + MASKING_OFFSET = $10000; +type + TByteInstruction = Array [ 0..MAX_INSTRUCTION_LEN_-1 ] of Byte; + pByteInstruction = ^TByteInstruction; +{$IFEND} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + TIced = class + private + fDecoder : TIcedDecoder; + fEncoder : TIcedEncoder; + fBlockEncoder : TIcedBlockEncoder; + fInfoFactory : TInstructionInfoFactory; + fFormatter : TIcedFormatter; + public + constructor Create( Bitness : TIcedBitness = bt64 ); reintroduce; + destructor Destroy; override; + property Decoder : TIcedDecoder read fDecoder; + property Encoder : TIcedEncoder read fEncoder; + property BlockEncoder : TIcedBlockEncoder read fBlockEncoder; + property InfoFactory : TInstructionInfoFactory read fInfoFactory; + property Formatter : TIcedFormatter read fFormatter; + + procedure DecodeFormat( var Instruction: TInstruction; var AOutput: PAnsiChar; Size : PNativeUInt = nil ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$IFDEF AssemblyTools} + procedure DecodeFormat( var Instruction: TInstruction; var AOutput: PAnsiChar; Size : PNativeUInt; var Details : TIcedDetails ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF AssemblyTools} + + procedure DecodeFormat( var Instruction: TInstruction ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} // TFormatterOutputCallback + {$IFDEF AssemblyTools} + procedure DecodeFormat( var Instruction: TInstruction; var Details : TIcedDetails ); overload; {$IF CompilerVersion >= 23}inline;{$IFEND} + {$ENDIF AssemblyTools} + + procedure DecodeFormatToEnd( Callback : TDecoderFormatCallback; UserData : Pointer = nil ); {$IF CompilerVersion >= 23}inline;{$IFEND} + + {$IF Declared( SynUnicode )} + function DecodeFromFile( FileName : String; Size : Cardinal; Offset : UInt64; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : Cardinal; overload; + function DecodeFromStream( Data : TMemoryStream; Size : Cardinal; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : Cardinal; overload; + + function Decode( Data : PByte; Size : Cardinal; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; overload; + function Decode( Data : PByte; Size : Cardinal; Count : Cardinal; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; overload; + function Decode( Data : string; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : boolean; overload; + function Decode( Data : TStrings; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : boolean; overload; + + function DecodeCombineNOP( Data : PByte; Size : Cardinal; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; overload; + function DecodeCombineNOP( Data : PByte; Size : Cardinal; Count : Cardinal; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; overload; + {$IFEND UNICODE} + + function DecodeFromFile( FileName : String; Size : Cardinal; Offset : UInt64; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : Cardinal; overload; + function DecodeFromStream( Data : TMemoryStream; Size : Cardinal; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : Cardinal; overload; + + function Decode( Data : PByte; Size : Cardinal; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; overload; + function Decode( Data : PByte; Size : Cardinal; Count : Cardinal; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; overload; + function Decode( Data : PByte; Size : Cardinal; var Instruction: String; CodeOffset : UInt64 = UInt64( 0 ); InstructionBytes : pString = nil; Offset : PUInt64 = nil; {$IFDEF AssemblyTools}Detail : pIcedDetail = nil;{$ENDIF AssemblyTools} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : Cardinal; overload; + function Decode( Data : string; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : boolean; overload; + function Decode( Data : TStrings; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : boolean; overload; + + function DecodeCombineNOP( Data : PByte; Size : Cardinal; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; overload; + function DecodeCombineNOP( Data : PByte; Size : Cardinal; Count : Cardinal; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; overload; + + {$IFDEF AssemblyTools} + function DecodeAddress( var Data : TByteInstruction; Address : UInt64; Instruction : PString = nil; {$IFDEF AssemblyTools}Detail : pIcedDetail = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; overload; + function DecodeAddress( Data : PByte; Size : Cardinal; Address : UInt64; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; {$IFDEF AssemblyTools}Detail : pIcedDetail = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; overload; + {$ENDIF AssemblyTools} + function Compare( Data : PByte; Size : Cardinal; Offset : UInt64; DataCompare : PByte; SizeCompare : Cardinal; OffsetCompare : UInt64; Count : Word; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyCompareMode = acmCenter ) : Cardinal; overload; + function Compare( Data : TMemoryStream; Offset : UInt64; DataCompare : TMemoryStream; OffsetCompare : UInt64; Count : Word; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyCompareMode = acmCenter ) : Cardinal; overload; + + function PointerScan( Data : PByte; Size : Cardinal; var results : tIcedPointerScanResults; CodeOffset : UInt64 = UInt64( 0 ); ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; overload; + function PointerScan( Data : TMemoryStream; var results : tIcedPointerScanResults; CodeOffset : UInt64 = UInt64( 0 ); ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; overload; + function ReferenceScan( Data : PByte; Size : Cardinal; Reference : UInt64; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; overload; + function ReferenceScan( Data : TMemoryStream; Reference : UInt64; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; overload; + + function AssemblyScan( Data : PByte; Size : Cardinal; Assembly : String; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; overload; + function AssemblyScan( Data : TMemoryStream; Assembly : String; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; overload; + + function AssemblyScan( Data : PByte; Size : Cardinal; Assembly : PInstruction; AssemblyCount : Cardinal; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; overload; + function AssemblyScan( Data : TMemoryStream; Assembly : PInstruction; AssemblyCount : Cardinal; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; overload; + function AssemblyScan( Data : PByte; Size : Cardinal; var Assembly : TInstructionArray; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; overload; + function AssemblyScan( Data : TMemoryStream; var Assembly : TInstructionArray; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; overload; + + function FindInstruction( Data : PByte; Size : Cardinal; Offset : UInt64; CodeOffset : UInt64 = UInt64( 0 ); {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; overload; + function FindInstruction( Data : TMemoryStream; Offset : UInt64; CodeOffset : UInt64 = UInt64( 0 ); {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; overload; + + function FindNextInstruction( Data : TMemoryStream; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; InstructionCount : Word = 1; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; overload; + function FindNextInstruction( Data : PByte; Size : Cardinal; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; InstructionCount : Word = 1; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; overload; + +// MS +// function FindPreviousInstructionCount( Data : TMemoryStream; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; InstructionCount : Word = 1; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; overload; +// function FindPreviousInstructionCount( Data : PByte; Size : Cardinal; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; InstructionCount : Word = 1; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; overload; +// function FindPreviousInstruction( Data : TMemoryStream; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; DesiredInstructionOffset : UInt64; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; overload; +// function FindPreviousInstruction( Data : PByte; Size : Cardinal; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; DesiredInstructionOffset : UInt64; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; overload; + end; + +var + Iced : TIced; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +{$IFDEF TEST_FUNCTIONS} +const + EXAMPLE_RIP: UInt64 = UInt64( $7FFAC46ACDA4 ); + EXAMPLE_CODE: Array [ 0..61 ] of Byte = ( + $48, $89, $5C, $24, $10, $48, $89, $74, $24, $18, $55, $57, $41, $56, $48, $8D, + $AC, $24, $00, $FF, $FF, $FF, $48, $81, $EC, $00, $02, $00, $00, $48, $8B, $05, + $18, $57, $0A, $00, $48, $33, $C4, $48, $89, $85, $F0, $00, $00, $00, $4C, $8B, + $05, $2F, $24, $0A, $00, $48, $8D, $05, $78, $7C, $04, $00, $33, $FF + ); + +function Test( StrL : TStringList ) : Boolean; +function Test_Decode( Data : PByte; Size : Cardinal; ARIP : UInt64; AOutput : TStringList; FormatterType : TIcedFormatterType = ftMasm; + SymbolResolver : TSymbolResolverCallback = nil; + FormatterOptionsProviderCallback : TFormatterOptionsProviderCallback = nil; + FormatterOutputCallback : TFormatterOutputCallback = nil; + Assembly : Boolean = True; DecodeInfos : Boolean = True; Infos : Boolean = True ) : Boolean; +function Test_ReEncode( Data : PByte; Size : Cardinal; ARIP : UInt64; {LocalBuffer : Boolean = False;} BlockEncode : Boolean = False; AOutput : TStringList = nil ) : Boolean; +procedure Test_Assemble( AOutput : TStringList; ARIP : UInt64 = UInt64( $00001248FC840000 ) ); + +function Benchmark( Data : PByte; Size : Cardinal; Bitness : TIcedBitness; AFormat : Boolean = False ) : Double; overload; +function Benchmark( FileName : String; Bitness : TIcedBitness; AFormat : Boolean = False ) : Double; overload; +{$ENDIF TEST_FUNCTIONS} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +implementation + +{$IF CompilerVersion >= 22} // XE +uses + RegularExpressions; +{$IFEND} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +constructor TIcedDecoder.Create( Bitness : TIcedBitness = bt64 ); +begin + inherited Create; + fHandle := nil; + fBitness := Bitness; + fData := nil; + fSize := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + fIPosition:= 0; + {$IFDEF DECODER_LOCAL_POSITION} + fPosition := 0; + {$ENDIF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +destructor TIcedDecoder.Destroy; +begin + if ( fHandle <> nil ) then + IcedFreeMemory( fHandle ); + + inherited; +end; + +function TIcedDecoder.GetHandle : Pointer; +begin + result := nil; + if ( self = nil ) then + Exit; + result := fHandle; +end; + +function TIcedDecoder.GetBitness : TIcedBitness; +begin + result := bt16; + if ( self = nil ) then + Exit; + result := fBitness; +// result := TIcedBitness( Decoder_GetBitness( fHandle ) ); +end; + +procedure TIcedDecoder.SetBitness( Value : TIcedBitness ); +begin + if ( self = nil ) then + Exit; + fBitness := Value; + + if ( fHandle <> nil ) then + begin + IcedFreeMemory( fHandle ); + fHandle := nil; + end; +end; + +procedure TIcedDecoder.SetData( Data : PByte; Size : NativeUInt; IP : UInt64 = UInt64( 0 ); Options : Cardinal = doNONE ); +begin + if ( self = nil ) then + Exit; + if NOT uIced.Imports.IsInitDLL then + Exit; + if ( fHandle <> nil ) then + IcedFreeMemory( fHandle ); + + if ( fData = Data ) AND ( fSize = 0 ) then + begin + Position := 0; + Exit; + end; + fData := Data; + fSize := Size; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + fIPosition:= 0; + {$IFDEF DECODER_LOCAL_POSITION} + fPosition := 0; + {$ENDIF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + fHandle := Decoder_Create( Cardinal( fBitness ), Data, Size, IP, Options ); +end; + +function TIcedDecoder.CanDecode : Boolean; +begin + result := False; + if ( self = nil ) then + Exit; + result := Decoder_CanDecode( fHandle ); +end; + +function TIcedDecoder.GetIP : UInt64; +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( self = nil ) then + Exit; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := Decoder_GetIP( fHandle ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TIcedDecoder.SetIP( Value : UInt64 ); +begin + if ( self = nil ) then + Exit; + Decoder_SetIP( fHandle, Value ); +end; + +function TIcedDecoder.GetPosition : NativeUInt; +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( self = nil ) then + Exit; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + {$IFDEF DECODER_LOCAL_POSITION} + result := fPosition; + {$ELSE} + result := Decoder_GetPosition( fHandle ); + {$ENDIF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TIcedDecoder.SetPosition( Value : NativeUInt ); +begin + if ( self = nil ) then + Exit; + + {$IFDEF DECODER_LOCAL_POSITION} + if ( fPosition = Value ) then + Exit; + if ( Value > fSize ) then + Exit; + fPosition := Value; + {$ELSE} + if ( Value > fSize ) then + Exit; + {$ENDIF DECODER_LOCAL_POSITION} + + Decoder_SetPosition( fHandle, Value ); +end; + +function TIcedDecoder.GetMaxPosition : NativeUInt; +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( self = nil ) then + Exit; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := fSize; +// result := Decoder_GetMaxPosition( fHandle ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TIcedDecoder.GetInstructionFirstByte : PByte; +begin + result := nil; + if ( self = nil ) then + Exit; + if ( fData = nil ) OR ( fSize = 0 ) then + Exit; + + {$IFDEF DECODER_LOCAL_POSITION} + if ( fPosition = 0 ) then + Exit; + {$ELSE} + if ( Position = 0 ) then + Exit; + {$ENDIF DECODER_LOCAL_POSITION} + + result := PByte( PAnsiChar( fData ) + fIPosition ); +end; + +function TIcedDecoder.GetCurrentByte : PByte; +begin + result := nil; + if ( self = nil ) then + Exit; + if ( fData = nil ) OR ( fSize = 0 ) then + Exit; + + {$IFDEF DECODER_LOCAL_POSITION} + result := PByte( PAnsiChar( fData ) + fPosition ); + {$ELSE} + result := PByte( PAnsiChar( fData ) + Position ); + {$ENDIF DECODER_LOCAL_POSITION} +end; + +function TIcedDecoder.GetLastError : TDecoderError; +begin + result.DecoderError := deNone; + if ( self = nil ) then + Exit; + result := Decoder_GetLastError( fHandle ); +end; + +procedure TIcedDecoder.Decode( var Instruction : TInstruction ); +begin + if ( self = nil ) then + begin + FillChar( Instruction, SizeOf( Instruction ), 0 ); + Exit; + end; + if ( fHandle = nil ) then + begin + FillChar( Instruction, SizeOf( Instruction ), 0 ); + Exit; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + {$IFDEF DECODER_LOCAL_POSITION} + fIPosition := fPosition; + {$ELSE} + fIPosition := Position; + {$ENDIF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + Decoder_Decode( fHandle, Instruction ); + + {$IFDEF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 +// fPosition := Position; + Inc( fPosition, Instruction.len ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + {$ENDIF DECODER_LOCAL_POSITION} +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +{$IFDEF AssemblyTools} +procedure TIcedDecoder.GenerateDetails( const Instruction : TInstruction; var Details : TIcedDetails ); +const + JUMPTARGET_BLOCKSIZE = 1000; +var + Offsets : TConstantOffsets; +begin + if ( self = nil ) then + begin +// FillChar( Detail, SizeOf( Detail ), 0 ); + Exit; + end; + + if ( fHandle = nil ) then + begin +// FillChar( Detail, SizeOf( Detail ), 0 ); + Exit; + end; + + // Details + Details.Items[ Details.Count ].Code := Instruction.code; + Move( Instruction.Regs[ 0 ], Details.Items[ Details.Count ].Registers[ 0 ], Length( Details.Items[ Details.Count ].Registers )*SizeOf( Details.Items[ Details.Count ].Registers[ 0 ] ) ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Details.Items[ Details.Count ].Offset := Instruction.RIP; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Details.Items[ Details.Count ].Size := Instruction.len; + + FillChar( Details.Items[ Details.Count ].Registers_, SizeOf( Details.Items[ Details.Count ].Registers_ ), 0 ); // MS ? + +// Details.Items[ Details.Count ].Registers_.Target := Instruction. // MS working for all but lea +// Details.Items[ Details.Count ].Registers_.Source := Instruction. +// Details.Items[ Details.Count ].Registers_.Parameter := Instruction. + +{ +LEA +Multiplier is always Byte 4 before displacement +If Length = 3 or Displacement starts at 3 its not used +488D84 1A 00010000 = 1A = 1 +488D84 5A 00010000 = 1A = 2 +488D84 9A 00010000 = 1A = 4 +488D84 DA 00010000 = 1A = 8 + +488D841A00010000 lea rax, [rdx+rbx+0x100] +488D845A00010000 lea rax, [rdx+rbx*2+0x100] +488D849A00010000 lea rax, [rdx+rbx*4+0x100] +488D84DA00010000 lea rax, [rdx+rbx*8+0x100] + +488D041A lea rax, [rdx+rbx*1] +488D045A lea rax, [rdx+rbx*2] +488D049A lea rax, [rdx+rbx*4] +488D04DA lea rax, [rdx+rbx*8] + +678D041A lea eax, [edx+ebx*1] +678D045A lea eax, [edx+ebx*2] +678D049A lea eax, [edx+ebx*4] +678D04DA lea eax, [edx+ebx*8] +} + + Decoder_GetConstantOffsets( fHandle, Instruction, Offsets ); + + {if ForceMask AND ( Offsets.displacement_offset <> 0 ) then + Details.Items[ Details.Count ].Mask := True + else} if ( Offsets.displacement_offset <> 0 ) AND ( Offsets.displacement_size = 4 ) then + Details.Items[ Details.Count ].Mask := ( ABS( Integer( Instruction.mem_displ-Instruction.Rip-Instruction.Len ) ) >= MASKING_OFFSET ); // value is bigger than 65535 (positive and negative) + + if Details.Items[ Details.Count ].IsJump AND ( ( Instruction.op_kinds[ 0 ] <> okRegister_ ) OR ( Instruction.mem_displ <> 0 ) ) then + begin + Details.Items[ Details.Count ].JumpTargetID := Details.TargetCount; + Inc( Details.TargetCount ); + if ( Details.TargetCount >= Length( Details.JumpTargets ) ) then + SetLength( Details.JumpTargets, Details.TargetCount+JUMPTARGET_BLOCKSIZE ); + + FillChar( Details.JumpTargets[ Details.Items[ Details.Count ].JumpTargetID ], SizeOf( Details.JumpTargets[ Details.Items[ Details.Count ].JumpTargetID ] ), 0 ); +// Details.JumpTargets[ Details.Items[ Details.Count ].JumpTargetID ].IsRegJump := Instruction.IsRegJump; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Details.JumpTargets[ Details.Items[ Details.Count ].JumpTargetID ].Target := Instruction.mem_displ; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + end + else + Details.Items[ Details.Count ].JumpTargetID := 0; +end; + +procedure TIcedDecoder.Decode( var Instruction : TInstruction; var Details : TIcedDetails ); +begin + if ( self = nil ) then + begin + FillChar( Instruction, SizeOf( Instruction ), 0 ); +// FillChar( Detail, SizeOf( Detail ), 0 ); + Exit; + end; + if ( fHandle = nil ) then + begin + FillChar( Instruction, SizeOf( Instruction ), 0 ); +// FillChar( Detail, SizeOf( Detail ), 0 ); + Exit; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + {$IFDEF DECODER_LOCAL_POSITION} + fIPosition := fPosition; + {$ELSE} + fIPosition := Position; + {$ENDIF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + Decoder_Decode( fHandle, Instruction ); + GenerateDetails( Instruction, Details ); + + {$IFDEF DECODER_LOCAL_POSITION} +// fPosition := Position; + Inc( fPosition, Instruction.len ); + {$ENDIF DECODER_LOCAL_POSITION} +end; +{$ENDIF AssemblyTools} + +procedure TIcedDecoder.DecodeToEnd( Callback : TDecoderCallback; UserData : Pointer = nil ); +begin + if ( self = nil ) then + Exit; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + {$IFDEF DECODER_LOCAL_POSITION} + fIPosition := fPosition; + {$ELSE} + fIPosition := Position; + {$ENDIF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + Decoder_DecodeToEnd( fHandle, Callback, UserData ); + + {$IFDEF DECODER_LOCAL_POSITION} + fPosition := fSize; + {$ENDIF DECODER_LOCAL_POSITION} +end; + +procedure TIcedDecoder.GetConstantOffsets( const Instruction : TInstruction; var ConstantOffsets : TConstantOffsets ); +begin + FillChar( ConstantOffsets, SizeOf( ConstantOffsets ), 0 ); + if ( self = nil ) then + Exit; + Decoder_GetConstantOffsets( fHandle, Instruction, ConstantOffsets ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +constructor TIcedEncoder.Create( Bitness : TIcedBitness = bt64; Capacity : NativeUInt = 0 ); +begin + inherited Create; + fHandle := nil; + fBitness := Bitness; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + fCapacity := Capacity; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +destructor TIcedEncoder.Destroy; +begin + if ( fHandle <> nil ) then + IcedFreeMemory( fHandle ); + + inherited; +end; + +function TIcedEncoder.GetHandle : Pointer; +begin + result := nil; + if ( self = nil ) then + Exit; + result := fHandle; +end; + +function TIcedEncoder.GetBitness : TIcedBitness; +begin + result := bt16; + if ( self = nil ) then + Exit; + result := fBitness; +// result := TIcedBitness( Encoder_GetBitness( fHandle ) ); +end; + +procedure TIcedEncoder.SetBitness( Value : TIcedBitness ); +begin + if ( self = nil ) then + Exit; + fBitness := Value; + + if ( fHandle <> nil ) then + begin + IcedFreeMemory( fHandle ); + fHandle := nil; + end; +end; + +function TIcedEncoder.GetCapacity : NativeUInt; +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( self = nil ) then + Exit; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := fCapacity; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +procedure TIcedEncoder.SetCapacity( Value : NativeUInt ); +begin + if ( self = nil ) then + Exit; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + fCapacity := Value; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + if ( fHandle <> nil ) then + begin + IcedFreeMemory( fHandle ); + fHandle := nil; + end; +end; + +procedure TIcedEncoder.Encode( var Instruction : TInstruction ); +begin + if ( self = nil ) then + Exit; + if NOT uIced.Imports.IsInitDLL then + Exit; + if ( fHandle = nil ) then + fHandle := Encoder_Create( Cardinal( fBitness ), fCapacity ); + + Encoder_Encode( fHandle, Instruction ); +end; + +procedure TIcedEncoder.Write( Byte : Byte ); +begin + if ( self = nil ) then + Exit; + Encoder_WriteByte( fHandle, Byte ); +end; + +function TIcedEncoder.GetBuffer( Buffer : PByte; Size : NativeUInt ) : Boolean; +begin + result := False; + FillChar( Buffer^, Size, 0 ); + if ( self = nil ) then + Exit; + result := Encoder_GetBuffer( fHandle, Buffer, Size ); +end; + +{ +function TIcedEncoder.SetBuffer( Buffer : PByte; Size : NativeUInt ) : Boolean; +begin + result := False; + if ( self = nil ) then + Exit; + if ( fHandle = nil ) then + fHandle := Encoder_Create( Cardinal( fBitness ) ); + FillChar( Buffer^, Size, 0 ); + result := Encoder_SetBuffer( fHandle, Buffer, Size ); +end; +} + +procedure TIcedEncoder.GetConstantOffsets( var ConstantOffsets : TConstantOffsets ); +begin + FillChar( ConstantOffsets, SizeOf( ConstantOffsets ), 0 ); + if ( self = nil ) then + Exit; + Encoder_GetConstantOffsets( fHandle, ConstantOffsets ); +end; + +function TIcedEncoder.GetPreventVex2 : Boolean; +begin + result := False; + if ( self = nil ) then + Exit; + result := Encoder_GetPreventVex2( fHandle ); +end; + +procedure TIcedEncoder.SetPreventVex2( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + {result := }Encoder_SetPreventVex2( fHandle, Value ); +end; + +function TIcedEncoder.GetVexWig : Cardinal; +begin + result := 0; + if ( self = nil ) then + Exit; + result := Encoder_GetVexWig( fHandle ); +end; + +procedure TIcedEncoder.SetVexWig( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + {result := }Encoder_SetVexWig( fHandle, Value ); +end; + +function TIcedEncoder.GetVexLig : Cardinal; +begin + result := 0; + if ( self = nil ) then + Exit; + result := Encoder_GetVexLig( fHandle ); +end; + +procedure TIcedEncoder.SetVexLig( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + {result := }Encoder_SetVexLig( fHandle, Value ); +end; + +function TIcedEncoder.GetEvexWig : Cardinal; +begin + result := 0; + if ( self = nil ) then + Exit; + result := Encoder_GetEvexWig( fHandle ); +end; + +procedure TIcedEncoder.SetEvexWig( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + {result := }Encoder_SetEvexWig( fHandle, Value ); +end; + +function TIcedEncoder.GetEvexLig : Cardinal; +begin + result := 0; + if ( self = nil ) then + Exit; + result := Encoder_GetEvexLig( fHandle ); +end; + +procedure TIcedEncoder.SetEvexLig( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + {result := }Encoder_SetEvexLig( fHandle, Value ); +end; + +function TIcedEncoder.GetMvexWig : Cardinal; +begin + result := 0; + if ( self = nil ) then + Exit; + result := Encoder_GetMvexWig( fHandle ); +end; + +procedure TIcedEncoder.SetMvexWig( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + {result := }Encoder_SetMvexWig( fHandle, Value ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +constructor TIcedBlockEncoder.Create( Bitness : TIcedBitness = bt64; Options : Cardinal = beoNONE ); +begin + inherited Create; + fBitness := Bitness; + fOptions := Options; + fMemory := nil; +end; + +destructor TIcedBlockEncoder.Destroy; +begin + if ( fMemory <> nil ) then + IcedFreeMemory( fMemory ); + + inherited; +end; + +function TIcedBlockEncoder.GetBitness : TIcedBitness; +begin + result := bt16; + if ( self = nil ) then + Exit; + result := fBitness; +// result := TIcedBitness( Decoder_GetBitness( fHandle ) ); +end; + +function TIcedBlockEncoder.GetOptions : Cardinal; +begin + result := beoNONE; + if ( self = nil ) then + Exit; + result := fOptions; +end; + +procedure TIcedBlockEncoder.SetOptions( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + fOptions := Value; +end; + +procedure TIcedBlockEncoder.SetBitness( Value : TIcedBitness ); +begin + if ( self = nil ) then + Exit; + fBitness := Value; +end; + +procedure TIcedBlockEncoder.Encode( RIP : UInt64; var Instructions : TInstruction; Count : NativeUInt; var Results : TBlockEncoderResult ); +begin + if ( self = nil ) then + Exit; + if NOT uIced.Imports.IsInitDLL then + Exit; + + if ( fMemory <> nil ) then + IcedFreeMemory( fMemory ); + fMemory := BlockEncoder( Cardinal( fBitness ), RIP, Instructions, Count, Results, fOptions ); +end; + +procedure TIcedBlockEncoder.Encode( RIP : UInt64; var Instructions : TInstructionArray; var Results : TBlockEncoderResult ); +begin + Encode( RIP, Instructions[ 0 ], NativeUInt( Length( Instructions ) ), Results ); +end; + +procedure TIcedBlockEncoder.Encode( RIP : UInt64; var Instructions : TInstructionList; var Results : TBlockEncoderResult ); +begin + Encode( RIP, Instructions.Pointer^, Instructions.Count, Results ); +end; + +procedure TIcedBlockEncoder.Clear; +begin + if ( self = nil ) then + Exit; + if ( fMemory <> nil ) then + begin + IcedFreeMemory( fMemory ); + fMemory := nil + end; +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +constructor TInstructionInfoFactory.Create( Options : Cardinal = iioNone ); +begin + inherited Create; + if uIced.Imports.IsInitDLL then + fHandle := InstructionInfoFactory_Create + else + fHandle := nil; + fOptions := Options; +end; + +destructor TInstructionInfoFactory.Destroy; +begin + if ( fHandle <> nil ) then + IcedFreeMemory( fHandle ); + + inherited; +end; + +function TInstructionInfoFactory.GetHandle : Pointer; +begin + result := nil; + if ( self = nil ) then + Exit; + result := fHandle; +end; + +function TInstructionInfoFactory.GetOptions : Cardinal; +begin + result := beoNONE; + if ( self = nil ) then + Exit; + result := fOptions; +end; + +procedure TInstructionInfoFactory.SetOptions( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + fOptions := Value; +end; + +procedure TInstructionInfoFactory.Info( const Instruction: TInstruction; var InstructionInfo : TInstructionInfo ); +begin + FillChar( InstructionInfo, SizeOf( InstructionInfo ), 0 ); + if ( self = nil ) then + Exit; + {result := }InstructionInfoFactory_Info( fHandle, Instruction, InstructionInfo, fOptions ); +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +function SymbolResolverCallback( const Instruction: TInstruction; Operand: Cardinal; InstructionOperand : Cardinal; Address: UInt64; Size: Cardinal; UserData : Pointer ) : PAnsiChar; cdecl; +begin + if ( userData = nil ) then + begin + result := ''; + Exit; + end; + {$IFDEF AssemblyTools} + if ( TIcedFormatter( UserData ).fSymbolHandler <> nil ) then + begin + result := PAnsiChar( AnsiString( TIcedFormatter( UserData ).fSymbolHandler.Symbol( Address ) ) ); + if ( result = '' ) AND ( @TIcedFormatter( UserData ).fSymbolResolver <> nil ) then + result := PAnsiChar( TIcedFormatter( UserData ).fSymbolResolver( Instruction, Operand, InstructionOperand, Address, Size, UserData ) ); + end + else + {$ENDIF AssemblyTools} + if ( @TIcedFormatter( UserData ).fSymbolResolver <> nil ) then + result := PAnsiChar( TIcedFormatter( UserData ).fSymbolResolver( Instruction, Operand, InstructionOperand, Address, Size, UserData ) ) + else + result := ''; +end; + +constructor TIcedFormatter.Create( FormatterType : TIcedFormatterType = DEFAULT_FORMATTER; SymbolResolver : TSymbolResolverCallback = nil; OptionsProvider : TFormatterOptionsProviderCallback = nil ); +begin + inherited Create; + fType := FormatterType; + fHandle := nil; + FillChar( fOptions, SizeOf( fOptions ), 0 ); + fSymbolResolver := SymbolResolver; + fOptionsProvider := OptionsProvider; + fFormatterOutput := nil; + fOutputHandle := nil; + + fSpecialized.ENABLE_SYMBOL_RESOLVER := False; // Internally Handled + fSpecialized.ENABLE_DB_DW_DD_DQ := False; + fSpecialized.verify_output_has_enough_bytes_left := True; + + fShowSymbols := True; + {$IFDEF AssemblyTools} + fSymbolHandler := nil; + {$ENDIF AssemblyTools} + + CreateHandle; +end; + +destructor TIcedFormatter.Destroy; +begin + if ( fOutputHandle <> nil ) then + IcedFreeMemory( fOutputHandle ); + if ( fHandle <> nil ) then + IcedFreeMemory( fHandle ); + + inherited; +end; + +procedure TIcedFormatter.CreateHandle( KeepConfiguration : Boolean = False ); +var + SymbolResolver : TSymbolResolverCallback; + tOptions : TIcedFormatterSettings; +begin + if ( self = nil ) then + Exit; + if NOT uIced.Imports.IsInitDLL then + Exit; + + if ( fHandle <> nil ) then + IcedFreeMemory( fHandle ); + + if fShowSymbols AND ( ( @fSymbolResolver <> nil ){$IFDEF AssemblyTools} OR ( fSymbolHandler <> nil ){$ENDIF} ) then + SymbolResolver := SymbolResolverCallback + else + SymbolResolver := nil; + + fSpecialized.ENABLE_SYMBOL_RESOLVER := ( @SymbolResolver <> nil ); + + case fType of +// ftMasm : fHandle := MasmFormatter_Create( SymbolResolver, fOptionsProvider, Pointer( self ) ); + ftNasm : fHandle := NasmFormatter_Create( SymbolResolver, fOptionsProvider, Pointer( self ) ); + ftGas : fHandle := GasFormatter_Create( SymbolResolver, fOptionsProvider, Pointer( self ) ); + ftIntel : fHandle := IntelFormatter_Create( SymbolResolver, fOptionsProvider, Pointer( self ) ); + ftFast : fHandle := FastFormatter_Create( SymbolResolver, Pointer( self ) ); + ftSpecialized : fHandle := SpecializedFormatter_Create( SymbolResolver, Pointer( self ) ); + else + fHandle := MasmFormatter_Create( SymbolResolver, fOptionsProvider, Pointer( self ) ); + end; + + if KeepConfiguration then + begin + tOptions := fOptions; + fOptions := GetOptions; + SetOptions( tOptions ); + end + else + begin + fOptions := GetOptions; + + if ( fType = ftCapstone ) then + SetCapstoneOptions; + end; +end; + +procedure TIcedFormatter.DefaultSettings; +begin + if ( self = nil ) then + Exit; + CreateHandle; +end; + +function TIcedFormatter.GetHandle : Pointer; +begin + result := nil; + if ( self = nil ) then + Exit; + result := fHandle; +end; + +procedure TIcedFormatter.SetType( Value : TIcedFormatterType ); +begin + if ( self = nil ) then + Exit; + if ( fType = Value ) then + Exit; + + fType := Value; + CreateHandle; +end; + +function TIcedFormatter.GetSymbolResolver : TSymbolResolverCallback; +begin + result := nil; + if ( self = nil ) then + Exit; + result := fSymbolResolver; +end; + +procedure TIcedFormatter.SetSymbolResolver( Value : TSymbolResolverCallback ); +begin + if ( self = nil ) then + Exit; + if ( @fSymbolResolver = @Value ) then + Exit; + + fSymbolResolver := Value; + CreateHandle( True{KeepConfiguration} ); +end; + +function TIcedFormatter.GetOptionsProvider : TFormatterOptionsProviderCallback; +begin + result := nil; + if ( self = nil ) then + Exit; + result := fOptionsProvider; +end; + +procedure TIcedFormatter.SetOptionsProvider( Value : TFormatterOptionsProviderCallback ); +begin + if ( self = nil ) then + Exit; + if ( @fOptionsProvider = @Value ) then + Exit; + + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + fOptionsProvider := Value; + CreateHandle( True{KeepConfiguration} ); +end; + +function TIcedFormatter.GetFormatterOutput : TFormatterOutputCallback; +begin + result := nil; + if ( self = nil ) then + Exit; + result := fFormatterOutput; +end; + +procedure TIcedFormatter.SetFormatterOutput( Value : TFormatterOutputCallback ); +begin + if ( self = nil ) then + Exit; + if ( @fFormatterOutput = @Value ) then + Exit; + + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + fFormatterOutput := Value; + if ( fOutputHandle <> nil ) then + IcedFreeMemory( fOutputHandle ); + if ( @Value <> nil ) then + fOutputHandle := FormatterOutput_Create( Value, Pointer( self ) ) + else + fOutputHandle := nil; +end; + +function TIcedFormatter.FormatToString( const Instruction: TInstruction ) : PAnsiChar; +var + Size : NativeUInt; +begin + result := nil; + if ( self = nil ) then + Exit; + + Size := 0; + case fType of + ftMasm : MasmFormatter_Format( fHandle, Instruction, result, Size ); + ftNasm : NasmFormatter_Format( fHandle, Instruction, result, Size ); + ftGas : GasFormatter_Format( fHandle, Instruction, result, Size ); + ftIntel : IntelFormatter_Format( fHandle, Instruction, result, Size ); + ftFast : FastFormatter_Format( fHandle, Instruction, result, Size ); + ftSpecialized : SpecializedFormatter_Format( fHandle, fSpecialized.Options, Instruction, result, Size ); + else + MasmFormatter_Format( fHandle, Instruction, result, Size ); + end; +end; + +procedure TIcedFormatter.Format( const Instruction: TInstruction; var AOutput: PAnsiChar; Size : PNativeUInt = nil ); +var + t : NativeUInt; +begin + AOutput := nil; + if ( Size <> nil ) then + Size^ := 0; + if ( self = nil ) then + Exit; + + t := 0; + case fType of +// ftMasm : MasmFormatter_Format( fHandle, Instruction, AOutput, t ); + ftNasm : NasmFormatter_Format( fHandle, Instruction, AOutput, t ); + ftGas : GasFormatter_Format( fHandle, Instruction, AOutput, t ); + ftIntel : IntelFormatter_Format( fHandle, Instruction, AOutput, t ); + ftFast : FastFormatter_Format( fHandle, Instruction, AOutput, t ); + ftSpecialized : SpecializedFormatter_Format( fHandle, fSpecialized.Options, Instruction, AOutput, t ); + else + MasmFormatter_Format( fHandle, Instruction, AOutput, t ); + end; + if ( Size <> nil ) then + Size^ := t; +end; + +procedure TIcedFormatter.Format( const Instruction: TInstruction ); // TFormatterOutputCallback +begin + if ( self = nil ) then + Exit; + + case fType of + ftMasm, + ftCapstone : MasmFormatter_FormatCallback( fHandle, Instruction, fOutputHandle ); + ftNasm : NasmFormatter_FormatCallback( fHandle, Instruction, fOutputHandle ); + ftGas : GasFormatter_FormatCallback( fHandle, Instruction, fOutputHandle ); + ftIntel : IntelFormatter_FormatCallback( fHandle, Instruction, fOutputHandle ); + else + Exit; + end; +end; + +// Options +function TIcedFormatter.GetOptions : TIcedFormatterSettings; +var + C : Array [ 0..255 ] of AnsiChar; +begin + FillChar( result, SizeOf( result ), 0 ); + if ( self = nil ) then + Exit; + if NOT uIced.Imports.IsInitDLL then + Exit; + + if ( fType in [ ftMasm, ftCapstone ] ) then + begin + // Masm + result.AddDsPrefix32 := MasmFormatter_GetAddDsPrefix32( fHandle ); + result.SymbolDisplacementInBrackets := MasmFormatter_GetSymbolDisplacementInBrackets( fHandle ); + result.DisplacementInBrackets := MasmFormatter_GetDisplacementInBrackets( fHandle ); + end; + + if ( fType = ftNasm ) then + // Nasm + result.ShowSignExtendedImmediateSize := NasmFormatter_GetShowSignExtendedImmediateSize( fHandle ); + + if ( fType = ftGas ) then + begin + // Gas + result.NakedRegisters := GasFormatter_GetNakedRegisters( fHandle ); + result.ShowMnemonicSizeSuffix := GasFormatter_GetShowMnemonicSizeSuffix( fHandle ); + result.SpaceAfterMemoryOperandComma := GasFormatter_GetSpaceAfterMemoryOperandComma( fHandle ); + end; + + if ( fType = ftSpecialized ) then + begin + // Specialized + result.UseHexPrefix := SpecializedFormatter_GetUseHexPrefix( fHandle ); + result.AlwaysShowMemorySize := SpecializedFormatter_GetAlwaysShowMemorySize( fHandle ); + end; + + // Common + result.SpaceAfterOperandSeparator := Formatter_GetSpaceAfterOperandSeparator( fHandle, fType ); + result.AlwaysShowSegmentRegister := Formatter_GetAlwaysShowSegmentRegister( fHandle, fType ); + result.UsePseudoOps := Formatter_GetUsePseudoOps( fHandle, fType ); + result.RipRelativeAddresses := Formatter_GetRipRelativeAddresses( fHandle, fType ); + result.ShowSymbolAddress := Formatter_GetShowSymbolAddress( fHandle, fType ); + result.UpperCaseHex := Formatter_GetUpperCaseHex( fHandle, fType ); + + if NOT ( fType in [ ftFast, ftSpecialized ] ) then + begin + // Common (All but Fast/Specialized) + result.UpperCasePrefixes := Formatter_GetUpperCasePrefixes( fHandle, fType ); + result.UpperCaseMnemonics := Formatter_GetUpperCaseMnemonics( fHandle, fType ); + result.UpperCaseRegisters := Formatter_GetUpperCaseRegisters( fHandle, fType ); + result.UpperCaseKeyWords := Formatter_GetUpperCaseKeyWords( fHandle, fType ); + result.UpperCaseDecorators := Formatter_GetUpperCaseDecorators( fHandle, fType ); + result.UpperCaseEverything := Formatter_GetUpperCaseEverything( fHandle, fType ); + result.FirstOperandCharIndex := Formatter_GetFirstOperandCharIndex( fHandle, fType ); + result.TabSize := Formatter_GetTabSize( fHandle, fType ); + result.SpaceAfterMemoryBracket := Formatter_GetSpaceAfterMemoryBracket( fHandle, fType ); + result.SpaceBetweenMemoryAddOperators := Formatter_GetSpaceBetweenMemoryAddOperators( fHandle, fType ); + result.SpaceBetweenMemoryMulOperators := Formatter_GetSpaceBetweenMemoryMulOperators( fHandle, fType ); + result.ScaleBeforeIndex := Formatter_GetScaleBeforeIndex( fHandle, fType ); + result.AlwaysShowScale := Formatter_GetAlwaysShowScale( fHandle, fType ); + result.ShowZeroDisplacements := Formatter_GetShowZeroDisplacements( fHandle, fType ); + Formatter_GetHexPrefix( fHandle, fType, @C[ 0 ], Length( C ) ); + result.HexPrefix := C; + Formatter_GetHexSuffix( fHandle, fType, @C[ 0 ], Length( C ) ); + result.HexSuffix := C; + result.HexDigitGroupSize := Formatter_GetHexDigitGroupSize( fHandle, fType ); + Formatter_GetDecimalPrefix( fHandle, fType, @C[ 0 ], Length( C ) ); + result.DecimalPrefix := C; + Formatter_GetDecimalSuffix( fHandle, fType, @C[ 0 ], Length( C ) ); + result.DecimalSuffix := C; + result.DecimalDigitGroupSize := Formatter_GetDecimalDigitGroupSize( fHandle, fType ); + Formatter_GetOctalPrefix( fHandle, fType, @C[ 0 ], Length( C ) ); + result.OctalPrefix := C; + Formatter_GetOctalSuffix( fHandle, fType, @C[ 0 ], Length( C ) ); + result.OctalSuffix := C; + result.OctalDigitGroupSize := Formatter_GetOctalDigitGroupSize( fHandle, fType ); + Formatter_GetBinaryPrefix( fHandle, fType, @C[ 0 ], Length( C ) ); + result.BinaryPrefix := C; + Formatter_GetBinarySuffix( fHandle, fType, @C[ 0 ], Length( C ) ); + result.BinarySuffix := C; + result.BinaryDigitGroupSize := Formatter_GetBinaryDigitGroupSize( fHandle, fType ); + Formatter_GetDigitSeparator( fHandle, fType, @C[ 0 ], Length( C ) ); + result.DigitSeparator := C; + result.LeadingZeros := Formatter_GetLeadingZeros( fHandle, fType ); + result.SmallHexNumbersInDecimal := Formatter_GetSmallHexNumbersInDecimal( fHandle, fType ); + result.AddLeadingZeroToHexNumbers := Formatter_GetAddLeadingZeroToHexNumbers( fHandle, fType ); + result.NumberBase := Formatter_GetNumberBase( fHandle, fType ); + result.BranchLeadingZeros := Formatter_GetBranchLeadingZeros( fHandle, fType ); + result.SignedImmediateOperands := Formatter_GetSignedImmediateOperands( fHandle, fType ); + result.SignedMemoryDisplacements := Formatter_GetSignedMemoryDisplacements( fHandle, fType ); + result.DisplacementLeadingZeros := Formatter_GetDisplacementLeadingZeros( fHandle, fType ); + result.MemorySizeOptions := Formatter_GetMemorySizeOptions( fHandle, fType ); + result.ShowBranchSize := Formatter_GetShowBranchSize( fHandle, fType ); + result.PreferST0 := Formatter_GetPreferST0( fHandle, fType ); + result.ShowUselessPrefixes := Formatter_GetShowUselessPrefixes( fHandle, fType ); + result.CC_b := Formatter_GetCC_b( fHandle, fType ); + result.CC_ae := Formatter_GetCC_ae( fHandle, fType ); + result.CC_e := Formatter_GetCC_e( fHandle, fType ); + result.CC_ne := Formatter_GetCC_ne( fHandle, fType ); + result.CC_be := Formatter_GetCC_be( fHandle, fType ); + result.CC_a := Formatter_GetCC_a( fHandle, fType ); + result.CC_p := Formatter_GetCC_p( fHandle, fType ); + result.CC_np := Formatter_GetCC_np( fHandle, fType ); + result.CC_l := Formatter_GetCC_l( fHandle, fType ); + result.CC_ge := Formatter_GetCC_ge( fHandle, fType ); + result.CC_le := Formatter_GetCC_le( fHandle, fType ); + result.CC_g := Formatter_GetCC_g( fHandle, fType ); + end; +end; + +procedure TIcedFormatter.SetOptions( Value : TIcedFormatterSettings ); +begin + if ( self = nil ) then + Exit; + + // Masm + AddDsPrefix32 := Value.AddDsPrefix32; + SymbolDisplacementInBrackets := Value.SymbolDisplacementInBrackets; + DisplacementInBrackets := Value.DisplacementInBrackets; + + // Nasm + ShowSignExtendedImmediateSize := Value.ShowSignExtendedImmediateSize; + // Gas + NakedRegisters := Value.NakedRegisters; + ShowMnemonicSizeSuffix := Value.ShowMnemonicSizeSuffix; + SpaceAfterMemoryOperandComma := Value.SpaceAfterMemoryOperandComma; + // Specialized + UseHexPrefix := Value.UseHexPrefix; + AlwaysShowMemorySize := Value.AlwaysShowMemorySize; + // Common + SpaceAfterOperandSeparator := Value.SpaceAfterOperandSeparator; + AlwaysShowSegmentRegister := Value.AlwaysShowSegmentRegister; + UsePseudoOps := Value.UsePseudoOps; + RipRelativeAddresses := Value.RipRelativeAddresses; + ShowSymbolAddress := Value.ShowSymbolAddress; + UpperCaseHex := Value.UpperCaseHex; + + // Common (All but Fast/Specialized) + UpperCasePrefixes := Value.UpperCasePrefixes; + UpperCaseMnemonics := Value.UpperCaseMnemonics; + UpperCaseRegisters := Value.UpperCaseRegisters; + UpperCaseKeyWords := Value.UpperCaseKeyWords; + UpperCaseDecorators := Value.UpperCaseDecorators; + UpperCaseEverything := Value.UpperCaseEverything; + FirstOperandCharIndex := Value.FirstOperandCharIndex; + TabSize := Value.TabSize; + SpaceAfterMemoryBracket := Value.SpaceAfterMemoryBracket; + SpaceBetweenMemoryAddOperators := Value.SpaceBetweenMemoryAddOperators; + SpaceBetweenMemoryMulOperators := Value.SpaceBetweenMemoryMulOperators; + ScaleBeforeIndex := Value.ScaleBeforeIndex; + AlwaysShowScale := Value.AlwaysShowScale; + ShowZeroDisplacements := Value.ShowZeroDisplacements; + HexPrefix := Value.HexPrefix; + HexSuffix := Value.HexSuffix; + HexDigitGroupSize := Value.HexDigitGroupSize; + DecimalPrefix := Value.DecimalPrefix; + DecimalSuffix := Value.DecimalSuffix; + DecimalDigitGroupSize := Value.DecimalDigitGroupSize; + OctalPrefix := Value.OctalPrefix; + OctalSuffix := Value.OctalSuffix; + OctalDigitGroupSize := Value.OctalDigitGroupSize; + BinaryPrefix := Value.BinaryPrefix; + BinarySuffix := Value.BinarySuffix; + BinaryDigitGroupSize := Value.BinaryDigitGroupSize; + DigitSeparator := Value.DigitSeparator; + LeadingZeros := Value.LeadingZeros; + SmallHexNumbersInDecimal := Value.SmallHexNumbersInDecimal; + AddLeadingZeroToHexNumbers := Value.AddLeadingZeroToHexNumbers; + NumberBase := Value.NumberBase; + BranchLeadingZeros := Value.BranchLeadingZeros; + SignedImmediateOperands := Value.SignedImmediateOperands; + SignedMemoryDisplacements := Value.SignedMemoryDisplacements; + DisplacementLeadingZeros := Value.DisplacementLeadingZeros; + MemorySizeOptions := Value.MemorySizeOptions; + ShowBranchSize := Value.ShowBranchSize; + PreferST0 := Value.PreferST0; + ShowUselessPrefixes := Value.ShowUselessPrefixes; + CC_b := Value.CC_b; + CC_ae := Value.CC_ae; + CC_e := Value.CC_e; + CC_ne := Value.CC_ne; + CC_be := Value.CC_be; + CC_a := Value.CC_a; + CC_p := Value.CC_p; + CC_np := Value.CC_np; + CC_l := Value.CC_l; + CC_ge := Value.CC_ge; + CC_le := Value.CC_le; + CC_g := Value.CC_g; +end; + +procedure TIcedFormatter.SettingsToStringList( Settings : TIcedFormatterSettings; var StrL : TStringList ); +begin + if ( self = nil ) then + Exit; + + if ( StrL = nil ) then + Exit; + StrL.Clear; + + StrL.Add( SysUtils.Format( '%s=%d', [ 'AddDsPrefix32', Byte( Settings.AddDsPrefix32 ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'SymbolDisplacementInBrackets', Byte( Settings.SymbolDisplacementInBrackets ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'DisplacementInBrackets', Byte( Settings.DisplacementInBrackets ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'ShowSignExtendedImmediateSize', Byte( Settings.ShowSignExtendedImmediateSize ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'NakedRegisters', Byte( Settings.NakedRegisters ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'ShowMnemonicSizeSuffix', Byte( Settings.ShowMnemonicSizeSuffix ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'SpaceAfterMemoryOperandComma', Byte( Settings.SpaceAfterMemoryOperandComma ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'UseHexPrefix', Byte( Settings.UseHexPrefix ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'AlwaysShowMemorySize', Byte( Settings.AlwaysShowMemorySize ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'SpaceAfterOperandSeparator', Byte( Settings.SpaceAfterOperandSeparator ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'AlwaysShowSegmentRegister', Byte( Settings.AlwaysShowSegmentRegister ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'UsePseudoOps', Byte( Settings.UsePseudoOps ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'RipRelativeAddresses', Byte( Settings.RipRelativeAddresses ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'ShowSymbolAddress', Byte( Settings.ShowSymbolAddress ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'UpperCaseHex', Byte( Settings.UpperCaseHex ) ] ) ); + + StrL.Add( SysUtils.Format( '%s=%d', [ 'UpperCasePrefixes', Byte( Settings.UpperCasePrefixes ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'UpperCaseMnemonics', Byte( Settings.UpperCaseMnemonics ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'UpperCaseRegisters', Byte( Settings.UpperCaseRegisters ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'UpperCaseKeyWords', Byte( Settings.UpperCaseKeyWords ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'UpperCaseDecorators', Byte( Settings.UpperCaseDecorators ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'UpperCaseEverything', Byte( Settings.UpperCaseEverything ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'FirstOperandCharIndex', Settings.FirstOperandCharIndex ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'TabSize', Settings.TabSize ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'SpaceAfterMemoryBracket', Byte( Settings.SpaceAfterMemoryBracket ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'SpaceBetweenMemoryAddOperators', Byte( Settings.SpaceBetweenMemoryAddOperators ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'SpaceBetweenMemoryMulOperators', Byte( Settings.SpaceBetweenMemoryMulOperators ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'ScaleBeforeIndex', Byte( Settings.ScaleBeforeIndex ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'AlwaysShowScale', Byte( Settings.AlwaysShowScale ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'ShowZeroDisplacements', Byte( Settings.ShowZeroDisplacements ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%s', [ 'HexPrefix', Settings.HexPrefix ] ) ); + StrL.Add( SysUtils.Format( '%s=%s', [ 'HexSuffix', Settings.HexSuffix ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'HexDigitGroupSize', Settings.HexDigitGroupSize ] ) ); + StrL.Add( SysUtils.Format( '%s=%s', [ 'DecimalPrefix', Settings.DecimalPrefix ] ) ); + StrL.Add( SysUtils.Format( '%s=%s', [ 'DecimalSuffix', Settings.DecimalSuffix ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'DecimalDigitGroupSize', Settings.DecimalDigitGroupSize ] ) ); + StrL.Add( SysUtils.Format( '%s=%s', [ 'OctalPrefix', Settings.OctalPrefix ] ) ); + StrL.Add( SysUtils.Format( '%s=%s', [ 'OctalSuffix', Settings.OctalSuffix ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'OctalDigitGroupSize', Settings.OctalDigitGroupSize ] ) ); + StrL.Add( SysUtils.Format( '%s=%s', [ 'BinaryPrefix', Settings.BinaryPrefix ] ) ); + StrL.Add( SysUtils.Format( '%s=%s', [ 'BinarySuffix', Settings.BinarySuffix ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'BinaryDigitGroupSize', Settings.BinaryDigitGroupSize ] ) ); + StrL.Add( SysUtils.Format( '%s=%s', [ 'DigitSeparator', Settings.DigitSeparator ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'LeadingZeros', Byte( Settings.LeadingZeros ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'SmallHexNumbersInDecimal', Byte( Settings.SmallHexNumbersInDecimal ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'AddLeadingZeroToHexNumbers', Byte( Settings.AddLeadingZeroToHexNumbers ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'NumberBase', Byte( Settings.NumberBase ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'BranchLeadingZeros', Byte( Settings.BranchLeadingZeros ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'SignedImmediateOperands', Byte( Settings.SignedImmediateOperands ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'SignedMemoryDisplacements', Byte( Settings.SignedMemoryDisplacements ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'DisplacementLeadingZeros', Byte( Settings.DisplacementLeadingZeros ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'MemorySizeOptions', Byte( Settings.MemorySizeOptions ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'ShowBranchSize', Byte( Settings.ShowBranchSize ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'PreferST0', Byte( Settings.PreferST0 ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'ShowUselessPrefixes', Byte( Settings.ShowUselessPrefixes ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_b', Byte( Settings.CC_b ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_ae', Byte( Settings.CC_ae ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_e', Byte( Settings.CC_e ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_ne', Byte( Settings.CC_ne ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_be', Byte( Settings.CC_be ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_a', Byte( Settings.CC_a ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_p', Byte( Settings.CC_p ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_np', Byte( Settings.CC_np ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_l', Byte( Settings.CC_l ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_ge', Byte( Settings.CC_ge ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_le', Byte( Settings.CC_le ) ] ) ); + StrL.Add( SysUtils.Format( '%s=%d', [ 'CC_g', Byte( Settings.CC_g ) ] ) ); +end; + +function TIcedFormatter.StringListToSettings( StrL : TStringList; Settings : PIcedFormatterSettings = nil ) : boolean; +var + tmp : TIcedFormatterSettings; +begin + result := False; + if ( self = nil ) then + Exit; + + if ( StrL = nil ) then + Exit; + StrL.Delimiter := '='; + + if ( Settings = nil ) then + Settings := @tmp; + + Settings^.AddDsPrefix32 := Boolean( StrToIntDef( StrL.Values[ 'AddDsPrefix32' ], Byte( fOptions.AddDsPrefix32 ) ) ); + Settings^.SymbolDisplacementInBrackets := Boolean( StrToIntDef( StrL.Values[ 'SymbolDisplacementInBrackets' ], Byte( fOptions.SymbolDisplacementInBrackets ) ) ); + Settings^.DisplacementInBrackets := Boolean( StrToIntDef( StrL.Values[ 'DisplacementInBrackets' ], Byte( fOptions.DisplacementInBrackets ) ) ); + Settings^.ShowSignExtendedImmediateSize := Boolean( StrToIntDef( StrL.Values[ 'ShowSignExtendedImmediateSize' ], Byte( fOptions.ShowSignExtendedImmediateSize ) ) ); + Settings^.NakedRegisters := Boolean( StrToIntDef( StrL.Values[ 'NakedRegisters' ], Byte( fOptions.NakedRegisters ) ) ); + Settings^.ShowMnemonicSizeSuffix := Boolean( StrToIntDef( StrL.Values[ 'ShowMnemonicSizeSuffix' ], Byte( fOptions.ShowMnemonicSizeSuffix ) ) ); + Settings^.SpaceAfterMemoryOperandComma := Boolean( StrToIntDef( StrL.Values[ 'SpaceAfterMemoryOperandComma' ], Byte( fOptions.SpaceAfterMemoryOperandComma ) ) ); + Settings^.UseHexPrefix := Boolean( StrToIntDef( StrL.Values[ 'UseHexPrefix' ], Byte( fOptions.UseHexPrefix ) ) ); + Settings^.AlwaysShowMemorySize := Boolean( StrToIntDef( StrL.Values[ 'AlwaysShowMemorySize' ], Byte( fOptions.AlwaysShowMemorySize ) ) ); + Settings^.SpaceAfterOperandSeparator := Boolean( StrToIntDef( StrL.Values[ 'SpaceAfterOperandSeparator' ], Byte( fOptions.SpaceAfterOperandSeparator ) ) ); + Settings^.AlwaysShowSegmentRegister := Boolean( StrToIntDef( StrL.Values[ 'AlwaysShowSegmentRegister' ], Byte( fOptions.AlwaysShowSegmentRegister ) ) ); + Settings^.UsePseudoOps := Boolean( StrToIntDef( StrL.Values[ 'UsePseudoOps' ], Byte( fOptions.UsePseudoOps ) ) ); + Settings^.RipRelativeAddresses := Boolean( StrToIntDef( StrL.Values[ 'RipRelativeAddresses' ], Byte( fOptions.RipRelativeAddresses ) ) ); + Settings^.ShowSymbolAddress := Boolean( StrToIntDef( StrL.Values[ 'ShowSymbolAddress' ], Byte( fOptions.ShowSymbolAddress ) ) ); + Settings^.UpperCaseHex := Boolean( StrToIntDef( StrL.Values[ 'UpperCaseHex' ], Byte( fOptions.UpperCaseHex ) ) ); + + Settings^.UpperCasePrefixes := Boolean( StrToIntDef( StrL.Values[ 'UpperCasePrefixes' ], Byte( fOptions.UpperCasePrefixes ) ) ); + Settings^.UpperCaseMnemonics := Boolean( StrToIntDef( StrL.Values[ 'UpperCaseMnemonics' ], Byte( fOptions.UpperCaseMnemonics ) ) ); + Settings^.UpperCaseRegisters := Boolean( StrToIntDef( StrL.Values[ 'UpperCaseRegisters' ], Byte( fOptions.UpperCaseRegisters ) ) ); + Settings^.UpperCaseKeyWords := Boolean( StrToIntDef( StrL.Values[ 'UpperCaseKeyWords' ], Byte( fOptions.UpperCaseKeyWords ) ) ); + Settings^.UpperCaseDecorators := Boolean( StrToIntDef( StrL.Values[ 'UpperCaseDecorators' ], Byte( fOptions.UpperCaseDecorators ) ) ); + Settings^.UpperCaseEverything := Boolean( StrToIntDef( StrL.Values[ 'UpperCaseEverything' ], Byte( fOptions.UpperCaseEverything ) ) ); + Settings^.FirstOperandCharIndex := StrToIntDef( StrL.Values[ 'FirstOperandCharIndex' ], 0 ); + Settings^.TabSize := StrToIntDef( StrL.Values[ 'TabSize' ], 0 ); + Settings^.SpaceAfterMemoryBracket := Boolean( StrToIntDef( StrL.Values[ 'SpaceAfterMemoryBracket' ], Byte( fOptions.SpaceAfterMemoryBracket ) ) ); + Settings^.SpaceBetweenMemoryAddOperators := Boolean( StrToIntDef( StrL.Values[ 'SpaceBetweenMemoryAddOperators' ], Byte( fOptions.SpaceBetweenMemoryAddOperators ) ) ); + Settings^.SpaceBetweenMemoryMulOperators := Boolean( StrToIntDef( StrL.Values[ 'SpaceBetweenMemoryMulOperators' ], Byte( fOptions.SpaceBetweenMemoryMulOperators ) ) ); + Settings^.ScaleBeforeIndex := Boolean( StrToIntDef( StrL.Values[ 'ScaleBeforeIndex' ], Byte( fOptions.ScaleBeforeIndex ) ) ); + Settings^.AlwaysShowScale := Boolean( StrToIntDef( StrL.Values[ 'AlwaysShowScale' ], Byte( fOptions.AlwaysShowScale ) ) ); + Settings^.ShowZeroDisplacements := Boolean( StrToIntDef( StrL.Values[ 'ShowZeroDisplacements' ], Byte( fOptions.ShowZeroDisplacements ) ) ); + Settings^.HexPrefix := AnsiString( StrL.Values[ 'HexPrefix' ] ); + Settings^.HexSuffix := AnsiString( StrL.Values[ 'HexSuffix' ] ); + Settings^.HexDigitGroupSize := StrToIntDef( StrL.Values[ 'HexDigitGroupSize' ], 0 ); + Settings^.DecimalPrefix := AnsiString( StrL.Values[ 'DecimalPrefix' ] ); + Settings^.DecimalSuffix := AnsiString( StrL.Values[ 'DecimalSuffix' ] ); + Settings^.DecimalDigitGroupSize := StrToIntDef( StrL.Values[ 'DecimalDigitGroupSize' ], 0 ); + Settings^.OctalPrefix := AnsiString( StrL.Values[ 'OctalPrefix' ] ); + Settings^.OctalSuffix := AnsiString( StrL.Values[ 'OctalSuffix' ] ); + Settings^.OctalDigitGroupSize := StrToIntDef( StrL.Values[ 'OctalDigitGroupSize' ], 0 ); + Settings^.BinaryPrefix := AnsiString( StrL.Values[ 'BinaryPrefix' ] ); + Settings^.BinarySuffix := AnsiString( StrL.Values[ 'BinarySuffix' ] ); + Settings^.BinaryDigitGroupSize := StrToIntDef( StrL.Values[ 'BinaryDigitGroupSize' ], 0 ); + Settings^.DigitSeparator := AnsiString( StrL.Values[ 'DigitSeparator' ] ); + Settings^.LeadingZeros := Boolean( StrToIntDef( StrL.Values[ 'LeadingZeros' ], Byte( fOptions.LeadingZeros ) ) ); + Settings^.SmallHexNumbersInDecimal := Boolean( StrToIntDef( StrL.Values[ 'SmallHexNumbersInDecimal' ], Byte( fOptions.SmallHexNumbersInDecimal ) ) ); + Settings^.AddLeadingZeroToHexNumbers := Boolean( StrToIntDef( StrL.Values[ 'AddLeadingZeroToHexNumbers' ], Byte( fOptions.AddLeadingZeroToHexNumbers ) ) ); + Settings^.NumberBase.NumberBase := TNumberBaseType( StrToIntDef( StrL.Values[ 'NumberBase' ], Byte( fOptions.NumberBase.NumberBase ) ) ); + Settings^.BranchLeadingZeros := Boolean( StrToIntDef( StrL.Values[ 'BranchLeadingZeros' ], Byte( fOptions.BranchLeadingZeros ) ) ); + Settings^.SignedImmediateOperands := Boolean( StrToIntDef( StrL.Values[ 'SignedImmediateOperands' ], Byte( fOptions.SignedImmediateOperands ) ) ); + Settings^.SignedMemoryDisplacements := Boolean( StrToIntDef( StrL.Values[ 'SignedMemoryDisplacements' ], Byte( fOptions.SignedMemoryDisplacements ) ) ); + Settings^.DisplacementLeadingZeros := Boolean( StrToIntDef( StrL.Values[ 'DisplacementLeadingZeros' ], Byte( fOptions.DisplacementLeadingZeros ) ) ); + Settings^.MemorySizeOptions.MemorySizeOptions := TMemorySizeOptionsType( StrToIntDef( StrL.Values[ 'MemorySizeOptions' ], Byte( fOptions.MemorySizeOptions.MemorySizeOptions ) ) ); + Settings^.ShowBranchSize := Boolean( StrToIntDef( StrL.Values[ 'ShowBranchSize' ], Byte( fOptions.ShowBranchSize ) ) ); + Settings^.PreferST0 := Boolean( StrToIntDef( StrL.Values[ 'PreferST0' ], Byte( fOptions.PreferST0 ) ) ); + Settings^.ShowUselessPrefixes := Boolean( StrToIntDef( StrL.Values[ 'ShowUselessPrefixes' ], Byte( fOptions.ShowUselessPrefixes ) ) ); + Settings^.CC_b := TCC_b( StrToIntDef( StrL.Values[ 'CC_b' ], Byte( fOptions.CC_b ) ) ); + Settings^.CC_ae := TCC_ae( StrToIntDef( StrL.Values[ 'CC_ae' ], Byte( fOptions.CC_ae ) ) ); + Settings^.CC_e := TCC_e( StrToIntDef( StrL.Values[ 'CC_e' ], Byte( fOptions.CC_e ) ) ); + Settings^.CC_ne := TCC_ne( StrToIntDef( StrL.Values[ 'CC_ne' ], Byte( fOptions.CC_ne ) ) ); + Settings^.CC_be := TCC_be( StrToIntDef( StrL.Values[ 'CC_be' ], Byte( fOptions.CC_be ) ) ); + Settings^.CC_a := TCC_a( StrToIntDef( StrL.Values[ 'CC_a' ], Byte( fOptions.CC_a ) ) ); + Settings^.CC_p := TCC_p( StrToIntDef( StrL.Values[ 'CC_p' ], Byte( fOptions.CC_p ) ) ); + Settings^.CC_np := TCC_np( StrToIntDef( StrL.Values[ 'CC_np' ], Byte( fOptions.CC_np ) ) ); + Settings^.CC_l := TCC_l( StrToIntDef( StrL.Values[ 'CC_l' ], Byte( fOptions.CC_l ) ) ); + Settings^.CC_ge := TCC_ge( StrToIntDef( StrL.Values[ 'CC_ge' ], Byte( fOptions.CC_ge ) ) ); + Settings^.CC_le := TCC_le( StrToIntDef( StrL.Values[ 'CC_le' ], Byte( fOptions.CC_le ) ) ); + Settings^.CC_g := TCC_g( StrToIntDef( StrL.Values[ 'CC_g' ], Byte( fOptions.CC_g ) ) ); + + if ( Settings = @tmp ) then + Options := tmp; +end; + +procedure TIcedFormatter.SetCapstoneOptions; +begin + if ( self = nil ) then + Exit; + + ShowSymbolAddress := True; + SpaceAfterMemoryOperandComma := True; + SpaceAfterOperandSeparator := True; + RipRelativeAddresses := True; + ShowBranchSize := False; + HexPrefix := '0x'; + HexSuffix := ''; +end; + +// Masm +function TIcedFormatter.GetAddDsPrefix32 : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if NOT ( fType in [ ftMasm, ftCapstone ] ) then + Exit; + + result := fOptions.AddDsPrefix32; +// result := MasmFormatter_GetAddDsPrefix32( fHandle ); +end; + +procedure TIcedFormatter.SetAddDsPrefix32( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if NOT ( fType in [ ftMasm, ftCapstone ] ) then + Exit; + if ( fOptions.AddDsPrefix32 = Value ) then + Exit; + fOptions.AddDsPrefix32 := Value; + + {result := }MasmFormatter_SetAddDsPrefix32( fHandle, Value ); +end; + +function TIcedFormatter.GetSymbolDisplacementInBrackets : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if NOT ( fType in [ ftMasm, ftCapstone ] ) then + Exit; + + result := fOptions.SymbolDisplacementInBrackets; +// result := MasmFormatter_GetSymbolDisplacementInBrackets( fHandle ); +end; + +procedure TIcedFormatter.SetSymbolDisplacementInBrackets( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if NOT ( fType in [ ftMasm, ftCapstone ] ) then + Exit; + if ( fOptions.SymbolDisplacementInBrackets = Value ) then + Exit; + fOptions.SymbolDisplacementInBrackets := Value; + + {result := }MasmFormatter_SetSymbolDisplacementInBrackets( fHandle, Value ); +end; + +function TIcedFormatter.GetDisplacementInBrackets : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if NOT ( fType in [ ftMasm, ftCapstone ] ) then + Exit; + + result := fOptions.DisplacementInBrackets; +// result := MasmFormatter_GetDisplacementInBrackets( fHandle ); +end; + +procedure TIcedFormatter.SetDisplacementInBrackets( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if NOT ( fType in [ ftMasm, ftCapstone ] ) then + Exit; + if ( fOptions.DisplacementInBrackets = Value ) then + Exit; + fOptions.DisplacementInBrackets := Value; + + {result := }MasmFormatter_SetDisplacementInBrackets( fHandle, Value ); +end; + +// Nasm +function TIcedFormatter.GetShowSignExtendedImmediateSize : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType <> ftNasm ) then + Exit; + + result := fOptions.ShowSignExtendedImmediateSize; +// result := NasmFormatter_GetShowSignExtendedImmediateSize( fHandle ); +end; + +procedure TIcedFormatter.SetShowSignExtendedImmediateSize( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType <> ftNasm ) then + Exit; + if ( fOptions.ShowSignExtendedImmediateSize = Value ) then + Exit; + fOptions.ShowSignExtendedImmediateSize := Value; + + {result := }NasmFormatter_SetShowSignExtendedImmediateSize( fHandle, Value ); +end; + +// Gas +function TIcedFormatter.GetNakedRegisters : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType <> ftGas ) then + Exit; + + result := fOptions.NakedRegisters; +// result := GasFormatter_GetNakedRegisters( fHandle ); +end; + +procedure TIcedFormatter.SetNakedRegisters( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType <> ftGas ) then + Exit; + if ( fOptions.NakedRegisters = Value ) then + Exit; + fOptions.NakedRegisters := Value; + + {result := }GasFormatter_SetNakedRegisters( fHandle, Value ); +end; + +function TIcedFormatter.GetShowMnemonicSizeSuffix : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType <> ftGas ) then + Exit; + + result := fOptions.ShowMnemonicSizeSuffix; +// result := GasFormatter_GetShowMnemonicSizeSuffix( fHandle ); +end; + +procedure TIcedFormatter.SetShowMnemonicSizeSuffix( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType <> ftGas ) then + Exit; + if ( fOptions.ShowMnemonicSizeSuffix = Value ) then + Exit; + fOptions.ShowMnemonicSizeSuffix := Value; + + {result := }GasFormatter_SetShowMnemonicSizeSuffix( fHandle, Value ); +end; + +function TIcedFormatter.GetSpaceAfterMemoryOperandComma : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType <> ftGas ) then + Exit; + + result := fOptions.SpaceAfterMemoryOperandComma; +// result := GasFormatter_GetSpaceAfterMemoryOperandComma( fHandle ); +end; + +procedure TIcedFormatter.SetSpaceAfterMemoryOperandComma( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType <> ftGas ) then + Exit; + if ( fOptions.SpaceAfterMemoryOperandComma = Value ) then + Exit; + fOptions.SpaceAfterMemoryOperandComma := Value; + + {result := }GasFormatter_SetSpaceAfterMemoryOperandComma( fHandle, Value ); +end; + +// Specialized +function TIcedFormatter.GetUseHexPrefix : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType <> ftSpecialized ) then + Exit; + + result := fOptions.UseHexPrefix; +// result := SpecializedFormatter_GetUseHexPrefix( fHandle ); +end; + +procedure TIcedFormatter.SetUseHexPrefix( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType <> ftSpecialized ) then + Exit; + if ( fOptions.UseHexPrefix = Value ) then + Exit; + fOptions.UseHexPrefix := Value; + + {result := }SpecializedFormatter_SetUseHexPrefix( fHandle, Value ); +end; + +function TIcedFormatter.GetAlwaysShowMemorySize : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType <> ftSpecialized ) then + Exit; + + result := fOptions.AlwaysShowMemorySize; +// result := SpecializedFormatter_GetAlwaysShowMemorySize( fHandle ); +end; + +procedure TIcedFormatter.SetAlwaysShowMemorySize( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType <> ftSpecialized ) then + Exit; + if ( fOptions.AlwaysShowMemorySize = Value ) then + Exit; + fOptions.AlwaysShowMemorySize := Value; + + {result := }SpecializedFormatter_SetAlwaysShowMemorySize( fHandle, Value ); +end; + +function TIcedFormatter.GetEnable_DB_DW_DD_DQ : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; +// if ( fType <> ftSpecialized ) then +// Exit; + result := fSpecialized.ENABLE_DB_DW_DD_DQ; +end; + +procedure TIcedFormatter.SetEnable_DB_DW_DD_DQ( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + + fSpecialized.ENABLE_DB_DW_DD_DQ := Value; + +// if ( fType <> ftSpecialized ) then +// Exit; +// CreateHandle; +end; + +function TIcedFormatter.GetVerifyOutputHasEnoughBytesLeft : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; +// if ( fType <> ftSpecialized ) then +// Exit; + result := fSpecialized.verify_output_has_enough_bytes_left; +end; + +procedure TIcedFormatter.SetVerifyOutputHasEnoughBytesLeft( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + + fSpecialized.verify_output_has_enough_bytes_left := Value; + +// if ( fType <> ftSpecialized ) then +// Exit; +// CreateHandle; +end; + +// Common +function TIcedFormatter.GetSpaceAfterOperandSeparator : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + + result := fOptions.SpaceAfterOperandSeparator; +// result := Formatter_GetSpaceAfterOperandSeparator( fHandle ); +end; + +procedure TIcedFormatter.SetSpaceAfterOperandSeparator( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + + if ( fOptions.SpaceAfterOperandSeparator = Value ) then + Exit; + fOptions.SpaceAfterOperandSeparator := Value; + + {result := }Formatter_SetSpaceAfterOperandSeparator( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetAlwaysShowSegmentRegister : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + + result := fOptions.AlwaysShowSegmentRegister; +// result := Formatter_GetAlwaysShowSegmentRegister( fHandle ); +end; + +procedure TIcedFormatter.SetAlwaysShowSegmentRegister( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fOptions.AlwaysShowSegmentRegister = Value ) then + Exit; + fOptions.AlwaysShowSegmentRegister := Value; + + {result := }Formatter_SetAlwaysShowSegmentRegister( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetUsePseudoOps : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + + result := fOptions.UsePseudoOps; +// result := Formatter_GetUsePseudoOps( fHandle ); +end; + +procedure TIcedFormatter.SetUsePseudoOps( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fOptions.UsePseudoOps = Value ) then + Exit; + fOptions.UsePseudoOps := Value; + + {result := }Formatter_SetUsePseudoOps( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetRipRelativeAddresses : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + + result := fOptions.RipRelativeAddresses; +// result := Formatter_GetRipRelativeAddresses( fHandle ); +end; + +procedure TIcedFormatter.SetRipRelativeAddresses( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fOptions.RipRelativeAddresses = Value ) then + Exit; + fOptions.RipRelativeAddresses := Value; + + {result := }Formatter_SetRipRelativeAddresses( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetShowSymbolAddress : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + + result := fOptions.ShowSymbolAddress; +// result := Formatter_GetShowSymbolAddress( fHandle ); +end; + +procedure TIcedFormatter.SetShowSymbolAddress( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fOptions.ShowSymbolAddress = Value ) then + Exit; + fOptions.ShowSymbolAddress := Value; + + {result := }Formatter_SetShowSymbolAddress( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetUpperCaseHex : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + + result := fOptions.UpperCaseHex; +// result := Formatter_GetUpperCaseHex( fHandle ); +end; + +procedure TIcedFormatter.SetUpperCaseHex( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fOptions.UpperCaseHex = Value ) then + Exit; + fOptions.UpperCaseHex := Value; + + {result := }Formatter_SetUpperCaseHex( fHandle, fType, Value ); +end; + +// Common (All but Fast/Specialized) +function TIcedFormatter.GetUpperCasePrefixes : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.UpperCasePrefixes; +// result := Formatter_GetUpperCasePrefixes( fHandle ); +end; + +procedure TIcedFormatter.SetUpperCasePrefixes( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.UpperCasePrefixes = Value ) then + Exit; + fOptions.UpperCasePrefixes := Value; + + {result := }Formatter_SetUpperCasePrefixes( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetUpperCaseMnemonics : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.UpperCaseMnemonics; +// result := Formatter_GetUpperCaseMnemonics( fHandle ); +end; + +procedure TIcedFormatter.SetUpperCaseMnemonics( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.UpperCaseMnemonics = Value ) then + Exit; + fOptions.UpperCaseMnemonics := Value; + + {result := }Formatter_SetUpperCaseMnemonics( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetUpperCaseRegisters : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.UpperCaseRegisters; +// result := Formatter_GetUpperCaseRegisters( fHandle ); +end; + +procedure TIcedFormatter.SetUpperCaseRegisters( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.UpperCaseRegisters = Value ) then + Exit; + fOptions.UpperCaseRegisters := Value; + + {result := }Formatter_SetUpperCaseRegisters( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetUpperCaseKeyWords : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.UpperCaseKeyWords; +// result := Formatter_GetUpperCaseKeyWords( fHandle ); +end; + +procedure TIcedFormatter.SetUpperCaseKeyWords( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.UpperCaseKeyWords = Value ) then + Exit; + fOptions.UpperCaseKeyWords := Value; + + {result := }Formatter_SetUpperCaseKeyWords( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetUpperCaseDecorators : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.UpperCaseDecorators; +// result := Formatter_GetUpperCaseDecorators( fHandle ); +end; + +procedure TIcedFormatter.SetUpperCaseDecorators( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.UpperCaseDecorators = Value ) then + Exit; + fOptions.UpperCaseDecorators := Value; + + {result := }Formatter_SetUpperCaseDecorators( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetUpperCaseEverything : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.UpperCaseEverything; +// result := Formatter_GetUpperCaseEverything( fHandle ); +end; + +procedure TIcedFormatter.SetUpperCaseEverything( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.UpperCaseEverything = Value ) then + Exit; + fOptions.UpperCaseEverything := Value; + + {result := }Formatter_SetUpperCaseEverything( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetFirstOperandCharIndex : Cardinal; +begin + result := 0; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.FirstOperandCharIndex; +// result := Formatter_GetFirstOperandCharIndex( fHandle ); +end; + +procedure TIcedFormatter.SetFirstOperandCharIndex( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.FirstOperandCharIndex = Value ) then + Exit; + fOptions.FirstOperandCharIndex := Value; + + {result := }Formatter_SetFirstOperandCharIndex( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetTabSize : Cardinal; +begin + result := 0; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.TabSize; +// result := Formatter_GetTabSize( fHandle ); +end; + +procedure TIcedFormatter.SetTabSize( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.TabSize = Value ) then + Exit; + fOptions.TabSize := Value; + + {result := }Formatter_SetTabSize( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetSpaceAfterMemoryBracket : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.SpaceAfterMemoryBracket; +// result := Formatter_GetSpaceAfterMemoryBracket( fHandle ); +end; + +procedure TIcedFormatter.SetSpaceAfterMemoryBracket( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.SpaceAfterMemoryBracket = Value ) then + Exit; + fOptions.SpaceAfterMemoryBracket := Value; + + {result := }Formatter_SetSpaceAfterMemoryBracket( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetSpaceBetweenMemoryAddOperators : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.SpaceBetweenMemoryAddOperators; +// result := Formatter_GetSpaceBetweenMemoryAddOperators( fHandle ); +end; + +procedure TIcedFormatter.SetSpaceBetweenMemoryAddOperators( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.SpaceBetweenMemoryAddOperators = Value ) then + Exit; + fOptions.SpaceBetweenMemoryAddOperators := Value; + + {result := }Formatter_SetSpaceBetweenMemoryAddOperators( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetSpaceBetweenMemoryMulOperators : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.SpaceBetweenMemoryMulOperators; +// result := Formatter_GetSpaceBetweenMemoryMulOperators( fHandle ); +end; + +procedure TIcedFormatter.SetSpaceBetweenMemoryMulOperators( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.SpaceBetweenMemoryMulOperators = Value ) then + Exit; + fOptions.SpaceBetweenMemoryMulOperators := Value; + + {result := }Formatter_SetSpaceBetweenMemoryMulOperators( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetScaleBeforeIndex : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.ScaleBeforeIndex; +// result := Formatter_GetScaleBeforeIndex( fHandle ); +end; + +procedure TIcedFormatter.SetScaleBeforeIndex( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.ScaleBeforeIndex = Value ) then + Exit; + fOptions.ScaleBeforeIndex := Value; + + {result := }Formatter_SetScaleBeforeIndex( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetAlwaysShowScale : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.AlwaysShowScale; +// result := Formatter_GetAlwaysShowScale( fHandle ); +end; + +procedure TIcedFormatter.SetAlwaysShowScale( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.AlwaysShowScale = Value ) then + Exit; + fOptions.AlwaysShowScale := Value; + + {result := }Formatter_SetAlwaysShowScale( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetShowZeroDisplacements : Boolean; +begin + result := False; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.ShowZeroDisplacements; +// result := Formatter_GetShowZeroDisplacements( fHandle ); +end; + +procedure TIcedFormatter.SetShowZeroDisplacements( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.ShowZeroDisplacements = Value ) then + Exit; + fOptions.ShowZeroDisplacements := Value; + + {result := }Formatter_SetShowZeroDisplacements( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetHexPrefix : AnsiString; +//var +// C : Array [ 0..255 ] of AnsiChar; +begin + result := ''; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.HexPrefix; +// Formatter_GetHexPrefix( fHandle, @C[ 0 ], Length( C ) ); +// result := C; +end; + +procedure TIcedFormatter.SetHexPrefix( Value : AnsiString ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.HexPrefix = Value ) then + Exit; + fOptions.HexPrefix := Value; + + {result := }Formatter_SetHexPrefix( fHandle, fType, PAnsiChar( Value ) ); +end; + +function TIcedFormatter.GetHexSuffix : AnsiString; +//var +// C : Array [ 0..255 ] of AnsiChar; +begin + result := ''; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.HexSuffix; +// Formatter_GetHexSuffix( fHandle, @C[ 0 ], Length( C ) ); +// result := C; +end; + +procedure TIcedFormatter.SetHexSuffix( Value : AnsiString ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.HexSuffix = Value ) then + Exit; + fOptions.HexSuffix := Value; + + {result := }Formatter_SetHexSuffix( fHandle, fType, PAnsiChar( Value ) ); +end; + +function TIcedFormatter.GetHexDigitGroupSize : Cardinal; +begin + result := 0; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.HexDigitGroupSize; +// result := Formatter_GetHexDigitGroupSize( fHandle ); +end; + +procedure TIcedFormatter.SetHexDigitGroupSize( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.HexDigitGroupSize = Value ) then + Exit; + fOptions.HexDigitGroupSize := Value; + + {result := }Formatter_SetHexDigitGroupSize( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetDecimalPrefix : AnsiString; +//var +// C : Array [ 0..255 ] of AnsiChar; +begin + result := ''; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.DecimalPrefix; +// Formatter_GetDecimalPrefix( fHandle, @C[ 0 ], Length( C ) ); +// result := C; +end; + +procedure TIcedFormatter.SetDecimalPrefix( Value : AnsiString ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.DecimalPrefix = Value ) then + Exit; + fOptions.DecimalPrefix := Value; + + {result := }Formatter_SetDecimalPrefix( fHandle, fType, PAnsiChar( Value ) ); +end; + +function TIcedFormatter.GetDecimalSuffix : AnsiString; +//var +// C : Array [ 0..255 ] of AnsiChar; +begin + result := ''; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.DecimalSuffix; +// Formatter_GetDecimalSuffix( fHandle, @C[ 0 ], Length( C ) ); +// result := C; +end; + +procedure TIcedFormatter.SetDecimalSuffix( Value : AnsiString ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.DecimalSuffix = Value ) then + Exit; + fOptions.DecimalSuffix := Value; + + {result := }Formatter_SetDecimalSuffix( fHandle, fType, PAnsiChar( Value ) ); +end; + +function TIcedFormatter.GetDecimalDigitGroupSize : Cardinal; +begin + result := 0; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.DecimalDigitGroupSize; +// result := Formatter_GetDecimalDigitGroupSize( fHandle ); +end; + +procedure TIcedFormatter.SetDecimalDigitGroupSize( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.DecimalDigitGroupSize = Value ) then + Exit; + fOptions.DecimalDigitGroupSize := Value; + + {result := }Formatter_SetDecimalDigitGroupSize( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetOctalPrefix : AnsiString; +//var +// C : Array [ 0..255 ] of AnsiChar; +begin + result := ''; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.OctalPrefix; +// Formatter_GetOctalPrefix( fHandle, @C[ 0 ], Length( C ) ); +// result := C; +end; + +procedure TIcedFormatter.SetOctalPrefix( Value : AnsiString ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.OctalPrefix = Value ) then + Exit; + fOptions.OctalPrefix := Value; + + {result := }Formatter_SetOctalPrefix( fHandle, fType, PAnsiChar( Value ) ); +end; + +function TIcedFormatter.GetOctalSuffix : AnsiString; +//var +// C : Array [ 0..255 ] of AnsiChar; +begin + result := ''; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.OctalSuffix; +// Formatter_GetOctalSuffix( fHandle, @C[ 0 ], Length( C ) ); +// result := C; +end; + +procedure TIcedFormatter.SetOctalSuffix( Value : AnsiString ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.OctalSuffix = Value ) then + Exit; + fOptions.OctalSuffix := Value; + + {result := }Formatter_SetOctalSuffix( fHandle, fType, PAnsiChar( Value ) ); +end; + +function TIcedFormatter.GetOctalDigitGroupSize : Cardinal; +begin + result := 0; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.OctalDigitGroupSize; +// result := Formatter_GetOctalDigitGroupSize( fHandle ); +end; + +procedure TIcedFormatter.SetOctalDigitGroupSize( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.OctalDigitGroupSize = Value ) then + Exit; + fOptions.OctalDigitGroupSize := Value; + + {result := }Formatter_SetOctalDigitGroupSize( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetBinaryPrefix : AnsiString; +//var +// C : Array [ 0..255 ] of AnsiChar; +begin + result := ''; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.BinaryPrefix; +// Formatter_GetBinaryPrefix( fHandle, @C[ 0 ], Length( C ) ); +// result := C; +end; + +procedure TIcedFormatter.SetBinaryPrefix( Value : AnsiString ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.BinaryPrefix = Value ) then + Exit; + fOptions.BinaryPrefix := Value; + + {result := }Formatter_SetBinaryPrefix( fHandle, fType, PAnsiChar( Value ) ); +end; + +function TIcedFormatter.GetBinarySuffix : AnsiString; +//var +// C : Array [ 0..255 ] of AnsiChar; +begin + result := ''; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.BinarySuffix; +// Formatter_GetBinarySuffix( fHandle, @C[ 0 ], Length( C ) ); +// result := C; +end; + +procedure TIcedFormatter.SetBinarySuffix( Value : AnsiString ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.BinarySuffix = Value ) then + Exit; + fOptions.BinarySuffix := Value; + + {result := }Formatter_SetBinarySuffix( fHandle, fType, PAnsiChar( Value ) ); +end; + +function TIcedFormatter.GetBinaryDigitGroupSize : Cardinal; +begin + result := 0; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.BinaryDigitGroupSize; +// result := Formatter_GetBinaryDigitGroupSize( fHandle ); +end; + +procedure TIcedFormatter.SetBinaryDigitGroupSize( Value : Cardinal ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.BinaryDigitGroupSize = Value ) then + Exit; + fOptions.BinaryDigitGroupSize := Value; + + {result := }Formatter_SetBinaryDigitGroupSize( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetDigitSeparator : AnsiString; +//var +// C : Array [ 0..255 ] of AnsiChar; +begin + result := ''; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.DigitSeparator; +// Formatter_GetDigitSeparator( fHandle, @C[ 0 ], Length( C ) ); +// result := C; +end; + +procedure TIcedFormatter.SetDigitSeparator( Value : AnsiString ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.DigitSeparator = Value ) then + Exit; + fOptions.DigitSeparator := Value; + + {result := }Formatter_SetDigitSeparator( fHandle, fType, PAnsiChar( Value ) ); +end; + +function TIcedFormatter.GetLeadingZeros : Boolean; +begin + result := False; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.LeadingZeros; +// result := Formatter_GetLeadingZeros( fHandle ); +end; + +procedure TIcedFormatter.SetLeadingZeros( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.LeadingZeros = Value ) then + Exit; + fOptions.LeadingZeros := Value; + + {result := }Formatter_SetLeadingZeros( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetSmallHexNumbersInDecimal : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.SmallHexNumbersInDecimal; +// result := Formatter_GetSmallHexNumbersInDecimal( fHandle ); +end; + +procedure TIcedFormatter.SetSmallHexNumbersInDecimal( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.SmallHexNumbersInDecimal = Value ) then + Exit; + fOptions.SmallHexNumbersInDecimal := Value; + + {result := }Formatter_SetSmallHexNumbersInDecimal( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetAddLeadingZeroToHexNumbers : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.AddLeadingZeroToHexNumbers; +// result := Formatter_GetAddLeadingZeroToHexNumbers( fHandle ); +end; + +procedure TIcedFormatter.SetAddLeadingZeroToHexNumbers( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.AddLeadingZeroToHexNumbers = Value ) then + Exit; + fOptions.AddLeadingZeroToHexNumbers := Value; + + {result := }Formatter_SetAddLeadingZeroToHexNumbers( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetNumberBase : TNumberBase; +begin + result.NumberBase := nbHexadecimal; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.NumberBase; +// result := Formatter_GetNumberBase( fHandle ); +end; + +procedure TIcedFormatter.SetNumberBase( Value : TNumberBase ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.NumberBase.NumberBase = Value.NumberBase ) then + Exit; + fOptions.NumberBase := Value; + + {result := }Formatter_SetNumberBase( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetBranchLeadingZeros : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.BranchLeadingZeros; +// result := Formatter_GetBranchLeadingZeros( fHandle ); +end; + +procedure TIcedFormatter.SetBranchLeadingZeros( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.BranchLeadingZeros = Value ) then + Exit; + fOptions.BranchLeadingZeros := Value; + + {result := }Formatter_SetBranchLeadingZeros( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetSignedImmediateOperands : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.SignedImmediateOperands; +// result := Formatter_GetSignedImmediateOperands( fHandle ); +end; + +procedure TIcedFormatter.SetSignedImmediateOperands( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.SignedImmediateOperands = Value ) then + Exit; + fOptions.SignedImmediateOperands := Value; + + {result := }Formatter_SetSignedImmediateOperands( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetSignedMemoryDisplacements : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.SignedMemoryDisplacements; +// result := Formatter_GetSignedMemoryDisplacements( fHandle ); +end; + +procedure TIcedFormatter.SetSignedMemoryDisplacements( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.SignedMemoryDisplacements = Value ) then + Exit; + fOptions.SignedMemoryDisplacements := Value; + + {result := }Formatter_SetSignedMemoryDisplacements( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetDisplacementLeadingZeros : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.DisplacementLeadingZeros; +// result := Formatter_GetDisplacementLeadingZeros( fHandle ); +end; + +procedure TIcedFormatter.SetDisplacementLeadingZeros( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.DisplacementLeadingZeros = Value ) then + Exit; + fOptions.DisplacementLeadingZeros := Value; + + {result := }Formatter_SetDisplacementLeadingZeros( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetMemorySizeOptions : TMemorySizeOptions; +begin + result.MemorySizeOptions := msoDefault; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.MemorySizeOptions; +// result := Formatter_GetMemorySizeOptions( fHandle ); +end; + +procedure TIcedFormatter.SetMemorySizeOptions( Value : TMemorySizeOptions ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.MemorySizeOptions.MemorySizeOptions = Value.MemorySizeOptions ) then + Exit; + fOptions.MemorySizeOptions := Value; + + {result := }Formatter_SetMemorySizeOptions( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetShowBranchSize : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.ShowBranchSize; +// result := Formatter_GetShowBranchSize( fHandle ); +end; + +procedure TIcedFormatter.SetShowBranchSize( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.ShowBranchSize = Value ) then + Exit; + fOptions.ShowBranchSize := Value; + + {result := }Formatter_SetShowBranchSize( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetPreferST0 : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.PreferST0; +// result := Formatter_GetPreferST0( fHandle ); +end; + +procedure TIcedFormatter.SetPreferST0( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.PreferST0 = Value ) then + Exit; + fOptions.PreferST0 := Value; + + {result := }Formatter_SetPreferST0( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetShowUselessPrefixes : Boolean; +begin + result := false; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.ShowUselessPrefixes; +// result := Formatter_GetShowUselessPrefixes( fHandle ); +end; + +procedure TIcedFormatter.SetShowUselessPrefixes( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.ShowUselessPrefixes = Value ) then + Exit; + fOptions.ShowUselessPrefixes := Value; + + {result := }Formatter_SetShowUselessPrefixes( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_b : TCC_b; +begin + result := b; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_b; +// result := Formatter_GetCC_b( fHandle ); +end; + +procedure TIcedFormatter.SetCC_b( Value : TCC_b ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_b = Value ) then + Exit; + fOptions.CC_b := Value; + + {result := }Formatter_SetCC_b( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_ae : TCC_ae; +begin + result := ae; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_ae; +// result := Formatter_GetCC_ae( fHandle ); +end; + +procedure TIcedFormatter.SetCC_ae( Value : TCC_ae ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_ae = Value ) then + Exit; + fOptions.CC_ae := Value; + + {result := }Formatter_SetCC_ae( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_e : TCC_e; +begin + result := e; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_e; +// result := Formatter_GetCC_e( fHandle ); +end; + +procedure TIcedFormatter.SetCC_e( Value : TCC_e ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_e = Value ) then + Exit; + fOptions.CC_e := Value; + + {result := }Formatter_SetCC_e( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_ne : TCC_ne; +begin + result := ne; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_ne; +// result := Formatter_GetCC_ne( fHandle ); +end; + +procedure TIcedFormatter.SetCC_ne( Value : TCC_ne ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_ne = Value ) then + Exit; + fOptions.CC_ne := Value; + + {result := }Formatter_SetCC_ne( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_be : TCC_be; +begin + result := be; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_be; +// result := Formatter_GetCC_be( fHandle ); +end; + +procedure TIcedFormatter.SetCC_be( Value : TCC_be ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_be = Value ) then + Exit; + fOptions.CC_be := Value; + + {result := }Formatter_SetCC_be( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_a : TCC_a; +begin + result := a; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_a; +// result := Formatter_GetCC_a( fHandle ); +end; + +procedure TIcedFormatter.SetCC_a( Value : TCC_a ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_a = Value ) then + Exit; + fOptions.CC_a := Value; + + {result := }Formatter_SetCC_a( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_p : TCC_p; +begin + result := p; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_p; +// result := Formatter_GetCC_p( fHandle ); +end; + +procedure TIcedFormatter.SetCC_p( Value : TCC_p ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_p = Value ) then + Exit; + fOptions.CC_p := Value; + + {result := }Formatter_SetCC_p( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_np : TCC_np; +begin + result := np; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_np; +// result := Formatter_GetCC_np( fHandle ); +end; + +procedure TIcedFormatter.SetCC_np( Value : TCC_np ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_np = Value ) then + Exit; + fOptions.CC_np := Value; + + {result := }Formatter_SetCC_np( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_l : TCC_l; +begin + result := l; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_l; +// result := Formatter_GetCC_l( fHandle ); +end; + +procedure TIcedFormatter.SetCC_l( Value : TCC_l ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_l = Value ) then + Exit; + fOptions.CC_l := Value; + + {result := }Formatter_SetCC_l( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_ge : TCC_ge; +begin + result := ge; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_ge; +// result := Formatter_GetCC_ge( fHandle ); +end; + +procedure TIcedFormatter.SetCC_ge( Value : TCC_ge ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_ge = Value ) then + Exit; + fOptions.CC_ge := Value; + + {result := }Formatter_SetCC_ge( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_le : TCC_le; +begin + result := le; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_le; +// result := Formatter_GetCC_le( fHandle ); +end; + +procedure TIcedFormatter.SetCC_le( Value : TCC_le ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_le = Value ) then + Exit; + fOptions.CC_le := Value; + + {result := }Formatter_SetCC_le( fHandle, fType, Value ); +end; + +function TIcedFormatter.GetCC_g : TCC_g; +begin + result := g; + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + result := fOptions.CC_g; +// result := Formatter_GetCC_g( fHandle ); +end; + +procedure TIcedFormatter.SetCC_g( Value : TCC_g ); +begin + if ( self = nil ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if ( fOptions.CC_g = Value ) then + Exit; + fOptions.CC_g := Value; + + {result := }Formatter_SetCC_g( fHandle, fType, Value ); +end; + +procedure TIcedFormatter.SetShowSymbols( Value : Boolean ); +begin + if ( self = nil ) then + Exit; + if ( fShowSymbols = Value ) then + Exit; + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + if Value AND ( ( @fSymbolResolver = nil ){$IFDEF AssemblyTools} AND ( fSymbolHandler = nil ){$ENDIF} ) then + Exit; + fShowSymbols := Value; + CreateHandle( True{KeepConfiguration} ); +end; + +{$IFDEF AssemblyTools} +procedure TIcedFormatter.SetSymbolHandler( Value : TSymbolHandler ); +begin + if ( self = nil ) then + Exit; + if ( fSymbolHandler = Value ) then + Exit; + + if ( fType in [ ftFast, ftSpecialized ] ) then + Exit; + + fSymbolHandler := Value; + CreateHandle( True{KeepConfiguration} ); +end; +{$ENDIF AssemblyTools} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +constructor TIced.Create( Bitness : TIcedBitness = bt64 ); +begin + inherited Create; + fDecoder := TIcedDecoder.Create( Bitness ); + fEncoder := TIcedEncoder.Create( Bitness ); + fBlockEncoder := TIcedBlockEncoder.Create( Bitness ); + fInfoFactory := TInstructionInfoFactory.Create; + fFormatter := TIcedFormatter.Create; +end; + +destructor TIced.Destroy; +begin + fDecoder.Free; + fEncoder.Free; + fBlockEncoder.Free; + fInfoFactory.Free; + fFormatter.Free; + + inherited; +end; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Decoder +procedure TIced.DecodeFormat( var Instruction: TInstruction; var AOutput: PAnsiChar; Size : PNativeUInt = nil ); +var + t : NativeUInt; +begin + AOutput := nil; + if ( Size <> nil ) then + Size^ := 0; + if ( self = nil ) then + Exit; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + {$IFDEF DECODER_LOCAL_POSITION} + fDecoder.fIPosition := fDecoder.fPosition; + {$ELSE} + fDecoder.fIPosition := fDecoder.Position; + {$ENDIF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + t := 0; + case Formatter.FormatterType of +// ftMasm : MasmFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + ftNasm : NasmFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + ftGas : GasFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + ftIntel : IntelFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + ftFast : FastFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + ftSpecialized : SpecializedFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Formatter.fSpecialized.Options, Instruction, AOutput, t ); + else + MasmFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + end; + if ( Size <> nil ) then + Size^ := t; + + {$IFDEF DECODER_LOCAL_POSITION} +// fDecoder.fPosition := Position; + Inc( fDecoder.fPosition, Instruction.len ); + {$ENDIF DECODER_LOCAL_POSITION} +end; + +{$IFDEF AssemblyTools} +procedure TIced.DecodeFormat( var Instruction: TInstruction; var AOutput: PAnsiChar; Size : PNativeUInt; var Details : TIcedDetails ); +var + t : NativeUInt; +begin + AOutput := nil; + if ( Size <> nil ) then + Size^ := 0; + if ( self = nil ) then + Exit; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + {$IFDEF DECODER_LOCAL_POSITION} + fDecoder.fIPosition := fDecoder.fPosition; + {$ELSE} + fDecoder.fIPosition := fDecoder.Position; + {$ENDIF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + t := 0; + case Formatter.FormatterType of +// ftMasm : MasmFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + ftNasm : NasmFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + ftGas : GasFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + ftIntel : IntelFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + ftFast : FastFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + ftSpecialized : SpecializedFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Formatter.fSpecialized.Options, Instruction, AOutput, t ); + else + MasmFormatter_DecodeFormat( fDecoder.Handle, Formatter.Handle, Instruction, AOutput, t ); + end; + if ( Size <> nil ) then + Size^ := t; + + Decoder.GenerateDetails( Instruction, Details ); + + {$IFDEF DECODER_LOCAL_POSITION} +// fDecoder.fPosition := Position; + Inc( fDecoder.fPosition, Instruction.len ); + {$ENDIF DECODER_LOCAL_POSITION} +end; +{$ENDIF AssemblyTools} + +procedure TIced.DecodeFormat( var Instruction: TInstruction ); +begin + if ( self = nil ) then + begin + FillChar( Instruction, SizeOf( Instruction ), 0 ); + Exit; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + {$IFDEF DECODER_LOCAL_POSITION} + fDecoder.fIPosition := fDecoder.fPosition; + {$ELSE} + fDecoder.fIPosition := fDecoder.Position; + {$ENDIF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + case Formatter.FormatterType of + ftMasm, + ftCapstone : MasmFormatter_DecodeFormatCallback( fDecoder.Handle, Formatter.Handle, Instruction, Formatter.fOutputHandle ); + ftNasm : NasmFormatter_DecodeFormatCallback( fDecoder.Handle, Formatter.Handle, Instruction, Formatter.fOutputHandle ); + ftGas : GasFormatter_DecodeFormatCallback( fDecoder.Handle, Formatter.Handle, Instruction, Formatter.fOutputHandle ); + ftIntel : IntelFormatter_DecodeFormatCallback( fDecoder.Handle, Formatter.Handle, Instruction, Formatter.fOutputHandle ); + else + begin + FillChar( Instruction, SizeOf( Instruction ), 0 ); + Exit; + end; + end; + + {$IFDEF DECODER_LOCAL_POSITION} +// fDecoder.fPosition := Position; + Inc( fDecoder.fPosition, Instruction.len ); + {$ENDIF DECODER_LOCAL_POSITION} +end; + +{$IFDEF AssemblyTools} +procedure TIced.DecodeFormat( var Instruction: TInstruction; var Details : TIcedDetails ); +begin + if ( self = nil ) then + begin + FillChar( Instruction, SizeOf( Instruction ), 0 ); +// FillChar( Detail, SizeOf( Detail ), 0 ); + Exit; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + {$IFDEF DECODER_LOCAL_POSITION} + fDecoder.fIPosition := fDecoder.fPosition; + {$ELSE} + fDecoder.fIPosition := fDecoder.Position; + {$ENDIF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + case Formatter.FormatterType of + ftMasm, + ftCapstone : MasmFormatter_DecodeFormatCallback( fDecoder.Handle, Formatter.Handle, Instruction, Formatter.fOutputHandle ); + ftNasm : NasmFormatter_DecodeFormatCallback( fDecoder.Handle, Formatter.Handle, Instruction, Formatter.fOutputHandle ); + ftGas : GasFormatter_DecodeFormatCallback( fDecoder.Handle, Formatter.Handle, Instruction, Formatter.fOutputHandle ); + ftIntel : IntelFormatter_DecodeFormatCallback( fDecoder.Handle, Formatter.Handle, Instruction, Formatter.fOutputHandle ); + else + begin + FillChar( Instruction, SizeOf( Instruction ), 0 ); + Exit; + end; + end; + + fDecoder.GenerateDetails( Instruction, Details ); + + {$IFDEF DECODER_LOCAL_POSITION} +// fDecoder.fPosition := Position; + Inc( fDecoder.fPosition, Instruction.len ); + {$ENDIF DECODER_LOCAL_POSITION} +end; +{$ENDIF AssemblyTools} + +procedure TIced.DecodeFormatToEnd( Callback : TDecoderFormatCallback; UserData : Pointer = nil ); +begin + if ( self = nil ) then + Exit; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + {$IFDEF DECODER_LOCAL_POSITION} + fDecoder.fIPosition := fDecoder.fPosition; + {$ELSE} + fDecoder.fIPosition := fDecoder.Position; + {$ENDIF DECODER_LOCAL_POSITION} + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + case Formatter.FormatterType of +// ftMasm : MasmFormatter_DecodeFormatToEnd( fDecoder.Handle, Formatter.Handle, Callback, UserData ); + ftNasm : NasmFormatter_DecodeFormatToEnd( fDecoder.Handle, Formatter.Handle, Callback, UserData ); + ftGas : GasFormatter_DecodeFormatToEnd( fDecoder.Handle, Formatter.Handle, Callback, UserData ); + ftIntel : IntelFormatter_DecodeFormatToEnd( fDecoder.Handle, Formatter.Handle, Callback, UserData ); + ftFast : FastFormatter_DecodeFormatToEnd( fDecoder.Handle, Formatter.Handle, Callback, UserData ); + ftSpecialized : SpecializedFormatter_DecodeFormatToEnd( fDecoder.Handle, Formatter.Handle, Formatter.fSpecialized.Options, Callback, UserData ); + else + MasmFormatter_DecodeFormatToEnd( fDecoder.Handle, Formatter.Handle, Callback, UserData ); + end; + + {$IFDEF DECODER_LOCAL_POSITION} +// fDecoder.fPosition := Position; + fDecoder.fPosition := fDecoder.Size; + {$ENDIF DECODER_LOCAL_POSITION} +end; + +function TIced.DecodeFromFile( FileName : String; Size : Cardinal; Offset : UInt64; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : Cardinal; +var + S : TMemoryStream; +begin + result := 0; + if ( self = nil ) then + Exit; + if ( FileName = '' ) then + Exit; + + if NOT FileExists( FileName ) then + Exit; + + S := TMemoryStream.Create; + S.LoadFromFile( FileName ); + + if ( Offset <= S.Size ) then + S.Position := Offset; + result := DecodeFromStream( S, Size, StrL_Assembly, CodeOffset, StrL_Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings, {$IFDEF AssemblyTools}CalcJumpLines,{$ENDIF} CombineNOP ); + S.Free; +end; + +function TIced.DecodeFromStream( Data : TMemoryStream; Size : Cardinal; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : Cardinal; +begin + if ( Data = nil ) then + begin + result := 0; + Exit; + end; + if ( Size = 0 ) then + Size := Data.Size-Data.Position; + if ( Size > Data.Size-Data.Position ) then + Size := Data.Size-Data.Position; + + if CombineNOP then + result := DecodeCombineNOP( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data.Memory )+Data.Position ), Size, StrL_Assembly, CodeOffset, StrL_Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings{$IFDEF AssemblyTools}, CalcJumpLines{$ENDIF} ) + else + result := Decode( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data.Memory )+Data.Position ), Size, StrL_Assembly, CodeOffset, StrL_Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings{$IFDEF AssemblyTools}, CalcJumpLines{$ENDIF} ); +end; + +function TIced.Decode( Data : PByte; Size : Cardinal; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; +const + DETAILS_BLOCKSIZE = 1000; +var + Instruction : TInstruction; + tOutput : PAnsiChar; + i : Integer; + S : String; +begin + result := 0; + if ( self = nil ) then + Exit; + if ( Data = nil ) OR ( Size = 0 ) then + Exit; + +// if ( StrL_Assembly <> nil ) then +// StrL_Assembly.Clear; + + fDecoder.SetData( Data, Size, CodeOffset, DecoderSettings ); + + {$IFDEF AssemblyTools} + if ( Details <> nil ) then + begin + if ( StrL_Assembly <> nil ) AND ( StrL_Hex <> nil ) then + begin + while fDecoder.CanDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + DecodeFormat( Instruction, tOutput, nil, Details^ ); +// fDecoder.Decode( Instruction, Details^ ); +// Formatter.Format( Instruction, tOutput ); + + Inc( Details^.Count ); + StrL_Assembly.Add( string( tOutput ) ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Assembly <> nil ) then + begin + while fDecoder.CanDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + DecodeFormat( Instruction, tOutput, nil, Details^ ); +// fDecoder.Decode( Instruction, Details^ ); +// Formatter.Format( Instruction, tOutput ); + + Inc( Details^.Count ); + StrL_Assembly.Add( string( tOutput ) ); + + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Hex <> nil ) then + begin + while fDecoder.CanDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + fDecoder.Decode( Instruction, Details^ ); + Inc( Details^.Count ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end + else + begin + while fDecoder.CanDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + fDecoder.Decode( Instruction, Details^ ); + Inc( Details^.Count ); + + Inc( result, Instruction.len ); + end; + end; + + SetLength( Details^.Items, Details^.Count ); + SetLength( Details^.JumpTargets, Details^.TargetCount ); + if CalcJumpLines then + JumpLines( Details^ ); + end + else + {$ENDIF AssemblyTools} + begin + if ( StrL_Assembly <> nil ) AND ( StrL_Hex <> nil ) then + begin + while fDecoder.CanDecode do + begin + DecodeFormat( Instruction, tOutput ); +// fDecoder.Decode( Instruction ); +// Formatter.Format( Instruction, tOutput ); + StrL_Assembly.Add( string( tOutput ) ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Assembly <> nil ) then + begin + while fDecoder.CanDecode do + begin + DecodeFormat( Instruction, tOutput ); +// fDecoder.Decode( Instruction ); +// Formatter.Format( Instruction, tOutput ); + StrL_Assembly.Add( string( tOutput ) ); + + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Hex <> nil ) then + begin + while fDecoder.CanDecode do + begin + fDecoder.Decode( Instruction ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end; + end; +end; + +function TIced.Decode( Data : PByte; Size : Cardinal; Count : Cardinal; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; +const + DETAILS_BLOCKSIZE = 1000; +var + Instruction : TInstruction; + tOutput : PAnsiChar; + i : Integer; + S : String; +begin + result := 0; + if ( self = nil ) then + Exit; + if ( Data = nil ) OR ( Size = 0 ) then + Exit; + if ( Count = 0 ) then + Exit; + +// if ( StrL_Assembly <> nil ) then +// StrL_Assembly.Clear; + + fDecoder.SetData( Data, Size, CodeOffset, DecoderSettings ); + + {$IFDEF AssemblyTools} + if ( Details <> nil ) then + begin + if ( StrL_Assembly <> nil ) AND ( StrL_Hex <> nil ) then + begin + while fDecoder.CanDecode AND ( Count > 0 ) do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + DecodeFormat( Instruction, tOutput, nil, Details^ ); +// fDecoder.Decode( Instruction, Details^ ); +// Formatter.Format( Instruction, tOutput ); + + Inc( Details^.Count ); + StrL_Assembly.Add( string( tOutput ) ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + Dec( Count ); + end; + end + else if ( StrL_Assembly <> nil ) then + begin + while fDecoder.CanDecode AND ( Count > 0 ) do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + DecodeFormat( Instruction, tOutput, nil, Details^ ); +// fDecoder.Decode( Instruction, Details^ ); +// Formatter.Format( Instruction, tOutput ); + + Inc( Details^.Count ); + StrL_Assembly.Add( string( tOutput ) ); + + Inc( result, Instruction.len ); + Dec( Count ); + end; + end + else if ( StrL_Hex <> nil ) then + begin + while fDecoder.CanDecode AND ( Count > 0 ) do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + fDecoder.Decode( Instruction, Details^ ); + Inc( Details^.Count ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + Dec( Count ); + end; + end + else + begin + while fDecoder.CanDecode AND ( Count > 0 ) do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + fDecoder.Decode( Instruction, Details^ ); + Inc( Details^.Count ); + + Inc( result, Instruction.len ); + Dec( Count ); + end; + end; + + SetLength( Details^.Items, Details^.Count ); + SetLength( Details^.JumpTargets, Details^.TargetCount ); + if CalcJumpLines then + JumpLines( Details^ ); + end + else + {$ENDIF AssemblyTools} + begin + if ( StrL_Assembly <> nil ) AND ( StrL_Hex <> nil ) then + begin + while fDecoder.CanDecode AND ( Count > 0 ) do + begin + DecodeFormat( Instruction, tOutput ); +// fDecoder.Decode( Instruction ); +// Formatter.Format( Instruction, tOutput ); + StrL_Assembly.Add( string( tOutput ) ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + Dec( Count ); + end; + end + else if ( StrL_Assembly <> nil ) then + begin + while fDecoder.CanDecode AND ( Count > 0 ) do + begin + DecodeFormat( Instruction, tOutput ); +// fDecoder.Decode( Instruction ); +// Formatter.Format( Instruction, tOutput ); + StrL_Assembly.Add( string( tOutput ) ); + + Inc( result, Instruction.len ); + Dec( Count ); + end; + end + else if ( StrL_Hex <> nil ) then + begin + while fDecoder.CanDecode AND ( Count > 0 ) do + begin + fDecoder.Decode( Instruction ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + Dec( Count ); + end; + end; + end; +end; + +function TIced.Decode( Data : PByte; Size : Cardinal; var Instruction: String; CodeOffset : UInt64 = UInt64( 0 ); InstructionBytes : pString = nil; Offset : PUInt64 = nil; {$IFDEF AssemblyTools}Detail : pIcedDetail = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : Cardinal; +var + StrL_Assembly : TStrings; + StrL_Hex : TStrings; + {$IFDEF AssemblyTools} + Details : TIcedDetails; + {$ENDIF AssemblyTools} +begin + StrL_Assembly := TStringList.Create; + StrL_Hex := TStringList.Create; + {$IFDEF AssemblyTools} + FillChar( Details, SizeOf( Details ), 0 ); + {$ENDIF AssemblyTools} + + if CombineNOP then + result := DecodeCombineNOP( Data, Size, 1{Count}, StrL_Assembly, CodeOffset, StrL_Hex, {$IFDEF AssemblyTools}@Details,{$ENDIF} DecoderSettings{$IFDEF AssemblyTools}, CalcJumpLines{$ENDIF} ) + else + result := Decode( Data, Size, 1{Count}, StrL_Assembly, CodeOffset, StrL_Hex, {$IFDEF AssemblyTools}@Details,{$ENDIF} DecoderSettings{$IFDEF AssemblyTools}, CalcJumpLines{$ENDIF} ); + if ( result > 0 ) then + begin + Instruction := StrL_Assembly[ 0 ]; + if ( InstructionBytes <> nil ) then + InstructionBytes^ := StrL_Hex[ 0 ]; + {$IFDEF AssemblyTools} + if ( Detail <> nil ) then + Detail^ := Details.Items[ 0 ]; + {$ENDIF AssemblyTools} + end + else + begin + Instruction := ''; + if ( InstructionBytes <> nil ) then + InstructionBytes^ := ''; + {$IFDEF AssemblyTools} + if ( Detail <> nil ) then + FillChar( Detail^, SizeOf( Detail ), 0 ); + {$ENDIF AssemblyTools} + end; + StrL_Assembly.Free; + StrL_Hex.Free; + {$IFDEF AssemblyTools} + SetLength( Details.Items, 0 ); + SetLength( Details.JumpTargets, 0 ); + {$ENDIF AssemblyTools} +end; + +function TIced.Decode( Data : string; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : boolean; +var + StrL : TStringList; +begin + StrL := TStringList.Create; + StrL.Text := Data; + result := Decode( StrL, StrL_Assembly, CodeOffset, StrL_Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings, {$IFDEF AssemblyTools}CalcJumpLines,{$ENDIF} CombineNOP ); + StrL.Free; +end; + +function TIced.Decode( Data : TStrings; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : boolean; + function IsHex( sHex : String ) : Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + var + i : Integer; + Begin + Result := false; + if ( Trim( sHex ) = '' ) Then + Exit; + + sHex := StringReplace( sHex, ' ', '', [ rfReplaceAll ] ); + sHex := StringReplace( sHex, '-', '', [ rfReplaceAll ] ); + if ( Copy( sHex, 1, 1 ) = '$' ) then + sHex := Copy( sHex, 2, Length( sHex )-1 ) + else if ( Copy( sHex, 1, 2 ) = '0x' ) then + sHex := Copy( sHex, 3, Length( sHex )-2 ); + + sHex := UpperCase( sHex ); + if Odd( Length( sHex ) ) then + sHex := '0' + sHex; + + for i := {$IF CompilerVersion >= 24}Low( sHex ){$ELSE}1{$IFEND} to {$IF CompilerVersion >= 24}High( sHex ){$ELSE}Length( sHex ){$IFEND} do + begin + // if NOT IsHexChar( sHex[ i ], WildCard ) then + // Exit; + + if NOT ( {$IF CompilerVersion >= 20}CharInSet( sHex[ i ],{$ELSE}( sHex[ i ] in{$IFEND} [ '0'..'9' ,'a'..'f', 'A'..'F' ] ) ) then + Exit; + end; + + Result := true; + end; +const + HexTable : Array[ 0..15 ] of Char = ( '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' ); + DETAILS_BLOCKSIZE = 1000; +var + i, j, k : Integer; + sHex : String; + Bts : Array of Byte; + StrL_In : TStringList; + tStrL : TStringList; + sCom : string; + iPos : Integer; + A, B : SmallInt; + IsDATA : Boolean; +begin + result := false; + if ( StrL_Hex <> nil ) then + StrL_Hex.Clear; + {$IFDEF AssemblyTools} + if ( Details <> nil ) then + FillChar( Details^, SizeOf( Details^ ), 0 ); + {$ENDIF AssemblyTools} + if ( Data = nil ) then + Exit; + if ( Data.Text = '' ) then + Exit; + StrL_Assembly.BeginUpdate; + if ( StrL_Assembly <> nil ) then + StrL_Assembly.Clear; + + if NOT uIced.Imports.IsInitDLL then + begin + if ( StrL_Assembly <> nil ) then + StrL_Assembly.Add( 'DLL not loaded.' ); + StrL_Assembly.EndUpdate; + Exit; + end; + + StrL_In := TStringList.Create; + StrL_In.Assign( Data ); + tStrL := TStringList.Create; + + // Merge/Join Lines + IsDATA := False; // MS !!!? + i := 0; + while ( i < StrL_In.Count ) do + begin + if ( CompareText( StrL_In[ i ], '[DATA]' ) = 0 ) then + IsDATA := True; + if IsHex( StrL_In[ i ] ) then + begin + sHex := Trim( StrL_In[ i ] ); + while ( i < StrL_In.Count-1 ) AND IsHex( StrL_In[ i+1 ] ) do + begin + sHex := sHex + Trim( StrL_In[ i+1 ] ); + Inc( i ); + end; + tStrL.Add( sHex ); + end + else + tStrL.Add( StrL_In[ i ] ); + if ( CompareText( StrL_In[ i ], '[/DATA]' ) = 0 ) then + IsDATA := False; + Inc( i ); + end; + StrL_In.Assign( tStrL ); + tStrL.free; + + IsDATA := False; + for i := 0 to StrL_In.Count-1 do + begin + StrL_In[ i ] := StringReplace( StrL_In[ i ], #9, #32, [rfReplaceAll] ); + StrL_In[ i ] := Trim( StrL_In[ i ] ); + + if ( CompareText( StrL_In[ i ], '[DATA]' ) = 0 ) then + begin + IsDATA := True; + j := 0; + end + else if ( CompareText( StrL_In[ i ], '[/DATA]' ) = 0 ) then + begin + IsDATA := False; + j := 1; + end + else + j := -1; + + if ( StrL_In[ i ] = '' ) OR ( j >= 0 ) then + begin + if ( StrL_Hex <> nil ) then + begin + if ( j >= 0 ) then + StrL_Hex.Add( StrL_In[ i ] ) + else + StrL_Hex.Add( '' ); + end; + if ( StrL_Assembly <> nil ) then + StrL_Assembly.Add( '' ); + {$IFDEF AssemblyTools} + if ( Details <> nil ) then + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + FillChar( Details^.Items[ Details^.Count ], SizeOf( TIcedDetail ), 0 ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} + Details^.Items[ Details^.Count ].Offset := CodeOffset; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} + Inc( Details^.Count ); + end; + {$ENDIF AssemblyTools} + continue; + end; + + if IsDATA then + begin + if ( StrL_Hex <> nil ) then + StrL_Hex.Add( StrL_In[ i ] ); + if ( StrL_Assembly <> nil ) then + StrL_Assembly.Add( StrL_In[ i ] ); + {$IFDEF AssemblyTools} + if ( Details <> nil ) then + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + FillChar( Details^.Items[ Details^.Count ], SizeOf( TIcedDetail ), 0 ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} + Details^.Items[ Details^.Count ].Offset := CodeOffset; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} + Inc( Details^.Count ); + end; + {$ENDIF AssemblyTools} + continue; + end; + + sCom := ''; + iPos := -1; + sHex := StrL_In[ i ]; + for j := 0 to 3 do + begin + case j of + 0 : iPos := Pos( '//', StrL_In[ i ] ); + 1 : iPos := Pos( '/*', StrL_In[ i ] ); + 2 : iPos := Pos( '{', StrL_In[ i ] ); + 3 : iPos := Pos( '(*', StrL_In[ i ] ); + end; + if ( iPos > 0 ) then + begin + sHex := Trim( Copy( StrL_In[ i ], 1, iPos-1 ) ); + sCom := ' ' + Copy( StrL_In[ i ], iPos, Length( StrL_In[ i ] )-iPos+1 ); + break; + end; + end; + + sHex := StringReplace( sHex, ' ', '', [ rfReplaceAll ] ); + sHex := StringReplace( sHex, '-', '', [ rfReplaceAll ] ); + if ( Copy( sHex, 1, 1 ) = '$' ) then + sHex := Copy( sHex, 2, Length( sHex )-1 ) + else if ( Copy( sHex, 1, 2 ) = '0x' ) then + sHex := Copy( sHex, 3, Length( sHex )-2 ); + + sHex := UpperCase( sHex ); + if Odd( Length( sHex ) ) then + sHex := '0' + sHex; + +// if ( Copy( StrL[ i ], 1, 2 ) = '//' ) OR ( Copy( StrL[ i ], 1, 2 ) = '/*' ) OR ( Copy( StrL[ i ], 1, 2 ) = '{' ) OR ( Copy( StrL[ i ], 1, 2 ) = '(*' ) then + if NOT IsHex( sHex ) then + begin + if ( StrL_Hex <> nil ) then + StrL_Hex.Add( StrL_In[ i ] ); + if ( StrL_Assembly <> nil ) then + StrL_Assembly.Add( StrL_In[ i ] ); + {$IFDEF AssemblyTools} + if ( Details <> nil ) then + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + FillChar( Details^.Items[ Details^.Count ], SizeOf( tIcedDetail ), 0 ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} + Details^.Items[ Details^.Count ].Offset := CodeOffset; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} + + Inc( Details^.Count ); + end; + {$ENDIF AssemblyTools} + continue; + end; + + SetLength( Bts, Length( sHex ) div 2 ); + j := {$IF CompilerVersion >= 24}Low( sHex ){$ELSE}1{$IFEND}; + while ( j < {$IF CompilerVersion >= 24}High( sHex ){$ELSE}Length( sHex ){$IFEND} ) do + begin +// HexToBytes( AnsiString( sHex[ j ] + sHex[ j+1 ] ), @Bts[ ( j-1 ) div 2 ], 1 ); + + A := -1; + B := -1; + for k := Low( HexTable ) to High( HexTable ) do + begin + if ( HexTable[ k ] = sHex[ j ] ) then + A := 16 * k; + if ( HexTable[ k ] = sHex[ j+1 ] ) then + B := k; + end; + if ( A < 0 ) or ( B < 0 ) then + Exit; + Bts[ ( j-1 ) div 2 ] := A + B; + Inc( j, 2 ); + end; + + if CombineNOP then + {k := }DecodeCombineNOP( @Bts[ 0 ], Length( Bts ), StrL_Assembly, CodeOffset, StrL_Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings{$IFDEF AssemblyTools}, CalcJumpLines AND ( i = StrL_In.Count-1 ){$ENDIF} ) + else + {k := }Decode( @Bts[ 0 ], Length( Bts ), StrL_Assembly, CodeOffset, StrL_Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings{$IFDEF AssemblyTools}, CalcJumpLines AND ( i = StrL_In.Count-1 ){$ENDIF} ); + + if ( sCom <> '' ) then + begin + StrL_Assembly[ StrL_Assembly.Count-1 ] := StrL_Assembly[ StrL_Assembly.Count-1 ] + sCom; + if ( StrL_Hex <> nil ) then + StrL_Hex[ StrL_Hex.Count-1 ] := StrL_Hex[ StrL_Hex.Count-1 ] + sCom; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} + Inc( CodeOffset, Length( Bts ) ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} + SetLength( Bts, 0 ); + end; + + {$IFDEF AssemblyTools} + if ( Details <> nil ) then + begin + SetLength( Details^.Items, Details^.Count ); + SetLength( Details^.JumpTargets, Details^.TargetCount ); + end; + {$ENDIF AssemblyTools} + + StrL_In.free; + StrL_Assembly.EndUpdate; +// if ( Details <> nil ) AND ( Architecture = CS_ARCH_X86 ) then +// JumpLines( Details^.Items ); + result := True; +end; + +function TIced.DecodeCombineNOP( Data : PByte; Size : Cardinal; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; +const + DETAILS_BLOCKSIZE = 1000; + BLOCKSIZE_NOP = MAX_INSTRUCTION_LEN_; +var + Instruction : TInstruction; + tOutput : PAnsiChar; + i : Integer; + S : String; + bDecode : Boolean; + bNOP : Byte; +begin + result := 0; + if ( self = nil ) then + Exit; + if ( Data = nil ) OR ( Size = 0 ) then + Exit; + +// if ( StrL_Assembly <> nil ) then +// StrL_Assembly.Clear; + + fDecoder.SetData( Data, Size, CodeOffset, DecoderSettings ); + + bNOP := 0; + {$IFDEF AssemblyTools} + if ( Details <> nil ) then + begin + if ( StrL_Assembly <> nil ) AND ( StrL_Hex <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + +// fDecoder.Decode( Instruction, Details^ ); + DecodeFormat( Instruction, tOutput, nil, Details^ ); + bDecode := fDecoder.CanDecode; + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + if ( bNOP = 0 ) then + begin + StrL_Assembly.Add( string( tOutput ) ); + Inc( Details^.Count ); + end; + + Inc( bNOP ); + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + Details^.Items[ Details^.Count-1 ].Size := bNOP; + StrL_Assembly[ StrL_Assembly.Count-1 ] := StrL_Assembly[ StrL_Assembly.Count-1 ] + ':' + IntToStr( bNOP ); + + S := ''; + for i := 0 to bNOP-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + end + else if ( bNOP = 1 ) then + begin + StrL_Hex.Add( IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ) ); + Inc( Data ); + end; + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + StrL_Assembly.Add( string( tOutput ) ); + + Inc( Details^.Count ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Assembly <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + +// fDecoder.Decode( Instruction, Details^ ); + DecodeFormat( Instruction, tOutput, nil, Details^ ); + bDecode := fDecoder.CanDecode; + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + if ( bNOP = 0 ) then + begin + StrL_Assembly.Add( string( tOutput ) ); + Inc( Details^.Count ); + end; + Inc( bNOP ); + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + Details^.Items[ Details^.Count-1 ].Size := bNOP; + StrL_Assembly[ StrL_Assembly.Count-1 ] := StrL_Assembly[ StrL_Assembly.Count-1 ] + ':' + IntToStr( bNOP ); + +// Inc( Data, bNOP-1 ); + end; +// else if ( bNOP = 1 ) then +// Inc( Data ); + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + StrL_Assembly.Add( string( tOutput ) ); + + Inc( Details^.Count ); + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Hex <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + fDecoder.Decode( Instruction, Details^ ); + bDecode := fDecoder.CanDecode; + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + if ( bNOP = 0 ) then + Inc( Details^.Count ); + Inc( bNOP ); + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + Details^.Items[ Details^.Count-1 ].Size := bNOP; + S := ''; + for i := 0 to bNOP-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + end + else if ( bNOP = 1 ) then + begin + StrL_Hex.Add( IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ) ); + Inc( Data ); + end; + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + Inc( Details^.Count ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end + else + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + fDecoder.Decode( Instruction, Details^ ); + bDecode := fDecoder.CanDecode; + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + if ( bNOP = 0 ) then + Inc( Details^.Count ); + Inc( bNOP ); + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + Details^.Items[ Details^.Count-1 ].Size := bNOP; +// Inc( Data, bNOP-1 ); + end; +// else if ( bNOP = 1 ) then +// Inc( Data ); + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + Inc( Details^.Count ); + + Inc( result, Instruction.len ); + end; + end; + + SetLength( Details^.Items, Details^.Count ); + SetLength( Details^.JumpTargets, Details^.TargetCount ); + if CalcJumpLines then + JumpLines( Details^ ); + end + else + {$ENDIF AssemblyTools} + begin + if ( StrL_Assembly <> nil ) AND ( StrL_Hex <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin +// fDecoder.Decode( Instruction ); + DecodeFormat( Instruction, tOutput ); + bDecode := fDecoder.CanDecode; + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + Inc( bNOP ); + + if ( bNOP = 0 ) then + StrL_Assembly.Add( string( tOutput ) ); + + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + StrL_Assembly[ StrL_Assembly.Count-1 ] := StrL_Assembly[ StrL_Assembly.Count-1 ] + ':' + IntToStr( bNOP ); + + S := ''; + for i := 0 to bNOP-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + end + else if ( bNOP = 1 ) then + begin + StrL_Hex.Add( IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ) ); + Inc( Data ); + end; + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + StrL_Assembly.Add( string( tOutput ) ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Assembly <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin +// fDecoder.Decode( Instruction ); + DecodeFormat( Instruction, tOutput ); + bDecode := fDecoder.CanDecode; + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + Inc( bNOP ); + + if ( bNOP = 0 ) then + StrL_Assembly.Add( string( tOutput ) ); + + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + StrL_Assembly[ StrL_Assembly.Count-1 ] := StrL_Assembly[ StrL_Assembly.Count-1 ] + ':' + IntToStr( bNOP ); + +// Inc( Data, bNOP-1 ); + end; +// else if ( bNOP = 1 ) then +// Inc( Data ); + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + StrL_Assembly.Add( string( tOutput ) ); + + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Hex <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin + fDecoder.Decode( Instruction ); + bDecode := fDecoder.CanDecode; + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + Inc( bNOP ); + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + S := ''; + for i := 0 to bNOP-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + end + else if ( bNOP = 1 ) then + begin + StrL_Hex.Add( IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ) ); + Inc( Data ); + end; + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end; + end; +end; + +function TIced.DecodeCombineNOP( Data : PByte; Size : Cardinal; Count : Cardinal; StrL_Assembly : TStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; +const + DETAILS_BLOCKSIZE = 1000; + BLOCKSIZE_NOP = 16; +var + Instruction : TInstruction; + tOutput : PAnsiChar; + i : Integer; + S : String; + bDecode : Boolean; + bNOP : Byte; +begin + result := 0; + if ( self = nil ) then + Exit; + if ( Data = nil ) OR ( Size = 0 ) then + Exit; + if ( Count = 0 ) then + Exit; + +// if ( StrL_Assembly <> nil ) then +// StrL_Assembly.Clear; + + fDecoder.SetData( Data, Size, CodeOffset, DecoderSettings ); + + bNOP := 0; + {$IFDEF AssemblyTools} + if ( Details <> nil ) then + begin + if ( StrL_Assembly <> nil ) AND ( StrL_Hex <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + +// fDecoder.Decode( Instruction, Details^ ); + DecodeFormat( Instruction, tOutput, nil, Details^ ); + Dec( Count ); + bDecode := fDecoder.CanDecode AND ( Count > 0 ); + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + if ( bNOP = 0 ) then + begin + StrL_Assembly.Add( string( tOutput ) ); + Inc( Details^.Count ); + end; + + Inc( bNOP ); + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + Details^.Items[ Details^.Count-1 ].Size := bNOP; + StrL_Assembly[ StrL_Assembly.Count-1 ] := StrL_Assembly[ StrL_Assembly.Count-1 ] + ':' + IntToStr( bNOP ); + + S := ''; + for i := 0 to bNOP-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + end + else if ( bNOP = 1 ) then + begin + StrL_Hex.Add( IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ) ); + Inc( Data ); + end; + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + StrL_Assembly.Add( string( tOutput ) ); + + Inc( Details^.Count ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Assembly <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + +// fDecoder.Decode( Instruction, Details^ ); + DecodeFormat( Instruction, tOutput, nil, Details^ ); + Dec( Count ); + bDecode := fDecoder.CanDecode AND ( Count > 0 ); + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + if ( bNOP = 0 ) then + begin + StrL_Assembly.Add( string( tOutput ) ); + Inc( Details^.Count ); + end; + Inc( bNOP ); + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + Details^.Items[ Details^.Count-1 ].Size := bNOP; + StrL_Assembly[ StrL_Assembly.Count-1 ] := StrL_Assembly[ StrL_Assembly.Count-1 ] + ':' + IntToStr( bNOP ); + +// Inc( Data, bNOP-1 ); + end; +// else if ( bNOP = 1 ) then +// Inc( Data ); + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + StrL_Assembly.Add( string( tOutput ) ); + + Inc( Details^.Count ); + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Hex <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + fDecoder.Decode( Instruction, Details^ ); + Dec( Count ); + bDecode := fDecoder.CanDecode AND ( Count > 0 ); + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + if ( bNOP = 0 ) then + Inc( Details^.Count ); + Inc( bNOP ); + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + Details^.Items[ Details^.Count-1 ].Size := bNOP; + S := ''; + for i := 0 to bNOP-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + end + else if ( bNOP = 1 ) then + begin + StrL_Hex.Add( IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ) ); + Inc( Data ); + end; + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + Inc( Details^.Count ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end + else + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin + if ( Details^.Count >= Length( Details^.Items ) ) then + SetLength( Details^.Items, Details^.Count+DETAILS_BLOCKSIZE ); + + fDecoder.Decode( Instruction, Details^ ); + Dec( Count ); + bDecode := fDecoder.CanDecode AND ( Count > 0 ); + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + if ( bNOP = 0 ) then + Inc( Details^.Count ); + Inc( bNOP ); + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + Details^.Items[ Details^.Count-1 ].Size := bNOP; +// Inc( Data, bNOP-1 ); + end; +// else if ( bNOP = 1 ) then +// Inc( Data ); + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + Inc( Details^.Count ); + + Inc( result, Instruction.len ); + end; + end; + + SetLength( Details^.Items, Details^.Count ); + SetLength( Details^.JumpTargets, Details^.TargetCount ); + if CalcJumpLines then + JumpLines( Details^ ); + end + else + {$ENDIF AssemblyTools} + begin + if ( StrL_Assembly <> nil ) AND ( StrL_Hex <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin +// fDecoder.Decode( Instruction ); + DecodeFormat( Instruction, tOutput ); + Dec( Count ); + bDecode := fDecoder.CanDecode AND ( Count > 0 ); + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + Inc( bNOP ); + + if ( bNOP = 0 ) then + StrL_Assembly.Add( string( tOutput ) ); + + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + StrL_Assembly[ StrL_Assembly.Count-1 ] := StrL_Assembly[ StrL_Assembly.Count-1 ] + ':' + IntToStr( bNOP ); + + S := ''; + for i := 0 to bNOP-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + end + else if ( bNOP = 1 ) then + begin + StrL_Hex.Add( IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ) ); + Inc( Data ); + end; + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + StrL_Assembly.Add( string( tOutput ) ); + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Assembly <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin +// fDecoder.Decode( Instruction ); + DecodeFormat( Instruction, tOutput ); + Dec( Count ); + bDecode := fDecoder.CanDecode AND ( Count > 0 ); + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + Inc( bNOP ); + + if ( bNOP = 0 ) then + StrL_Assembly.Add( string( tOutput ) ); + + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + StrL_Assembly[ StrL_Assembly.Count-1 ] := StrL_Assembly[ StrL_Assembly.Count-1 ] + ':' + IntToStr( bNOP ); + +// Inc( Data, bNOP-1 ); + end; +// else if ( bNOP = 1 ) then +// Inc( Data ); + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + StrL_Assembly.Add( string( tOutput ) ); + + Inc( result, Instruction.len ); + end; + end + else if ( StrL_Hex <> nil ) then + begin + bDecode := fDecoder.CanDecode; + while bDecode do + begin + fDecoder.Decode( Instruction ); + Dec( Count ); + bDecode := fDecoder.CanDecode AND ( Count > 0 ); + + if ( Instruction.code.Code = Nopd ) AND ( bNOP < BLOCKSIZE_NOP ) then + begin + Inc( bNOP ); + if bDecode AND ( bNOP <= BLOCKSIZE_NOP ) then + Continue; + end; + + if ( bNOP > 1 ) then + begin + S := ''; + for i := 0 to bNOP-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + end + else if ( bNOP = 1 ) then + begin + StrL_Hex.Add( IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ) ); + Inc( Data ); + end; + if ( bNOP > 0 ) then + begin + Inc( result, bNOP ); + if NOT bDecode then + break; + end; + bNOP := 0; + + S := ''; + for i := 0 to Instruction.len-1 do + begin + S := S + IntToHex( Data^{$IFNDEF UNICODE}, 2{$ENDIF} ); + Inc( Data ); + end; + StrL_Hex.Add( S ); + + Inc( result, Instruction.len ); + end; + end; + end; +end; + +{$IF Declared( SynUnicode )} +function TIced.DecodeFromFile( FileName : String; Size : Cardinal; Offset : UInt64; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : Cardinal; +var + Assembly, + Hex : TStringList; +begin + if ( StrL_Assembly <> nil ) then + Assembly := TStringList.Create + else + Assembly := nil; + + if ( StrL_Hex <> nil ) then + Hex := TStringList.Create + else + Hex := nil; + + result := DecodeFromFile( FileName, Size, Offset, Assembly, CodeOffset, Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings, {$IFDEF AssemblyTools}CalcJumpLines, {$ENDIF}CombineNOP ); + + if ( Assembly <> nil ) then + begin + StrL_Assembly.Text := Assembly.Text; + Assembly.free; + end; + if ( Hex <> nil ) then + begin + StrL_Hex.Text := Hex.Text; + Hex.free; + end; +end; + +function TIced.DecodeFromStream( Data : TMemoryStream; Size : Cardinal; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : Cardinal; +var + Assembly, + Hex : TStringList; +begin + if ( StrL_Assembly <> nil ) then + Assembly := TStringList.Create + else + Assembly := nil; + + if ( StrL_Hex <> nil ) then + Hex := TStringList.Create + else + Hex := nil; + + result := DecodeFromStream( Data, Size, Assembly, CodeOffset, Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings, {$IFDEF AssemblyTools}CalcJumpLines, {$ENDIF}CombineNOP ); + + if ( Assembly <> nil ) then + begin + StrL_Assembly.Text := Assembly.Text; + Assembly.free; + end; + if ( Hex <> nil ) then + begin + StrL_Hex.Text := Hex.Text; + Hex.free; + end; +end; + +function TIced.Decode( Data : PByte; Size : Cardinal; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; +var + Assembly, + Hex : TStringList; +begin + if ( StrL_Assembly <> nil ) then + Assembly := TStringList.Create + else + Assembly := nil; + + if ( StrL_Hex <> nil ) then + Hex := TStringList.Create + else + Hex := nil; + + result := Decode( Data, Size, Assembly, CodeOffset, Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings{$IFDEF AssemblyTools}, CalcJumpLines{$ENDIF} ); + + if ( Assembly <> nil ) then + begin + StrL_Assembly.Text := Assembly.Text; + Assembly.free; + end; + if ( Hex <> nil ) then + begin + StrL_Hex.Text := Hex.Text; + Hex.free; + end; +end; + +function TIced.Decode( Data : PByte; Size : Cardinal; Count : Cardinal; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; +var + Assembly, + Hex : TStringList; +begin + if ( StrL_Assembly <> nil ) then + Assembly := TStringList.Create + else + Assembly := nil; + + if ( StrL_Hex <> nil ) then + Hex := TStringList.Create + else + Hex := nil; + + result := Decode( Data, Size, Assembly, CodeOffset, Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings{$IFDEF AssemblyTools}, CalcJumpLines{$ENDIF} ); + + if ( Assembly <> nil ) then + begin + StrL_Assembly.Text := Assembly.Text; + Assembly.free; + end; + if ( Hex <> nil ) then + begin + StrL_Hex.Text := Hex.Text; + Hex.free; + end; +end; + +function TIced.Decode( Data : string; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : boolean; +var + Assembly, + Hex : TStringList; +begin + if ( StrL_Assembly <> nil ) then + Assembly := TStringList.Create + else + Assembly := nil; + + if ( StrL_Hex <> nil ) then + Hex := TStringList.Create + else + Hex := nil; + + result := Decode( Data, Assembly, CodeOffset, Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings, {$IFDEF AssemblyTools}CalcJumpLines, {$ENDIF}CombineNOP ); + + if ( Assembly <> nil ) then + begin + StrL_Assembly.Text := Assembly.Text; + Assembly.free; + end; + if ( Hex <> nil ) then + begin + StrL_Hex.Text := Hex.Text; + Hex.free; + end; +end; + +function TIced.Decode( Data : TStrings; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE; {$IFDEF AssemblyTools}CalcJumpLines : Boolean = True;{$ENDIF} CombineNOP : boolean = False ) : boolean; +var + Assembly, + Hex : TStringList; +begin + if ( StrL_Assembly <> nil ) then + Assembly := TStringList.Create + else + Assembly := nil; + + if ( StrL_Hex <> nil ) then + Hex := TStringList.Create + else + Hex := nil; + + result := Decode( Data, Assembly, CodeOffset, Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings, {$IFDEF AssemblyTools}CalcJumpLines, {$ENDIF}CombineNOP ); + + if ( Assembly <> nil ) then + begin + StrL_Assembly.Text := Assembly.Text; + Assembly.free; + end; + if ( Hex <> nil ) then + begin + StrL_Hex.Text := Hex.Text; + Hex.free; + end; +end; + +function TIced.DecodeCombineNOP( Data : PByte; Size : Cardinal; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; +var + Assembly, + Hex : TStringList; +begin + if ( StrL_Assembly <> nil ) then + Assembly := TStringList.Create + else + Assembly := nil; + + if ( StrL_Hex <> nil ) then + Hex := TStringList.Create + else + Hex := nil; + + result := DecodeCombineNOP( Data, Size, Assembly, CodeOffset, Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings{$IFDEF AssemblyTools}, CalcJumpLines{$ENDIF} ); + + if ( Assembly <> nil ) then + begin + StrL_Assembly.Text := Assembly.Text; + Assembly.free; + end; + if ( Hex <> nil ) then + begin + StrL_Hex.Text := Hex.Text; + Hex.free; + end; +end; + +function TIced.DecodeCombineNOP( Data : PByte; Size : Cardinal; Count : Cardinal; StrL_Assembly : TUnicodeStrings; CodeOffset : UInt64 = UInt64( 0 ); StrL_Hex : TUnicodeStrings = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE{$IFDEF AssemblyTools}; CalcJumpLines : Boolean = True{$ENDIF} ) : Cardinal; +var + Assembly, + Hex : TStringList; +begin + if ( StrL_Assembly <> nil ) then + Assembly := TStringList.Create + else + Assembly := nil; + + if ( StrL_Hex <> nil ) then + Hex := TStringList.Create + else + Hex := nil; + + result := DecodeCombineNOP( Data, Size, Count, Assembly, CodeOffset, Hex, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings{$IFDEF AssemblyTools}, CalcJumpLines{$ENDIF} ); + + if ( Assembly <> nil ) then + begin + StrL_Assembly.Text := Assembly.Text; + Assembly.free; + end; + if ( Hex <> nil ) then + begin + StrL_Hex.Text := Hex.Text; + Hex.free; + end; +end; +{$IFEND UNICODE} + +{$IFDEF AssemblyTools} +function TIced.DecodeAddress( var Data : TByteInstruction; Address : UInt64; Instruction : PString = nil; {$IFDEF AssemblyTools}Detail : pIcedDetail = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; +var + StrL_Assembly : TStrings; + StrL_Hex : TStrings; + {$IFDEF AssemblyTools} + Details : TIcedDetails; + {$ENDIF AssemblyTools} +begin + StrL_Assembly := TStringList.Create; + StrL_Hex := TStringList.Create; + {$IFDEF AssemblyTools} + FillChar( Details, SizeOf( Details ), 0 ); + {$ENDIF AssemblyTools} + + result := Decode( @Data[ 0 ], Length( Data ), 1, StrL_Assembly, Address, StrL_Hex, {$IFDEF AssemblyTools}@Details,{$ENDIF} DecoderSettings, False{CalcJumpLines} ); + if ( result > 0 ) then + begin + if ( Instruction <> nil ) then + Instruction^ := StrL_Assembly[ 0 ]; + {$IFDEF AssemblyTools} + if ( Detail <> nil ) then + Detail^ := Details.Items[ 0 ]; + {$ENDIF AssemblyTools} + end + else + begin + if ( Instruction <> nil ) then + Instruction^ := ''; + {$IFDEF AssemblyTools} + if ( Detail <> nil ) then + FillChar( Detail^, SizeOf( Detail ), 0 ); + {$ENDIF AssemblyTools} + end; + + StrL_Assembly.Free; + StrL_Hex.Free; + {$IFDEF AssemblyTools} + SetLength( Details.Items, 0 ); + SetLength( Details.JumpTargets, 0 ); + {$ENDIF AssemblyTools} +end; + +function TIced.DecodeAddress( Data : PByte; Size : Cardinal; Address : UInt64; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; {$IFDEF AssemblyTools}Detail : pIcedDetail = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; +var + StrL_Assembly : TStrings; + StrL_Hex : TStrings; + {$IFDEF AssemblyTools} + Details : TIcedDetails; + {$ENDIF AssemblyTools} +begin + StrL_Assembly := TStringList.Create; + StrL_Hex := TStringList.Create; + {$IFDEF AssemblyTools} + FillChar( Details, SizeOf( Details ), 0 ); + {$ENDIF AssemblyTools} + + result := Decode( Data, Size, 1, StrL_Assembly, Address, StrL_Hex, {$IFDEF AssemblyTools}@Details,{$ENDIF} DecoderSettings, False{CalcJumpLines} ); + if ( result > 0 ) then + begin + if ( Instruction <> nil ) then + Instruction^ := StrL_Assembly[ 0 ]; + {$IFDEF AssemblyTools} + if ( Detail <> nil ) then + Detail^ := Details.Items[ 0 ]; + {$ENDIF AssemblyTools} + end + else + begin + if ( Instruction <> nil ) then + Instruction^ := ''; + {$IFDEF AssemblyTools} + if ( Detail <> nil ) then + FillChar( Detail^, SizeOf( Detail ), 0 ); + {$ENDIF AssemblyTools} + end; + + StrL_Assembly.Free; + StrL_Hex.Free; + {$IFDEF AssemblyTools} + SetLength( Details.Items, 0 ); + SetLength( Details.JumpTargets, 0 ); + {$ENDIF AssemblyTools} +end; +{$ENDIF AssemblyTools} + +function TIced.Compare( Data : PByte; Size : Cardinal; Offset : UInt64; DataCompare : PByte; SizeCompare : Cardinal; OffsetCompare : UInt64; Count : Word; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyCompareMode = acmCenter ) : Cardinal; +var + Decoder2 : TIcedDecoder; + Inst1 : TInstruction; + Inst2 : TInstruction; +begin + result := 0; + if ( Data = nil ) OR ( Size = 0 ) OR ( DataCompare = nil ) OR ( SizeCompare = 0 ) OR ( Count = 0 ) then + Exit; + + Decoder2 := TIcedDecoder.Create( fDecoder.Bitness ); + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Offset := Offset-CodeOffset; + OffsetCompare := OffsetCompare-CodeOffset; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Size := Size-( Offset-CodeOffset ); + SizeCompare := SizeCompare-( OffsetCompare-CodeOffset ); + + case Mode of // MS FindPreviousInstruction + acmCenter : begin +// if ( FindPreviousInstructionCount( Data, Size, 0{CodeOffset}, Offset, Offset, Count div 2 ) = 0 ) then +// Exit; +// if ( FindPreviousInstructionCount( DataCompare, SizeCompare, 0{CodeOffset}, OffsetCompare, OffsetCompare, Count div 2 ) = 0 ) then +// Exit; + end; + acmBackward : begin +// if ( FindPreviousInstructionCount( Data, Size, 0{CodeOffset}, Offset, Offset, Count ) = 0 ) then +// Exit; +// if ( FindPreviousInstructionCount( DataCompare, SizeCompare, 0{CodeOffset}, OffsetCompare, OffsetCompare, Count ) = 0 ) then +// Exit; + end; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + fDecoder.SetData( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data ) + Offset ), Size, CodeOffset ); + Decoder2.SetData( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( DataCompare ) + OffsetCompare ), SizeCompare, CodeOffset ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + while ( Count > 0 ) AND ( fDecoder.CanDecode ) AND ( Decoder2.CanDecode ) do + begin + fDecoder.Decode( Inst1 ); + Decoder2.Decode( Inst2 ); + + if Inst1.IsEqual( Inst2 ) then + Inc( result ); + +// Inc( Data, Inst1.len ); +// Inc( DataCompare, Inst2.len ); +// {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 +// Inc( CodeOffset, Inst1.len ); +// {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Dec( Count ); + end; + Decoder2.free; +end; + +function TIced.Compare( Data : TMemoryStream; Offset : UInt64; DataCompare : TMemoryStream; OffsetCompare : UInt64; Count : Word; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyCompareMode = acmCenter ) : Cardinal; +begin + if ( Data = nil ) OR ( DataCompare = nil ) then + begin + result := 0; + Exit; + end; + + result := Compare( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data.Memory )+Data.Position ), + Data.Size-Data.Position, Offset, + {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( DataCompare.Memory )+DataCompare.Position ), + DataCompare.Size-DataCompare.Position, OffsetCompare, + Count, CodeOffset, Mode ); +end; + +type + TPointerScanData = packed record + Data : PByte; + Size : Cardinal; + Results : PIcedPointerScanResults; + Count : Cardinal; + Upd : Cardinal; + UpdBytes : Cardinal; + done : UInt64; + ProcessEvent : tIcedPointerScanProcessEvent; + Decoder : TIcedDecoder; + Formatter : TIcedFormatter; + end; + PPointerScanData = ^TPointerScanData; + +procedure PointerScanCallback( const Instruction: TInstruction; var Stop : Boolean; UserData : PPointerScanData ); cdecl; +const + BLOCK_SIZE = 100000; +var + Offsets : TConstantOffsets; + i : Integer; + + b : Boolean; + Off : UInt64; + Disp : Int64; +begin + if ( @UserData^.ProcessEvent <> nil ) AND ( UserData^.Upd = 0 ) then + begin + UserData^.ProcessEvent( UserData^.done, UserData^.size, Stop ); + if Stop then + Exit; + UserData^.Upd := UserData^.UpdBytes; + end; + + if Instruction.IsValid then + begin + UserData^.Decoder.GetConstantOffsets( Instruction, Offsets ); + + if ( Offsets.displacement_size > 0 ) OR ( Offsets.immediate_size > 0 ) OR ( Offsets.immediate_size2 > 0 ) then + begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Off := Instruction.next_rip; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + case Offsets.displacement_size of + 1 : Disp := PShortInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.displacement_offset )^; + 2 : Disp := PSmallInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.displacement_offset )^; + 4 : Disp := PInteger( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.displacement_offset )^; + 8 : Disp := PInt64( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.displacement_offset )^; + else + Disp := 0; + end; + + if ( Disp > 0 ) then + Inc( Off, Disp ) + else if ( Disp < 0 ) then + Dec( Off, Abs( Disp ) ); + + case Offsets.immediate_size of + 1 : Disp := PShortInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset )^; + 2 : Disp := PSmallInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset )^; + 4 : Disp := PInteger( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset )^; + 8 : Disp := PInt64( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset )^; + else + Disp := 0; + end; + + if ( Disp > 0 ) then + Inc( Off, Disp ) + else if ( Disp < 0 ) then + Dec( Off, Abs( Disp ) ); + + case Offsets.immediate_size2 of + 1 : Disp := PShortInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset2 )^; + 2 : Disp := PSmallInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset2 )^; + 4 : Disp := PInteger( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset2 )^; + 8 : Disp := PInt64( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset2 )^; + else + Disp := 0; + end; + + if ( Disp > 0 ) then + Inc( Off, Disp ) + else if ( Disp < 0 ) then + Dec( Off, Abs( Disp ) ); + + if ( ABS( Instruction.next_rip-Off ) >= MASKING_OFFSET ) then + begin + // Filter duplicates + b := false; + for i := Low( UserData^.results^ ) to UserData^.Count-1 do // High( Results ) do + begin + if ( UserData^.results^[ i ].vPointer = Off ) then + begin + if ( UserData^.results^[ i ].Count < High( UserData^.results^[ i ].Count ) ) then + Inc( UserData^.results^[ i ].Count ); + b := True; + break; + end; + end; + if NOT b then + begin + if ( UserData^.Count >= Length( UserData^.results^ ) ) then + SetLength( UserData^.results^, Length( UserData^.results^ )+BLOCK_SIZE ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData^.results^[ UserData^.Count ].Origin := Instruction.RIP; + UserData^.results^[ UserData^.Count ].Instruction := string( UserData^.Formatter.FormatToString( Instruction ) ); + UserData^.results^[ UserData^.Count ].vPointer := Off; + UserData^.results^[ UserData^.Count ].Count := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Inc( UserData^.Count ); + end; + end; + end; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData^.done := UserData^.done + Instruction.len; + Inc( UserData^.Data, Instruction.len ); +// Inc( UserData^.CodeOffset, Instruction.len ); + if ( UserData^.Upd > Instruction.len ) then + Dec( UserData^.Upd, Instruction.len ) + else + UserData^.Upd := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TIced.PointerScan( Data : PByte; Size : Cardinal; var results : tIcedPointerScanResults; CodeOffset : UInt64 = UInt64( 0 ); ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; +const + UPDATE_PERCENT = 0.01; +var + UserData : TPointerScanData; +begin + result := 0; + SetLength( results, 0 ); + if ( Data = nil ) then + Exit; + if ( Size = 0 ) then + Exit; + + fDecoder.SetData( Data, Size, CodeOffset ); + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData.done := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + UserData.Data := Data; + UserData.Size := Size; + UserData.Results := @Results; + UserData.Count := 0; + UserData.Upd := 0; + UserData.UpdBytes := Trunc( size * UPDATE_PERCENT ); + UserData.ProcessEvent := ProcessEvent; + UserData.Decoder := fDecoder; + UserData.Formatter := fFormatter; + + fDecoder.DecodeToEnd( @PointerScanCallback, @UserData ); + + result := UserData.Count; + SetLength( results, result ); +end; + +function TIced.PointerScan( Data : TMemoryStream; var results : tIcedPointerScanResults; CodeOffset : UInt64 = UInt64( 0 ); ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; +begin + if ( Data = nil ) then + begin + result := 0; + Exit; + end; + result := PointerScan( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data.Memory )+Data.Position ), Data.Size-Data.Position, Results, CodeOffset, ProcessEvent ); +end; + +type + TReferenceScanData = packed record + Reference : UInt64; + Data : PByte; + Size : Cardinal; + Results : PIcedReferenceScanResults; + Count : Cardinal; + Upd : Cardinal; + UpdBytes : Cardinal; + done : UInt64; + ProcessEvent : tIcedPointerScanProcessEvent; + Decoder : TIcedDecoder; + Formatter : TIcedFormatter; + end; + PReferenceScanData = ^TReferenceScanData; + +procedure ReferenceScanCallback( const Instruction: TInstruction; var Stop : Boolean; UserData : PReferenceScanData ); cdecl; +const + BLOCK_SIZE = 10000; +var + Offsets : TConstantOffsets; + Off : UInt64; + Disp : Int64; +begin + if ( @UserData^.ProcessEvent <> nil ) AND ( UserData^.Upd = 0 ) then + begin + UserData^.ProcessEvent( UserData^.done, UserData^.size, Stop ); + if Stop then + Exit; + UserData^.Upd := UserData^.UpdBytes; + end; + + if Instruction.IsValid then + begin + UserData^.Decoder.GetConstantOffsets( Instruction, Offsets ); + + if ( Offsets.displacement_size > 0 ) OR ( Offsets.immediate_size > 0 ) OR ( Offsets.immediate_size2 > 0 ) then + begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Off := Instruction.next_rip; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + case Offsets.displacement_size of + 1 : Disp := PShortInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.displacement_offset )^; + 2 : Disp := PSmallInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.displacement_offset )^; + 4 : Disp := PInteger( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.displacement_offset )^; + 8 : Disp := PInt64( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.displacement_offset )^; + else + Disp := 0; + end; + + if ( Disp > 0 ) then + Inc( Off, Disp ) + else if ( Disp < 0 ) then + Dec( Off, Abs( Disp ) ); + + case Offsets.immediate_size of + 1 : Disp := PShortInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset )^; + 2 : Disp := PSmallInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset )^; + 4 : Disp := PInteger( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset )^; + 8 : Disp := PInt64( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset )^; + else + Disp := 0; + end; + + if ( Disp > 0 ) then + Inc( Off, Disp ) + else if ( Disp < 0 ) then + Dec( Off, Abs( Disp ) ); + + case Offsets.immediate_size2 of + 1 : Disp := PShortInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset2 )^; + 2 : Disp := PSmallInt( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset2 )^; + 4 : Disp := PInteger( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset2 )^; + 8 : Disp := PInt64( PAnsiChar( UserData^.Data{fDecoder.InstructionFirstByte} ) + Offsets.immediate_offset2 )^; + else + Disp := 0; + end; + + if ( Disp > 0 ) then + Inc( Off, Disp ) + else if ( Disp < 0 ) then + Dec( Off, Abs( Disp ) ); + + if ( UserData^.Reference = Off ) then + begin + if ( UserData^.Count >= Length( UserData^.Results^ ) ) then + SetLength( UserData^.Results^, Length( UserData^.Results^ )+BLOCK_SIZE ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData^.Results^[ UserData^.Count ].Origin := Instruction.RIP; + UserData^.Results^[ UserData^.Count ].Instruction := string( UserData^.Formatter.FormatToString( Instruction ) ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Inc( UserData^.Count ); + end; + end; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData^.done := UserData^.done + Instruction.len; + Inc( UserData^.Data, Instruction.len ); +// Inc( UserData^.CodeOffset, Instruction.len ); + if ( UserData^.Upd > Instruction.len ) then + Dec( UserData^.Upd, Instruction.len ) + else + UserData^.Upd := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TIced.ReferenceScan( Data : PByte; Size : Cardinal; Reference : UInt64; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; +const + UPDATE_PERCENT = 0.25; +var + UserData : TReferenceScanData; +begin + result := 0; + SetLength( results, 0 ); + if ( Data = nil ) then + Exit; + if ( Size = 0 ) then + Exit; + + fDecoder.SetData( Data, Size, CodeOffset ); + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData.Reference := Reference; + UserData.done := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + UserData.Data := Data; + UserData.Size := Size; + UserData.Results := @Results; + UserData.Count := 0; + UserData.Upd := 0; + UserData.UpdBytes := Trunc( size * UPDATE_PERCENT ); + UserData.ProcessEvent := ProcessEvent; + UserData.Decoder := fDecoder; + UserData.Formatter := fFormatter; + + fDecoder.DecodeToEnd( @ReferenceScanCallback, @UserData ); + + result := UserData.Count; + SetLength( results, result ); +end; + +function TIced.ReferenceScan( Data : TMemoryStream; Reference : UInt64; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; +begin + if ( Data = nil ) then + begin + result := 0; + Exit; + end; + result := ReferenceScan( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data.Memory )+Data.Position ), Data.Size-Data.Position, Reference, Results, CodeOffset, ProcessEvent ); +end; + +type + TAssemblyScanFormattedData = packed record + Mode : tIcedAssemblyScanMode; + Assembly : TStringList; + CurCount : Cardinal; + sInstruction : TStringList; + {$IF Declared( RegularExpressions )} + RegEx : TRegEx; + {$IFEND} + Offset : UInt64; + + Size : Cardinal; + Results : PIcedReferenceScanResults; + Count : Cardinal; + Upd : Cardinal; + UpdBytes : Cardinal; + done : UInt64; + ProcessEvent : tIcedPointerScanProcessEvent; + end; + PTAssemblyScanFormattedData = ^TAssemblyScanFormattedData; + +procedure AssemblyScanFormattedCallback( const Instruction: TInstruction; Formatted : PAnsiChar; Size : NativeUInt; var Stop : Boolean; UserData : PTAssemblyScanFormattedData ); cdecl; + function IsWm( Text, MatchText: String; caseSensitive : boolean = false ): Boolean; {$IF CompilerVersion >= 23}inline;{$IFEND} + var + StringPtr: PChar; + PatternPtr: PChar; + StringRes: PChar; + PatternRes: PChar; + tText, + tMatchText : String; + begin + Result := False; + + if ( Text = '' ) or ( MatchText = '' ) then + Exit; + + if ( caseSensitive ) then + begin + tText := Text; + tMatchText := MatchText; + end + else + begin + tText := {$IFDEF STANDALONE}SysUtils.{$ENDIF}UpperCase( Text ); + tMatchText := {$IFDEF STANDALONE}SysUtils.{$ENDIF}UpperCase( MatchText ); + end; + + StringPtr := PChar( tText ); + PatternPtr := PChar( tMatchText ); + StringRes := nil; + PatternRes := nil; + + repeat + repeat + case PatternPtr^ of + #0: + begin + Result := StringPtr^ = #0; + if Result or ( StringRes = nil ) or ( PatternRes = nil ) then + Exit; + + StringPtr := StringRes; + PatternPtr := PatternRes; + Break; + end; + '*': + begin + Inc( PatternPtr ); + PatternRes := PatternPtr; + Break; + end; + '?': + begin + if StringPtr^ = #0 then + Exit; + Inc( StringPtr ); + Inc( PatternPtr ); + end; + else + begin + if StringPtr^ = #0 then + Exit; + if StringPtr^ <> PatternPtr^ then + begin + if ( StringRes = nil ) or ( PatternRes = nil ) then + Exit; + StringPtr := StringRes; + PatternPtr := PatternRes; + Break; + end + else + begin + Inc( StringPtr ); + Inc( PatternPtr ); + end; + end; + end; + until False; + + repeat + case PatternPtr^ of + #0: + begin + Result := True; + Exit; + end; + '*': + begin + Inc( PatternPtr ); + PatternRes := PatternPtr; + end; + '?': + begin + if StringPtr^ = #0 then + Exit; + Inc( StringPtr ); + Inc( PatternPtr ); + end; + else + begin + repeat + if StringPtr^ = #0 then + Exit; + if StringPtr^ = PatternPtr^ then + Break; + Inc( StringPtr ); + until False; + Inc( StringPtr ); + StringRes := StringPtr; + Inc( PatternPtr ); + Break; + end; + end; + until False; + until False; + end; +const + BLOCK_SIZE = 10000; + NOP = 'nop'; +var + b : Boolean; + i, j : Integer; +begin + if ( @UserData^.ProcessEvent <> nil ) AND ( UserData^.Upd = 0 ) then + begin + UserData^.ProcessEvent( UserData^.done, UserData^.size, Stop ); + if Stop then + Exit;; + UserData^.Upd := UserData^.UpdBytes; + end; + + if Instruction.IsValid then + begin + case UserData^.Mode of + asmEqual : b := ( CompareText( UserData^.Assembly[ UserData^.CurCount ], string( Formatted ) ) = 0 ); + asmWildcard : b := IsWm( string( Formatted ), UserData^.Assembly[ UserData^.CurCount ], False ); + {$IF Declared( RegularExpressions )} + asmRegExp : b := UserData^.RegEx.IsMatch( string( Formatted ) ); + {$IFEND} + else + b := False; + end; + + if b then + begin + if ( UserData^.CurCount = 0 ) then + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData^.Offset := Instruction.RIP; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + if ( UserData^.CurCount = UserData^.Assembly.Count-1 ) then + begin + UserData^.sInstruction.Add( string( Formatted ) ); + j := 0; + for i := UserData^.sInstruction.Count-1 downTo 0 do + begin + if ( LowerCase( UserData^.sInstruction[ i ] ) = NOP ) then + begin + UserData^.sInstruction.Delete( i ); + Inc( j ); + end + else + begin + if ( j > 0 ) then + UserData^.sInstruction.Insert( i, NOP + ':' + IntToStr( j ) ); + j := 0; + end; + end; + if ( j > 0 ) then + UserData^.sInstruction.Insert( 0, NOP + ':' + IntToStr( j ) ); + + if ( UserData^.Count >= Length( UserData^.Results^ ) ) then + SetLength( UserData^.Results^, Length( UserData^.Results^ )+BLOCK_SIZE ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData^.Results^[ UserData^.Count ].Origin := UserData^.Offset; + UserData^.Results^[ UserData^.Count ].Instruction := Trim( UserData^.sInstruction.Text ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Inc( UserData^.Count ); + + UserData^.CurCount := 0; + UserData^.sInstruction.Clear; + end + else + begin + Inc( UserData^.CurCount ); + UserData^.sInstruction.Add( string( Formatted ) ); + end; + end + else + begin + UserData^.CurCount := 0; + UserData^.sInstruction.Clear; + end; + + {$IF Declared( RegularExpressions )} + if UserData^.Mode = asmRegExp then + UserData^.RegEx := TRegEx.Create( UserData^.Assembly[ UserData^.CurCount ] ); + {$IFEND Declared( RegularExpressions )} + end + else + begin + UserData^.CurCount := 0; + UserData^.sInstruction.Clear; + {$IF Declared( RegularExpressions )} + if UserData^.Mode = asmRegExp then + UserData^.RegEx := TRegEx.Create( UserData^.Assembly[ UserData^.CurCount ] ); + {$IFEND Declared( RegularExpressions )} + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData^.done := UserData^.done + Instruction.len; +// Inc( UserData^.Data, Instruction.len ); +// Inc( UserData^.CodeOffset, Instruction.len ); + if ( UserData^.Upd > Instruction.len ) then + Dec( UserData^.Upd, Instruction.len ) + else + UserData^.Upd := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TIced.AssemblyScan( Data : PByte; Size : Cardinal; Assembly : String; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; +const + UPDATE_PERCENT = 0.25; + NOP = 'nop'; +var + i, j : Integer; + S, ts : string; + UserData : TAssemblyScanFormattedData; +begin + result := 0; + SetLength( results, 0 ); + if ( Data = nil ) then + Exit; + if ( Size = 0 ) then + Exit; + if ( Assembly = '' ) then + Exit; + if ( Mode = asmSimiliar ) then + Exit; + + UserData.Assembly := TStringList.Create; + UserData.Assembly.Text := LowerCase( Trim( Assembly ) ); + + for i := UserData.Assembly.Count-1 downTo 0 do + begin + S := Trim( UserData.Assembly[ i ] ); + S := StringReplace( S, #9, ' ', [ rfReplaceAll ] ); + if ( S = '' ) then + UserData.Assembly.Delete( i ) + else if ( Copy( S, 1, 4 ) = NOP + ':' ) then + begin + j := StrToIntDef( Copy( S, 5, Length( S )-4 ), 1); + while ( j > 1 ) do + begin + UserData.Assembly.Insert( i+1, NOP ); + Dec( j ); + end; + UserData.Assembly[ i ] := NOP; + end + else + begin + tS := ''; + while ( tS <> S ) do + begin + tS := S; + S := StringReplace( S, ' ', ' ', [ rfReplaceAll ] ); + end; + + {$IF Declared( asmRegExp )} + if ( Mode <> asmRegExp ) then + {$IFEND} + begin + if fFormatter.fOptions.SpaceAfterOperandSeparator then + S := StringReplace( S, ',', ', ', [ rfReplaceAll ] ) + else + S := StringReplace( S, ', ', ',', [ rfReplaceAll ] ); + + if fFormatter.fOptions.SpaceAfterMemoryBracket then + begin + S := StringReplace( S, '[', '[ ', [ rfReplaceAll ] ); + S := StringReplace( S, ']', ' ]', [ rfReplaceAll ] ); + end + else + begin + S := StringReplace( S, '[ ', '[', [ rfReplaceAll ] ); + S := StringReplace( S, ' ]', ']', [ rfReplaceAll ] ); + end; + + if fFormatter.fOptions.SpaceBetweenMemoryAddOperators then + begin + S := StringReplace( S, '+', ' + ', [ rfReplaceAll ] ); + S := StringReplace( S, '-', ' - ', [ rfReplaceAll ] ); + end + else + begin + S := StringReplace( S, ' +', '+', [ rfReplaceAll ] ); + S := StringReplace( S, '+ ', '+', [ rfReplaceAll ] ); + S := StringReplace( S, ' -', '-', [ rfReplaceAll ] ); + S := StringReplace( S, '- ', '-', [ rfReplaceAll ] ); + end; + end; + + if ( Mode = asmEqual ) then + begin + if fFormatter.fOptions.SpaceBetweenMemoryMulOperators then + S := StringReplace( S, '*', ' * ', [ rfReplaceAll ] ) + else + begin + S := StringReplace( S, ' *', '*', [ rfReplaceAll ] ); + S := StringReplace( S, '* ', '*', [ rfReplaceAll ] ); + end; + end; + + S := StringReplace( S, ' ,', ',', [ rfReplaceAll ] ); + tS := ''; + while ( tS <> S ) do + begin + tS := S; + S := StringReplace( S, ' ', ' ', [ rfReplaceAll ] ); + end; + UserData.Assembly[ i ] := S; + end; + end; + + fDecoder.SetData( Data, Size, CodeOffset ); + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData.done := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + UserData.Size := Size; + UserData.Results := @Results; + UserData.Count := 0; + UserData.Upd := 0; + UserData.UpdBytes := Trunc( size * UPDATE_PERCENT ); + UserData.ProcessEvent := ProcessEvent; + UserData.Mode := Mode; + UserData.CurCount := 0; + UserData.sInstruction := TStringList.Create; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData.Offset := CodeOffset; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + {$IF Declared( RegularExpressions )} + if Mode = asmRegExp then + UserData.RegEx := TRegEx.Create( UserData.Assembly[ 0 ] ); + {$IFEND} + + DecodeFormatToEnd( @AssemblyScanFormattedCallback, @UserData ); + + UserData.Assembly.free; + UserData.sInstruction.Free; + + result := UserData.Count; + SetLength( results, result ); +end; + +function TIced.AssemblyScan( Data : TMemoryStream; Assembly : String; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; +begin + if ( Data = nil ) then + begin + result := 0; + Exit; + end; + result := AssemblyScan( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data.Memory )+Data.Position ), Data.Size-Data.Position, Assembly, Results, CodeOffset, Mode, ProcessEvent ); +end; + +type + TInstructionArrayStatic = Array [ 0..0 ] of TInstruction; + PInstructionArrayStatic = ^TInstructionArrayStatic; + + TAssemblyScanData = packed record + Mode : tIcedAssemblyScanMode; + Assembly : PInstructionArrayStatic; + AssemblyCount : Cardinal; + sInstruction : String; + CurCount : Integer; + Offset : UInt64; + + Size : Cardinal; + Results : PIcedReferenceScanResults; + Count : Cardinal; + Upd : Cardinal; + UpdBytes : Cardinal; + done : UInt64; + ProcessEvent : tIcedPointerScanProcessEvent; + Formatter : TIcedFormatter; + end; + PAssemblyScanData = ^TAssemblyScanData; + +procedure AssemblyScanCallback( const Instruction: TInstruction; var Stop : Boolean; UserData : PAssemblyScanData ); cdecl; +const + BLOCK_SIZE = 100000; +var + b : Boolean; +begin + if ( @UserData^.ProcessEvent <> nil ) AND ( UserData^.Upd = 0 ) then + begin + UserData^.ProcessEvent( UserData^.done, UserData^.size, Stop ); + if Stop then + Exit; + UserData^.Upd := UserData^.UpdBytes; + end; + + if Instruction.IsValid then + begin + case UserData^.Mode of + asmEqual : b := Instruction.IsEqual( {$R-}UserData^.Assembly^[ UserData^.CurCount ]{$R+} ); + asmSimiliar : b := Instruction.IsSimiliar( {$R-}UserData^.Assembly^[ UserData^.CurCount ]{$R+} ); + else + b := False; + end; + + if b then + begin + if ( UserData^.CurCount = 0 ) then + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData^.Offset := Instruction.RIP; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData^.sInstruction := UserData^.sInstruction + string( UserData^.Formatter.FormatToString( Instruction ) ) + #13#10; + Inc( UserData^.CurCount ); + + if ( UserData^.CurCount >= UserData^.AssemblyCount ) then + begin + if ( UserData^.Count >= Length( UserData^.Results^ ) ) then + SetLength( UserData^.Results^, Length( UserData^.Results^ )+BLOCK_SIZE ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData^.Results^[ UserData^.Count ].Origin := UserData^.Offset; + UserData^.Results^[ UserData^.Count ].Instruction := Copy( UserData^.sInstruction, 1, Length( UserData^.sInstruction )-2 ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Inc( UserData^.Count ); + + UserData^.CurCount := 0; + UserData^.sInstruction := ''; + end; + end + else + begin + UserData^.CurCount := 0; + UserData^.sInstruction := ''; + end; + end; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData^.done := UserData^.done + Instruction.len; +// Inc( UserData^.Data, Instruction.len ); +// Inc( UserData^.CodeOffset, Instruction.len ); + if ( UserData^.Upd > Instruction.len ) then + Dec( UserData^.Upd, Instruction.len ) + else + UserData^.Upd := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TIced.AssemblyScan( Data : PByte; Size : Cardinal; Assembly : PInstruction; AssemblyCount : Cardinal; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; +const + UPDATE_PERCENT = 0.25; +var + UserData : TAssemblyScanData; +begin + result := 0; + SetLength( results, 0 ); + if ( Data = nil ) then + Exit; + if ( Size = 0 ) then + Exit; + if ( Assembly = nil ) OR ( AssemblyCount = 0 ) then + Exit; + if NOT ( Mode in [ asmEqual, asmSimiliar ] ) then + Exit; + + fDecoder.SetData( Data, Size, CodeOffset ); + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData.done := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + UserData.Size := Size; + UserData.Results := @Results; + UserData.Count := 0; + UserData.Upd := 0; + UserData.UpdBytes := Trunc( size * UPDATE_PERCENT ); + UserData.ProcessEvent := ProcessEvent; + UserData.Formatter := fFormatter; + UserData.Mode := Mode; + UserData.Assembly := PInstructionArrayStatic( Assembly ); + UserData.AssemblyCount := AssemblyCount; + UserData.sInstruction := ''; + UserData.CurCount := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + UserData.Offset := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + fDecoder.DecodeToEnd( @AssemblyScanCallback, @UserData ); + + result := UserData.Count; + SetLength( results, result ); +end; + +function TIced.AssemblyScan( Data : TMemoryStream; Assembly : PInstruction; AssemblyCount : Cardinal; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; +begin + if ( Data = nil ) then + begin + result := 0; + Exit; + end; + result := AssemblyScan( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data.Memory )+Data.Position ), Data.Size-Data.Position, Assembly, AssemblyCount, Results, CodeOffset, Mode, ProcessEvent ); +end; + +function TIced.AssemblyScan( Data : PByte; Size : Cardinal; var Assembly : TInstructionArray; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; +begin + if ( Length( Assembly ) = 0 ) then + begin + result := 0; + Exit; + end; + result := AssemblyScan( Data, Size, @Assembly[ 0 ], Length( Assembly ), Results, CodeOffset, Mode, ProcessEvent ); +end; + +function TIced.AssemblyScan( Data : TMemoryStream; var Assembly : TInstructionArray; var results : tIcedReferenceScanResults; CodeOffset : UInt64 = UInt64( 0 ); Mode : tIcedAssemblyScanMode = asmEqual; ProcessEvent : tIcedPointerScanProcessEvent = nil ) : Cardinal; +begin + if ( Data = nil ) OR ( Length( Assembly ) = 0 ) then + begin + result := 0; + Exit; + end; + result := AssemblyScan( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data.Memory )+Data.Position ), Data.Size-Data.Position, @Assembly[ 0 ], Length( Assembly ), Results, CodeOffset, Mode, ProcessEvent ); +end; + +function TIced.FindInstruction( Data : PByte; Size : Cardinal; Offset : UInt64; CodeOffset : UInt64 = UInt64( 0 ); {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; +const + BLOCKSIZE = 20; +var + Instruction : TInstruction; + i : Cardinal; +begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := 0; + if ( self = nil ) then + Exit; + if ( Data = nil ) OR ( Size = 0 ) then + Exit; + + if ( Offset > CodeOffset+Size ) then + Exit; + + if ( CodeOffset > Offset ) then + Exit; + + Offset := Offset-CodeOffset; + if ( Offset > BLOCKSIZE ) then + begin + i := Offset-BLOCKSIZE; + Inc( Data, i ); + end + else + i := 0; + + fDecoder.SetData( Data, Size-i, {CodeOffset+}i, DecoderSettings ); + {$IFDEF AssemblyTools} + if ( Details <> nil ) then + begin + while fDecoder.CanDecode do + begin + fDecoder.Decode( Instruction, Details^ ); + if ( Instruction.next_rip >= Offset ) then + begin + result := Instruction.next_rip; + Break; + end; + end; + end + else + {$ENDIF AssemblyTools} + begin + while fDecoder.CanDecode do + begin + fDecoder.Decode( Instruction ); + if ( Instruction.next_rip >= Offset ) then + begin + result := Instruction.next_rip; + Break; + end; + end; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TIced.FindInstruction( Data : TMemoryStream; Offset : UInt64; CodeOffset : UInt64 = UInt64( 0 ); {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; +begin + if ( Data = nil ) then + begin + result := 0; + Exit; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := FindInstruction( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data.Memory )+Data.Position ), Data.Size-Data.Position, Offset, CodeOffset, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TIced.FindNextInstruction( Data : TMemoryStream; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; InstructionCount : Word = 1; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; +begin + if ( Data = nil ) then + begin + result := 0; + Exit; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := FindNextInstruction( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data.Memory )+Data.Position ), Data.Size-Data.Position, Address, Offset, CodeOffset, InstructionCount, InstructionBytes, Instruction, {$IFDEF AssemblyTools}Details,{$ENDIF} DecoderSettings ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +end; + +function TIced.FindNextInstruction( Data : PByte; Size : Cardinal; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; InstructionCount : Word = 1; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; {$IFDEF AssemblyTools}Details : pIcedDetails = nil;{$ENDIF} DecoderSettings : Cardinal = doNONE ) : Cardinal; +var + Inst : TInstruction; +begin + result := 0; + if ( self = nil ) then + Exit; + + if ( Data = nil ) OR ( Size = 0 ) then + Exit; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( Address > CodeOffset+Size ) then + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Exit; + + if ( CodeOffset > Address ) then + Exit; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + fDecoder.SetData( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data ) + CodeOffset ), Size-CodeOffset, 0{Address}, DecoderSettings ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + Inc( InstructionCount ); + {$IFDEF AssemblyTools} + if ( Details <> nil ) then + begin + while fDecoder.CanDecode AND ( InstructionCount > 0 ) do + begin + fDecoder.Decode( Inst, Details^ ); + Dec( InstructionCount ); + end; + end + else + {$ENDIF AssemblyTools} + begin + while fDecoder.CanDecode AND ( InstructionCount > 0 ) do + begin + fDecoder.Decode( Inst ); + Dec( InstructionCount ); + end; + end; + + if ( InstructionCount = 0 ) then + begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Offset := Inst.RIP+Address; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := Inst.len; + + if ( InstructionBytes <> nil ) then + Move( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Data ) + result )^, InstructionBytes^[ 0 ], Inst.len ); + if ( Instruction <> nil ) then + Instruction^ := string( Formatter.FormatToString( Inst ) ); + end; +end; + +(* +function TIced.FindPreviousInstructionCount( Code : TMemoryStream; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; InstructionCount : Word = 1; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; Detail : px86AssemblyDetail = nil ) : Cardinal; +begin + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Offset := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( InstructionBytes <> nil ) then + FillChar( InstructionBytes^, SizeOf( InstructionBytes^ ), 0 ); + if ( Instruction <> nil ) then + Instruction^ := ''; + if ( Detail <> nil ) then + FillChar( Detail^, SizeOf( Detail^ ), 0 ); + if ( self = nil ) then + Exit; + if ( Code = nil ) then + Exit; + result := FindPreviousInstructionCount( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Code.Memory )+Code.Position ), Code.Size-Code.Position, CodeOffset, Address, Offset, InstructionCount, InstructionBytes, Instruction, Detail ); +end; + +function TIced.FindPreviousInstructionCount( Code : PByte; Size : Cardinal; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; InstructionCount : Word = 1; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; Detail : px86AssemblyDetail = nil ) : Cardinal; +var + i, j : Integer; + StrL_Out : TStringList; + CurInst : String; + tDetails : tx86AssemblyDetails; + B : PByte; +begin + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Offset := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( InstructionBytes <> nil ) then + FillChar( InstructionBytes^, SizeOf( InstructionBytes^ ), 0 ); + if ( Instruction <> nil ) then + Instruction^ := ''; + if ( Detail <> nil ) then + FillChar( Detail^, SizeOf( Detail^ ), 0 ); + if ( self = nil ) then + Exit; + if ( Code = nil ) then + Exit; + if ( InstructionCount = 0 ) then + Exit; + if ( Size < ( InstructionCount+1 )*MAX_INSTRUCTION_LEN_ ) then + Exit; + + StrL_Out := TStringList.Create; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( Execute( Pointer( {$IF CompilerVersion < 23}PAnsiChar{$ELSE}PByte{$IFEND}( Code ) + CodeOffset ), MAX_INSTRUCTION_LEN_, StrL_Out, Address, nil, nil ) > 0 ) then + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + CurInst := StrL_Out[ 0 ] + else + begin + StrL_Out.Free; + Exit; + end; + + Code := Pointer( {$IF CompilerVersion < 23}PAnsiChar{$ELSE}PByte{$IFEND}( Code ) + CodeOffset - InstructionCount*MAX_INSTRUCTION_LEN_ ); + for i := 0 to MAX_INSTRUCTION_LEN_-1 do + begin + if ( result > 0 ) then + Break; + StrL_Out.Clear; + FillChar( tDetails, SizeOf( tDetails ), 0 ); + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( Execute( Code, ( InstructionCount+1 )*MAX_INSTRUCTION_LEN_, StrL_Out, Address-( Cardinal( InstructionCount*MAX_INSTRUCTION_LEN_-i ) ), nil, @tDetails ) > 0 ) then + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + begin + for j := InstructionCount to StrL_Out.Count-1 do + begin + if ( tDetails.Items[ j ].Offset = Address ) AND ( StrL_Out[ j ] = CurInst ) AND ( StrL_Out[ j-InstructionCount ] <> 'INVALID' ) then + begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Offset := tDetails.Items[ j-InstructionCount ].Offset; + result := tDetails.Items[ j ].Offset; + result := result-Offset; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( InstructionBytes <> nil ) then + begin + B := Code; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Inc( B, Offset - Address ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + CopyMemory( InstructionBytes, B, tDetails.Items[ j-InstructionCount ].Size ); + end; + if ( Instruction <> nil ) then + Instruction^ := StrL_Out[ j-InstructionCount ]; + if ( Detail <> nil ) then + CopyMemory( Detail, @tDetails.Items[ j-InstructionCount ], SizeOf( tx86AssemblyDetail ) ); + Break; + end; + end; + end; + Inc( Code ); + end; + SetLength( tDetails.Items, 0 ); + SetLength( tDetails.JumpTargets, 0 ); + StrL_Out.free; +end; + +function TIced.FindPreviousInstruction( Code : TMemoryStream; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; DesiredInstructionOffset : UInt64; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; Detail : pIcedDetail = nil ) : Cardinal; +begin + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Offset := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( InstructionBytes <> nil ) then + FillChar( InstructionBytes^, SizeOf( InstructionBytes^ ), 0 ); + if ( Instruction <> nil ) then + Instruction^ := ''; + if ( Detail <> nil ) then + FillChar( Detail^, SizeOf( Detail^ ), 0 ); + if ( self = nil ) then + Exit; + if ( Code = nil ) then + Exit; + result := FindPreviousInstruction( {$IF CompilerVersion < 23}PByte( PAnsiChar{$ELSE}( PByte{$IFEND}( Code.Memory )+Code.Position ), Code.Size-Code.Position, CodeOffset, Address, Offset, DesiredInstructionOffset, InstructionBytes, Instruction, Detail ); +end; + +function TIced.FindPreviousInstruction( Code : PByte; Size : Cardinal; CodeOffset : UInt64; Address : UInt64; var Offset : UInt64; DesiredInstructionOffset : UInt64; InstructionBytes : pByteInstruction = nil; Instruction : PString = nil; Detail : pIcedDetail = nil ) : Cardinal; +var + i, j, k : Integer; + StrL_Out : TStringList; + CurInst : String; + tDetails : TIcedDetails; + bOK : Boolean; +begin + result := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Offset := 0; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( InstructionBytes <> nil ) then + FillChar( InstructionBytes^, SizeOf( InstructionBytes^ ), 0 ); + if ( Instruction <> nil ) then + Instruction^ := ''; + if ( Detail <> nil ) then + FillChar( Detail^, SizeOf( Detail^ ), 0 ); + if ( self = nil ) then + Exit; + if ( Code = nil ) then + Exit; +// if ( Size < ( InstructionCount+1 )*MAX_INSTRUCTION_LEN_ ) then +// Exit; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( CodeOffset < MAX_INSTRUCTION_LEN_ ) then + Exit; + if ( DesiredInstructionOffset >= Address ) OR ( DesiredInstructionOffset-MAX_INSTRUCTION_LEN_ < Address-CodeOffset ) then + Exit; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + StrL_Out := TStringList.Create; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( Execute( Pointer( {$IF CompilerVersion < 23}PAnsiChar{$ELSE}PByte{$IFEND}( Code ) + CodeOffset ), MAX_INSTRUCTION_LEN_, StrL_Out, Address, nil, nil ) > 0 ) then + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + CurInst := StrL_Out[ 0 ] + else + begin + StrL_Out.Free; + Exit; + end; + + k := DesiredInstructionOffset-( Address-CodeOffset )-MAX_INSTRUCTION_LEN_; + for i := k to k+MAX_INSTRUCTION_LEN_-1 do + begin + StrL_Out.Clear; + SetLength( tDetails.Items, 0 ); + SetLength( tDetails.JumpTargets, 0 ); + FillChar( tDetails, SizeOf( tDetails ), 0 ); + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( Execute( Pointer( {$IF CompilerVersion < 23}PAnsiChar{$ELSE}PByte{$IFEND}( Code ) + i ), Address-DesiredInstructionOffset+MAX_INSTRUCTION_LEN_, StrL_Out, Address-CodeOffset+Cardinal( i ), nil, @tDetails ) > 0 ) then + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + begin + bOK := False; + k := StrL_Out.Count; + for j := 0 to StrL_Out.Count-1 do + begin + if ( j > 0 ) AND ( StrL_Out[ j ] = 'INVALID' ) then + begin + bOK := False; + Break; + end + else if ( j > 0 ) AND ( tDetails.Items[ j ].Offset = Address ) AND ( StrL_Out[ j ] = CurInst ) AND ( StrL_Out[ j-1 ] <> 'INVALID' ) then + begin + bOK := True; + k := j; + Break; + end; + end; + if NOT bOK then + Continue; + + for j := k downTo 1 do + begin + if ( DesiredInstructionOffset > tDetails.Items[ j ].Offset ) then + Continue; + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + if ( Offset = 0 ) OR ( ABS( tDetails.Items[ j ].Offset - DesiredInstructionOffset ) < ABS( Offset-DesiredInstructionOffset ) ) then + begin + Offset := tDetails.Items[ j ].Offset; + result := Address-Offset; + k := j; + end; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + end; + + if ( InstructionBytes <> nil ) then + CopyMemory( InstructionBytes, Pointer( {$IF CompilerVersion < 23}PAnsiChar{$ELSE}PByte{$IFEND}( Code ) + CodeOffset - result ), tDetails.Items[ k ].Size ); + + if ( Instruction <> nil ) then + Instruction^ := StrL_Out[ k ]; + if ( Detail <> nil ) then + CopyMemory( Detail, @tDetails.Items[ k ], SizeOf( TIcedDetail ) ); + Break; + end; + end; + + SetLength( tDetails.Items, 0 ); + SetLength( tDetails.JumpTargets, 0 ); + StrL_Out.free; +end; +*) + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +{$IFDEF TEST_FUNCTIONS} +{ + i9, Delphi 7 + 193mb without Formatting in: 0.8066524 seconds (239.260mb/s) + 193mb with Masm in: 4.3577244 seconds (44.289mb/s) + 193mb with Specialized in: 1.5322712 seconds (125.95mb/s) + + i9, Delphi 10.3 + 193mb without Formatting in: 0.8023189 seconds (240.552mb/s) + 193mb with Masm in: 4.3152221 seconds (44.725mb/s) + 193mb with Specialized in: 1.5449057 seconds (124.926mb/s) +} + +procedure Benchmark_DecoderCallback( const Instruction: TInstruction; var Stop : Boolean; UserData : Pointer ); cdecl; +begin + +end; + +procedure Benchmark_DecoderFormatCallback( const Instruction: TInstruction; Formatted : PAnsiChar; Size : NativeUInt; var Stop : Boolean; UserData : Pointer ); cdecl; +begin + +end; + +function Benchmark( Data : PByte; Size : Cardinal; Bitness : TIcedBitness; AFormat : Boolean = False ) : Double; +var + f, t1, t2 : Int64; +// Instruction : TInstruction; +// tOutput : PAnsiChar; +begin + Iced.Decoder.Bitness := Bitness; + Iced.Decoder.SetData( Data, Size ); + + if AFormat then + begin + Iced.Formatter.FormatterType := ftSpecialized; + Iced.Formatter.VerifyOutputHasEnoughBytesLeft := False; + QueryPerformanceCounter( t1 ); +// while Iced.Decoder.CanDecode do +// begin +// Iced.Decoder.Decode( Instruction ); +// Iced.Formatter.Format( Instruction, tOutput ); + +// Iced.DecodeFormat( Instruction, tOutput ); +// end; + + Iced.DecodeFormatToEnd( Benchmark_DecoderFormatCallback ); + QueryPerformanceCounter( t2 ); + end + else + begin + QueryPerformanceCounter( t1 ); +// while Iced.Decoder.CanDecode do +// Iced.Decoder.Decode( Instruction ); + + Iced.Decoder.DecodeToEnd( Benchmark_DecoderCallback ); + QueryPerformanceCounter( t2 ); + end; + + QueryPerformanceFrequency( f ); + result := ( t2-t1 ) / f; // * 1000; +end; + +function Benchmark( FileName : String; Bitness : TIcedBitness; AFormat : Boolean = False ) : Double; +var + ms : TMemoryStream; +begin + if NOT FileExists( FileName ) then + begin + result := 0; + Exit; + end; + + ms := TMemoryStream.Create; + ms.LoadFromFile( FileName ); + Result := Benchmark( ms.Memory, ms.Size, Bitness, AFormat ); + ms.Free; +end; + +function Test( StrL : TStringList ) : Boolean; +begin + if ( StrL <> nil ) then + begin + StrL.Clear; + StrL.Add( 'Disassemble' ); + StrL.Add( '---' ); + end; + result := Test_Decode( + @EXAMPLE_CODE, Length( EXAMPLE_CODE ), EXAMPLE_RIP, + + StrL, + ftMasm{FormatterType}, + + nil{SymbolResolverCallback}, +// SymbolResolverCallback{SymbolResolverCallback}, + nil{FormatterOptionsProviderCallback}, +// FormatterOptionsProviderCallback{FormatterOptionsProviderCallback}, + nil{FormatterOutputCallback}, +// FormatterOutputCallback{FormatterOutputCallback}, + +// False{Assembly}, + True{Assembly}, + + False{DecodeInfo}, +// True{DecodeInfo}, + + False{Info} +// True{Info} + ); + + if ( StrL <> nil ) then + begin + StrL.Add( '' ); + StrL.Add( 'Re-Assemble' ); + StrL.Add( '---' ); + end; + result := result AND Test_ReEncode( + @EXAMPLE_CODE, Length( EXAMPLE_CODE ), EXAMPLE_RIP, + +// True{LocalBuffer}, +// False{LocalBuffer}, + +// True{BlockEncode}, + False{BlockEncode}, + StrL + ); + + if ( StrL <> nil ) then + begin + StrL.Add( '' ); + StrL.Add( 'Assemble' ); + StrL.Add( '---' ); + end; + Test_Assemble( StrL ); +end; + +const + HEXBYTES_COLUMN_BYTE_LENGTH = 16; // 30; + +function Test_Decode( Data : PByte; Size : Cardinal; ARIP : UInt64; AOutput : TStringList; FormatterType : TIcedFormatterType = ftMasm; + SymbolResolver : TSymbolResolverCallback = nil; + FormatterOptionsProviderCallback : TFormatterOptionsProviderCallback = nil; + FormatterOutputCallback : TFormatterOutputCallback = nil; + Assembly : Boolean = True; DecodeInfos : Boolean = True; Infos : Boolean = True ) : Boolean; +var + Instruction : TInstruction; + Offsets : TConstantOffsets; + FPU_Info : TFpuStackIncrementInfo; + CPUIDFeatures : TCPUIDFeaturesArray; + OPKinds : TOPKindsArray; + Encoding : TEncodingKind; + Mnemonic : TMnemonic; + FlowControl : TFlowControl; + OPKind : TOPCodeOperandKind; + MemorySize : TMemorySize; +// OPKinds_ : TOPCodeOperandKindArray; + Info : TInstructionInfo; + CC : TConditionCode; + RFlags : TRFlags; + tOutput : PAnsiChar; + + S : String; + C : UInt64; + i : Integer; +begin + result := False; + if ( AOutput = nil ) then + Exit; + AOutput.Clear; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( Data, Size, ARIP, doNONE ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Formatter.FormatterType := FormatterType; + Iced.Formatter.SymbolResolver := SymbolResolver; + Iced.Formatter.OptionsProvider := FormatterOptionsProviderCallback; + Iced.Formatter.Callback := FormatterOutputCallback; + + while Iced.Decoder.CanDecode do + begin + if Assembly then + begin + if ( @FormatterOutputCallback <> nil ) then + Iced.DecodeFormat( Instruction ) + else + Iced.DecodeFormat( Instruction, tOutput ); + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + C := Instruction.next_rip-Instruction.len; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + S := Format( '%.16x ', [ C ] ); + + for i := 0 to Instruction.len-1 do + begin + S := S + Format( '%.2x', [ Data^ ] ); + Inc( Data ); + end; + + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len*2+1 do + S := S + ' '; + + AOutput.Add( S + string( tOutput ) ); + end + else + Iced.Decoder.Decode( Instruction ); + + if DecodeInfos then + begin + // Gets offsets in the instruction of the displacement and immediates and their sizes. + // This can be useful if there are relocations in the binary. The encoder has a similar + // method. This method must be called after decode() and you must pass in the last + // instruction decode() returned. + Iced.Decoder.GetConstantOffsets( Instruction, Offsets ); + +// FillChar( OPKinds_, SizeOf( OPKinds_ ), 0 ); +// Instruction.OpCodeInfo_OPKinds( OPKinds_ ); + + if Infos then + begin + AOutput.Add( ' OpCode: ' + Instruction.OpCodeString ); + AOutput.Add( ' Instruction: ' + Instruction.InstructionString ); + + Encoding := Instruction.Encoding; + AOutput.Add( ' Encoding: ' + Encoding.AsString ); + + Mnemonic := Instruction.Mnemonic; + AOutput.Add( ' Mnemonic: ' + Mnemonic.AsString ); + AOutput.Add( ' Code: ' + Instruction.code.AsString ); + end; + + CPUIDFeatures := Instruction.CPUIDFeatures; + if Infos then + begin + S := ''; + for i := 0 to CPUIDFeatures.Count-1 do + begin + if ( i > 0 ) then + S := S + 'AND ' + CPUIDFeatures.Entries[ i ].AsString + else + S := CPUIDFeatures.Entries[ i ].AsString; + end; + AOutput.Add( ' CpuidFeature: ' + S ); + + FlowControl := Instruction.FlowControl; + AOutput.Add( ' FlowControl: ' + FlowControl.AsString ); + end; + + FPU_Info := Instruction.FPU_StackIncrementInfo; + if Infos then + begin + if FPU_Info.writes_top then + begin + if ( FPU_Info.increment = 0 ) then + AOutput.Add( ' FPU TOP: the instruction overwrites TOP' ) + else + AOutput.Add( Format( ' FPU TOP inc: %d', [ FPU_Info.increment ] ) ); + + if FPU_Info.conditional then + AOutput.Add( ' FPU TOP cond write: true' ) + else + AOutput.Add( ' FPU TOP cond write: false' ); + end; + + if ( Offsets.displacement_size <> 0 ) then + AOutput.Add( Format( ' Displacement offset = %d, size = %d', [ Offsets.displacement_offset, Offsets.displacement_size ] ) ); + if ( Offsets.immediate_size <> 0 ) then + AOutput.Add( Format( ' Immediate offset = %d, size = %d', [ Offsets.immediate_offset, Offsets.immediate_size ] ) ); + if ( Offsets.immediate_size2 <> 0 ) then + AOutput.Add( Format( ' Immediate #2 offset = %d, size = %d', [ Offsets.immediate_offset2, Offsets.immediate_size2 ] ) ); + + if Instruction.IsStackInstruction then + AOutput.Add( Format( ' SP Increment: %d', [ Instruction.StackPointerIncrement ] ) ); + end; + + CC := Instruction.ConditionCode; + RFlags := Instruction.RFlags; + if Infos then + begin + if ( CC.ConditionCode <> cc_None ) then + AOutput.Add( Format( ' Condition code: %s', [ CC.AsString ] ) ); + + if ( NOT RFlags.Read.IsNone ) OR ( NOT RFlags.Written.IsNone ) OR ( NOT RFlags.Cleared.IsNone ) OR ( NOT RFlags.Set_.IsNone ) OR ( NOT RFlags.Undefined.IsNone ) OR ( NOT RFlags.Modified.IsNone ) then + begin + if ( NOT RFlags.Read.IsNone ) then + AOutput.Add( ' RFLAGS Read: ' + RFlags.Read.AsString ); + if ( NOT RFlags.Written.IsNone ) then + AOutput.Add( ' RFLAGS Written: ' + RFlags.Written.AsString ); + if ( NOT RFlags.Cleared.IsNone ) then + AOutput.Add( ' RFLAGS Cleared: ' + RFlags.Cleared.AsString ); + if ( NOT RFlags.Set_.IsNone ) then + AOutput.Add( ' RFLAGS Set: ' + RFlags.Set_.AsString ); + if ( NOT RFlags.Undefined.IsNone ) then + AOutput.Add( ' RFLAGS Undefined: ' + RFlags.Undefined.AsString ); + if ( NOT RFlags.Modified.IsNone ) then + AOutput.Add( ' RFLAGS Modified: ' + RFlags.Modified.AsString ); + end; + end; + + FillChar( OPKinds, SizeOf( OPKinds ), 0 ); + Instruction.OPKinds( OPKinds ); + if Infos then + begin + for i := 0 to OPKinds.Count-1 do + begin + if ( OPKinds.Entries[ i ].OpKind = okMemory ) then + begin + MemorySize := Instruction.MemorySize; + if ( MemorySize.Size <> 0 ) then + AOutput.Add( ' Memory Size: ' + IntToStr( MemorySize.Size ) ); + break; + end; + end; + end; + + Iced.InfoFactory.Info( Instruction, Info ); + if Infos then + begin + for i := 0 to Instruction.OPCount-1 do + AOutput.Add( Format( ' Op%dAccess: %s', [ i, Info.op_accesses[ i ].AsString ] ) ); + + for i := 0 to Instruction.OpCodeInfo.OPCount-1 do + begin + OPKind := Instruction.OpCodeInfo.op_kinds[ i ]; + AOutput.Add( Format( ' Op%d: %s', [ i, OPKind.AsString ] ) ); + end; + + for i := 0 to Info.used_registers.Count-1 do + AOutput.Add( Format( ' Used reg: %s:%s', [ Info.used_registers.Entries[ i ].register_.AsString, Info.used_registers.Entries[ i ].access.AsString ] ) ); + + for i := 0 to Info.used_memory_locations.Count-1 do + AOutput.Add( Format( ' Used mem: %s:%s+0x%.2x:%s:%d:%s:%s:%s:%d', [ + Info.used_memory_locations.Entries[ i ].segment.AsString, + Info.used_memory_locations.Entries[ i ].base.AsString, + Info.used_memory_locations.Entries[ i ].displacement, + Info.used_memory_locations.Entries[ i ].index.AsString, + Info.used_memory_locations.Entries[ i ].scale, + Info.used_memory_locations.Entries[ i ].memory_size.AsString, + Info.used_memory_locations.Entries[ i ].access.AsString, + Info.used_memory_locations.Entries[ i ].address_size.AsString, + Info.used_memory_locations.Entries[ i ].vsib_size + ] ) ); + end; + end; + end; +// Iced.Decoder.SetIP( Decoder, EXAMPLE_RIP ); +// Iced.Decoder.SetPosition( Decoder, 0 ); + + result := True; +end; + +function Test_ReEncode( Data : PByte; Size : Cardinal; ARIP : UInt64; {LocalBuffer : Boolean = False;} BlockEncode : Boolean = False; AOutput : TStringList = nil ) : Boolean; +var + Instruction : TInstruction; + tOutput : PAnsiChar; + Buffer : Array of Byte; + Block : TInstructionArray; + Results : TBlockEncoderResult; + S : String; + C : UInt64; + i : Integer; +begin +// if ( Output <> nil ) then +// AOutput.Clear; + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Iced.Decoder.SetData( Data, Size, ARIP, doNONE ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 +// if LocalBuffer AND NOT BlockEncode then +// begin +// SetLength( Buffer, Size ); +// Iced.Encoder.SetBuffer( @Buffer[ 0 ], Size ); +// end; + + SetLength( Block, 0 ); + while Iced.Decoder.CanDecode do + begin + if BlockEncode then + begin + SetLength( Block, Length( Block )+1 ); + Iced.Decoder.Decode( Block[ High( Block ) ] ); + end + else + begin + Iced.Decoder.Decode( Instruction ); + Iced.Encoder.Encode( Instruction ); + end; + end; + + if BlockEncode then + begin + Iced.BlockEncoder.Encode( ARIP, Block, Results ); + SetLength( Block, 0 ); + result := CompareMem( Data, Results.code_buffer, Size ); + end + else + begin +// if NOT LocalBuffer then +// begin + SetLength( Buffer, Size ); + Iced.Encoder.GetBuffer( @Buffer[ 0 ], Size ); +// end; + result := CompareMem( Data, @Buffer[ 0 ], Size ); + +// if LocalBuffer then +// Iced.Encoder.SetBuffer( nil, 0 ); + end; + + if ( AOutput <> nil ) then + begin + if BlockEncode then + Iced.Decoder.SetData( PByte( Results.code_buffer ), Results.code_buffer_len, Results.RIP, doNONE ) + else + Iced.Decoder.SetData( @Buffer[ 0 ], Size, ARIP, doNONE ); + + while Iced.Decoder.CanDecode do + begin + Iced.DecodeFormat( Instruction, tOutput ); + + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + C := Instruction.next_rip-Instruction.len; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + S := Format( '%.16x ', [ C ] ); + + for i := 0 to Instruction.len-1 do + begin + S := S + Format( '%.2x', [ Data^ ] ); + Inc( Data ); + end; + + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len*2+1 do + S := S + ' '; + + AOutput.Add( S + string( tOutput ) ); + end; + end; + + SetLength( Buffer, 0 ); +end; + +procedure Test_Assemble( AOutput : TStringList; ARIP : UInt64 = UInt64( $00001248FC840000 ) ); +var + LabelID : UInt64; + + function CreateLabel : UInt64; + begin + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + result := LabelID; + Inc( LabelID ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + end; + + function AddLabel( ID : UInt64; Instruction : TInstruction ) : TInstruction; + begin + Instruction.SetRIP( ID ); + result := Instruction; + end; + +const + Bitness : TIcedBitness = bt64; + raw_data : Array [ 0..3 ] of Byte = ( $12, $34, $56, $78 ); +var + Instructions : TInstructionArray; + MemoryOperand: TMemoryOperand; + Results : TBlockEncoderResult; + label1 : UInt64; + data1 : UInt64; + i : Integer; + Instruction : TInstruction; + tOutput : PAnsiChar; + S : String; + Data : PByte; + C : Cardinal; +begin +// if ( AOutput <> nil ) then +// AOutput.Clear; + + // All created instructions get an IP of 0. The label id is just an IP. + // The branch instruction's *target* IP should be equal to the IP of the + // target instruction. + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + LabelID := 1; + + label1 := CreateLabel; + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + + SetLength( Instructions, 18 ); + Instructions[ 0 ] := {T}Instruction.with1( Push_r64, RBP ); + Instructions[ 1 ] := {T}Instruction.with1( Push_r64, RDI ); + Instructions[ 2 ] := {T}Instruction.with1( Push_r64, RSI ); + Instructions[ 3 ] := {T}Instruction.with2( Sub_rm64_imm32, RSP, Cardinal( $50 ) ); + Instructions[ 4 ] := {T}Instruction.with_( VEX_Vzeroupper ); + Instructions[ 5 ] := {T}Instruction.with2( + Lea_r64_m, + RBP, + {T}MemoryOperand.with_base_displ( RSP, $60 ) + ); + Instructions[ 6 ] := {T}Instruction.with2( Mov_r64_rm64, RSI, RCX ); + Instructions[ 7 ] := {T}Instruction.with2( + Lea_r64_m, + RDI, + {T}MemoryOperand.with_base_displ( RBP, -$38 ) + ); + Instructions[ 8 ] := {T}Instruction.with2( Mov_r32_imm32, ECX, Cardinal( $0A ) ); + Instructions[ 9 ] := {T}Instruction.with2( Xor_r32_rm32, EAX, EAX ); + Instructions[ 10 ] := {T}Instruction.with_rep_stosd( Cardinal( Bitness ) ); + Instructions[ 11 ] := {T}Instruction.with2( Cmp_rm64_imm32, RSI, Cardinal( $12345678 ) ); + // Create a branch instruction that references label1 + Instructions[ 12 ] := {T}Instruction.with_branch( Jne_rel32_64, label1 ); + Instructions[ 13 ] := {T}Instruction.with_( Nopd ); + + // Add the instruction that is the target of the branch + Instructions[ 14 ] := AddLabel( label1, {T}Instruction.with2( Xor_r32_rm32, R15D, R15D ) ); + + // Create an instruction that accesses some data using an RIP relative memory operand + {$IF CompilerVersion < 23}{$RANGECHECKS OFF}{$IFEND} // RangeCheck might cause Internal-Error C1118 + data1 := CreateLabel; + Instructions[ 15 ] := {T}Instruction.with2( + Lea_r64_m, + R14, + {T}MemoryOperand.with_base_displ( RIP, Int64( data1 ) ) ); + {$IF CompilerVersion < 23}{$RANGECHECKS ON}{$IFEND} // RangeCheck might cause Internal-Error C1118 + Instructions[ 16 ] := {T}Instruction.with_( Nopd ); + Instructions[ 17 ] := AddLabel( data1, {T}Instruction.with_declare_byte( raw_data ) ); + Instructions[ 18 ] := {T}Instruction.with_declare_byte( raw_data ); + + // Use BlockEncoder to encode a block of instructions. This block can contain any + // number of branches and any number of instructions. It does support encoding more + // than one block but it's rarely needed. + // It uses Encoder to encode all instructions. + // If the target of a branch is too far away, it can fix it to use a longer branch. + // This can be disabled by enabling some BlockEncoderOptions flags. + Iced.BlockEncoder.Encode( ARIP, Instructions, Results ); + + // Now disassemble the encoded instructions. Note that the 'jmp near' + // instruction was turned into a 'jmp short' instruction because we + // didn't disable branch optimizations. + Iced.Formatter.FormatterType := ftGas; + Iced.Formatter.FirstOperandCharIndex := 8; + + if ( AOutput <> nil ) then + begin + Iced.Decoder.SetData( PByte( Results.code_buffer ), Results.code_buffer_len-NativeUInt( Length( raw_data ) ), Results.RIP, doNONE ); + Data := PByte( Results.code_buffer ); + + while Iced.Decoder.CanDecode do + begin + Iced.DecodeFormat( Instruction, tOutput ); + + C := Instruction.next_rip-Instruction.len; + S := Format( '%.16x ', [ C ] ); + C := C-ARIP; + + for i := C to C+Instruction.len-1 do + begin + S := S + Format( '%.2x', [ Data^ ] ); + Inc( Data ); + end; + + for i := 0 to HEXBYTES_COLUMN_BYTE_LENGTH-Instruction.len*2+1 do + S := S + ' '; + + AOutput.Add( S + string( tOutput ) ); + end; + + Instruction := {T}Instruction.with_declare_byte( raw_data ); + Iced.Formatter.Format( Instruction, tOutput ); + AOutput.Add( S + string( tOutput ) ); + end; + + Iced.BlockEncoder.Clear; +end; +{$ENDIF TEST_FUNCTIONS} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +initialization + Iced := TIced.Create; + +finalization + Iced.Free; + +end. diff --git a/src/rust/Cargo.toml b/src/rust/Cargo.toml index af0b3cc18..5f1245be5 100644 --- a/src/rust/Cargo.toml +++ b/src/rust/Cargo.toml @@ -7,6 +7,7 @@ exclude = [ "iced-x86-js", "iced-x86-lua", "iced-x86-py", + "iced-x86-c", ] members = [ diff --git a/src/rust/iced-x86-c/Cargo.lock b/src/rust/iced-x86-c/Cargo.lock new file mode 100644 index 000000000..9783a3d76 --- /dev/null +++ b/src/rust/iced-x86-c/Cargo.lock @@ -0,0 +1,106 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "Iced" +version = "1.0.4" +dependencies = [ + "iced-x86", + "libc", + "winres", +] + +[[package]] +name = "iced-x86" +version = "1.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c447cff8c7f384a7d4f741cfcff32f75f3ad02b406432e8d6c878d56b1edf6b" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "libc" +version = "0.2.152" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13e3bf6590cbc649f4d1a3eefc9d5d6eb746f5200ffb04e5e142700b8faa56e7" + +[[package]] +name = "proc-macro2" +version = "1.0.66" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "serde" +version = "1.0.188" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.188" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "syn" +version = "2.0.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "toml" +version = "0.5.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234" +dependencies = [ + "serde", +] + +[[package]] +name = "unicode-ident" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c" + +[[package]] +name = "winres" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b68db261ef59e9e52806f688020631e987592bd83619edccda9c47d42cde4f6c" +dependencies = [ + "toml", +] diff --git a/src/rust/iced-x86-c/Cargo.toml b/src/rust/iced-x86-c/Cargo.toml new file mode 100644 index 000000000..059118e00 --- /dev/null +++ b/src/rust/iced-x86-c/Cargo.toml @@ -0,0 +1,66 @@ +[package] +name = "iced-x86" +# The version number can't be the same as iced-x86's version number or cargo build will fail +version = "1.21.1000" +license = "MIT" +description = "iced-x86 is a blazing fast and correct x86/x64 disassembler, assembler and instruction decoder written in Rust and compiled to WebAssembly" +homepage = "https://github.com/icedland/iced" +repository = "https://github.com/icedland/iced" +readme = "README.md" +keywords = ["disassembler", "delphi", "pascal", "assembler", "x86", "amd64"] +categories = ["wasm", "development-tools::debugging", "encoding", "hardware-support"] +edition = "2021" +publish = false +rust-version = "1.60.0" +build = "build.rs" + +[lib] +crate-type = ["cdylib"] # Creates dynamic lib +# crate-type = ["staticlib"] # Creates static lib + +[package.metadata.winres] +FileDescription = "" +FileVersion = "1.0.6.1" +ProductName = "Iced" +ProductVersion = "1.2.1.0" +OriginalFilename = "Iced.dll" +LegalCopyright = "TetzkatLipHoka © 2022-2024" + +[dependencies] +libc = "0.2.155" + +[target.'cfg(windows)'.build-dependencies] +winres = "0.1.12" + +[features] +#default = ["instr_api", "instr_create", "decoder", "encoder", "block_encoder", "op_code_info", "instr_info", "gas", "intel", "masm", "nasm", "fast_fmt", "code_asm", "mvex"] +default = ["instr_api", "instr_create", "decoder", "encoder", "block_encoder", "op_code_info", "instr_info", "gas", "intel", "masm", "nasm", "fast_fmt", "mvex"] +base = ["iced-x86-rust/std"] +formatter = [] +instr_api = ["base"] +decoder = ["base", "iced-x86-rust/decoder"] +encoder = ["base", "iced-x86-rust/encoder"] +block_encoder = ["base", "iced-x86-rust/block_encoder"] +instr_create = ["base", "iced-x86-rust/encoder"] +op_code_info = ["base", "iced-x86-rust/op_code_info"] +instr_info = ["base", "iced-x86-rust/instr_info"] +gas = ["base", "formatter", "iced-x86-rust/gas"] +intel = ["base", "formatter", "iced-x86-rust/intel"] +masm = ["base", "formatter", "iced-x86-rust/masm"] +nasm = ["base", "formatter", "iced-x86-rust/nasm"] +fast_fmt = ["base", "formatter", "iced-x86-rust/fast_fmt"] +no_vex = ["iced-x86-rust/no_vex"] +no_evex = ["iced-x86-rust/no_evex"] +no_xop = ["iced-x86-rust/no_xop"] +no_d3now = ["iced-x86-rust/no_d3now"] +mvex = ["iced-x86-rust/mvex"] + +[dependencies.iced-x86-rust] +package = "iced-x86" +path = "../iced-x86" +default-features = false + +[profile.release] +codegen-units = 1 +lto = true +opt-level = 3 \ No newline at end of file diff --git a/src/rust/iced-x86-c/Iced.ico b/src/rust/iced-x86-c/Iced.ico new file mode 100644 index 000000000..be6739379 Binary files /dev/null and b/src/rust/iced-x86-c/Iced.ico differ diff --git a/src/rust/iced-x86-c/README.md b/src/rust/iced-x86-c/README.md new file mode 100644 index 000000000..7a7ef963f --- /dev/null +++ b/src/rust/iced-x86-c/README.md @@ -0,0 +1,49 @@ +iced-x86 C-Compatible Exports +[![Latest version](https://img.shields.io/crates/v/iced-x86.svg)](https://crates.io/crates/iced-x86) +[![Documentation](https://docs.rs/iced-x86/badge.svg)](https://docs.rs/iced-x86) +[![Minimum rustc version](https://img.shields.io/badge/rustc-1.60.0+-blue.svg)](#minimum-supported-rustc-version) +![License](https://img.shields.io/crates/l/iced-x86.svg) + +iced-x86 is a blazing fast and correct x86 (16/32/64-bit) instruction decoder, disassembler and assembler written in Rust. + +- 👍 Supports all Intel and AMD instructions +- 👍 Correct: All instructions are tested and iced has been tested against other disassemblers/assemblers (xed, gas, objdump, masm, dumpbin, nasm, ndisasm) and fuzzed +- 👍 100% Rust code with C-Compatible Exports +- 👍 The formatter supports masm, nasm, gas (AT&T), Intel (XED) and there are many options to customize the output +- 👍 Blazing fast: Decodes >200 MB/s, 93MB/s with Formatting +- 👍 Small decoded instructions, only 40 bytes and the decoder doesn't allocate any memory +- 👍 The encoder can be used to re-encode decoded instructions at any address +- 👍 API to get instruction info, eg. read/written registers, memory and rflags bits; CPUID feature flag, control flow info, etc +- 👍 Supports `#![no_std]` +- 👍 Supports `rustc` `1.60.0` or later +- 👍 License: MIT + +## Usage +Build using cargo or run _Build.bat + +## Crate feature flags + +- `decoder`: (👍 Enabled by default) Enables the decoder +- `encoder`: (👍 Enabled by default) Enables the encoder +- `block_encoder`: (👍 Enabled by default) Enables the [`BlockEncoder`]. This feature enables `encoder` +- `op_code_info`: (👍 Enabled by default) Enables getting instruction metadata ([`OpCodeInfo`]). This feature enables `encoder` +- `instr_info`: (👍 Enabled by default) Enables the instruction info code +- `gas`: (👍 Enabled by default) Enables the GNU Assembler (AT&T) formatter +- `intel`: (👍 Enabled by default) Enables the Intel (XED) formatter +- `masm`: (👍 Enabled by default) Enables the masm formatter +- `nasm`: (👍 Enabled by default) Enables the nasm formatter +- `fast_fmt`: (👍 Enabled by default) Enables [`SpecializedFormatter`] (and [`FastFormatter`]) (masm syntax) which is ~3.3x faster than the other formatters (the time includes decoding + formatting). Use it if formatting speed is more important than being able to re-assemble formatted instructions or if targeting wasm (this formatter uses less code). +- `std`: (👍 Enabled by default) Enables the `std` crate. `std` or `no_std` must be defined, but not both. +- `mvex`: Enables `MVEX` instructions (Knights Corner). You must also pass in `DecoderOptions::KNC` to the [`Decoder`] constructor. + +[`BlockEncoder`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.BlockEncoder.html +[`CodeAssembler`]: https://docs.rs/iced-x86/1.21.0/iced_x86/code_asm/struct.CodeAssembler.html +[`Instruction`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.Instruction.html +[`OpCodeInfo`]: https://docs.rs/iced-x86/1.21.0/iced_x86/struct.OpCodeInfo.html + +## Minimum supported `rustc` version + +iced-x86 supports `rustc` `1.60.0` or later. +This is checked in CI builds where the minimum supported version and the latest stable version are used to build the source code and run tests. + +Bumping the minimum supported version of `rustc` is considered a minor breaking change. The minor version of iced-x86 will be incremented. diff --git a/src/rust/iced-x86-c/_Build.bat b/src/rust/iced-x86-c/_Build.bat new file mode 100644 index 000000000..edf72cf25 --- /dev/null +++ b/src/rust/iced-x86-c/_Build.bat @@ -0,0 +1,20 @@ +@echo off +cls + +::SET CARGO_TARGET_DIR=C:\tmp\targets\myapp64 +::SET RELEASE_DIR=%CARGO_TARGET_DIR%\release + +::_Clean.bat +::Pause + +echo Building x64, Release +cargo build --release +echo Building x64, Debug +cargo build + +echo Building x86, Release +cargo build --target i686-pc-windows-msvc --release +echo Building x86, Debug +cargo build --target i686-pc-windows-msvc + +pause \ No newline at end of file diff --git a/src/rust/iced-x86-c/_CBindGen.bat b/src/rust/iced-x86-c/_CBindGen.bat new file mode 100644 index 000000000..0db9294b6 --- /dev/null +++ b/src/rust/iced-x86-c/_CBindGen.bat @@ -0,0 +1,6 @@ +@echo off +cls + +cbindgen --config cbindgen.toml --lang c --crate Iced --output iCed.h + +pause \ No newline at end of file diff --git a/src/rust/iced-x86-c/_Clean.bat b/src/rust/iced-x86-c/_Clean.bat new file mode 100644 index 000000000..fb696da5b --- /dev/null +++ b/src/rust/iced-x86-c/_Clean.bat @@ -0,0 +1,20 @@ +@echo off +cls + +::SET CARGO_TARGET_DIR=C:\tmp\targets\myapp64 +::SET RELEASE_DIR=%CARGO_TARGET_DIR%\release + +::cargo clean +::Pause + +echo Cleaning x64, Release +cargo clean --release +echo Cleaning x64, Debug +cargo clean + +echo Cleaning x86, Release +cargo clean --target i686-pc-windows-msvc --release +echo Cleaning x86, Debug +cargo clean --target i686-pc-windows-msvc + +pause \ No newline at end of file diff --git a/src/rust/iced-x86-c/build.rs b/src/rust/iced-x86-c/build.rs new file mode 100644 index 000000000..baad7d435 --- /dev/null +++ b/src/rust/iced-x86-c/build.rs @@ -0,0 +1,14 @@ +extern crate winres; + +#[cfg(windows)] +fn main() { + if cfg!(target_os = "windows") { + let res = winres::WindowsResource::new(); +// res.set_icon("Iced.ico"); + res.compile().unwrap(); + } +} + +#[cfg(unix)] +fn main() { +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/cbindgen.toml b/src/rust/iced-x86-c/cbindgen.toml new file mode 100644 index 000000000..d5c4d20f1 --- /dev/null +++ b/src/rust/iced-x86-c/cbindgen.toml @@ -0,0 +1,158 @@ +# This is a template cbindgen.toml file with all of the default values. +# Some values are commented out because their absence is the real default. +# +# See https://github.com/mozilla/cbindgen/blob/master/docs.md#cbindgentoml +# for detailed documentation of every option here. + + + +language = "C++" + + + +############## Options for Wrapping the Contents of the Header ################# + +# header = "/* Text to put at the beginning of the generated file. Probably a license. */" +# trailer = "/* Text to put at the end of the generated file */" +# include_guard = "my_bindings_h" +# pragma_once = true +# autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */" +include_version = false +# namespace = "my_namespace" +namespaces = [] +using_namespaces = [] +sys_includes = [] +includes = [] +no_includes = false +after_includes = "" + + + + +############################ Code Style Options ################################ + +braces = "SameLine" +line_length = 100 +tab_width = 2 +documentation = true +documentation_style = "auto" +documentation_length = "full" +line_endings = "LF" # also "CR", "CRLF", "Native" + + + + +############################# Codegen Options ################################## + +style = "both" +sort_by = "Name" # default for `fn.sort_by` and `const.sort_by` +usize_is_size_t = true + + + +[defines] +# "target_os = freebsd" = "DEFINE_FREEBSD" +# "feature = serde" = "DEFINE_SERDE" + + + +[export] +include = [] +exclude = [] +# prefix = "CAPI_" +item_types = [] +renaming_overrides_prefixing = false + + + +[export.rename] + + + +[export.body] + + +[export.mangle] + + +[fn] +rename_args = "None" +# must_use = "MUST_USE_FUNC" +# deprecated = "DEPRECATED_FUNC" +# deprecated_with_note = "DEPRECATED_FUNC_WITH_NOTE" +# no_return = "NO_RETURN" +# prefix = "START_FUNC" +# postfix = "END_FUNC" +args = "auto" +sort_by = "Name" + + + + +[struct] +rename_fields = "None" +# must_use = "MUST_USE_STRUCT" +# deprecated = "DEPRECATED_STRUCT" +# deprecated_with_note = "DEPRECATED_STRUCT_WITH_NOTE" +derive_constructor = false +derive_eq = false +derive_neq = false +derive_lt = false +derive_lte = false +derive_gt = false +derive_gte = false + + + + +[enum] +rename_variants = "None" +# must_use = "MUST_USE_ENUM" +# deprecated = "DEPRECATED_ENUM" +# deprecated_with_note = "DEPRECATED_ENUM_WITH_NOTE" +add_sentinel = false +prefix_with_name = false +derive_helper_methods = false +derive_const_casts = false +derive_mut_casts = false +# cast_assert_name = "ASSERT" +derive_tagged_enum_destructor = false +derive_tagged_enum_copy_constructor = false +enum_class = true +private_default_tagged_enum_constructor = false + + + + +[const] +allow_static_const = true +allow_constexpr = false +sort_by = "Name" + + + + +[macro_expansion] +bitflags = false + + + + + + +############## Options for How Your Rust library Should Be Parsed ############## + +[parse] +parse_deps = false +# include = [] +exclude = [] +clean = false +extra_bindings = [] + + + +[parse.expand] +crates = [] +all_features = false +default_features = true +features = [] \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/BlockEncoder.rs b/src/rust/iced-x86-c/src/BlockEncoder.rs new file mode 100644 index 000000000..6d4fb658c --- /dev/null +++ b/src/rust/iced-x86-c/src/BlockEncoder.rs @@ -0,0 +1,132 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, InstructionBlock, ConstantOffsets, RelocInfo, BlockEncoder, BlockEncoderResult}; +use std::{slice, ptr::null_mut}; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// BlockEncoder + +// Encodes instructions. Any number of branches can be part of this block. +// You can use this function to move instructions from one location to another location. +// If the target of a branch is too far away, it'll be rewritten to a longer branch. +// You can disable this by passing in [`BlockEncoderOptions::DONT_FIX_BRANCHES`]. +// If the block has any `RIP`-relative memory operands, make sure the data isn't too +// far away from the new location of the encoded instructions. Every OS should have +// some API to allocate memory close (+/-2GB) to the original code location. +// +// # Errors +// Returns 0-Data if it failed to encode one or more instructions. +// +// # Arguments +// * `bitness`: 16, 32, or 64 +// * `Intructions`: First Instruction to encode +// * `Count`: Instruction-Count +// * `Options`: Encoder options, see [`TBlockEncoderOptions`] +// * `Results`: Result-Structure +// +// # Result +// * Pointer to Result-Data. Musst be free'd using RustFreeMemory() +//#[repr(C)] +#[repr(packed)] +pub struct TBlockEncoderResult { + /// Base IP of all encoded instructions + pub rip: u64, + + /// The bytes of all encoded instructions + pub code_buffer: *const u8, + pub code_buffer_len: usize, + + /// If [`BlockEncoderOptions::RETURN_RELOC_INFOS`] option was enabled: + /// + /// All [`RelocInfo`]s. + /// + /// [`BlockEncoderOptions::RETURN_RELOC_INFOS`]: struct.BlockEncoderOptions.html#associatedconstant.RETURN_RELOC_INFOS + /// [`RelocInfo`]: struct.RelocInfo.html + pub reloc_infos: *const RelocInfo, + pub reloc_infos_len: usize, + + /// If [`BlockEncoderOptions::RETURN_NEW_INSTRUCTION_OFFSETS`] option was enabled: + /// + /// Offsets of the instructions relative to the base IP. If the instruction was rewritten to a new instruction + /// (eg. `JE TARGET_TOO_FAR_AWAY` -> `JNE SHORT SKIP ;JMP QWORD PTR [MEM]`), the value `u32::MAX` is stored in that element. + /// + /// [`BlockEncoderOptions::RETURN_NEW_INSTRUCTION_OFFSETS`]: struct.BlockEncoderOptions.html#associatedconstant.RETURN_NEW_INSTRUCTION_OFFSETS + pub new_instruction_offsets: *const u32, + pub new_instruction_offsets_len: usize, + + /// If [`BlockEncoderOptions::RETURN_CONSTANT_OFFSETS`] option was enabled: + /// + /// Offsets of all constants in the new encoded instructions. If the instruction was rewritten, + /// the `default()` value is stored in the corresponding element. + /// + /// [`BlockEncoderOptions::RETURN_CONSTANT_OFFSETS`]: struct.BlockEncoderOptions.html#associatedconstant.RETURN_CONSTANT_OFFSETS + pub constant_offsets: *const ConstantOffsets, + pub constant_offsets_len: usize, +} + +#[no_mangle] +pub unsafe extern "C" fn BlockEncoder( Bitness: u32, RIP : u64, Instructions: *mut Instruction, Count: usize, Result: *mut TBlockEncoderResult, Options: u32 ) -> *mut BlockEncoderResult { + if Instructions.is_null() { + return null_mut(); + } + if Count <= 0 { + return null_mut(); + } + if Result.is_null() { + return null_mut(); + } + + let instructions = slice::from_raw_parts( Instructions, Count ); + let block = InstructionBlock::new( &instructions, RIP ); + match BlockEncoder::encode( Bitness, block, Options ) { + Ok( value ) => { + (*Result).rip = value.rip; + + if value.code_buffer.len() > 0 { + (*Result).code_buffer = value.code_buffer.as_ptr(); + }else { + (*Result).code_buffer = null_mut(); + } + (*Result).code_buffer_len = value.code_buffer.len(); + + if value.reloc_infos.len() > 0 { + (*Result).reloc_infos = value.reloc_infos.as_ptr(); + }else { + (*Result).reloc_infos = null_mut(); + } + (*Result).reloc_infos_len = value.reloc_infos.len(); + + if value.new_instruction_offsets.len() > 0 { + (*Result).new_instruction_offsets = value.new_instruction_offsets.as_ptr(); + }else { + (*Result).new_instruction_offsets = null_mut(); + } + (*Result).new_instruction_offsets_len = value.new_instruction_offsets.len(); + + if value.constant_offsets.len() > 0 { + (*Result).constant_offsets = value.constant_offsets.as_ptr(); + }else { + (*Result).constant_offsets = null_mut(); + } + (*Result).constant_offsets_len = value.constant_offsets.len(); + return Box::into_raw( Box::new( value ) ); + }, + Err( _e ) => { + (*Result).rip = 0 as u64; + (*Result).code_buffer = null_mut(); + (*Result).code_buffer_len = 0; + (*Result).reloc_infos = null_mut(); + (*Result).reloc_infos_len = 0; + (*Result).new_instruction_offsets = null_mut(); + (*Result).new_instruction_offsets_len = 0; + (*Result).constant_offsets = null_mut(); + (*Result).constant_offsets_len = 0; + return null_mut(); + } + } +} diff --git a/src/rust/iced-x86-c/src/CPUIdFeature.rs b/src/rust/iced-x86-c/src/CPUIdFeature.rs new file mode 100644 index 000000000..143adc4d1 --- /dev/null +++ b/src/rust/iced-x86-c/src/CPUIdFeature.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::CpuidFeature; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn CPUidFeature_AsString( CPUidFeature : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: CPUidFeature + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let CPUidfeature : CpuidFeature = transmute( CPUidFeature as u8 ); + let output = format!("{CPUidfeature:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/Code.rs b/src/rust/iced-x86-c/src/Code.rs new file mode 100644 index 000000000..9736a382a --- /dev/null +++ b/src/rust/iced-x86-c/src/Code.rs @@ -0,0 +1,282 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::Code; +#[cfg(feature = "instr_info")] +use iced_x86_rust::CpuidFeature; +#[cfg(feature = "op_code_info")] +use iced_x86_rust::OpCodeOperandKind; +#[cfg(feature = "op_code_info")] +use crate::OpCodeInfo::TOpCodeInfo; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn Code_AsString( Code : u16, Output : *mut u8, Size : usize ) { // FFI-Unsafe: Code + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let code : Code = transmute( Code as u16 ); + let output = format!("{code:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} + +#[no_mangle] +pub unsafe extern "C" fn Code_Mnemonic( Code : u16 ) -> u16/*Mnemonic*/ { // FFI-Unsafe: Code, Mnemonic + let code : Code = transmute( Code as u16 ); + code.mnemonic() as u16 +} + +#[cfg(feature = "op_code_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_OPCode( Code : u16, Info : *mut TOpCodeInfo ) { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + +/* + // OpCodeString + let output = info.op_code_string().as_bytes(); + let n = std::cmp::min( output.len(), (*Info).op_code_string.len() ); + (*Info).op_code_string[0..n].copy_from_slice(&output[0..n]); + (*Info).op_code_string[n] = 0; + + // InstructionString + let output = info.instruction_string().as_bytes(); + let n = std::cmp::min( output.len(), (*Info).instruction_string.len() ); + (*Info).instruction_string[0..n].copy_from_slice(&output[0..n]); + (*Info).instruction_string[n] = 0; +*/ + + (*Info).code = info.code() as u16; + (*Info).op_code = info.op_code() as u16; + (*Info).encoding = info.encoding() as u8; + (*Info).operand_size = info.operand_size() as u8; + (*Info).address_size = info.address_size() as u8; + (*Info).l = info.l() as u8; + (*Info).tuple_type = info.tuple_type() as u8; + (*Info).table = info.table() as u8; + (*Info).mandatory_prefix = info.mandatory_prefix() as u8; + (*Info).group_index = info.group_index() as i8; + (*Info).rm_group_index = info.rm_group_index() as i8; + for i in 0..(info.op_count() as usize) { + (*Info).op_kinds[ i ] = info.op_kinds()[ i ] as u8; + } + + for i in (info.op_count() as usize)..(*Info).op_kinds.len() { + (*Info).op_kinds[ i ] = OpCodeOperandKind::None as u8; + } +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_Encoding( Code : u16 ) -> u16/*EncodingKind*/ { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + + code.encoding() as u16 +} + +// Gets the CPU or CPUID feature flags +#[cfg(feature = "instr_info")] +#[allow( non_upper_case_globals )] +pub const CPUIDFeaturesMaxEntries : usize = 5; +#[cfg(feature = "instr_info")] +//#[repr(C)] +#[repr(packed)] +pub struct TCPUIDFeaturesArray { + pub Entries : [CpuidFeature;CPUIDFeaturesMaxEntries], + pub Count : u8 +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_CPUidFeature( Code : u16, CPUIDFeatures : *mut TCPUIDFeaturesArray ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + if CPUIDFeatures.is_null() { + return false; + } + + let cpuidfeaturesA = code.cpuid_features(); + + (*CPUIDFeatures).Count = cpuidfeaturesA.len() as u8; + for ( i, x ) in cpuidfeaturesA.iter().enumerate() { + if i < (*CPUIDFeatures).Entries.len() { + (*CPUIDFeatures).Entries[ i ] = *x; + } + } + + return true; +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_FlowControl( Code : u16 ) -> u16/*FlowControl*/ { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.flow_control() as u16 +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsPrivileged( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_privileged() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsStackInstruction( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_stack_instruction() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsSaveRestoreInstruction( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_save_restore_instruction() +} + +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsJccShort( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_jkcc_short() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsJmpShort( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_jmp_short() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsJmpShortOrNear( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_jmp_short_or_near() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsJmpNear( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_jmp_near() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsJmpFar( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_jmp_far() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsCallNear( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_call_near() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsCallFar( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_call_far() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsJmpNearIndirect( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_jmp_near_indirect() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsJmpFarIndirect( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_jmp_far_indirect() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsCallNearIndirect( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_call_near_indirect() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsCallFarIndirect( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_call_far_indirect() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_ConditionCode( Code : u16 ) -> u8/*ConditionCode*/ { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.condition_code() as u8 +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsJcxShort( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_jcx_short() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsLoopCC( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_loopcc() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsLoop( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_loop() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Code_IsJccShortOrNear( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.is_jcc_short_or_near() +} + +#[cfg(feature = "instr_create")] +#[no_mangle] +pub unsafe extern "C" fn Code_NegateConditionCode( Code : u16 ) -> u16/*Code*/ { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.negate_condition_code() as u16 +} + +#[cfg(feature = "instr_create")] +#[no_mangle] +pub unsafe extern "C" fn Code_AsShortBranch( Code : u16 ) -> u16/*Code*/ { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.as_short_branch() as u16 +} + +#[cfg(feature = "instr_create")] +#[no_mangle] +pub unsafe extern "C" fn Code_AsNearBranch( Code : u16 ) -> u16/*Code*/ { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + code.as_near_branch() as u16 +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/CodeSize.rs b/src/rust/iced-x86-c/src/CodeSize.rs new file mode 100644 index 000000000..4d5692f11 --- /dev/null +++ b/src/rust/iced-x86-c/src/CodeSize.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::CodeSize; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn CodeSize_AsString( CodeSize : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: CodeSize + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let codeSize : CodeSize = transmute( CodeSize as u8 ); + let output = format!("{codeSize:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/ConditionCode.rs b/src/rust/iced-x86-c/src/ConditionCode.rs new file mode 100644 index 000000000..a449ad444 --- /dev/null +++ b/src/rust/iced-x86-c/src/ConditionCode.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::ConditionCode; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn ConditionCode_AsString( ConditionCode : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: ConditionCode + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let conditionCode : ConditionCode = transmute( ConditionCode as u8 ); + let output = format!("{conditionCode:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/Decoder.rs b/src/rust/iced-x86-c/src/Decoder.rs new file mode 100644 index 000000000..7af2bf540 --- /dev/null +++ b/src/rust/iced-x86-c/src/Decoder.rs @@ -0,0 +1,225 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, Decoder, ConstantOffsets}; +use std::{slice, ptr::null_mut}; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Decoder + +// Creates a decoder +// +// # Errors +// Fails if `bitness` is not one of 16, 32, 64. +// +// # Arguments +// * `bitness`: 16, 32 or 64 +// * `data`: Data to decode +// * `data`: ByteSize of `Data` +// * `options`: Decoder options, `0` or eg. `DecoderOptions::NO_INVALID_CHECK | DecoderOptions::AMD` +#[no_mangle] +pub extern "C" fn Decoder_Create( Bitness: u32, Data: *const u8, DataSize : usize, IP: u64, Options: u32 ) -> *mut Decoder<'static> { + let data2 = unsafe { slice::from_raw_parts( Data, DataSize ) }; + match Decoder::try_with_ip( Bitness, data2, IP, Options ) { + Ok( value ) => return Box::into_raw( Box::new( value ) ), + Err( _e ) => return null_mut() + } +} + +// Returns `true` if there's at least one more byte to decode. It doesn't verify that the +// next instruction is valid, it only checks if there's at least one more byte to read. +// See also [ `position()` ] and [ `max_position()` ] +// +// It's not required to call this method. If this method returns `false`, then [ `decode_out()` ] +// and [ `decode()` ] will return an instruction whose [ `code()` ] == [ `Code::INVALID` ]. +#[no_mangle] +pub unsafe extern "C" fn Decoder_CanDecode( Decoder: *mut Decoder ) -> bool { + if Decoder.is_null() { + return false; + } + let obj = Box::from_raw( Decoder ); + + let value = obj.can_decode(); + + Box::into_raw( obj ); + + return value; +} + +// Gets the current `IP`/`EIP`/`RIP` value, see also [ `position()` ] +#[no_mangle] +pub unsafe extern "C" fn Decoder_GetIP( Decoder: *mut Decoder ) -> u64 { + if Decoder.is_null() { + return 0; + } + let obj = Box::from_raw( Decoder ); + + let value = obj.ip(); + + Box::into_raw( obj ); + + return value; +} + +// Sets the current `IP`/`EIP`/`RIP` value, see also [ `try_set_position()` ] +// This method only updates the IP value, it does not change the data position, use [ `try_set_position()` ] to change the position. +#[no_mangle] +pub unsafe extern "C" fn Decoder_SetIP( Decoder: *mut Decoder, Value : u64 ) -> bool { + if Decoder.is_null() { + return false; + } + let mut obj = Box::from_raw( Decoder ); + + obj.set_ip( Value ); + + Box::into_raw( obj ); + + return true; +} + +// Gets the bitness ( 16, 32 or 64 ) +#[no_mangle] +pub unsafe extern "C" fn Decoder_GetBitness( Decoder: *mut Decoder ) -> u32 { + if Decoder.is_null() { + return 0; + } + let obj = Box::from_raw( Decoder ); + + let value = obj.bitness(); + + Box::into_raw( obj ); + + return value; +} + +// Gets the max value that can be passed to [ `try_set_position()` ]. This is the size of the data that gets +// decoded to instructions and it's the length of the slice that was passed to the constructor. +#[no_mangle] +pub unsafe extern "C" fn Decoder_GetMaxPosition( Decoder: *mut Decoder ) -> usize { + if Decoder.is_null() { + return 0; + } + let obj = Box::from_raw( Decoder ); + + let value = obj.max_position(); + + Box::into_raw( obj ); + + return value; +} + +// Gets the current data position. This value is always <= [ `max_position()` ]. +// When [ `position()` ] == [ `max_position()` ], it's not possible to decode more +// instructions and [ `can_decode()` ] returns `false`. +#[no_mangle] +pub unsafe extern "C" fn Decoder_GetPosition( Decoder: *mut Decoder ) -> usize { + if Decoder.is_null() { + return 0; + } + let obj = Box::from_raw( Decoder ); + + let value = obj.position(); + + Box::into_raw( obj ); + + return value; +} + +// Sets the current data position, which is the index into the data passed to the constructor. +// This value is always <= [ `max_position()` ] +#[no_mangle] +pub unsafe extern "C" fn Decoder_SetPosition( Decoder: *mut Decoder, Value : usize ) -> bool { + if Decoder.is_null() { + return false; + } + let mut obj = Box::from_raw( Decoder ); + + let value = obj.set_position( Value ); + + Box::into_raw( obj ); + + return value.is_ok(); +} + +// Gets the last decoder error. Unless you need to know the reason it failed, +// it's better to check [ `instruction.is_invalid()` ]. +#[no_mangle] +pub unsafe extern "C" fn Decoder_GetLastError( Decoder: *mut Decoder ) -> u8 { // FFI-Unsafe: TDecoderError + if Decoder.is_null() { + return 0;// TDecoderError::None; + } + let obj = Box::from_raw( Decoder ); + + let value: u8/*TDecoderError*/ = obj.last_error() as u8; + + Box::into_raw( obj ); + + return value; +} + +// Decodes and returns the next instruction, see also [ `decode_out( &mut Instruction )` ] +// which avoids copying the decoded instruction to the caller's return variable. +// See also [ `last_error()` ]. +#[no_mangle] +pub unsafe extern "C" fn Decoder_Decode( Decoder: *mut Decoder, Instruction: *mut Instruction ) { + if Decoder.is_null() { + return; + } + if Instruction.is_null() { + return; + } + let mut obj = Box::from_raw( Decoder ); + + obj.decode_out( Instruction.as_mut().unwrap() ); + + Box::into_raw( obj ); +} + +type + TDecoderCallback = unsafe extern "C" fn( Instruction: *mut Instruction, Stop : *mut bool, UserData : *const usize ); + +#[cfg(feature = "formatter")] +pub(crate) type + TDecoderFormatCallback = unsafe extern "C" fn( Instruction: *mut Instruction, Output : *const u8, Size : usize, Stop : *mut bool, UserData : *const usize ); + +#[no_mangle] +pub unsafe extern "C" fn Decoder_DecodeToEnd( Decoder: *mut Decoder, Callback: Option, UserData : *const usize ) { + if Decoder.is_null() { + return; + } + if Callback.is_none() { + return; + } + let mut obj = Box::from_raw( Decoder ); + + let mut Instruction: Instruction = Instruction::new(); + let mut Stop: bool = false; + while obj.can_decode() && !Stop { + obj.decode_out( &mut Instruction ); + Callback.unwrap()( &mut Instruction, &mut Stop, UserData ); + } + + Box::into_raw( obj ); +} + +// Gets the offsets of the constants ( memory displacement and immediate ) in the decoded instruction. +// The caller can check if there are any relocations at those addresses. +// +// # Arguments +// * `instruction`: The latest instruction that was decoded by this decoder +#[no_mangle] +pub unsafe extern "C" fn Decoder_GetConstantOffsets( Decoder: *mut Decoder, Instruction: *mut Instruction, ConstantOffsets : *mut ConstantOffsets ) -> bool { + if Decoder.is_null() { + return false; + } + let obj = Box::from_raw( Decoder ); + + *ConstantOffsets = obj.get_constant_offsets( Instruction.as_mut().unwrap() ); + + Box::into_raw( obj ); + return true; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/DecoderError.rs b/src/rust/iced-x86-c/src/DecoderError.rs new file mode 100644 index 000000000..3e4ffa37e --- /dev/null +++ b/src/rust/iced-x86-c/src/DecoderError.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::DecoderError; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn DecoderError_AsString( DecoderError : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: DecoderError + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let DecoderError : DecoderError = transmute( DecoderError as u8 ); + let output = format!("{DecoderError:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/Encoder.rs b/src/rust/iced-x86-c/src/Encoder.rs new file mode 100644 index 000000000..5203eddf5 --- /dev/null +++ b/src/rust/iced-x86-c/src/Encoder.rs @@ -0,0 +1,370 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, Encoder, ConstantOffsets}; +use std::ptr::null_mut; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Encoder + +// Creates an encoder +// +// Returns NULL if `bitness` is not one of 16, 32, 64. +// +// # Arguments +// * `bitness`: 16, 32 or 64 +#[no_mangle] +pub extern "C" fn Encoder_Create( Bitness: u32, Capacity: usize ) -> *mut Encoder { + if Capacity > 0 { + match Encoder::try_with_capacity( Bitness, Capacity ) { + Ok( value ) => return Box::into_raw( Box::new( value ) ), + Err( _e ) => return null_mut() + } + }else { + match Encoder::try_new( Bitness ) { + Ok( value ) => return Box::into_raw( Box::new( value ) ), + Err( _e ) => return null_mut() + } + } +} + +// Encodes an instruction and returns the size of the encoded instruction +// +// # Result +// * Returns written amount of encoded Bytes +// +// # Arguments +// * `instruction`: Instruction to encode +// * `rip`: `RIP` of the encoded instruction +#[no_mangle] +pub unsafe extern "C" fn Encoder_Encode( Encoder: *mut Encoder, Instruction: *mut Instruction, RIP: u64 ) -> usize { + if Encoder.is_null() { + return 0; + } + let mut obj = Box::from_raw( Encoder ); + + let value = obj.encode( Instruction.as_mut().unwrap(), RIP ); + + Box::into_raw( obj ); + + match value { + Ok( v ) => return v, + Err( _e ) => return 0, + } +} + +// Writes a byte to the output buffer +// +// # Arguments +// +// `value`: Value to write +#[no_mangle] +pub unsafe extern "C" fn Encoder_WriteByte( Encoder: *mut Encoder, Value : u8 ) -> bool { + if Encoder.is_null() { + return false; + } + let mut obj = Box::from_raw( Encoder ); + + obj.write_u8( Value ); + + Box::into_raw( obj ); + + return true; +} + +// Returns the buffer and initializes the internal buffer to an empty vector. Should be called when +// you've encoded all instructions and need the raw instruction bytes. See also [ `Encoder_SetBuffer()` ]. +#[no_mangle] +pub unsafe extern "C" fn Encoder_GetBuffer( Encoder: *mut Encoder, Buffer : *mut u8, Size : usize ) -> bool { + if Encoder.is_null() { + return false; + } + + if Buffer.is_null() { + return false; + } + + if Size <= 0 { + return false; + } + + let mut obj = Box::from_raw( Encoder ); + + let value = obj.take_buffer(); + Box::into_raw( obj ); + + let mut l = value.len(); + if l > Size { + l = Size; + } + + if l > 0 { + for i in 0..l { + *( Buffer.add( i ) ) = value[ i ]; + } + } + *( Buffer.add( l ) ) = 0; + + return true; +} + +// Overwrites the buffer with a new vector. The old buffer is dropped. See also [ `Encoder_GetBuffer()` ]. +// NOTE: Monitor the result of [`Encoder_Encode`] (Encoded Bytes). +// DO NOT Encode more Bytes than fitting your provided Buffer as this would cause a realloc - which will lead to an access violation. +// Disabled: Unsetting the Buffer seems impossible as Rust wants to deallocate the Vector .. +/* +#[no_mangle] +pub unsafe extern "C" fn Encoder_SetBuffer( Encoder: *mut Encoder, Buffer : *mut u8, Size : usize ) -> bool { + if Encoder.is_null() { + return false; + } + + if !Buffer.is_null() && ( Size <= 0 ) { + return false; + } + + let mut obj = Box::from_raw( Encoder ); + + if Buffer.is_null() { + obj.set_buffer( Vec::new() ); + }else { + obj.set_buffer( Vec::from_raw_parts( Buffer, 0/*Used*/, Size/*TotalSize*/ ) ); + } + + Box::into_raw( obj ); + + return true; +} +*/ + +// Gets the offsets of the constants ( memory displacement and immediate ) in the encoded instruction. +// The caller can use this information to add relocations if needed. +#[no_mangle] +pub unsafe extern "C" fn Encoder_GetConstantOffsets( Encoder: *mut Encoder, ConstantOffsets : *mut ConstantOffsets ) { + if Encoder.is_null() { + return; + } + let obj = Box::from_raw( Encoder ); + *ConstantOffsets = obj.get_constant_offsets(); + + Box::into_raw( obj ); +} + +// Disables 2-byte VEX encoding and encodes all VEX instructions with the 3-byte VEX encoding +#[no_mangle] +pub unsafe extern "C" fn Encoder_GetPreventVex2( Encoder: *mut Encoder ) -> bool { + if Encoder.is_null() { + return false; + } + let obj = Box::from_raw( Encoder ); + + let value = obj.prevent_vex2(); + + Box::into_raw( obj ); + + return value; +} + +// Disables 2-byte VEX encoding and encodes all VEX instructions with the 3-byte VEX encoding +// +// # Arguments +// * `new_value`: new value +#[no_mangle] +pub unsafe extern "C" fn Encoder_SetPreventVex2( Encoder: *mut Encoder, Value : bool ) -> bool { + if Encoder.is_null() { + return false; + } + let mut obj = Box::from_raw( Encoder ); + + obj.set_prevent_vex2( Value ); + + Box::into_raw( obj ); + + return true; +} + +// Value of the `VEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. +#[no_mangle] +pub unsafe extern "C" fn Encoder_GetVexWig( Encoder: *mut Encoder ) -> u32 { + if Encoder.is_null() { + return 0; + } + let obj = Box::from_raw( Encoder ); + + let value = obj.vex_wig(); + + Box::into_raw( obj ); + + return value; +} + +// Value of the `VEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. +// +// # Arguments +// * `new_value`: new value ( 0 or 1 ) +#[no_mangle] +pub unsafe extern "C" fn Encoder_SetVexWig( Encoder: *mut Encoder, Value : u32 ) -> bool { + if Encoder.is_null() { + return false; + } + let mut obj = Box::from_raw( Encoder ); + + obj.set_vex_wig( Value ); + + Box::into_raw( obj ); + + return true; +} + +// Value of the `VEX.L` bit to use if it's an instruction that ignores the bit. Default is 0. +#[no_mangle] +pub unsafe extern "C" fn Encoder_GetVexLig( Encoder: *mut Encoder ) -> u32 { + if Encoder.is_null() { + return 0; + } + let obj = Box::from_raw( Encoder ); + + let value = obj.vex_lig(); + + Box::into_raw( obj ); + + return value; +} + +// Value of the `VEX.L` bit to use if it's an instruction that ignores the bit. Default is 0. +// +// # Arguments +// * `new_value`: new value ( 0 or 1 ) +#[no_mangle] +pub unsafe extern "C" fn Encoder_SetVexLig( Encoder: *mut Encoder, Value : u32 ) -> bool { + if Encoder.is_null() { + return false; + } + let mut obj = Box::from_raw( Encoder ); + + obj.set_vex_lig( Value ); + + Box::into_raw( obj ); + + return true; +} + +// Value of the `EVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. +#[no_mangle] +pub unsafe extern "C" fn Encoder_GetEvexWig( Encoder: *mut Encoder ) -> u32 { + if Encoder.is_null() { + return 0; + } + let obj = Box::from_raw( Encoder ); + + let value = obj.evex_wig(); + + Box::into_raw( obj ); + + return value; +} + +// Value of the `EVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. +// +// # Arguments +// * `new_value`: new value ( 0 or 1 ) +#[no_mangle] +pub unsafe extern "C" fn Encoder_SetEvexWig( Encoder: *mut Encoder, Value : u32 ) -> bool { + if Encoder.is_null() { + return false; + } + let mut obj = Box::from_raw( Encoder ); + + obj.set_evex_wig( Value ); + + Box::into_raw( obj ); + + return true; +} + +// Value of the `EVEX.L'L` bits to use if it's an instruction that ignores the bits. Default is 0. +#[no_mangle] +pub unsafe extern "C" fn Encoder_GetEvexLig( Encoder: *mut Encoder ) -> u32 { + if Encoder.is_null() { + return 0; + } + let obj = Box::from_raw( Encoder ); + + let value = obj.evex_lig(); + + Box::into_raw( obj ); + + return value; +} + +// Value of the `EVEX.L'L` bits to use if it's an instruction that ignores the bits. Default is 0. +// +// # Arguments +// * `new_value`: new value ( 0 or 3 ) +#[no_mangle] +pub unsafe extern "C" fn Encoder_SetEvexLig( Encoder: *mut Encoder, Value : u32 ) -> bool { + if Encoder.is_null() { + return false; + } + let mut obj = Box::from_raw( Encoder ); + + obj.set_evex_lig( Value ); + + Box::into_raw( obj ); + + return true; +} + +// Value of the `MVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn Encoder_GetMvexWig( Encoder: *mut Encoder ) -> u32 { + if Encoder.is_null() { + return 0; + } + let obj = Box::from_raw( Encoder ); + + let value = obj.mvex_wig(); + + Box::into_raw( obj ); + + return value; +} + +// Value of the `MVEX.W` bit to use if it's an instruction that ignores the bit. Default is 0. +// +// # Arguments +// * `new_value`: new value ( 0 or 1 ) +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn Encoder_SetMvexWig( Encoder: *mut Encoder, Value : u32 ) -> bool { + if Encoder.is_null() { + return false; + } + let mut obj = Box::from_raw( Encoder ); + + obj.set_mvex_wig( Value ); + + Box::into_raw( obj ); + + return true; +} + +// Gets the bitness ( 16, 32 or 64 ) +#[no_mangle] +pub unsafe extern "C" fn Encoder_GetBitness( Encoder: *mut Encoder ) -> u32 { + if Encoder.is_null() { + return 0; + } + let obj = Box::from_raw( Encoder ); + + let value = obj.bitness(); + + Box::into_raw( obj ); + + return value; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/EncodingKind.rs b/src/rust/iced-x86-c/src/EncodingKind.rs new file mode 100644 index 000000000..40d4822a8 --- /dev/null +++ b/src/rust/iced-x86-c/src/EncodingKind.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::EncodingKind; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn EncodingKind_AsString( EncodingKind : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: EncodingKind + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let encodingKind : EncodingKind = transmute( EncodingKind as u8 ); + let output = format!("{encodingKind:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/FastFormatter.rs b/src/rust/iced-x86-c/src/FastFormatter.rs new file mode 100644 index 000000000..0fc0ee868 --- /dev/null +++ b/src/rust/iced-x86-c/src/FastFormatter.rs @@ -0,0 +1,151 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, SpecializedFormatter, DefaultFastFormatterTraitOptions}; +#[cfg(feature = "decoder")] +use iced_x86_rust::Decoder; +use crate::SymbolResolver::{TSymbolResolver, TSymbolResolverCallback}; +#[cfg(feature = "decoder")] +use crate::Decoder::TDecoderFormatCallback; +use std::ptr::null_mut; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Fast-Formatter +pub(crate) type + TFastFormatterDefault = SpecializedFormatter; + +pub(crate) struct TFastFormatter { + pub Formatter : TFastFormatterDefault, + pub Output : String, +} + +// Creates a Fast formatter +#[no_mangle] +pub extern "C" fn FastFormatter_Create( SymbolResolver : Option, UserData : *const usize ) -> *mut TFastFormatter { + if !SymbolResolver.is_none() { + let symbols = Box::new( TSymbolResolver { callback:SymbolResolver, userData:UserData }); + + match TFastFormatterDefault::try_with_options( Some( symbols ) ) { + Ok( value ) => return Box::into_raw( Box::new( TFastFormatter { Formatter: value, Output: String::new() } ) ), + Err( _e ) => return null_mut() + } + } else { + match TFastFormatterDefault::try_with_options( None ) { + Ok( value ) => return Box::into_raw( Box::new( TFastFormatter { Formatter: value, Output: String::new() } ) ), + Err( _e ) => return null_mut() + } + } +} + +// Format Instruction +#[no_mangle] +pub unsafe extern "C" fn FastFormatter_Format( Formatter: *mut TFastFormatter, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); +} + +// Decode and Format Instruction +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn FastFormatter_DecodeFormat( Decoder: *mut Decoder, Formatter: *mut TFastFormatter, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + // Decode + let mut obj = Box::from_raw( Decoder ); + obj.decode_out( Instruction.as_mut().unwrap() ); + Box::into_raw( obj ); + + // Format + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); +} + +// Decode and Format Instruction until end +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn FastFormatter_DecodeFormatToEnd( Decoder: *mut Decoder, Formatter: *mut TFastFormatter, Callback: Option, UserData : *const usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Callback.is_none() { + return; + } + + // Decode + let mut decoder = Box::from_raw( Decoder ); + let mut formatter = Box::from_raw( Formatter ); + let mut stop: bool = false; + let mut instruction: Instruction = Instruction::new(); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + // Format + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + + if formatter.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *formatter.Output.as_mut_ptr().add(formatter.Output.len()) = 0; + } else { + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + } + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw( formatter ); + Box::into_raw( decoder ); +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/FlowControl.rs b/src/rust/iced-x86-c/src/FlowControl.rs new file mode 100644 index 000000000..76667c8c1 --- /dev/null +++ b/src/rust/iced-x86-c/src/FlowControl.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::FlowControl; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn FlowControl_AsString( FlowControl : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: FlowControl + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let flowControl : FlowControl = transmute( FlowControl as u8 ); + let output = format!("{flowControl:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/Formatter.rs b/src/rust/iced-x86-c/src/Formatter.rs new file mode 100644 index 000000000..c17eb6abd --- /dev/null +++ b/src/rust/iced-x86-c/src/Formatter.rs @@ -0,0 +1,7570 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, Formatter}; +use crate::OutputCallback::TFormatterOutput; +#[cfg(feature = "masm")] +use crate::MasmFormatter::TMasmFormatter; +#[cfg(feature = "nasm")] +use crate::NasmFormatter::TNasmFormatter; +#[cfg(feature = "gas")] +use crate::GasFormatter::TGasFormatter; +#[cfg(feature = "intel")] +use crate::IntelFormatter::TIntelFormatter; +#[cfg(feature = "fast_fmt")] +use crate::FastFormatter::TFastFormatter; +#[cfg(feature = "fast_fmt")] +use crate::SpecializedFormatter::TSpecializedFormatter; +use std::{slice, str}; +use libc::{c_char, strlen}; +use std::mem::transmute;// Enum<->Int + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Formatter Options +enum TFormatterType { + #[cfg(feature = "masm")] + Masm, + #[cfg(feature = "nasm")] + Nasm, + #[cfg(feature = "gas")] + Gas, + #[cfg(feature = "intel")] + Intel, + #[cfg(feature = "fast_fmt")] + Fast, + #[cfg(feature = "fast_fmt")] + Specialized, + #[cfg(feature = "masm")] + Capstone, + + End +} + +#[no_mangle] +pub unsafe extern "C" fn Formatter_Format( Formatter: *mut u8, FormatterType : u8, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + Box::into_raw( obj ); + } + _ => { return; } + } +} + +#[no_mangle] +pub unsafe extern "C" fn Formatter_FormatCallback( Formatter: *mut u8, FormatterType : u8, Instruction: *mut Instruction, FormatterOutput : *mut TFormatterOutput ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if FormatterOutput.is_null() { + return; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( obj ); + Box::into_raw( output ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( obj ); + Box::into_raw( output ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( obj ); + Box::into_raw( output ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( obj ); + Box::into_raw( output ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( obj ); + Box::into_raw( output ); + } + */ + _ => { return; } + } +} + +// Prefixes are uppercased +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `REP stosd` +// 👍 | `false` | `rep stosd` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetUpperCasePrefixes( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().uppercase_prefixes(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().uppercase_prefixes(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().uppercase_prefixes(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().uppercase_prefixes(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().uppercase_prefixes(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().uppercase_prefixes(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Prefixes are uppercased +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `REP stosd` +// 👍 | `false` | `rep stosd` +// +// # Arguments +// +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetUpperCasePrefixes( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_uppercase_prefixes( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_uppercase_prefixes( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_uppercase_prefixes( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_uppercase_prefixes( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_uppercase_prefixes( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_uppercase_prefixes( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonics are uppercased +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `MOV rcx,rax` +// 👍 | `false` | `mov rcx,rax` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetUpperCaseMnemonics( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().uppercase_mnemonics(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().uppercase_mnemonics(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().uppercase_mnemonics(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().uppercase_mnemonics(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().uppercase_mnemonics(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().uppercase_mnemonics(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Mnemonics are uppercased +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `MOV rcx,rax` +// 👍 | `false` | `mov rcx,rax` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetUpperCaseMnemonics( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_uppercase_mnemonics( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_uppercase_mnemonics( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_uppercase_mnemonics( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_uppercase_mnemonics( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_uppercase_mnemonics( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_uppercase_mnemonics( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Registers are uppercased +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov RCX,[ RAX+RDX*8 ]` +// 👍 | `false` | `mov rcx,[ rax+rdx*8 ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetUpperCaseRegisters( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().uppercase_registers(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().uppercase_registers(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().uppercase_registers(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().uppercase_registers(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().uppercase_registers(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().uppercase_registers(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Registers are uppercased +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov RCX,[ RAX+RDX*8 ]` +// 👍 | `false` | `mov rcx,[ rax+rdx*8 ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetUpperCaseRegisters( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_uppercase_registers( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_uppercase_registers( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_uppercase_registers( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_uppercase_registers( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_uppercase_registers( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_uppercase_registers( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Keywords are uppercased ( eg. `BYTE PTR`, `SHORT` ) +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov BYTE PTR [ rcx ],12h` +// 👍 | `false` | `mov byte ptr [ rcx ],12h` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetUpperCaseKeyWords( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().uppercase_keywords(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().uppercase_keywords(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().uppercase_keywords(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().uppercase_keywords(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().uppercase_keywords(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().uppercase_keywords(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Keywords are uppercased ( eg. `BYTE PTR`, `SHORT` ) +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov BYTE PTR [ rcx ],12h` +// 👍 | `false` | `mov byte ptr [ rcx ],12h` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetUpperCaseKeyWords( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_uppercase_keywords( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_uppercase_keywords( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_uppercase_keywords( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_uppercase_keywords( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_uppercase_keywords( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_uppercase_keywords( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Uppercase decorators, eg. `{z}`, `{sae}`, `{rd-sae}` ( but not opmask registers: `{k1}` ) +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `vunpcklps xmm2{k5}{Z},xmm6,dword bcst [ rax+4 ]` +// 👍 | `false` | `vunpcklps xmm2{k5}{z},xmm6,dword bcst [ rax+4 ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetUpperCaseDecorators( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().uppercase_decorators(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().uppercase_decorators(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().uppercase_decorators(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().uppercase_decorators(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().uppercase_decorators(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().uppercase_decorators(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Uppercase decorators, eg. `{z}`, `{sae}`, `{rd-sae}` ( but not opmask registers: `{k1}` ) +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `vunpcklps xmm2{k5}{Z},xmm6,dword bcst [ rax+4 ]` +// 👍 | `false` | `vunpcklps xmm2{k5}{z},xmm6,dword bcst [ rax+4 ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetUpperCaseDecorators( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_uppercase_decorators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_uppercase_decorators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_uppercase_decorators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_uppercase_decorators( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_uppercase_decorators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_uppercase_decorators( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Everything is uppercased, except numbers and their prefixes/suffixes +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `MOV EAX,GS:[ RCX*4+0ffh ]` +// 👍 | `false` | `mov eax,gs:[ rcx*4+0ffh ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetUpperCaseEverything( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().uppercase_all(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().uppercase_all(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().uppercase_all(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().uppercase_all(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().uppercase_all(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().uppercase_all(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Everything is uppercased, except numbers and their prefixes/suffixes +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `MOV EAX,GS:[ RCX*4+0ffh ]` +// 👍 | `false` | `mov eax,gs:[ rcx*4+0ffh ]` +// +// # Arguments +// +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetUpperCaseEverything( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_uppercase_all( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_uppercase_all( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_uppercase_all( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_uppercase_all( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_uppercase_all( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_uppercase_all( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Character index ( 0-based ) where the first operand is formatted. Can be set to 0 to format it immediately after the mnemonic. +// At least one space or tab is always added between the mnemonic and the first operand. +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `0` | `mov•rcx,rbp` +// _ | `8` | `mov•••••rcx,rbp` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetFirstOperandCharIndex( Formatter: *mut u8, FormatterType: u8 ) -> u32 { + if Formatter.is_null() { + return 0; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().first_operand_char_index(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().first_operand_char_index(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().first_operand_char_index(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().first_operand_char_index(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().first_operand_char_index(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().first_operand_char_index(); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Character index ( 0-based ) where the first operand is formatted. Can be set to 0 to format it immediately after the mnemonic. +// At least one space or tab is always added between the mnemonic and the first operand. +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `0` | `mov•rcx,rbp` +// _ | `8` | `mov•••••rcx,rbp` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetFirstOperandCharIndex( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_first_operand_char_index( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_first_operand_char_index( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_first_operand_char_index( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_first_operand_char_index( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_first_operand_char_index( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_first_operand_char_index( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Size of a tab character or 0 to use spaces +// +// - Default: `0` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetTabSize( Formatter: *mut u8, FormatterType: u8 ) -> u32 { + if Formatter.is_null() { + return 0; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().tab_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().tab_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().tab_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().tab_size(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().tab_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().tab_size(); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Size of a tab character or 0 to use spaces +// +// - Default: `0` +// +// # Arguments +// +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetTabSize( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_tab_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_tab_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_tab_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_tab_size( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_tab_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_tab_size( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Add a space after the operand separator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov rax, rcx` +// 👍 | `false` | `mov rax,rcx` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetSpaceAfterOperandSeparator( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().space_after_operand_separator(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().space_after_operand_separator(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().space_after_operand_separator(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().space_after_operand_separator(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().space_after_operand_separator(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().space_after_operand_separator(); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return value; +} + +// Add a space after the operand separator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov rax, rcx` +// 👍 | `false` | `mov rax,rcx` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetSpaceAfterOperandSeparator( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_space_after_operand_separator( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_space_after_operand_separator( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_space_after_operand_separator( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_space_after_operand_separator( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_space_after_operand_separator( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_space_after_operand_separator( Value ); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return true; +} + +// Add a space between the memory expression and the brackets +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[rcx+rdx ]` +// 👍 | `false` | `mov eax,[ rcx+rdx ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetSpaceAfterMemoryBracket( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().space_after_memory_bracket(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().space_after_memory_bracket(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().space_after_memory_bracket(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().space_after_memory_bracket(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().space_after_memory_bracket(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().space_after_memory_bracket(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Add a space between the memory expression and the brackets +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[rcx+rdx ]` +// 👍 | `false` | `mov eax,[ rcx+rdx ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetSpaceAfterMemoryBracket( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_space_after_memory_bracket( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_space_after_memory_bracket( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_space_after_memory_bracket( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_space_after_memory_bracket( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_space_after_memory_bracket( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_space_after_memory_bracket( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Add spaces between memory operand `+` and `-` operators +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ rcx + rdx*8 - 80h ]` +// 👍 | `false` | `mov eax,[ rcx+rdx*8-80h ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetSpaceBetweenMemoryAddOperators( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().space_between_memory_add_operators(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().space_between_memory_add_operators(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().space_between_memory_add_operators(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().space_between_memory_add_operators(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().space_between_memory_add_operators(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().space_between_memory_add_operators(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Add spaces between memory operand `+` and `-` operators +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ rcx + rdx*8 - 80h ]` +// 👍 | `false` | `mov eax,[ rcx+rdx*8-80h ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetSpaceBetweenMemoryAddOperators( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_space_between_memory_add_operators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_space_between_memory_add_operators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_space_between_memory_add_operators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_space_between_memory_add_operators( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_space_between_memory_add_operators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_space_between_memory_add_operators( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Add spaces between memory operand `*` operator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ rcx+rdx * 8-80h ]` +// 👍 | `false` | `mov eax,[ rcx+rdx*8-80h ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetSpaceBetweenMemoryMulOperators( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().space_between_memory_mul_operators(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().space_between_memory_mul_operators(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().space_between_memory_mul_operators(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().space_between_memory_mul_operators(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().space_between_memory_mul_operators(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().space_between_memory_mul_operators(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Add spaces between memory operand `*` operator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ rcx+rdx * 8-80h ]` +// 👍 | `false` | `mov eax,[ rcx+rdx*8-80h ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetSpaceBetweenMemoryMulOperators( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_space_between_memory_mul_operators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_space_between_memory_mul_operators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_space_between_memory_mul_operators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_space_between_memory_mul_operators( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_space_between_memory_mul_operators( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_space_between_memory_mul_operators( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Show memory operand scale value before the index register +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ 8*rdx ]` +// 👍 | `false` | `mov eax,[ rdx*8 ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetScaleBeforeIndex( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().scale_before_index(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().scale_before_index(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().scale_before_index(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().scale_before_index(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().scale_before_index(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().scale_before_index(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Show memory operand scale value before the index register +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ 8*rdx ]` +// 👍 | `false` | `mov eax,[ rdx*8 ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetScaleBeforeIndex( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_scale_before_index( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_scale_before_index( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_scale_before_index( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_scale_before_index( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_scale_before_index( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_scale_before_index( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Always show the scale value even if it's `*1` +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ rbx+rcx*1 ]` +// 👍 | `false` | `mov eax,[ rbx+rcx ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetAlwaysShowScale( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().always_show_scale(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().always_show_scale(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().always_show_scale(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().always_show_scale(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().always_show_scale(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().always_show_scale(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Always show the scale value even if it's `*1` +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ rbx+rcx*1 ]` +// 👍 | `false` | `mov eax,[ rbx+rcx ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetAlwaysShowScale( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_always_show_scale( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_always_show_scale( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_always_show_scale( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_always_show_scale( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_always_show_scale( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_always_show_scale( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Always show the effective segment register. If the option is `false`, only show the segment register if +// there's a segment override prefix. +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,ds:[ ecx ]` +// 👍 | `false` | `mov eax,[ ecx ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetAlwaysShowSegmentRegister( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().always_show_segment_register(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().always_show_segment_register(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().always_show_segment_register(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().always_show_segment_register(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().always_show_segment_register(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().always_show_segment_register(); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return value; +} + +// Always show the effective segment register. If the option is `false`, only show the segment register if +// there's a segment override prefix. +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,ds:[ ecx ]` +// 👍 | `false` | `mov eax,[ ecx ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetAlwaysShowSegmentRegister( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_always_show_segment_register( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_always_show_segment_register( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_always_show_segment_register( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_always_show_segment_register( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_always_show_segment_register( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_always_show_segment_register( Value ); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return true; +} + +// Show zero displacements +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ rcx*2+0 ]` +// 👍 | `false` | `mov eax,[ rcx*2 ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetShowZeroDisplacements( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().show_zero_displacements(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().show_zero_displacements(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().show_zero_displacements(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().show_zero_displacements(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().show_zero_displacements(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().show_zero_displacements(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Show zero displacements +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ rcx*2+0 ]` +// 👍 | `false` | `mov eax,[ rcx*2 ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetShowZeroDisplacements( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_show_zero_displacements( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_show_zero_displacements( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_show_zero_displacements( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_show_zero_displacements( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_show_zero_displacements( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_show_zero_displacements( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Hex number prefix or an empty string, eg. `"0x"` +// +// - Default: `""` ( masm/nasm/intel ), `"0x"` ( gas ) +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetHexPrefix( Formatter: *mut u8, FormatterType: u8, Value : *mut u8, Size : usize ) -> usize { + if Formatter.is_null() { + return 0; + } + if Value.is_null() { + return 0; + } + + if Size <= 0 { + return 0 + } + + let n: usize; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + let tmp = obj.Formatter.options_mut().hex_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + let tmp = obj.Formatter.options_mut().hex_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + let tmp = obj.Formatter.options_mut().hex_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + let tmp = obj.Formatter.options_mut().hex_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + let tmp = obj.Formatter.options_mut().hex_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + let tmp = obj.Formatter.options_mut().hex_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return n; +} + +// Hex number prefix or an empty string, eg. `"0x"` +// +// - Default: `""` ( masm/nasm/intel ), `"0x"` ( gas ) +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetHexPrefix( Formatter: *mut u8, FormatterType : u8, Value : *const c_char ) -> bool { + if Formatter.is_null() { + return false; + } + + let value = { + let c_s = Value; + str::from_utf8_unchecked( slice::from_raw_parts( c_s as *const u8, strlen( c_s ) ) ).to_owned() + }; + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_hex_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_hex_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_hex_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_hex_prefix_string( value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_hex_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_hex_prefix_string( value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Hex number suffix or an empty string, eg. `"h"` +// +// - Default: `"h"` ( masm/nasm/intel ), `""` ( gas ) +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetHexSuffix( Formatter: *mut u8, FormatterType: u8, Value : *mut u8, Size : usize ) -> usize { + if Formatter.is_null() { + return 0; + } + if Value.is_null() { + return 0; + } + + if Size <= 0 { + return 0 + } + + let n: usize; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + let tmp = obj.Formatter.options_mut().hex_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + let tmp = obj.Formatter.options_mut().hex_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + let tmp = obj.Formatter.options_mut().hex_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + let tmp = obj.Formatter.options_mut().hex_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + let tmp = obj.Formatter.options_mut().hex_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + let tmp = obj.Formatter.options_mut().hex_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return n; +} + +// Hex number suffix or an empty string, eg. `"h"` +// +// - Default: `"h"` ( masm/nasm/intel ), `""` ( gas ) +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetHexSuffix( Formatter: *mut u8, FormatterType : u8, Value : *const c_char ) -> bool { + if Formatter.is_null() { + return false; + } + + let value = { + let c_s = Value; + str::from_utf8_unchecked( slice::from_raw_parts( c_s as *const u8, strlen( c_s ) ) ).to_owned() + }; + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_hex_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_hex_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_hex_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_hex_suffix_string( value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_hex_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_hex_suffix_string( value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Size of a digit group, see also [ `digit_separator()` ] +// +// [ `digit_separator()` ]: #method.digit_separator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `0` | `0x12345678` +// 👍 | `4` | `0x1234_5678` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetHexDigitGroupSize( Formatter: *mut u8, FormatterType: u8 ) -> u32 { + if Formatter.is_null() { + return 0; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().hex_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().hex_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().hex_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().hex_digit_group_size(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().hex_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().hex_digit_group_size(); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Size of a digit group, see also [ `digit_separator()` ] +// +// [ `digit_separator()` ]: #method.digit_separator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `0` | `0x12345678` +// 👍 | `4` | `0x1234_5678` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetHexDigitGroupSize( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_hex_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_hex_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_hex_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_hex_digit_group_size( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_hex_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_hex_digit_group_size( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Decimal number prefix or an empty string +// +// - Default: `""` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetDecimalPrefix( Formatter: *mut u8, FormatterType: u8, Value : *mut u8, Size : usize ) -> usize { + if Formatter.is_null() { + return 0; + } + if Value.is_null() { + return 0; + } + + if Size <= 0 { + return 0 + } + + let n: usize; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + let tmp = obj.Formatter.options_mut().decimal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + let tmp = obj.Formatter.options_mut().decimal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + let tmp = obj.Formatter.options_mut().decimal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + let tmp = obj.Formatter.options_mut().decimal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + let tmp = obj.Formatter.options_mut().decimal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + let tmp = obj.Formatter.options_mut().decimal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return n; +} + +// Decimal number prefix or an empty string +// +// - Default: `""` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetDecimalPrefix( Formatter: *mut u8, FormatterType : u8, Value : *const c_char ) -> bool { + if Formatter.is_null() { + return false; + } + + let value = { + let c_s = Value; + str::from_utf8_unchecked( slice::from_raw_parts( c_s as *const u8, strlen( c_s ) ) ).to_owned() + }; + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_decimal_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_decimal_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_decimal_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_decimal_prefix_string( value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_decimal_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_decimal_prefix_string( value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Decimal number suffix or an empty string +// +// - Default: `""` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetDecimalSuffix( Formatter: *mut u8, FormatterType: u8, Value : *mut u8, Size : usize ) -> usize { + if Formatter.is_null() { + return 0; + } + if Value.is_null() { + return 0; + } + + if Size <= 0 { + return 0 + } + + let n: usize; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + let tmp = obj.Formatter.options_mut().decimal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + let tmp = obj.Formatter.options_mut().decimal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + let tmp = obj.Formatter.options_mut().decimal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + let tmp = obj.Formatter.options_mut().decimal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + let tmp = obj.Formatter.options_mut().decimal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + let tmp = obj.Formatter.options_mut().decimal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return n; +} + +// Decimal number suffix or an empty string +// +// - Default: `""` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetDecimalSuffix( Formatter: *mut u8, FormatterType : u8, Value : *const c_char ) -> bool { + if Formatter.is_null() { + return false; + } + + let value = { + let c_s = Value; + str::from_utf8_unchecked( slice::from_raw_parts( c_s as *const u8, strlen( c_s ) ) ).to_owned() + }; + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_decimal_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_decimal_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_decimal_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_decimal_suffix_string( value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_decimal_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_decimal_suffix_string( value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Size of a digit group, see also [ `digit_separator()` ] +// +// [ `digit_separator()` ]: #method.digit_separator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `0` | `12345678` +// 👍 | `3` | `12_345_678` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetDecimalDigitGroupSize( Formatter: *mut u8, FormatterType: u8 ) -> u32 { + if Formatter.is_null() { + return 0; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().decimal_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().decimal_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().decimal_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().decimal_digit_group_size(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().decimal_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().decimal_digit_group_size(); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Size of a digit group, see also [ `digit_separator()` ] +// +// [ `digit_separator()` ]: #method.digit_separator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `0` | `12345678` +// 👍 | `3` | `12_345_678` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetDecimalDigitGroupSize( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_decimal_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_decimal_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_decimal_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_decimal_digit_group_size( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_decimal_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_decimal_digit_group_size( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Octal number prefix or an empty string +// +// - Default: `""` ( masm/nasm/intel ), `"0"` ( gas ) +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetOctalPrefix( Formatter: *mut u8, FormatterType: u8, Value : *mut u8, Size : usize ) -> usize { + if Formatter.is_null() { + return 0; + } + if Value.is_null() { + return 0; + } + + if Size <= 0 { + return 0 + } + + let n: usize; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + let tmp = obj.Formatter.options_mut().octal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + let tmp = obj.Formatter.options_mut().octal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + let tmp = obj.Formatter.options_mut().octal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + let tmp = obj.Formatter.options_mut().octal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + let tmp = obj.Formatter.options_mut().octal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + let tmp = obj.Formatter.options_mut().octal_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return n; +} + +// Octal number prefix or an empty string +// +// - Default: `""` ( masm/nasm/intel ), `"0"` ( gas ) +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetOctalPrefix( Formatter: *mut u8, FormatterType : u8, Value : *const c_char ) -> bool { + if Formatter.is_null() { + return false; + } + + let value = { + let c_s = Value; + str::from_utf8_unchecked( slice::from_raw_parts( c_s as *const u8, strlen( c_s ) ) ).to_owned() + }; + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_octal_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_octal_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_octal_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_octal_prefix_string( value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_octal_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_octal_prefix_string( value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Octal number suffix or an empty string +// +// - Default: `"o"` ( masm/nasm/intel ), `""` ( gas ) +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetOctalSuffix( Formatter: *mut u8, FormatterType: u8, Value : *mut u8, Size : usize ) -> usize { + if Formatter.is_null() { + return 0; + } + if Value.is_null() { + return 0; + } + + if Size <= 0 { + return 0 + } + + let n: usize; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + let tmp = obj.Formatter.options_mut().octal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + let tmp = obj.Formatter.options_mut().octal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + let tmp = obj.Formatter.options_mut().octal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + let tmp = obj.Formatter.options_mut().octal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + let tmp = obj.Formatter.options_mut().octal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + let tmp = obj.Formatter.options_mut().octal_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return n; +} + +// Octal number suffix or an empty string +// +// - Default: `"o"` ( masm/nasm/intel ), `""` ( gas ) +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetOctalSuffix( Formatter: *mut u8, FormatterType : u8, Value : *const c_char ) -> bool { + if Formatter.is_null() { + return false; + } + + let value = { + let c_s = Value; + str::from_utf8_unchecked( slice::from_raw_parts( c_s as *const u8, strlen( c_s ) ) ).to_owned() + }; + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_octal_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_octal_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_octal_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_octal_suffix_string( value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_octal_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_octal_suffix_string( value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Size of a digit group, see also [ `digit_separator()` ] +// +// [ `digit_separator()` ]: #method.digit_separator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `0` | `12345670` +// 👍 | `4` | `1234_5670` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetOctalDigitGroupSize( Formatter: *mut u8, FormatterType: u8 ) -> u32 { + if Formatter.is_null() { + return 0; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().octal_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().octal_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().octal_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().octal_digit_group_size(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().octal_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().octal_digit_group_size(); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Size of a digit group, see also [ `digit_separator()` ] +// +// [ `digit_separator()` ]: #method.digit_separator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `0` | `12345670` +// 👍 | `4` | `1234_5670` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetOctalDigitGroupSize( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_octal_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_octal_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_octal_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_octal_digit_group_size( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_octal_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_octal_digit_group_size( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Binary number prefix or an empty string +// +// - Default: `""` ( masm/nasm/intel ), `"0b"` ( gas ) +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetBinaryPrefix( Formatter: *mut u8, FormatterType: u8, Value : *mut u8, Size : usize ) -> usize { + if Formatter.is_null() { + return 0; + } + if Value.is_null() { + return 0; + } + + if Size <= 0 { + return 0 + } + + let n: usize; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + let tmp = obj.Formatter.options_mut().binary_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + let tmp = obj.Formatter.options_mut().binary_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + let tmp = obj.Formatter.options_mut().binary_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + let tmp = obj.Formatter.options_mut().binary_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + let tmp = obj.Formatter.options_mut().binary_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + let tmp = obj.Formatter.options_mut().binary_prefix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return n; +} + +// Binary number prefix or an empty string +// +// - Default: `""` ( masm/nasm/intel ), `"0b"` ( gas ) +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetBinaryPrefix( Formatter: *mut u8, FormatterType : u8, Value : *const c_char ) -> bool { + if Formatter.is_null() { + return false; + } + + let value = { + let c_s = Value; + str::from_utf8_unchecked( slice::from_raw_parts( c_s as *const u8, strlen( c_s ) ) ).to_owned() + }; + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_binary_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_binary_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_binary_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_binary_prefix_string( value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_binary_prefix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_binary_prefix_string( value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Binary number suffix or an empty string +// +// - Default: `"b"` ( masm/nasm/intel ), `""` ( gas ) +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetBinarySuffix( Formatter: *mut u8, FormatterType: u8, Value : *mut u8, Size : usize ) -> usize { + if Formatter.is_null() { + return 0; + } + if Value.is_null() { + return 0; + } + + if Size <= 0 { + return 0 + } + + let n: usize; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + let tmp = obj.Formatter.options_mut().binary_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + let tmp = obj.Formatter.options_mut().binary_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + let tmp = obj.Formatter.options_mut().binary_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + let tmp = obj.Formatter.options_mut().binary_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + let tmp = obj.Formatter.options_mut().binary_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + let tmp = obj.Formatter.options_mut().binary_suffix(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return n; +} + +// Binary number suffix or an empty string +// +// - Default: `"b"` ( masm/nasm/intel ), `""` ( gas ) +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetBinarySuffix( Formatter: *mut u8, FormatterType : u8, Value : *const c_char ) -> bool { + if Formatter.is_null() { + return false; + } + + let value = { + let c_s = Value; + str::from_utf8_unchecked( slice::from_raw_parts( c_s as *const u8, strlen( c_s ) ) ).to_owned() + }; + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_binary_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_binary_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_binary_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_binary_suffix_string( value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_binary_suffix_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_binary_suffix_string( value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Size of a digit group, see also [ `digit_separator()` ] +// +// [ `digit_separator()` ]: #method.digit_separator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `0` | `11010111` +// 👍 | `4` | `1101_0111` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetBinaryDigitGroupSize( Formatter: *mut u8, FormatterType: u8 ) -> u32 { + if Formatter.is_null() { + return 0; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().binary_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().binary_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().binary_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().binary_digit_group_size(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().binary_digit_group_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().binary_digit_group_size(); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Size of a digit group, see also [ `digit_separator()` ] +// +// [ `digit_separator()` ]: #method.digit_separator +// +// Default | Value | Example +// --------|-------|-------- +// _ | `0` | `11010111` +// 👍 | `4` | `1101_0111` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetBinaryDigitGroupSize( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_binary_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_binary_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_binary_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_binary_digit_group_size( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_binary_digit_group_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_binary_digit_group_size( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Digit separator or an empty string. See also eg. [ `hex_digit_group_size()` ] +// +// [ `hex_digit_group_size()` ]: #method.hex_digit_group_size +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `""` | `0x12345678` +// _ | `"_"` | `0x1234_5678` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetDigitSeparator( Formatter: *mut u8, FormatterType: u8, Value : *mut u8, Size : usize ) -> usize { + if Formatter.is_null() { + return 0; + } + if Value.is_null() { + return 0; + } + + if Size <= 0 { + return 0 + } + + let n: usize; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + let tmp = obj.Formatter.options_mut().digit_separator(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + let tmp = obj.Formatter.options_mut().digit_separator(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + let tmp = obj.Formatter.options_mut().digit_separator(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + let tmp = obj.Formatter.options_mut().digit_separator(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + let tmp = obj.Formatter.options_mut().digit_separator(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + let tmp = obj.Formatter.options_mut().digit_separator(); + + let aValue = Value as *mut [u8;1024]; + let aTmp = tmp.as_bytes(); + + n = std::cmp::min( aTmp.len(), Size/*(*aValue).len()*/ ); + (*aValue)[0..n].copy_from_slice(&aTmp[0..n]); + (*aValue)[n] = 0; + + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return n; +} + +// Digit separator or an empty string. See also eg. [ `hex_digit_group_size()` ] +// +// [ `hex_digit_group_size()` ]: #method.hex_digit_group_size +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `""` | `0x12345678` +// _ | `"_"` | `0x1234_5678` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetDigitSeparator( Formatter: *mut u8, FormatterType : u8, Value : *const c_char ) -> bool { + if Formatter.is_null() { + return false; + } + + let value = { + let c_s = Value; + str::from_utf8_unchecked( slice::from_raw_parts( c_s as *const u8, strlen( c_s ) ) ).to_owned() + }; + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_digit_separator_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_digit_separator_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_digit_separator_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_digit_separator_string( value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_digit_separator_string( value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_digit_separator_string( value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Add leading zeros to hexadecimal/octal/binary numbers. +// This option has no effect on branch targets and displacements, use [ `branch_leading_zeros` ] +// and [ `displacement_leading_zeros` ]. +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `0x0000000A`/`0000000Ah` +// 👍 | `false` | `0xA`/`0Ah` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetLeadingZeros( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().leading_zeros(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().leading_zeros(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().leading_zeros(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().leading_zeros(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().leading_zeros(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().leading_zeros(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Add leading zeros to hexadecimal/octal/binary numbers. +// This option has no effect on branch targets and displacements, use [ `branch_leading_zeros` ] +// and [ `displacement_leading_zeros` ]. +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `0x0000000A`/`0000000Ah` +// 👍 | `false` | `0xA`/`0Ah` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetLeadingZeros( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_leading_zeros( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_leading_zeros( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Use uppercase hex digits +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `0xFF` +// _ | `false` | `0xff` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetUppercaseHex( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().uppercase_hex(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().uppercase_hex(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().uppercase_hex(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().uppercase_hex(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().uppercase_hex(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().uppercase_hex(); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return value; +} + +// Use uppercase hex digits +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `0xFF` +// _ | `false` | `0xff` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetUppercaseHex( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_uppercase_hex( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_uppercase_hex( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_uppercase_hex( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_uppercase_hex( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_uppercase_hex( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_uppercase_hex( Value ); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return true; +} + +// Small hex numbers ( -9 .. 9 ) are shown in decimal +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `9` +// _ | `false` | `0x9` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetSmallHexNumbersInDecimal( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().small_hex_numbers_in_decimal(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().small_hex_numbers_in_decimal(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().small_hex_numbers_in_decimal(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().small_hex_numbers_in_decimal(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().small_hex_numbers_in_decimal(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().small_hex_numbers_in_decimal(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Small hex numbers ( -9 .. 9 ) are shown in decimal +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `9` +// _ | `false` | `0x9` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetSmallHexNumbersInDecimal( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_small_hex_numbers_in_decimal( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_small_hex_numbers_in_decimal( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_small_hex_numbers_in_decimal( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_small_hex_numbers_in_decimal( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_small_hex_numbers_in_decimal( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_small_hex_numbers_in_decimal( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Add a leading zero to hex numbers if there's no prefix and the number starts with hex digits `A-F` +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `0FFh` +// _ | `false` | `FFh` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetAddLeadingZeroToHexNumbers( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().add_leading_zero_to_hex_numbers(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().add_leading_zero_to_hex_numbers(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().add_leading_zero_to_hex_numbers(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().add_leading_zero_to_hex_numbers(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().add_leading_zero_to_hex_numbers(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().add_leading_zero_to_hex_numbers(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Add a leading zero to hex numbers if there's no prefix and the number starts with hex digits `A-F` +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `0FFh` +// _ | `false` | `FFh` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetAddLeadingZeroToHexNumbers( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_add_leading_zero_to_hex_numbers( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_add_leading_zero_to_hex_numbers( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_add_leading_zero_to_hex_numbers( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_add_leading_zero_to_hex_numbers( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_add_leading_zero_to_hex_numbers( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_add_leading_zero_to_hex_numbers( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Number base +// +// - Default: [ `Hexadecimal` ] +// +// [ `Hexadecimal` ]: enum.NumberBase.html#variant.Hexadecimal +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetNumberBase( Formatter: *mut u8, FormatterType: u8 ) -> u32 { // FFI-Unsafe: NumberBase + if Formatter.is_null() { + return 0;// NumberBase::Hexadecimal; + } + + let value: u32/*TNumberBase*/; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().number_base() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().number_base() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().number_base() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().number_base() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().number_base() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().number_base() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Number base +// +// - Default: [ `Hexadecimal` ] +// +// [ `Hexadecimal` ]: enum.NumberBase.html#variant.Hexadecimal +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetNumberBase( Formatter: *mut u8, FormatterType : u8, Value : u32 /*NumberBase*/ ) -> bool { // FFI-Unsafe: + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_number_base( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_number_base( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_number_base( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_number_base( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_number_base( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_number_base( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Add leading zeros to branch offsets. Used by `CALL NEAR`, `CALL FAR`, `JMP NEAR`, `JMP FAR`, `Jcc`, `LOOP`, `LOOPcc`, `XBEGIN` +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `je 00000123h` +// _ | `false` | `je 123h` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetBranchLeadingZeros( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().show_zero_displacements(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().branch_leading_zeros(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().branch_leading_zeros(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().branch_leading_zeros(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().branch_leading_zeros(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().branch_leading_zeros(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Add leading zeros to branch offsets. Used by `CALL NEAR`, `CALL FAR`, `JMP NEAR`, `JMP FAR`, `Jcc`, `LOOP`, `LOOPcc`, `XBEGIN` +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `je 00000123h` +// _ | `false` | `je 123h` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetBranchLeadingZeros( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_branch_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_branch_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_branch_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_branch_leading_zeros( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_branch_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_branch_leading_zeros( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Show immediate operands as signed numbers +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,-1` +// 👍 | `false` | `mov eax,FFFFFFFF` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetSignedImmediateOperands( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().signed_immediate_operands(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().signed_immediate_operands(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().signed_immediate_operands(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().signed_immediate_operands(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().signed_immediate_operands(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().signed_immediate_operands(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Show immediate operands as signed numbers +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,-1` +// 👍 | `false` | `mov eax,FFFFFFFF` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetSignedImmediateOperands( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_signed_immediate_operands( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_signed_immediate_operands( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_signed_immediate_operands( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_signed_immediate_operands( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_signed_immediate_operands( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_signed_immediate_operands( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Displacements are signed numbers +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `mov al,[ eax-2000h ]` +// _ | `false` | `mov al,[ eax+0FFFFE000h ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetSignedMemoryDisplacements( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().signed_memory_displacements(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().signed_memory_displacements(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().signed_memory_displacements(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().signed_memory_displacements(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().signed_memory_displacements(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().signed_memory_displacements(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Displacements are signed numbers +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `mov al,[ eax-2000h ]` +// _ | `false` | `mov al,[ eax+0FFFFE000h ]` +// +// # Arguments +// +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetSignedMemoryDisplacements( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_signed_memory_displacements( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_signed_memory_displacements( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_signed_memory_displacements( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_signed_memory_displacements( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_signed_memory_displacements( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_signed_memory_displacements( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Add leading zeros to displacements +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov al,[ eax+00000012h ]` +// 👍 | `false` | `mov al,[ eax+12h ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetDisplacementLeadingZeros( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().displacement_leading_zeros(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().displacement_leading_zeros(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().displacement_leading_zeros(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().displacement_leading_zeros(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().displacement_leading_zeros(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().displacement_leading_zeros(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Add leading zeros to displacements +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov al,[ eax+00000012h ]` +// 👍 | `false` | `mov al,[ eax+12h ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetDisplacementLeadingZeros( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_displacement_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_displacement_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_displacement_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_displacement_leading_zeros( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_displacement_leading_zeros( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_displacement_leading_zeros( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Options that control if the memory size ( eg. `DWORD PTR` ) is shown or not. +// This is ignored by the gas ( AT&T ) formatter. +// +// - Default: [ `Default` ] +// +// [ `Default` ]: enum.MemorySizeOptions.html#variant.Default +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetMemorySizeOptions( Formatter: *mut u8, FormatterType: u8 ) -> u32 { // FFI-Unsafe: MemorySizeOptions + if Formatter.is_null() { + return 0;// MemorySizeOptions::Default; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().memory_size_options() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().memory_size_options() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().memory_size_options() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().memory_size_options() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().memory_size_options() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().memory_size_options() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Options that control if the memory size ( eg. `DWORD PTR` ) is shown or not. +// This is ignored by the gas ( AT&T ) formatter. +// +// - Default: [ `Default` ] +// +// [ `Default` ]: enum.MemorySizeOptions.html#variant.Default +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetMemorySizeOptions( Formatter: *mut u8, FormatterType : u8, Value : u32 /*MemorySizeOptions*/ ) -> bool { // FFI-Unsafe: MemorySizeOptions + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_memory_size_options( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_memory_size_options( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_memory_size_options( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_memory_size_options( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_memory_size_options( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_memory_size_options( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Show `RIP+displ` or the virtual address +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ rip+12345678h ]` +// 👍 | `false` | `mov eax,[ 1029384756AFBECDh ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetRipRelativeAddresses( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().rip_relative_addresses(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().rip_relative_addresses(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().rip_relative_addresses(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().rip_relative_addresses(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().rip_relative_addresses(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().rip_relative_addresses(); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return value; +} + +// Show `RIP+displ` or the virtual address +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ rip+12345678h ]` +// 👍 | `false` | `mov eax,[ 1029384756AFBECDh ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetRipRelativeAddresses( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_rip_relative_addresses( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_rip_relative_addresses( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_rip_relative_addresses( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_rip_relative_addresses( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_rip_relative_addresses( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_rip_relative_addresses( Value ); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return true; +} + +// Show `NEAR`, `SHORT`, etc if it's a branch instruction +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `je short 1234h` +// _ | `false` | `je 1234h` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetShowBranchSize( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().show_branch_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().show_branch_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().show_branch_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().show_branch_size(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().show_branch_size(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().show_branch_size(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Show `NEAR`, `SHORT`, etc if it's a branch instruction +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `je short 1234h` +// _ | `false` | `je 1234h` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetShowBranchSize( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_show_branch_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_show_branch_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_show_branch_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_show_branch_size( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_show_branch_size( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_show_branch_size( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Use pseudo instructions +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `vcmpnltsd xmm2,xmm6,xmm3` +// _ | `false` | `vcmpsd xmm2,xmm6,xmm3,5` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetUsePseudoOps( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().use_pseudo_ops(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().use_pseudo_ops(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().use_pseudo_ops(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().use_pseudo_ops(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().use_pseudo_ops(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().use_pseudo_ops(); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return value; +} + +// Use pseudo instructions +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `vcmpnltsd xmm2,xmm6,xmm3` +// _ | `false` | `vcmpsd xmm2,xmm6,xmm3,5` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetUsePseudoOps( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_use_pseudo_ops( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_use_pseudo_ops( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_use_pseudo_ops( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_use_pseudo_ops( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_use_pseudo_ops( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_use_pseudo_ops( Value ); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return true; +} + +// Show the original value after the symbol name +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ myfield ( 12345678 ) ]` +// 👍 | `false` | `mov eax,[ myfield ]` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetShowSymbolAddress( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().show_symbol_address(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().show_symbol_address(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().show_symbol_address(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().show_symbol_address(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().show_symbol_address(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().show_symbol_address(); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return value; +} + +// Show the original value after the symbol name +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,[ myfield ( 12345678 ) ]` +// 👍 | `false` | `mov eax,[ myfield ]` +// +// # Arguments +// +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetShowSymbolAddress( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_show_symbol_address( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_show_symbol_address( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_show_symbol_address( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_show_symbol_address( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_show_symbol_address( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_show_symbol_address( Value ); + Box::into_raw( obj ); + } + _ => { return false; } + } + + return true; +} + +// Use `st( 0 )` instead of `st` if `st` can be used. Ignored by the nasm formatter. +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `fadd st( 0 ),st( 3 )` +// 👍 | `false` | `fadd st,st( 3 )` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetPreferST0( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().prefer_st0(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().prefer_st0(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().prefer_st0(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().prefer_st0(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().prefer_st0(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().prefer_st0(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Use `st( 0 )` instead of `st` if `st` can be used. Ignored by the nasm formatter. +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `fadd st( 0 ),st( 3 )` +// 👍 | `false` | `fadd st,st( 3 )` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetPreferST0( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_prefer_st0( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_prefer_st0( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_prefer_st0( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_prefer_st0( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_prefer_st0( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_prefer_st0( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Show useless prefixes. If it has useless prefixes, it could be data and not code. +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `es rep add eax,ecx` +// 👍 | `false` | `add eax,ecx` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetShowUselessPrefixes( Formatter: *mut u8, FormatterType: u8 ) -> bool { + if Formatter.is_null() { + return false; + } + + let value: bool; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = obj.Formatter.options_mut().show_useless_prefixes(); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = obj.Formatter.options_mut().show_useless_prefixes(); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = obj.Formatter.options_mut().show_useless_prefixes(); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = obj.Formatter.options_mut().show_useless_prefixes(); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = obj.Formatter.options_mut().show_useless_prefixes(); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = obj.Formatter.options_mut().show_useless_prefixes(); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return value; +} + +// Show useless prefixes. If it has useless prefixes, it could be data and not code. +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `es rep add eax,ecx` +// 👍 | `false` | `add eax,ecx` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetShowUselessPrefixes( Formatter: *mut u8, FormatterType : u8, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_show_useless_prefixes( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_show_useless_prefixes( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_show_useless_prefixes( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_show_useless_prefixes( Value ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_show_useless_prefixes( Value ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_show_useless_prefixes( Value ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JB` / `JC` / `JNAE` ) +// +// Default: `JB`, `CMOVB`, `SETB` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_b( Formatter: *mut u8, FormatterType: u8 ) -> u32 { // FFI-Unsafe: CC_b + if Formatter.is_null() { + return 0;// CC_b::b; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_b() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_b() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_b() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_b() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_b() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_b() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JB` / `JC` / `JNAE` ) +// +// Default: `JB`, `CMOVB`, `SETB` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_b( Formatter: *mut u8, FormatterType : u8, Value : u32/*CC_b*/ ) -> bool { // FFI-Unsafe: CC_b + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_b( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_b( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_b( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_b( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_b( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_b( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JAE` / `JNB` / `JNC` ) +// +// Default: `JAE`, `CMOVAE`, `SETAE` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_ae( Formatter: *mut u8, FormatterType: u8 ) -> u32 { // FFI-Unsafe: CC_ae + if Formatter.is_null() { + return 0;// CC_ae::ae; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ae() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ae() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ae() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ae() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ae() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ae() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JAE` / `JNB` / `JNC` ) +// +// Default: `JAE`, `CMOVAE`, `SETAE` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_ae( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { // FFI-Unsafe: CC_ae + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_ae( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_ae( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_ae( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_ae( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_ae( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_ae( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JE` / `JZ` ) +// +// Default: `JE`, `CMOVE`, `SETE`, `LOOPE`, `REPE` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_e( Formatter: *mut u8, FormatterType: u8 ) -> u32 { // FFI-Unsafe: CC_e + if Formatter.is_null() { + return 0;// CC_e::e; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_e() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_e() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_e() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_e() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_e() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_e() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JE` / `JZ` ) +// +// Default: `JE`, `CMOVE`, `SETE`, `LOOPE`, `REPE` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_e( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { // FFI-Unsafe: CC_e + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_e( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_e( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_e( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_e( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_e( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_e( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JNE` / `JNZ` ) +// +// Default: `JNE`, `CMOVNE`, `SETNE`, `LOOPNE`, `REPNE` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_ne( Formatter: *mut u8, FormatterType: u8 ) -> u32 { // FFI-Unsafe: CC_ne + if Formatter.is_null() { + return 0;// CC_ne::ne; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ne() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ne() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ne() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ne() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ne() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ne() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JNE` / `JNZ` ) +// +// Default: `JNE`, `CMOVNE`, `SETNE`, `LOOPNE`, `REPNE` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_ne( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { // FFI-Unsafe: CC_ne + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_ne( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_ne( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_ne( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_ne( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_ne( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_ne( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JBE` / `JNA` ) +// +// Default: `JBE`, `CMOVBE`, `SETBE` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_be( Formatter: *mut u8, FormatterType: u8 ) -> u32 { // FFI-Unsafe: CC_be + if Formatter.is_null() { + return 0;// CC_be::be; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_be() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_be() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_be() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_be() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_be() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_be() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JBE` / `JNA` ) +// +// Default: `JBE`, `CMOVBE`, `SETBE` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_be( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { // FFI-Unsafe: CC_be + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_be( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_be( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_be( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_be( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_be( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_be( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JA` / `JNBE` ) +// +// Default: `JA`, `CMOVA`, `SETA` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_a( Formatter: *mut u8, FormatterType : u8 ) -> u32 { // FFI-Unsafe: CC_a + if Formatter.is_null() { + return 0;// CC_a::a; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_a() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_a() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_a() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_a() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_a() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_a() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JA` / `JNBE` ) +// +// Default: `JA`, `CMOVA`, `SETA` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_a( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { // FFI-Unsafe: CC_a + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_a( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_a( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_a( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_a( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_a( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_a( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JP` / `JPE` ) +// +// Default: `JP`, `CMOVP`, `SETP` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_p( Formatter: *mut u8, FormatterType : u8 ) -> u32 { // FFI-Unsafe: CC_p + if Formatter.is_null() { + return 0;// CC_p::p; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_p() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_p() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_p() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_p() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_p() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_p() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JP` / `JPE` ) +// +// Default: `JP`, `CMOVP`, `SETP` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_p( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { // FFI-Unsafe: CC_p + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_p( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_p( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_p( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_p( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_p( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_p( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JNP` / `JPO` ) +// +// Default: `JNP`, `CMOVNP`, `SETNP` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_np( Formatter: *mut u8, FormatterType : u8 ) -> u32 { // FFI-Unsafe: CC_np + if Formatter.is_null() { + return 0;// CC_np::np; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_np() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_np() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_np() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_np() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_np() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_np() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JNP` / `JPO` ) +// +// Default: `JNP`, `CMOVNP`, `SETNP` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_np( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { // FFI-Unsafe: CC_np + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_np( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_np( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_np( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_np( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_np( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_np( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JL` / `JNGE` ) +// +// Default: `JL`, `CMOVL`, `SETL` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_l( Formatter: *mut u8, FormatterType: u8 ) -> u32 { // FFI-Unsafe: CC_l + if Formatter.is_null() { + return 0;// CC_l::l; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_l() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_l() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_l() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_l() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_l() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_l() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JL` / `JNGE` ) +// +// Default: `JL`, `CMOVL`, `SETL` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_l( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { // FFI-Unsafe: CC_l + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_l( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_l( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_l( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_l( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_l( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_l( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JGE` / `JNL` ) +// +// Default: `JGE`, `CMOVGE`, `SETGE` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_ge( Formatter: *mut u8, FormatterType : u8 ) -> u32 { // FFI-Unsafe: CC_ge + if Formatter.is_null() { + return 0;// CC_ge::ge; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ge() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ge() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ge() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ge() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ge() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_ge() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JGE` / `JNL` ) +// +// Default: `JGE`, `CMOVGE`, `SETGE` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_ge( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { // FFI-Unsafe: CC_ge + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_ge( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_ge( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_ge( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_ge( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_ge( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_ge( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JLE` / `JNG` ) +// +// Default: `JLE`, `CMOVLE`, `SETLE` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_le( Formatter: *mut u8, FormatterType : u8 ) -> u32 { // FFI-Unsafe: CC_le + if Formatter.is_null() { + return 0;// CC_le::le; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_le() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_le() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_le() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_le() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_le() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_le() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JLE` / `JNG` ) +// +// Default: `JLE`, `CMOVLE`, `SETLE` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_le( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { // FFI-Unsafe: CC_le + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_le( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_le( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_le( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_le( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_le( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_le( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} + +// Mnemonic condition code selector ( eg. `JG` / `JNLE` ) +// +// Default: `JG`, `CMOVG`, `SETG` +#[no_mangle] +pub unsafe extern "C" fn Formatter_GetCC_g( Formatter: *mut u8, FormatterType : u8 ) -> u32 { // FFI-Unsafe: CC_g + if Formatter.is_null() { + return 0;// CC_g::g; + } + + let value: u32; + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_g() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + value = transmute( obj.Formatter.options_mut().cc_g() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + value = transmute( obj.Formatter.options_mut().cc_g() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + value = transmute( obj.Formatter.options_mut().cc_g() as u32 ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + value = transmute( obj.Formatter.options_mut().cc_g() as u32 ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + value = transmute( obj.Formatter.options_mut().cc_g() as u32 ); + Box::into_raw( obj ); + } + */ + _ => { return 0; } + } + + return value; +} + +// Mnemonic condition code selector ( eg. `JG` / `JNLE` ) +// +// Default: `JG`, `CMOVG`, `SETG` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn Formatter_SetCC_g( Formatter: *mut u8, FormatterType : u8, Value : u32 ) -> bool { // FFI-Unsafe: CC_h + if Formatter.is_null() { + return false; + } + + let formatterType : TFormatterType = transmute( FormatterType as u8 ); + match formatterType { + #[cfg(feature = "masm")] + TFormatterType::Masm | + TFormatterType::Capstone => { + let mut obj = Box::from_raw( Formatter as *mut TMasmFormatter ); + obj.Formatter.options_mut().set_cc_g( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "nasm")] + TFormatterType::Nasm => { + let mut obj = Box::from_raw( Formatter as *mut TNasmFormatter ); + obj.Formatter.options_mut().set_cc_g( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "gas")] + TFormatterType::Gas => { + let mut obj = Box::from_raw( Formatter as *mut TGasFormatter ); + obj.Formatter.options_mut().set_cc_g( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "intel")] + TFormatterType::Intel => { + let mut obj = Box::from_raw( Formatter as *mut TIntelFormatter ); + obj.Formatter.options_mut().set_cc_g( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } +/* + #[cfg(feature = "fast_fmt")] + TFormatterType::Fast => { + let mut obj = Box::from_raw( Formatter as *mut TFastFormatter ); + obj.Formatter.options_mut().set_cc_g( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + #[cfg(feature = "fast_fmt")] + TFormatterType::Specialized => { + let mut obj = Box::from_raw( Formatter as *mut TSpecializedFormatter ); + obj.Formatter.options_mut().set_cc_g( transmute( Value as u8 ) ); + Box::into_raw( obj ); + } + */ + _ => { return false; } + } + + return true; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/FormatterTextKind.rs b/src/rust/iced-x86-c/src/FormatterTextKind.rs new file mode 100644 index 000000000..6dbc67e85 --- /dev/null +++ b/src/rust/iced-x86-c/src/FormatterTextKind.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::FormatterTextKind; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn FormatterTextKind_AsString( FormatterTextKind : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: FormatterTextKind + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let formatterTextKind : FormatterTextKind = transmute( FormatterTextKind as u8 ); + let output = format!("{formatterTextKind:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/FreeMemory.rs b/src/rust/iced-x86-c/src/FreeMemory.rs new file mode 100644 index 000000000..2d82700af --- /dev/null +++ b/src/rust/iced-x86-c/src/FreeMemory.rs @@ -0,0 +1,18 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Free Memory +#[no_mangle] +pub unsafe extern "C" fn IcedFreeMemory( Pointer: *mut u8 ) -> bool { + if Pointer.is_null() { + return false; + } + + drop( Box::from_raw( Pointer ) ); + return true; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/GasFormatter.rs b/src/rust/iced-x86-c/src/GasFormatter.rs new file mode 100644 index 000000000..44083b467 --- /dev/null +++ b/src/rust/iced-x86-c/src/GasFormatter.rs @@ -0,0 +1,318 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, Formatter, GasFormatter}; +#[cfg(feature = "decoder")] +use iced_x86_rust::Decoder; +use crate::SymbolResolver::{TSymbolResolver, TSymbolResolverCallback}; +use crate::OptionsProvider::{TFormatterOptionsProvider, TFormatterOptionsProviderCallback}; +use crate::OutputCallback::TFormatterOutput; +#[cfg(feature = "decoder")] +use crate::Decoder::TDecoderFormatCallback; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Gas-Formatter +pub(crate) struct TGasFormatter { + pub Formatter : GasFormatter, + pub Output : String, + } + +// Creates a Gas formatter +// +// # Arguments +// - `symbol_resolver`: Symbol resolver or `None` +// - `options_provider`: Operand options provider or `None` +#[no_mangle] +pub extern "C" fn GasFormatter_Create( SymbolResolver : Option, OptionsProvider : Option, UserData : *const usize ) -> *mut TGasFormatter { + if !SymbolResolver.is_none() && !OptionsProvider.is_none() { + let symbols = Box::new( TSymbolResolver { callback:SymbolResolver, userData:UserData }); + let options = Box::new( TFormatterOptionsProvider { callback:OptionsProvider, userData:UserData }); + Box::into_raw( Box::new( TGasFormatter { Formatter: GasFormatter::with_options( Some( symbols ), Some( options ) ), Output: String::new() } ) ) + } else if !SymbolResolver.is_none() { + let symbols = Box::new( TSymbolResolver { callback:SymbolResolver, userData:UserData }); + Box::into_raw( Box::new( TGasFormatter { Formatter: GasFormatter::with_options( Some( symbols ), None ), Output: String::new() } ) ) + } else if !OptionsProvider.is_none() { + let options = Box::new( TFormatterOptionsProvider { callback:OptionsProvider, userData:UserData }); + Box::into_raw( Box::new( TGasFormatter { Formatter: GasFormatter::with_options( None, Some( options ) ), Output: String::new() } ) ) + } else { + Box::into_raw( Box::new( TGasFormatter { Formatter: GasFormatter::with_options( None, None ), Output: String::new() } ) ) + } +} + +// Format Instruction +#[no_mangle] +pub unsafe extern "C" fn GasFormatter_Format( Formatter: *mut TGasFormatter, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); + } + +#[no_mangle] +pub unsafe extern "C" fn GasFormatter_FormatCallback( Formatter: *mut TGasFormatter, Instruction: *mut Instruction, FormatterOutput : *mut TFormatterOutput ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if FormatterOutput.is_null() { + return; + } + + let mut obj = Box::from_raw( Formatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( output ); + Box::into_raw( obj ); +} + +// Decode and Format Instruction +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn GasFormatter_DecodeFormat( Decoder: *mut Decoder, Formatter: *mut TGasFormatter, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + // Decode + let mut obj = Box::from_raw( Decoder ); + obj.decode_out( Instruction.as_mut().unwrap() ); + Box::into_raw( obj ); + + // Format + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); +} + +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn GasFormatter_DecodeFormatCallback( Decoder: *mut Decoder, Formatter: *mut TGasFormatter, Instruction: *mut Instruction, FormatterOutput : *mut TFormatterOutput ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if FormatterOutput.is_null() { + return; + } + + // Decode + let mut obj = Box::from_raw( Decoder ); + obj.decode_out( Instruction.as_mut().unwrap() ); + Box::into_raw( obj ); + + // Format + let mut obj = Box::from_raw( Formatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( output ); + Box::into_raw( obj ); +} + +// Decode and Format Instruction until end +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn GasFormatter_DecodeFormatToEnd( Decoder: *mut Decoder, Formatter: *mut TGasFormatter, Callback: Option, UserData : *const usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Callback.is_none() { + return; + } + + // Decode + let mut decoder = Box::from_raw( Decoder ); + let mut formatter = Box::from_raw( Formatter ); + let mut stop: bool = false; + let mut instruction: Instruction = Instruction::new(); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + // Format + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw( formatter ); + Box::into_raw( decoder ); +} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// ( gas only ): If `true`, the formatter doesn't add `%` to registers +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,ecx` +// 👍 | `false` | `mov %eax,%ecx` +#[no_mangle] +pub unsafe extern "C" fn GasFormatter_GetNakedRegisters( Formatter: *mut TGasFormatter ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + let value = obj.Formatter.options_mut().gas_naked_registers(); + + Box::into_raw( obj ); + + return value; +} + +// ( gas only ): If `true`, the formatter doesn't add `%` to registers +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `mov eax,ecx` +// 👍 | `false` | `mov %eax,%ecx` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn GasFormatter_SetNakedRegisters( Formatter: *mut TGasFormatter, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + obj.Formatter.options_mut().set_gas_naked_registers( Value ); + + Box::into_raw( obj ); + + return true; +} + +// ( gas only ): Shows the mnemonic size suffix even when not needed +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `movl %eax,%ecx` +// 👍 | `false` | `mov %eax,%ecx` +#[no_mangle] +pub unsafe extern "C" fn GasFormatter_GetShowMnemonicSizeSuffix( Formatter: *mut TGasFormatter ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + let value = obj.Formatter.options_mut().gas_show_mnemonic_size_suffix(); + + Box::into_raw( obj ); + + return value; +} + +// ( gas only ): Shows the mnemonic size suffix even when not needed +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `movl %eax,%ecx` +// 👍 | `false` | `mov %eax,%ecx` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn GasFormatter_SetShowMnemonicSizeSuffix( Formatter: *mut TGasFormatter, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + obj.Formatter.options_mut().set_gas_show_mnemonic_size_suffix( Value ); + + Box::into_raw( obj ); + + return true; +} + +// ( gas only ): Add a space after the comma if it's a memory operand +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `( %eax, %ecx, 2 )` +// 👍 | `false` | `( %eax,%ecx,2 )` +#[no_mangle] +pub unsafe extern "C" fn GasFormatter_GetSpaceAfterMemoryOperandComma( Formatter: *mut TGasFormatter ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + let value = obj.Formatter.options_mut().gas_space_after_memory_operand_comma(); + + Box::into_raw( obj ); + + return value; +} + +// ( gas only ): Add a space after the comma if it's a memory operand +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `( %eax, %ecx, 2 )` +// 👍 | `false` | `( %eax,%ecx,2 )` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn GasFormatter_SetSpaceAfterMemoryOperandComma( Formatter: *mut TGasFormatter, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + obj.Formatter.options_mut().set_gas_space_after_memory_operand_comma( Value ); + + Box::into_raw( obj ); + + return true; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/Instruction.rs b/src/rust/iced-x86-c/src/Instruction.rs new file mode 100644 index 000000000..defa547ef --- /dev/null +++ b/src/rust/iced-x86-c/src/Instruction.rs @@ -0,0 +1,185 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, OpKind}; +#[cfg(feature = "instr_info")] +use iced_x86_rust::FpuStackIncrementInfo; +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Instruction + +// Gets the FPU status word's `TOP` increment and whether it's a conditional or unconditional push/pop +// and whether `TOP` is written. +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Instruction_FPU_StackIncrementInfo( Instruction: *mut Instruction, Info: *mut FpuStackIncrementInfo ) -> bool { + if Instruction.is_null() { + return false; + } + if Info.is_null() { + return false; + } + *Info = (*Instruction).fpu_stack_increment_info(); + + return true; +} + +// Gets the number of bytes added to `SP`/`ESP`/`RSP` or 0 if it's not an instruction that pushes or pops data. This method assumes +// the instruction doesn't change the privilege level (eg. `IRET/D/Q`). If it's the `LEAVE` instruction, this method returns 0. +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Instruction_StackPointerIncrement( Instruction: *mut Instruction ) -> i32 { + if Instruction.is_null() { + return 0; + } + + return (*Instruction).stack_pointer_increment(); +} + +// All flags that are read by the CPU when executing the instruction. +// This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Instruction_RFlagsRead( Instruction: *mut Instruction ) -> u32 { + if Instruction.is_null() { + return 0; + } + + return (*Instruction).rflags_read(); +} + +// All flags that are written by the CPU, except those flags that are known to be undefined, always set or always cleared. +// This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Instruction_RFlagsWritten( Instruction: *mut Instruction ) -> u32 { + if Instruction.is_null() { + return 0; + } + + return (*Instruction).rflags_written(); +} + +// All flags that are always cleared by the CPU. +// This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Instruction_RFlagsCleared( Instruction: *mut Instruction ) -> u32 { + if Instruction.is_null() { + return 0; + } + + return (*Instruction).rflags_cleared(); +} + +// All flags that are always set by the CPU. +// This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Instruction_RFlagsSet( Instruction: *mut Instruction ) -> u32 { + if Instruction.is_null() { + return 0; + } + + return (*Instruction).rflags_set(); +} + +// All flags that are undefined after executing the instruction. +// This method returns an [`RflagsBits`] value. See also [`rflags_modified()`]. +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Instruction_RFlagsUndefined( Instruction: *mut Instruction ) -> u32 { + if Instruction.is_null() { + return 0; + } + + return (*Instruction).rflags_undefined(); +} + +// All flags that are modified by the CPU. This is `rflags_written() + rflags_cleared() + rflags_set() + rflags_undefined()`. This method returns an [`RflagsBits`] value. +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Instruction_RFlagsModified( Instruction: *mut Instruction ) -> u32 { + if Instruction.is_null() { + return 0; + } + + return (*Instruction).rflags_modified(); +} + +// Gets all op kinds ([`op_count()`] values) +#[allow( non_upper_case_globals )] +pub const OPKindsMaxEntries : usize = 5; +//#[repr(C)] +#[repr(packed)] +pub struct TOPKindsArray { + Entries : [OpKind;OPKindsMaxEntries], + Count : u8 +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_OPKinds( Instruction: *mut Instruction, OPKinds : *mut TOPKindsArray ) -> bool { + if Instruction.is_null() { + return false; + } + if OPKinds.is_null() { + return false; + } + + let opkindsA = (*Instruction).op_kinds(); + + (*OPKinds).Count = opkindsA.len() as u8; + for ( i, x ) in opkindsA.enumerate() { + if i < (*OPKinds).Entries.len() { + (*OPKinds).Entries[ i ] = x; + } + } + + return true; +} + +// Gets the size of the memory location that is referenced by the operand. See also [`is_broadcast()`]. +// Use this method if the operand has kind [`OpKind::Memory`], +#[no_mangle] +pub unsafe extern "C" fn Instruction_MemorySize( Instruction: *mut Instruction ) -> u8 { + if Instruction.is_null() { + return 0; + } + + return (*Instruction).memory_size() as u8; +} + +// Gets the operand count. An instruction can have 0-5 operands. +#[no_mangle] +pub unsafe extern "C" fn Instruction_OPCount( Instruction: *mut Instruction ) -> u32 { + if Instruction.is_null() { + return 0; + } + + return (*Instruction).op_count(); +} + +// `true` if eviction hint bit is set (`{eh}`) (MVEX instructions only) +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn Instruction_IsMvexEvictionHint( Instruction: *mut Instruction ) -> bool { + if Instruction.is_null() { + return false; + } + + return (*Instruction).is_mvex_eviction_hint(); +} + +// (MVEX) Register/memory operand conversion function +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn Instruction_MvexRegMemConv( Instruction: *mut Instruction ) -> u8 { + if Instruction.is_null() { + return 0; + } + + return (*Instruction).mvex_reg_mem_conv() as u8; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/InstructionInfoFactory.rs b/src/rust/iced-x86-c/src/InstructionInfoFactory.rs new file mode 100644 index 000000000..bb29749af --- /dev/null +++ b/src/rust/iced-x86-c/src/InstructionInfoFactory.rs @@ -0,0 +1,122 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, InstructionInfoFactory, OpAccess}; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// InstructionInfoFactory + +// Creates a new instance. +// +// If you don't need to know register and memory usage, it's faster to call [`Instruction`] and +// [`Code`] methods such as [`Instruction::flow_control()`] instead of getting that info from this struct. +// +// [`Instruction`]: struct.Instruction.html +// [`Code`]: enum.Code.html +// [`Instruction::flow_control()`]: struct.Instruction.html#method.flow_control +#[no_mangle] +pub extern "C" fn InstructionInfoFactory_Create() -> *mut InstructionInfoFactory { + return Box::into_raw( Box::new( InstructionInfoFactory::new() ) ); +} + +// Creates a new [`InstructionInfo`], see also [`info()`]. +// +// If you don't need to know register and memory usage, it's faster to call [`Instruction`] and +// [`Code`] methods such as [`Instruction::flow_control()`] instead of getting that info from this struct. +#[allow( non_upper_case_globals )] +pub const UsedRegisterMaxEntries : usize = 100; +//#[repr(C)] +#[repr(packed)] +pub struct TUsedRegister { + register: u8/*Register*/, + access: u8/*OpAccess*/, +} +//#[repr(C)] +#[repr(packed)] +pub struct TUsedRegisterArray { + Entries : [TUsedRegister;UsedRegisterMaxEntries], + Count : u8 +} + +//#[repr(C)] +#[repr(packed)] +pub struct TUsedMemory { + displacement: u64, + segment: u8/*Register*/, + base: u8/*Register*/, + index: u8/*Register*/, + scale: u8, + memory_size: u8/*MemorySize*/, + access: u8/*OpAccess*/, + address_size: u8/*CodeSize*/, + vsib_size: u8, +} + +#[allow( non_upper_case_globals )] +pub const UsedMemoryMaxEntries : usize = 255; +//#[repr(C)] +#[repr(packed)] +pub struct TUsedMemoryArray { + Entries : [TUsedMemory;UsedMemoryMaxEntries], + Count : u8 +} + +//#[repr(C)] +#[repr(packed)] +pub struct TInstructionInfo { + used_registers: TUsedRegisterArray, + used_memory_locations: TUsedMemoryArray, + op_accesses: [OpAccess;5/*IcedConstants::MAX_OP_COUNT*/] +} + +#[no_mangle] +pub unsafe extern "C" fn InstructionInfoFactory_Info( InstructionInfoFactory: *mut InstructionInfoFactory, Instruction: *mut Instruction, InstructionInfo: *mut TInstructionInfo, Options: u32/*InstructionInfoOptions*/ ) -> bool { + if InstructionInfoFactory.is_null() { + return false; + } + if Instruction.is_null() { + return false; + } + if InstructionInfo.is_null() { + return false; + } + + let value = &*(*InstructionInfoFactory).info_options( &(*Instruction), Options ); + + let usedregistersA = value.used_registers(); + (*InstructionInfo).used_registers.Count = usedregistersA.len() as u8; + for ( i, x ) in usedregistersA.iter().enumerate() { + if i < UsedRegisterMaxEntries { + (*InstructionInfo).used_registers.Entries[ i ].register = x.register() as u8; + (*InstructionInfo).used_registers.Entries[ i ].access = x.access() as u8; + } + } + + let usedmemoryA = value.used_memory(); + (*InstructionInfo).used_memory_locations.Count = usedmemoryA.len() as u8; + for ( i, x ) in usedmemoryA.iter().enumerate() { + if i < UsedMemoryMaxEntries { + (*InstructionInfo).used_memory_locations.Entries[ i ].displacement = x.displacement(); + (*InstructionInfo).used_memory_locations.Entries[ i ].segment = x.segment() as u8; + (*InstructionInfo).used_memory_locations.Entries[ i ].base = x.base() as u8; + (*InstructionInfo).used_memory_locations.Entries[ i ].index = x.index() as u8; + (*InstructionInfo).used_memory_locations.Entries[ i ].scale = x.scale() as u8; + (*InstructionInfo).used_memory_locations.Entries[ i ].memory_size = x.memory_size() as u8; + (*InstructionInfo).used_memory_locations.Entries[ i ].access = x.access() as u8; + (*InstructionInfo).used_memory_locations.Entries[ i ].address_size = x.address_size() as u8; + (*InstructionInfo).used_memory_locations.Entries[ i ].vsib_size = x.vsib_size() as u8; + } + } + + (*InstructionInfo).op_accesses[ 0 ] = value.op0_access(); + (*InstructionInfo).op_accesses[ 1 ] = value.op1_access(); + (*InstructionInfo).op_accesses[ 2 ] = value.op2_access(); + (*InstructionInfo).op_accesses[ 3 ] = value.op3_access(); + (*InstructionInfo).op_accesses[ 4 ] = value.op4_access(); + + return true; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/InstructionWith.rs b/src/rust/iced-x86-c/src/InstructionWith.rs new file mode 100644 index 000000000..33ad2a65b --- /dev/null +++ b/src/rust/iced-x86-c/src/InstructionWith.rs @@ -0,0 +1,2505 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, Register, MemoryOperand, RepPrefixKind}; +use std::mem::transmute;// Enum<->Int + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Instruction 'WITH' +// Creates an instruction with no operands +#[no_mangle] +pub unsafe extern "C" fn Instruction_With( Instruction : *mut Instruction, Code : u16 ) -> bool { // FFI-Unsafe: Code + if Instruction.is_null() { + return false; + } + + (*Instruction) = Instruction::with( transmute( Code as u16 ) ); + return true; +} + +// Creates an instruction with 1 operand +// +// # Errors +// Fails if one of the operands is invalid (basic checks) +#[no_mangle] +pub unsafe extern "C" fn Instruction_With1_Register( Instruction : *mut Instruction, Code : u16, Register : u8 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register: Register = transmute( Register ); + match Instruction::with1( transmute( Code as u16 ), register ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With1_i32( Instruction : *mut Instruction, Code : u16, Immediate : i32 ) -> bool { // FFI-Unsafe: Code + if Instruction.is_null() { + return false; + } + + match Instruction::with1( transmute( Code as u16 ), Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With1_u32( Instruction : *mut Instruction, Code : u16, Immediate : u32 ) -> bool { // FFI-Unsafe: Code + if Instruction.is_null() { + return false; + } + + match Instruction::with1( transmute( Code as u16 ), Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[repr(C)] +//#[repr(packed)] +pub struct TMemoryOperand { + /// Segment override or [`Register::None`] + /// + /// [`Register::None`]: enum.Register.html#variant.None + pub segment_prefix: u8, // FFI-Unsafe: Register + + /// Base register or [`Register::None`] + /// + /// [`Register::None`]: enum.Register.html#variant.None + pub base: u8, // FFI-Unsafe: Register + + /// Index register or [`Register::None`] + /// + /// [`Register::None`]: enum.Register.html#variant.None + pub index: u8, // FFI-Unsafe: Register + + /// Index register scale (1, 2, 4, or 8) + pub scale: u32, + + /// Memory displacement + pub displacement: i64, + + /// 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn't fit in a `i8`), 2 (16-bit), 4 (32-bit) or 8 (64-bit) + pub displ_size: u32, + + /// `true` if it's broadcast memory (EVEX instructions) + pub is_broadcast: bool, +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With1_Memory( Instruction : *mut Instruction, Code : u16, Memory : *mut TMemoryOperand ) -> bool { // FFI-Unsafe: Code + if Instruction.is_null() { + return false; + } + + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with1( transmute( Code as u16 ), memory ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_Register_Register( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + match Instruction::with2( transmute( Code as u16 ), register1, register2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_Register_i32( Instruction : *mut Instruction, Code : u16, Register : u8, Immediate : i32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register: Register = transmute( Register ); + match Instruction::with2( transmute( Code as u16 ), register, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_Register_u32( Instruction : *mut Instruction, Code : u16, Register : u8, Immediate : u32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register: Register = transmute( Register ); + match Instruction::with2( transmute( Code as u16 ), register, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_Register_i64( Instruction : *mut Instruction, Code : u16, Register : u8, Immediate : i64 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register: Register = transmute( Register ); + match Instruction::with2( transmute( Code as u16 ), register, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_Register_u64( Instruction : *mut Instruction, Code : u16, Register : u8, Immediate : u64 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register: Register = transmute( Register ); + match Instruction::with2( transmute( Code as u16 ), register, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_Register_MemoryOperand( Instruction : *mut Instruction, Code : u16, Register : u8, Memory : *mut TMemoryOperand ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register: Register = transmute( Register as u8 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with2( transmute( Code as u16 ), register, memory ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_i32_Register( Instruction : *mut Instruction, Code : u16, Immediate : i32, Register : u8 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register: Register = transmute( Register ); + match Instruction::with2( transmute( Code as u16 ), Immediate, register ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_u32_Register( Instruction : *mut Instruction, Code : u16, Immediate : u32, Register : u8 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register: Register = transmute( Register ); + match Instruction::with2( transmute( Code as u16 ), Immediate, register ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_i32_i32( Instruction : *mut Instruction, Code : u16, Immediate1 : i32, Immediate2 : i32 ) -> bool { // FFI-Unsafe: Code + if Instruction.is_null() { + return false; + } + + match Instruction::with2( transmute( Code as u16 ), Immediate1, Immediate2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_u32_u32( Instruction : *mut Instruction, Code : u16, Immediate1 : u32, Immediate2 : u32 ) -> bool { // FFI-Unsafe: Code + if Instruction.is_null() { + return false; + } + + match Instruction::with2( transmute( Code as u16 ), Immediate1, Immediate2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_MemoryOperand_Register( Instruction : *mut Instruction, Code : u16, Memory : *mut TMemoryOperand, Register : u8 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + let register: Register = transmute( Register as u8 ); + + match Instruction::with2( transmute( Code as u16 ), memory, register ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_MemoryOperand_i32( Instruction : *mut Instruction, Code : u16, Memory : *mut TMemoryOperand, Immediate : i32 ) -> bool { // FFI-Unsafe: Code + if Instruction.is_null() { + return false; + } + + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with2( transmute( Code as u16 ), memory, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With2_MemoryOperand_u32( Instruction : *mut Instruction, Code : u16, Memory : *mut TMemoryOperand, Immediate : u32 ) -> bool { // FFI-Unsafe: Code + if Instruction.is_null() { + return false; + } + + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with2( transmute( Code as u16 ), memory, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_Register_Register_Register( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Register3 : u8 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let register3: Register = transmute( Register3 ); + + match Instruction::with3( transmute( Code as u16 ), register1, register2, register3 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_Register_Register_i32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Immediate : i32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + + match Instruction::with3( transmute( Code as u16 ), register1, register2, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_Register_Register_u32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Immediate : u32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + + match Instruction::with3( transmute( Code as u16 ), register1, register2, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_Register_Register_MemoryOperand( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Memory : *mut TMemoryOperand ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with3( transmute( Code as u16 ), register1, register2, memory ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_Register_i32_i32( Instruction : *mut Instruction, Code : u16, Register : u8, Immediate1 : i32, Immediate2 : i32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register: Register = transmute( Register ); + + match Instruction::with3( transmute( Code as u16 ), register, Immediate1, Immediate2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_Register_u32_u32( Instruction : *mut Instruction, Code : u16, Register : u8, Immediate1 : u32, Immediate2 : u32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register: Register = transmute( Register as u8 ); + + match Instruction::with3( transmute( Code as u16 ), register, Immediate1, Immediate2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_Register_MemoryOperand_Register( Instruction : *mut Instruction, Code : u16, Register1 : u8, Memory : *mut TMemoryOperand, Register2 : u8 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + let register2: Register = transmute( Register2 ); + + match Instruction::with3( transmute( Code as u16 ), register1, memory, register2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_Register_MemoryOperand_i32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Memory : *mut TMemoryOperand, Immediate : i32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with3( transmute( Code as u16 ), register1, memory, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_Register_MemoryOperand_u32( Instruction : *mut Instruction, Code : u16, Register : u8, Memory : *mut TMemoryOperand, Immediate : u32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register: Register = transmute( Register as u8 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with3( transmute( Code as u16 ), register, memory, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_MemoryOperand_Register_Register( Instruction : *mut Instruction, Code : u16, Memory : *mut TMemoryOperand, Register1 : u8, Register2 : u8 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + + match Instruction::with3( transmute( Code as u16 ), memory, register1, register2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_MemoryOperand_Register_i32( Instruction : *mut Instruction, Code : u16, Memory : *mut TMemoryOperand, Register : u8, Immediate : i32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + let register: Register = transmute( Register ); + + match Instruction::with3( transmute( Code as u16 ), memory, register, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With3_MemoryOperand_Register_u32( Instruction : *mut Instruction, Code : u16, Memory : *mut TMemoryOperand, Register : u8, Immediate : u32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + let register: Register = transmute( Register ); + + match Instruction::with3( transmute( Code as u16 ), memory, register, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With4_Register_Register_Register_Register( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Register3 : u8, Register4 : u8 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let register3: Register = transmute( Register3 ); + let register4: Register = transmute( Register4 ); + + match Instruction::with4( transmute( Code as u16 ), register1, register2, register3, register4 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With4_Register_Register_Register_i32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Register3 : u8, Immediate : i32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let register3: Register = transmute( Register3 ); + + match Instruction::with4( transmute( Code as u16 ), register1, register2, register3, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With4_Register_Register_Register_u32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Register3 : u8, Immediate : u32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let register3: Register = transmute( Register3 ); + + match Instruction::with4( transmute( Code as u16 ), register1, register2, register3, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With4_Register_Register_Register_MemoryOperand( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Register3 : u8, Memory : *mut TMemoryOperand ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let register3: Register = transmute( Register3 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with4( transmute( Code as u16 ), register1, register2, register3, memory ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With4_Register_Register_i32_i32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Immediate1 : i32, Immediate2 : i32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + + match Instruction::with4( transmute( Code as u16 ), register1, register2, Immediate1, Immediate2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With4_Register_Register_u32_u32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Immediate1 : u32, Immediate2 : u32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + + match Instruction::with4( transmute( Code as u16 ), register1, register2, Immediate1, Immediate2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With4_Register_Register_MemoryOperand_Register( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Memory : *mut TMemoryOperand, Register3 : u8 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + let register3: Register = transmute( Register3 ); + + match Instruction::with4( transmute( Code as u16 ), register1, register2, memory, register3 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With4_Register_Register_MemoryOperand_i32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Memory : *mut TMemoryOperand, Immediate : i32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with4( transmute( Code as u16 ), register1, register2, memory, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With4_Register_Register_MemoryOperand_u32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Memory : *mut TMemoryOperand, Immediate : u32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with4( transmute( Code as u16 ), register1, register2, memory, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With5_Register_Register_Register_Register_i32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Register3 : u8, Register4 : u8, Immediate : i32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let register3: Register = transmute( Register3 ); + let register4: Register = transmute( Register4 ); + + match Instruction::with5( transmute( Code as u16 ), register1, register2, register3, register4, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With5_Register_Register_Register_Register_u32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Register3 : u8, Register4 : u8, Immediate : u32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let register3: Register = transmute( Register3 ); + let register4: Register = transmute( Register4 ); + + match Instruction::with5( transmute( Code as u16 ), register1, register2, register3, register4, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With5_Register_Register_Register_MemoryOperand_i32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Register3 : u8, Memory : *mut TMemoryOperand, Immediate : i32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let register3: Register = transmute( Register3 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with5( transmute( Code as u16 ), register1, register2, register3, memory, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With5_Register_Register_Register_MemoryOperand_u32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Register3 : u8, Memory : *mut TMemoryOperand, Immediate : u32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let register3: Register = transmute( Register3 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + + match Instruction::with5( transmute( Code as u16 ), register1, register2, register3, memory, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With5_Register_Register_MemoryOperand_Register_i32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Memory : *mut TMemoryOperand, Register3 : u8, Immediate : i32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + let register3: Register = transmute( Register3 ); + + match Instruction::with5( transmute( Code as u16 ), register1, register2, memory, register3, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With5_Register_Register_MemoryOperand_Register_u32( Instruction : *mut Instruction, Code : u16, Register1 : u8, Register2 : u8, Memory : *mut TMemoryOperand, Register3 : u8, Immediate : u32 ) -> bool { // FFI-Unsafe: Code, Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let memory = MemoryOperand { + segment_prefix: transmute( (*Memory).segment_prefix ), + base: transmute( (*Memory).base ), + index: transmute( (*Memory).index ), + scale: (*Memory).scale, + displacement: (*Memory).displacement, + displ_size: (*Memory).displ_size, + is_broadcast: (*Memory).is_broadcast + }; + let register3: Register = transmute( Register3 ); + + match Instruction::with5( transmute( Code as u16 ), register1, register2, memory, register3, Immediate ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Branch( Instruction : *mut Instruction, Code : u16, Target : u64 ) -> bool { // FFI-Unsafe: Code + if Instruction.is_null() { + return false; + } + + match Instruction::with_branch( transmute( Code as u16 ), Target ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Far_Branch( Instruction : *mut Instruction, Code : u16, Selector : u16, Offset : u32 ) -> bool { // FFI-Unsafe: Code + if Instruction.is_null() { + return false; + } + + match Instruction::with_far_branch( transmute( Code as u16 ), Selector, Offset ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_xbegin( Instruction : *mut Instruction, Bitness : u32, Target : u64 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_xbegin( Bitness, Target ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_outsb( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_outsb( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_outsb( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_outsb( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_outsw( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_outsw( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_outsw( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_outsw( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_outsd( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_outsd( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_outsd( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_outsd( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_lodsb( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_lodsb( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_lodsb( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_lodsb( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_lodsw( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_lodsw( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_lodsw( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_lodsw( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_lodsd( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_lodsd( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_lodsd( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_lodsd( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_lodsq( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_lodsq( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_lodsq( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_lodsq( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_scasb( Instruction : *mut Instruction, AddressSize: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: RepPrefixKind + if Instruction.is_null() { + return false; + } + + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_scasb( AddressSize, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repe_scasb( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repe_scasb( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repne_scasb( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repne_scasb( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_scasw( Instruction : *mut Instruction, AddressSize: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: RepPrefixKind + if Instruction.is_null() { + return false; + } + + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_scasw( AddressSize, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repe_scasw( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repe_scasw( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repne_scasw( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repne_scasw( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_scasd( Instruction : *mut Instruction, AddressSize: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: RepPrefixKind + if Instruction.is_null() { + return false; + } + + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_scasd( AddressSize, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repe_scasd( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repe_scasd( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repne_scasd( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repne_scasd( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_scasq( Instruction : *mut Instruction, AddressSize: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: RepPrefixKind + if Instruction.is_null() { + return false; + } + + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_scasq( AddressSize, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repe_scasq( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repe_scasq( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repne_scasq( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repne_scasq( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_insb( Instruction : *mut Instruction, AddressSize: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: RepPrefixKind + if Instruction.is_null() { + return false; + } + + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_insb( AddressSize, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_insb( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_insb( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_insw( Instruction : *mut Instruction, AddressSize: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: RepPrefixKind + if Instruction.is_null() { + return false; + } + + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_insw( AddressSize, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_insw( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_insw( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_insd( Instruction : *mut Instruction, AddressSize: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: RepPrefixKind + if Instruction.is_null() { + return false; + } + + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_insd( AddressSize, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_insd( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_insd( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_stosb( Instruction : *mut Instruction, AddressSize: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: RepPrefixKind + if Instruction.is_null() { + return false; + } + + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_stosb( AddressSize, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_stosb( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_stosb( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_stosw( Instruction : *mut Instruction, AddressSize: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: RepPrefixKind + if Instruction.is_null() { + return false; + } + + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_stosw( AddressSize, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_stosw( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_stosw( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_stosd( Instruction : *mut Instruction, AddressSize: u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: RepPrefixKind + if Instruction.is_null() { + return false; + } + + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_stosd( AddressSize, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_stosd( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_stosd( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_stosq( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_stosq( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_cmpsb( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix : u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_cmpsb( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repe_cmpsb( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repe_cmpsb( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repne_cmpsb( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repne_cmpsb( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_cmpsw( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix : u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_cmpsw( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repe_cmpsw( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repe_cmpsw( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repne_cmpsw( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repne_cmpsw( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_cmpsd( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix : u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_cmpsd( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repe_cmpsd( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repe_cmpsd( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repne_cmpsd( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repne_cmpsd( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_cmpsq( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix : u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_cmpsq( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repe_cmpsq( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repe_cmpsq( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Repne_cmpsq( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_repne_cmpsq( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_movsb( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix : u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_movsb( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_movsb( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_movsb( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_movsw( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix : u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_movsw( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_movsw( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_movsw( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_movsd( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix : u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_movsd( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_movsd( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_movsd( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_movsq( Instruction : *mut Instruction, AddressSize: u32, SegmentPrefix : u32, RepPrefix: u32 ) -> bool { // FFI-Unsafe: Register, RepPrefixKind + if Instruction.is_null() { + return false; + } + + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + let repprefix: RepPrefixKind = transmute( RepPrefix as u8 ); + + match Instruction::with_movsq( AddressSize, segmentprefix, repprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Rep_movsq( Instruction : *mut Instruction, AddressSize: u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::with_rep_movsq( AddressSize ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_maskmovq( Instruction : *mut Instruction, AddressSize: u32, Register1 : u8, Register2 : u8, SegmentPrefix : u32 ) -> bool { // FFI-Unsafe: Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + + match Instruction::with_maskmovq( AddressSize, register1, register2, segmentprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_maskmovdqu( Instruction : *mut Instruction, AddressSize: u32, Register1 : u8, Register2 : u8, SegmentPrefix : u32 ) -> bool { // FFI-Unsafe: Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + + match Instruction::with_maskmovdqu( AddressSize, register1, register2, segmentprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_vmaskmovdqu( Instruction : *mut Instruction, AddressSize: u32, Register1 : u8, Register2 : u8, SegmentPrefix : u32 ) -> bool { // FFI-Unsafe: Register + if Instruction.is_null() { + return false; + } + + let register1: Register = transmute( Register1 ); + let register2: Register = transmute( Register2 ); + let segmentprefix: Register = transmute( SegmentPrefix as u8 ); + + match Instruction::with_vmaskmovdqu( AddressSize, register1, register2, segmentprefix ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_1( Instruction : *mut Instruction, B0 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_1( B0 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_2( Instruction : *mut Instruction, B0 : u8, B1 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_2( B0, B1 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_3( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_3( B0, B1, B2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_4( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_4( B0, B1, B2, B3 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_5( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_5( B0, B1, B2, B3, B4 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_6( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8, B5 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_6( B0, B1, B2, B3, B4, B5 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_7( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8, B5 : u8, B6 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_7( B0, B1, B2, B3, B4, B5, B6 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_8( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8, B5 : u8, B6 : u8, B7 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_8( B0, B1, B2, B3, B4, B5, B6, B7 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_9( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8, B5 : u8, B6 : u8, B7 : u8, B8 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_9( B0, B1, B2, B3, B4, B5, B6, B7, B8 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_10( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8, B5 : u8, B6 : u8, B7 : u8, B8 : u8, B9 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_10( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_11( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8, B5 : u8, B6 : u8, B7 : u8, B8 : u8, B9 : u8, B10 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_11( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_12( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8, B5 : u8, B6 : u8, B7 : u8, B8 : u8, B9 : u8, B10 : u8, B11 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_12( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_13( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8, B5 : u8, B6 : u8, B7 : u8, B8 : u8, B9 : u8, B10 : u8, B11 : u8, B12 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_13( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_14( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8, B5 : u8, B6 : u8, B7 : u8, B8 : u8, B9 : u8, B10 : u8, B11 : u8, B12 : u8, B13 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_14( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_15( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8, B5 : u8, B6 : u8, B7 : u8, B8 : u8, B9 : u8, B10 : u8, B11 : u8, B12 : u8, B13 : u8, B14 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_15( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Byte_16( Instruction : *mut Instruction, B0 : u8, B1 : u8, B2 : u8, B3 : u8, B4 : u8, B5 : u8, B6 : u8, B7 : u8, B8 : u8, B9 : u8, B10 : u8, B11 : u8, B12 : u8, B13 : u8, B14 : u8, B15 : u8 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_byte_16( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Word_1( Instruction : *mut Instruction, W0 : u16 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_word_1( W0 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Word_2( Instruction : *mut Instruction, W0 : u16, W1 : u16 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_word_2( W0, W1 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Word_3( Instruction : *mut Instruction, W0 : u16, W1 : u16, W2 : u16 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_word_3( W0, W1, W2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Word_4( Instruction : *mut Instruction, W0 : u16, W1 : u16, W2 : u16, W3 : u16 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_word_4( W0, W1, W2, W3 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Word_5( Instruction : *mut Instruction, W0 : u16, W1 : u16, W2 : u16, W3 : u16, W4 : u16 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_word_5( W0, W1, W2, W3, W4 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Word_6( Instruction : *mut Instruction, W0 : u16, W1 : u16, W2 : u16, W3 : u16, W4 : u16, W5 : u16 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_word_6( W0, W1, W2, W3, W4, W5 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Word_7( Instruction : *mut Instruction, W0 : u16, W1 : u16, W2 : u16, W3 : u16, W4 : u16, W5 : u16, W6 : u16 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_word_7( W0, W1, W2, W3, W4, W5, W6 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_Word_8( Instruction : *mut Instruction, W0 : u16, W1 : u16, W2 : u16, W3 : u16, W4 : u16, W5 : u16, W6 : u16, W7 : u16 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_word_8( W0, W1, W2, W3, W4, W5, W6, W7 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_DWord_1( Instruction : *mut Instruction, D0 : u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_dword_1( D0 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_DWord_2( Instruction : *mut Instruction, D0 : u32, D1 : u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_dword_2( D0, D1 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_DWord_3( Instruction : *mut Instruction, D0 : u32, D1 : u32, D2 : u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_dword_3( D0, D1, D2 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_DWord_4( Instruction : *mut Instruction, D0 : u32, D1 : u32, D2 : u32, D3 : u32 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_dword_4( D0, D1, D2, D3 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_QWord_1( Instruction : *mut Instruction, Q0 : u64 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_qword_1( Q0 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} + +#[no_mangle] +pub unsafe extern "C" fn Instruction_With_Declare_QWord_2( Instruction : *mut Instruction, Q0 : u64, Q1 : u64 ) -> bool { + if Instruction.is_null() { + return false; + } + + match Instruction::try_with_declare_qword_2( Q0, Q1 ) { + Err( _e ) => return false, + Ok( instruction ) => { + (*Instruction) = instruction; + return true + } + }; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/IntelFormatter.rs b/src/rust/iced-x86-c/src/IntelFormatter.rs new file mode 100644 index 000000000..7cbc2613e --- /dev/null +++ b/src/rust/iced-x86-c/src/IntelFormatter.rs @@ -0,0 +1,188 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, Formatter, IntelFormatter}; +#[cfg(feature = "decoder")] +use iced_x86_rust::Decoder; +use crate::SymbolResolver::{TSymbolResolver, TSymbolResolverCallback}; +use crate::OptionsProvider::{TFormatterOptionsProvider, TFormatterOptionsProviderCallback}; +use crate::OutputCallback::TFormatterOutput; +#[cfg(feature = "decoder")] +use crate::Decoder::TDecoderFormatCallback; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Intel-Formatter +pub(crate) struct TIntelFormatter { + pub Formatter : IntelFormatter, + pub Output : String, + } + +// Creates a Intel formatter +// +// # Arguments +// - `symbol_resolver`: Symbol resolver or `None` +// - `options_provider`: Operand options provider or `None` +#[no_mangle] +pub extern "C" fn IntelFormatter_Create( SymbolResolver : Option, OptionsProvider : Option, UserData : *const usize ) -> *mut TIntelFormatter { + if !SymbolResolver.is_none() && !OptionsProvider.is_none() { + let symbols = Box::new( TSymbolResolver { callback:SymbolResolver, userData:UserData }); + let options = Box::new( TFormatterOptionsProvider { callback:OptionsProvider, userData:UserData }); + Box::into_raw( Box::new( TIntelFormatter { Formatter: IntelFormatter::with_options( Some( symbols ), Some( options ) ), Output: String::new() } ) ) + } else if !SymbolResolver.is_none() { + let symbols = Box::new( TSymbolResolver { callback:SymbolResolver, userData:UserData }); + Box::into_raw( Box::new( TIntelFormatter { Formatter: IntelFormatter::with_options( Some( symbols ), None ), Output: String::new() } ) ) + } else if !OptionsProvider.is_none() { + let options = Box::new( TFormatterOptionsProvider { callback:OptionsProvider, userData:UserData }); + Box::into_raw( Box::new( TIntelFormatter { Formatter: IntelFormatter::with_options( None, Some( options ) ), Output: String::new() } ) ) + } else { + Box::into_raw( Box::new( TIntelFormatter { Formatter: IntelFormatter::with_options( None, None ), Output: String::new() } ) ) + } +} + +// Format Instruction +#[no_mangle] +pub unsafe extern "C" fn IntelFormatter_Format( Formatter: *mut TIntelFormatter, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); +} + +#[no_mangle] +pub unsafe extern "C" fn IntelFormatter_FormatCallback( Formatter: *mut TIntelFormatter, Instruction: *mut Instruction, FormatterOutput : *mut TFormatterOutput ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if FormatterOutput.is_null() { + return; + } + + let mut obj = Box::from_raw( Formatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( output ); + Box::into_raw( obj ); +} + +// Decode and Format Instruction +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn IntelFormatter_DecodeFormat( Decoder: *mut Decoder, Formatter: *mut TIntelFormatter, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + // Decode + let mut obj = Box::from_raw( Decoder ); + obj.decode_out( Instruction.as_mut().unwrap() ); + Box::into_raw( obj ); + + // Format + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); +} + +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn IntelFormatter_DecodeFormatCallback( Decoder: *mut Decoder, Formatter: *mut TIntelFormatter, Instruction: *mut Instruction, FormatterOutput : *mut TFormatterOutput ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if FormatterOutput.is_null() { + return; + } + + // Decode + let mut obj = Box::from_raw( Decoder ); + obj.decode_out( Instruction.as_mut().unwrap() ); + Box::into_raw( obj ); + + // Format + let mut obj = Box::from_raw( Formatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( output ); + Box::into_raw( obj ); +} + +// Decode and Format Instruction until end +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn IntelFormatter_DecodeFormatToEnd( Decoder: *mut Decoder, Formatter: *mut TIntelFormatter, Callback: Option, UserData : *const usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Callback.is_none() { + return; + } + + // Decode + let mut decoder = Box::from_raw( Decoder ); + let mut formatter = Box::from_raw( Formatter ); + let mut stop: bool = false; + let mut instruction: Instruction = Instruction::new(); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + // Format + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw( formatter ); + Box::into_raw( decoder ); +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/MandatoryPrefix.rs b/src/rust/iced-x86-c/src/MandatoryPrefix.rs new file mode 100644 index 000000000..65e2f0f70 --- /dev/null +++ b/src/rust/iced-x86-c/src/MandatoryPrefix.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::MandatoryPrefix; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn MandatoryPrefix_AsString( MandatoryPrefix : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: MandatoryPrefix + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let mandatoryPrefix : MandatoryPrefix = transmute( MandatoryPrefix as u8 ); + let output = format!("{mandatoryPrefix:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/MasmFormatter.rs b/src/rust/iced-x86-c/src/MasmFormatter.rs new file mode 100644 index 000000000..a326ec5e7 --- /dev/null +++ b/src/rust/iced-x86-c/src/MasmFormatter.rs @@ -0,0 +1,318 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, Formatter, MasmFormatter}; +#[cfg(feature = "decoder")] +use iced_x86_rust::Decoder; +use crate::SymbolResolver::{TSymbolResolver, TSymbolResolverCallback}; +use crate::OptionsProvider::{TFormatterOptionsProvider, TFormatterOptionsProviderCallback}; +use crate::OutputCallback::TFormatterOutput; +#[cfg(feature = "decoder")] +use crate::Decoder::TDecoderFormatCallback; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Masm-Formatter +pub(crate) struct TMasmFormatter { + pub Formatter : MasmFormatter, + pub Output : String, + } + +// Creates a masm formatter +// +// # Arguments +// - `symbol_resolver`: Symbol resolver or `None` +// - `options_provider`: Operand options provider or `None` +#[no_mangle] +pub extern "C" fn MasmFormatter_Create( SymbolResolver : Option, OptionsProvider : Option, UserData : *const usize ) -> *mut TMasmFormatter { + if !SymbolResolver.is_none() && !OptionsProvider.is_none() { + let symbols = Box::new( TSymbolResolver { callback:SymbolResolver, userData:UserData }); + let options = Box::new( TFormatterOptionsProvider { callback:OptionsProvider, userData:UserData }); + Box::into_raw( Box::new( TMasmFormatter { Formatter: MasmFormatter::with_options( Some( symbols ), Some( options ) ), Output: String::new() } ) ) + } else if !SymbolResolver.is_none() { + let symbols = Box::new( TSymbolResolver { callback:SymbolResolver, userData:UserData }); + Box::into_raw( Box::new( TMasmFormatter { Formatter: MasmFormatter::with_options( Some( symbols ), None ), Output: String::new() } ) ) + } else if !OptionsProvider.is_none() { + let options = Box::new( TFormatterOptionsProvider { callback:OptionsProvider, userData:UserData }); + Box::into_raw( Box::new( TMasmFormatter { Formatter: MasmFormatter::with_options( None, Some( options ) ), Output: String::new() } ) ) + } else { + Box::into_raw( Box::new( TMasmFormatter { Formatter: MasmFormatter::with_options( None, None ), Output: String::new() } ) ) + } +} + +// Format Instruction +#[no_mangle] +pub unsafe extern "C" fn MasmFormatter_Format( Formatter: *mut TMasmFormatter, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); + } + +#[no_mangle] +pub unsafe extern "C" fn MasmFormatter_FormatCallback( Formatter: *mut TMasmFormatter, Instruction: *mut Instruction, FormatterOutput : *mut TFormatterOutput ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if FormatterOutput.is_null() { + return; + } + + let mut obj = Box::from_raw( Formatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( output ); + Box::into_raw( obj ); +} + +// Decode and Format Instruction +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn MasmFormatter_DecodeFormat( Decoder: *mut Decoder, Formatter: *mut TMasmFormatter, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + // Decode + let mut obj = Box::from_raw( Decoder ); + obj.decode_out( Instruction.as_mut().unwrap() ); + Box::into_raw( obj ); + + // Format + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); +} + +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn MasmFormatter_DecodeFormatCallback( Decoder: *mut Decoder, Formatter: *mut TMasmFormatter, Instruction: *mut Instruction, FormatterOutput : *mut TFormatterOutput ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if FormatterOutput.is_null() { + return; + } + + // Decode + let mut obj = Box::from_raw( Decoder ); + obj.decode_out( Instruction.as_mut().unwrap() ); + Box::into_raw( obj ); + + // Format + let mut obj = Box::from_raw( Formatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( output ); + Box::into_raw( obj ); +} + +// Decode and Format Instruction until end +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn MasmFormatter_DecodeFormatToEnd( Decoder: *mut Decoder, Formatter: *mut TMasmFormatter, Callback: Option, UserData : *const usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Callback.is_none() { + return; + } + + // Decode + let mut decoder = Box::from_raw( Decoder ); + let mut formatter = Box::from_raw( Formatter ); + let mut stop: bool = false; + let mut instruction: Instruction = Instruction::new(); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + // Format + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw( formatter ); + Box::into_raw( decoder ); +} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// ( masm only ): Add a `DS` segment override even if it's not present. Used if it's 16/32-bit code and mem op is a displ +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `mov eax,ds:[ 12345678 ]` +// _ | `false` | `mov eax,[ 12345678 ]` +#[no_mangle] +pub unsafe extern "C" fn MasmFormatter_GetAddDsPrefix32( Formatter: *mut TMasmFormatter ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + let value = obj.Formatter.options_mut().masm_add_ds_prefix32(); + + Box::into_raw( obj ); + + return value; +} + +// ( masm only ): Add a `DS` segment override even if it's not present. Used if it's 16/32-bit code and mem op is a displ +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `mov eax,ds:[ 12345678 ]` +// _ | `false` | `mov eax,[ 12345678 ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn MasmFormatter_SetAddDsPrefix32( Formatter: *mut TMasmFormatter, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + obj.Formatter.options_mut().set_masm_add_ds_prefix32( Value ); + + Box::into_raw( obj ); + + return true; +} + +// ( masm only ): Show symbols in brackets +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `[ ecx+symbol ]` / `[ symbol ]` +// _ | `false` | `symbol[ ecx ]` / `symbol` +#[no_mangle] +pub unsafe extern "C" fn MasmFormatter_GetSymbolDisplacementInBrackets( Formatter: *mut TMasmFormatter ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + let value = obj.Formatter.options_mut().masm_symbol_displ_in_brackets(); + + Box::into_raw( obj ); + + return value; +} + +// ( masm only ): Show symbols in brackets +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `[ ecx+symbol ]` / `[ symbol ]` +// _ | `false` | `symbol[ ecx ]` / `symbol` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn MasmFormatter_SetSymbolDisplacementInBrackets( Formatter: *mut TMasmFormatter, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + obj.Formatter.options_mut().set_masm_symbol_displ_in_brackets( Value ); + + Box::into_raw( obj ); + + return true; +} + +// ( masm only ): Show displacements in brackets +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `[ ecx+1234h ]` +// _ | `false` | `1234h[ ecx ]` +#[no_mangle] +pub unsafe extern "C" fn MasmFormatter_GetDisplacementInBrackets( Formatter: *mut TMasmFormatter ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + let value = obj.Formatter.options_mut().masm_displ_in_brackets(); + + Box::into_raw( obj ); + + return value; +} + +// ( masm only ): Show displacements in brackets +// +// Default | Value | Example +// --------|-------|-------- +// 👍 | `true` | `[ ecx+1234h ]` +// _ | `false` | `1234h[ ecx ]` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn MasmFormatter_SetDisplacementInBrackets( Formatter: *mut TMasmFormatter, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + obj.Formatter.options_mut().set_masm_displ_in_brackets( Value ); + + Box::into_raw( obj ); + + return true; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/MemorySize.rs b/src/rust/iced-x86-c/src/MemorySize.rs new file mode 100644 index 000000000..55f544e6e --- /dev/null +++ b/src/rust/iced-x86-c/src/MemorySize.rs @@ -0,0 +1,43 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::MemorySize; +#[cfg(feature = "instr_create")] +use iced_x86_rust::MemorySizeInfo; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn MemorySize_AsString( MemorySize : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: MemorySize + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let memorySize : MemorySize = transmute( MemorySize as u8 ); + let output = format!("{memorySize:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} + +#[cfg(feature = "instr_create")] +#[no_mangle] +pub unsafe extern "C" fn MemorySize_Info( MemorySize : u8, Info : *mut MemorySizeInfo ) { // FFI-Unsafe: MemorySize + if Info.is_null() { + return; + } + + let memorySize : MemorySize = transmute( MemorySize as u8 ); + let info = memorySize.info(); + *Info = *info; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/MemorySizeOptions.rs b/src/rust/iced-x86-c/src/MemorySizeOptions.rs new file mode 100644 index 000000000..5d6de094d --- /dev/null +++ b/src/rust/iced-x86-c/src/MemorySizeOptions.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::MemorySizeOptions; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn MemorySizeOptions_AsString( MemorySizeOptions : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: MemorySizeOptions + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let MemorySizeOptions : MemorySizeOptions = transmute( MemorySizeOptions as u8 ); + let output = format!("{MemorySizeOptions:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/Mnemonic.rs b/src/rust/iced-x86-c/src/Mnemonic.rs new file mode 100644 index 000000000..357d66402 --- /dev/null +++ b/src/rust/iced-x86-c/src/Mnemonic.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::Mnemonic; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn Mnemonic_AsString( Mnemonic : u16, Output : *mut u8, Size : usize ) { // FFI-Unsafe: Mnemonic + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let mnemonic : Mnemonic = transmute( Mnemonic as u16 ); + let output = format!("{mnemonic:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/MvexConvFn.rs b/src/rust/iced-x86-c/src/MvexConvFn.rs new file mode 100644 index 000000000..ddbd930db --- /dev/null +++ b/src/rust/iced-x86-c/src/MvexConvFn.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::MvexConvFn; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn MvexConvFn_AsString( MvexConvFn : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: MvexConvFn + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let mvexConvFn : MvexConvFn = transmute( MvexConvFn as u8 ); + let output = format!("{mvexConvFn:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/MvexEHBit.rs b/src/rust/iced-x86-c/src/MvexEHBit.rs new file mode 100644 index 000000000..b19ef606b --- /dev/null +++ b/src/rust/iced-x86-c/src/MvexEHBit.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::MvexEHBit; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn MvexEHBit_AsString( MvexEHBit : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: MvexEHBit + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let mvexEHBit : MvexEHBit = transmute( MvexEHBit as u8 ); + let output = format!("{mvexEHBit:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/MvexRegMemConv.rs b/src/rust/iced-x86-c/src/MvexRegMemConv.rs new file mode 100644 index 000000000..ddfee4eb9 --- /dev/null +++ b/src/rust/iced-x86-c/src/MvexRegMemConv.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::MvexRegMemConv; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn MvexRegMemConv_AsString( MvexRegMemConv : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: MvexRegMemConv + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let MvexRegMemConv : MvexRegMemConv = transmute( MvexRegMemConv as u8 ); + let output = format!("{MvexRegMemConv:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/MvexTupleTypeLutKind.rs b/src/rust/iced-x86-c/src/MvexTupleTypeLutKind.rs new file mode 100644 index 000000000..8f7667d75 --- /dev/null +++ b/src/rust/iced-x86-c/src/MvexTupleTypeLutKind.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::MvexTupleTypeLutKind; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn MvexTupleTypeLutKind_AsString( MvexTupleTypeLutKind : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: MvexTupleTypeLutKind + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let mvexTupleTypeLutKind : MvexTupleTypeLutKind = transmute( MvexTupleTypeLutKind as u8 ); + let output = format!("{mvexTupleTypeLutKind:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/NasmFormatter.rs b/src/rust/iced-x86-c/src/NasmFormatter.rs new file mode 100644 index 000000000..7e517ed7d --- /dev/null +++ b/src/rust/iced-x86-c/src/NasmFormatter.rs @@ -0,0 +1,232 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, Formatter, NasmFormatter}; +#[cfg(feature = "decoder")] +use iced_x86_rust::Decoder; +use crate::SymbolResolver::{TSymbolResolver, TSymbolResolverCallback}; +use crate::OptionsProvider::{TFormatterOptionsProvider, TFormatterOptionsProviderCallback}; +use crate::OutputCallback::TFormatterOutput; +#[cfg(feature = "decoder")] +use crate::Decoder::TDecoderFormatCallback; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Nasm-Formatter +pub(crate) struct TNasmFormatter { + pub Formatter : NasmFormatter, + pub Output : String, + } + +// Creates a Nasm formatter +// +// # Arguments +// - `symbol_resolver`: Symbol resolver or `None` +// - `options_provider`: Operand options provider or `None` +#[no_mangle] +pub extern "C" fn NasmFormatter_Create( SymbolResolver : Option, OptionsProvider : Option, UserData : *const usize ) -> *mut TNasmFormatter { + if !SymbolResolver.is_none() && !OptionsProvider.is_none() { + let symbols = Box::new( TSymbolResolver { callback:SymbolResolver, userData:UserData }); + let options = Box::new( TFormatterOptionsProvider { callback:OptionsProvider, userData:UserData }); + Box::into_raw( Box::new( TNasmFormatter { Formatter: NasmFormatter::with_options( Some( symbols ), Some( options ) ), Output: String::new() } ) ) + } else if !SymbolResolver.is_none() { + let symbols = Box::new( TSymbolResolver { callback:SymbolResolver, userData:UserData }); + Box::into_raw( Box::new( TNasmFormatter { Formatter: NasmFormatter::with_options( Some( symbols ), None ), Output: String::new() } ) ) + } else if !OptionsProvider.is_none() { + let options = Box::new( TFormatterOptionsProvider { callback:OptionsProvider, userData:UserData }); + Box::into_raw( Box::new( TNasmFormatter { Formatter: NasmFormatter::with_options( None, Some( options ) ), Output: String::new() } ) ) + } else { + Box::into_raw( Box::new( TNasmFormatter { Formatter: NasmFormatter::with_options( None, None ), Output: String::new() } ) ) + } +} + +// Format Instruction +#[no_mangle] +pub unsafe extern "C" fn NasmFormatter_Format( Formatter: *mut TNasmFormatter, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); + } + +#[no_mangle] +pub unsafe extern "C" fn NasmFormatter_FormatCallback( Formatter: *mut TNasmFormatter, Instruction: *mut Instruction, FormatterOutput : *mut TFormatterOutput ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if FormatterOutput.is_null() { + return; + } + + let mut obj = Box::from_raw( Formatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( output ); + Box::into_raw( obj ); +} + +// Decode and Format Instruction +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn NasmFormatter_DecodeFormat( Decoder: *mut Decoder, Formatter: *mut TNasmFormatter, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + // Decode + let mut obj = Box::from_raw( Decoder ); + obj.decode_out( Instruction.as_mut().unwrap() ); + Box::into_raw( obj ); + + // Format + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); +} + +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn NasmFormatter_DecodeFormatCallback( Decoder: *mut Decoder, Formatter: *mut TNasmFormatter, Instruction: *mut Instruction, FormatterOutput : *mut TFormatterOutput ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if FormatterOutput.is_null() { + return; + } + + // Decode + let mut obj = Box::from_raw( Decoder ); + obj.decode_out( Instruction.as_mut().unwrap() ); + Box::into_raw( obj ); + + // Format + let mut obj = Box::from_raw( Formatter ); + let mut output = Box::from_raw( FormatterOutput ); + obj.Formatter.format( Instruction.as_mut().unwrap(), output.as_mut() ); + Box::into_raw( output ); + Box::into_raw( obj ); +} + +// Decode and Format Instruction until end +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn NasmFormatter_DecodeFormatToEnd( Decoder: *mut Decoder, Formatter: *mut TNasmFormatter, Callback: Option, UserData : *const usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Callback.is_none() { + return; + } + + // Decode + let mut decoder = Box::from_raw( Decoder ); + let mut formatter = Box::from_raw( Formatter ); + let mut stop: bool = false; + let mut instruction: Instruction = Instruction::new(); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + // Format + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw( formatter ); + Box::into_raw( decoder ); +} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// ( nasm only ): Shows `BYTE`, `WORD`, `DWORD` or `QWORD` if it's a sign extended immediate operand value +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `or rcx,byte -1` +// 👍 | `false` | `or rcx,-1` +#[no_mangle] +pub unsafe extern "C" fn NasmFormatter_GetShowSignExtendedImmediateSize( Formatter: *mut TNasmFormatter ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + let value = obj.Formatter.options_mut().nasm_show_sign_extended_immediate_size(); + + Box::into_raw( obj ); + + return value; +} + +// ( nasm only ): Shows `BYTE`, `WORD`, `DWORD` or `QWORD` if it's a sign extended immediate operand value +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `or rcx,byte -1` +// 👍 | `false` | `or rcx,-1` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn NasmFormatter_SetShowSignExtendedImmediateSize( Formatter: *mut TNasmFormatter, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + obj.Formatter.options_mut().set_nasm_show_sign_extended_immediate_size( Value ); + + Box::into_raw( obj ); + + return true; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/NumberBase.rs b/src/rust/iced-x86-c/src/NumberBase.rs new file mode 100644 index 000000000..83e07fb79 --- /dev/null +++ b/src/rust/iced-x86-c/src/NumberBase.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::NumberBase; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn NumberBase_AsString( NumberBase : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: NumberBase + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let NumberBase : NumberBase = transmute( NumberBase as u8 ); + let output = format!("{NumberBase:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/OpAccess.rs b/src/rust/iced-x86-c/src/OpAccess.rs new file mode 100644 index 000000000..7ac97303d --- /dev/null +++ b/src/rust/iced-x86-c/src/OpAccess.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::OpAccess; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn OpAccess_AsString( OpAccess : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: OpAccess + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let opAccess : OpAccess = transmute( OpAccess as u8 ); + let output = format!("{opAccess:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/OpCodeInfo.rs b/src/rust/iced-x86-c/src/OpCodeInfo.rs new file mode 100644 index 000000000..f1a4007d8 --- /dev/null +++ b/src/rust/iced-x86-c/src/OpCodeInfo.rs @@ -0,0 +1,962 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::Code; +use std::mem::transmute;// Enum<->Int + +//#[allow( non_upper_case_globals )] +//pub const OpCodeInfoCharCount : usize = 30; + +//#[repr(C)] +#[repr(packed)] +pub struct TOpCodeInfo { +// pub op_code_string: [u8;OpCodeInfoCharCount], +// pub instruction_string: [u8;OpCodeInfoCharCount], + + pub code: u16/*Code*/, + pub op_code: u16, + pub encoding: u8/*EncodingKind*/, + pub operand_size: u8, + pub address_size: u8, + pub l: u8, + pub tuple_type: u8/*TupleType*/, + pub table: u8/*OpCodeTableKind*/, + pub mandatory_prefix: u8/*MandatoryPrefix*/, + pub group_index: i8, + pub rm_group_index: i8, + pub op_kinds: [u8/*OpCodeOperandKind*/; 5/*IcedConstants::MAX_OP_COUNT*/], +} + +// Gets the opcode string, eg. `VEX.128.66.0F38.W0 78 /r`, see also [`instruction_string()`] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_OpCodeString( Code : u16, Output : *mut u8, Size : usize ) { // FFI-Unsafe: Code + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + let output = info.op_code_string(); + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} + +// Gets the instruction string, eg. `VPBROADCASTB xmm1, xmm2/m8`, see also [`op_code_string()`] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_InstructionString( Code : u16, Output : *mut u8, Size : usize ) { // FFI-Unsafe: Code + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + let output = info.instruction_string(); + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} + +// `true` if it's an instruction available in 16-bit mode +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_Mode16( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mode16(); +} + +// `true` if it's an instruction available in 32-bit mode +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_Mode32( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mode32(); +} + +// `true` if it's an instruction available in 64-bit mode +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_Mode64( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mode64(); +} + +// `true` if an `FWAIT` (`9B`) instruction is added before the instruction +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_Fwait( Code : u16 ) -> bool { // FFI-Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.fwait(); +} + +// (VEX/XOP/EVEX/MVEX) `W` value or default value if [`is_wig()`] or [`is_wig32()`] is `true` +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_W( Code : u16 ) -> u32 { // FFI Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.w(); +} + +// (VEX/XOP/EVEX) `true` if the `L` / `L'L` fields are ignored. +// +// EVEX: if reg-only ops and `{er}` (`EVEX.b` is set), `L'L` is the rounding control and not ignored. +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsLig( Code : u16 ) -> bool { // FFI Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_lig(); +} + +// (VEX/XOP/EVEX/MVEX) `true` if the `W` field is ignored in 16/32/64-bit modes +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsWig( Code : u16 ) -> bool { // FFI Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_wig(); +} + +// (VEX/XOP/EVEX/MVEX) `true` if the `W` field is ignored in 16/32-bit modes (but not 64-bit mode) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsWig32( Code : u16 ) -> bool { // FFI Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_wig32(); +} + +// (MVEX) Gets the `EH` bit that's required to encode this instruction +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MvexEhBit( Code : u16 ) -> u8 { // FFI Unsafe: Code, MvexEHBit + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mvex_eh_bit() as u8; +} + +// (MVEX) `true` if the instruction supports eviction hint (if it has a memory operand) +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MvexCanUseEvictionHint( Code : u16 ) -> bool { // FFI Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mvex_can_use_eviction_hint(); +} + +// (MVEX) `true` if the instruction's rounding control bits are stored in `imm8[1:0]` +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MvexCanUseImmRoundingControl( Code : u16 ) -> bool { // FFI Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mvex_can_use_imm_rounding_control(); +} + +// (MVEX) `true` if the instruction ignores op mask registers (eg. `{k1}`) +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MvexIgnoresOpMaskRegister( Code : u16 ) -> bool { // FFI Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mvex_ignores_op_mask_register(); +} + +// (MVEX) `true` if the instruction must have `MVEX.SSS=000` if `MVEX.EH=1` +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MvexNoSaeRc( Code : u16 ) -> bool { // FFI Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mvex_no_sae_rc(); +} + +// (MVEX) Gets the tuple type / conv lut kind +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MvexTupleTypeLutKind( Code : u16 ) -> u8 { // FFI Unsafe: Code, MvexTupleTypeLutKind + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mvex_tuple_type_lut_kind() as u8; +} + +// (MVEX) Gets the conversion function, eg. `Sf32` +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MvexConversionFunc( Code : u16 ) -> u8 { // FFI Unsafe: Code, MvexConvFn + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mvex_conversion_func() as u8; +} + +// (MVEX) Gets flags indicating which conversion functions are valid (bit 0 == func 0) +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MvexValidConversionFuncsMask( Code : u16 ) -> u8 { // FFI Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mvex_valid_conversion_funcs_mask(); +} + +// (MVEX) Gets flags indicating which swizzle functions are valid (bit 0 == func 0) +#[cfg(feature = "mvex")] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MvexValidSwizzleFuncsMask( Code : u16 ) -> u8 { // FFI Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.mvex_valid_swizzle_funcs_mask(); +} + +// If it has a memory operand, gets the [`MemorySize`] (non-broadcast memory type) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MemorySize( Code : u16 ) -> u8 { // FFI Unsafe: Code, MemorySize + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.memory_size() as u8; +} + +// If it has a memory operand, gets the [`MemorySize`] (broadcast memory type) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_BroadcastMemorySize( Code : u16 ) -> u8 { // FFI Unsafe: Code, MemorySize + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.broadcast_memory_size() as u8; +} + +// (EVEX) `true` if the instruction supports broadcasting (`EVEX.b` bit) (if it has a memory operand) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanBroadcast( Code : u16 ) -> bool { // FFI Unsafe: Code + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_broadcast(); +} + +// (EVEX/MVEX) `true` if the instruction supports rounding control +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanUseRoundingControl( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_use_rounding_control(); +} + +// (EVEX/MVEX) `true` if the instruction supports suppress all exceptions +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanSuppressAllExceptions( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_suppress_all_exceptions(); +} + +// (EVEX/MVEX) `true` if an opmask register can be used +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanUseOpMaskRegister( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_use_op_mask_register(); +} + +// (EVEX/MVEX) `true` if a non-zero opmask register must be used +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_RequireOpMaskRegister( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.require_op_mask_register(); +} + +// (EVEX) `true` if the instruction supports zeroing masking (if one of the opmask registers `K1`-`K7` is used and destination operand is not a memory operand) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanUseZeroingMasking( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_use_zeroing_masking(); +} + +// `true` if the `LOCK` (`F0`) prefix can be used +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanUseLockPrefix( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_use_lock_prefix(); +} + +// `true` if the `XACQUIRE` (`F2`) prefix can be used +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanUseXacquirePrefix( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_use_xacquire_prefix(); +} + +// `true` if the `XRELEASE` (`F3`) prefix can be used +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanUseXreleasePrefix( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_use_xrelease_prefix(); +} + +// `true` if the `REP` / `REPE` (`F3`) prefixes can be used +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanUseRepPrefix( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_use_rep_prefix(); +} + +// `true` if the `REPNE` (`F2`) prefix can be used +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanUseRepnePrefix( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_use_repne_prefix(); +} + +// `true` if the `BND` (`F2`) prefix can be used +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanUseBndPrefix( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_use_bnd_prefix(); +} + +// `true` if the `HINT-TAKEN` (`3E`) and `HINT-NOT-TAKEN` (`2E`) prefixes can be used +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanUseHintTakenPrefix( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_use_hint_taken_prefix(); +} + +// `true` if the `NOTRACK` (`3E`) prefix can be used +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CanUseNotrackPrefix( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.can_use_notrack_prefix(); +} + +// `true` if rounding control is ignored (#UD is not generated) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IgnoresRoundingControl( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.ignores_rounding_control(); +} + +// `true` if the `LOCK` prefix can be used as an extra register bit (bit 3) to access registers 8-15 without a `REX` prefix (eg. in 32-bit mode) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_AmdLockRegBit( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.amd_lock_reg_bit(); +} + +// `true` if the default operand size is 64 in 64-bit mode. A `66` prefix can switch to 16-bit operand size. +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_DefaultOpSize64( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.default_op_size64(); +} + +// `true` if the operand size is always 64 in 64-bit mode. A `66` prefix is ignored. +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_ForceOpSize64( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.force_op_size64(); +} + +// `true` if the Intel decoder forces 64-bit operand size. A `66` prefix is ignored. +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IntelForceOpSize64( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.intel_force_op_size64(); +} + +// `true` if it can only be executed when CPL=0 +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MustBeCpl0( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.must_be_cpl0(); +} + +// `true` if it can be executed when CPL=0 +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_Cpl0( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.cpl0(); +} + +// `true` if it can be executed when CPL=1 +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_Cpl1( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.cpl1(); +} + +// `true` if it can be executed when CPL=2 +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_Cpl2( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.cpl2(); +} + +// `true` if it can be executed when CPL=3 +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_Cpl3( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.cpl3(); +} + +// `true` if the instruction accesses the I/O address space (eg. `IN`, `OUT`, `INS`, `OUTS`) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsInputOutput( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_input_output(); +} + +// `true` if it's one of the many nop instructions (does not include FPU nop instructions, eg. `FNOP`) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsNop( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_nop(); +} + +// `true` if it's one of the many reserved nop instructions (eg. `0F0D`, `0F18-0F1F`) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsReservedNop( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_reserved_nop(); +} + +// `true` if it's a serializing instruction (Intel CPUs) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsSerializingIntel( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_serializing_intel(); +} + +// `true` if it's a serializing instruction (AMD CPUs) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsSerializingAmd( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_serializing_amd(); +} + +// `true` if the instruction requires either CPL=0 or CPL<=3 depending on some CPU option (eg. `CR4.TSD`, `CR4.PCE`, `CR4.UMIP`) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_MayRequireCpl0( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.may_require_cpl0(); +} + +// `true` if it's a tracked `JMP`/`CALL` indirect instruction (CET) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsCetTracked( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_cet_tracked(); +} + +// `true` if it's a non-temporal hint memory access (eg. `MOVNTDQ`) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsNonTemporal( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_non_temporal(); +} + +// `true` if it's a no-wait FPU instruction, eg. `FNINIT` +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsFpuNoWait( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_fpu_no_wait(); +} + +// `true` if the mod bits are ignored and it's assumed `modrm[7:6] == 11b` +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IgnoresModBits( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.ignores_mod_bits(); +} + +// `true` if the `66` prefix is not allowed (it will #UD) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_No66( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.no66(); +} + +// `true` if the `F2`/`F3` prefixes aren't allowed +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_Nfx( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.nfx(); +} + +// `true` if the index reg's reg-num (vsib op) (if any) and register ops' reg-nums must be unique, +// eg. `MNEMONIC XMM1,YMM1,[RAX+ZMM1*2]` is invalid. Registers = `XMM`/`YMM`/`ZMM`/`TMM`. +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_RequiresUniqueRegNums( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.requires_unique_reg_nums(); +} + +// `true` if the destination register's reg-num must not be present in any other operand, eg. `MNEMONIC XMM1,YMM1,[RAX+ZMM1*2]` +// is invalid. Registers = `XMM`/`YMM`/`ZMM`/`TMM`. +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_RequiresUniqueDestRegNum( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.requires_unique_dest_reg_num(); +} + +// `true` if it's a privileged instruction (all CPL=0 instructions (except `VMCALL`) and IOPL instructions `IN`, `INS`, `OUT`, `OUTS`, `CLI`, `STI`) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsPrivileged( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_privileged(); +} + +// `true` if it reads/writes too many registers +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsSaveRestore( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_save_restore(); +} + +// `true` if it's an instruction that implicitly uses the stack register, eg. `CALL`, `POP`, etc +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsStackInstruction( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_stack_instruction(); +} + +// `true` if the instruction doesn't read the segment register if it uses a memory operand +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IgnoresSegment( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.ignores_segment(); +} + +// `true` if the opmask register is read and written (instead of just read). This also implies that it can't be `K0`. +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IsOpMaskReadWrite( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.is_op_mask_read_write(); +} + +// `true` if it can be executed in real mode +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_RealMode( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.real_mode(); +} + +// `true` if it can be executed in protected mode +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_ProtectedMode( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.protected_mode(); +} + +// `true` if it can be executed in virtual 8086 mode +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_Virtual8086Mode( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.virtual8086_mode(); +} + +// `true` if it can be executed in compatibility mode +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_CompatibilityMode( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.compatibility_mode(); +} + +// `true` if it can be executed in 64-bit mode +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_LongMode( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.long_mode(); +} + +// `true` if it can be used outside SMM +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_UseOutsideSmm( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.use_outside_smm(); +} + +// `true` if it can be used in SMM +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_UseInSmm( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.use_in_smm(); +} + +// `true` if it can be used outside an enclave (SGX) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_UseOutsideEnclaveSgx( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.use_outside_enclave_sgx(); +} + +// `true` if it can be used inside an enclave (SGX1) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_UseInEnclaveSgx1( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.use_in_enclave_sgx1(); +} + +// `true` if it can be used inside an enclave (SGX2) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_UseInEnclaveSgx2( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.use_in_enclave_sgx2(); +} + +// `true` if it can be used outside VMX operation +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_UseOutsideVmxOp( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.use_outside_vmx_op(); +} + +// `true` if it can be used in VMX root operation +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_UseInVmxRootOp( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.use_in_vmx_root_op(); +} + +// `true` if it can be used in VMX non-root operation +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_UseInVmxNonRootOp( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.use_in_vmx_non_root_op(); +} + +// `true` if it can be used outside SEAM +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_UseOutsideSeam( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.use_outside_seam(); +} + +// `true` if it can be used in SEAM +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_UseInSeam( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.use_in_seam(); +} + +// `true` if #UD is generated in TDX non-root operation +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_TdxNonRootGenUd( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.tdx_non_root_gen_ud(); +} + +// `true` if #VE is generated in TDX non-root operation +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_TdxNonRootGenVe( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.tdx_non_root_gen_ve(); +} + +// `true` if an exception (eg. #GP(0), #VE) may be generated in TDX non-root operation +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_TdxNonRootMayGenEx( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.tdx_non_root_may_gen_ex(); +} + +// (Intel VMX) `true` if it causes a VM exit in VMX non-root operation +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IntelVMExit( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.intel_vm_exit(); +} + +// (Intel VMX) `true` if it may cause a VM exit in VMX non-root operation +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IntelMayVMExit( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.intel_may_vm_exit(); +} + +// (Intel VMX) `true` if it causes an SMM VM exit in VMX root operation (if dual-monitor treatment is activated) +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IntelSmmVMExit( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.intel_smm_vm_exit(); +} + +// (AMD SVM) `true` if it causes a #VMEXIT in guest mode +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_AmdVMExit( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.amd_vm_exit(); +} + +// (AMD SVM) `true` if it may cause a #VMEXIT in guest mode +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_AmdMayVMExit( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.amd_may_vm_exit(); +} + +// `true` if it causes a TSX abort inside a TSX transaction +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_TsxAbort( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.tsx_abort(); +} + +// `true` if it causes a TSX abort inside a TSX transaction depending on the implementation +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_TsxImplAbort( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.tsx_impl_abort(); +} + +// `true` if it may cause a TSX abort inside a TSX transaction depending on some condition +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_TsxMayAbort( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.tsx_may_abort(); +} + +// `true` if it's decoded by iced's 16-bit Intel decoder +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IntelDecoder16( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.intel_decoder16(); +} + +// `true` if it's decoded by iced's 32-bit Intel decoder +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IntelDecoder32( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.intel_decoder32(); +} + +// `true` if it's decoded by iced's 64-bit Intel decoder +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_IntelDecoder64( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.intel_decoder64(); +} + +// `true` if it's decoded by iced's 16-bit AMD decoder +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_AmdDecoder16( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.amd_decoder16(); +} + +// `true` if it's decoded by iced's 32-bit AMD decoder +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_AmdDecoder32( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.amd_decoder32(); +} + +// `true` if it's decoded by iced's 64-bit AMD decoder +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_AmdDecoder64( Code : u16 ) -> bool { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.amd_decoder64(); +} + +// Gets the decoder option that's needed to decode the instruction or [`DecoderOptions::NONE`]. +// The return value is a [`DecoderOptions`] value. +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_DecoderOption( Code : u16 ) -> u32 { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.decoder_option(); +} + +// Gets the length of the opcode bytes ([`op_code()`]). The low bytes is the opcode value. +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_OpCodeLen( Code : u16 ) -> u32 { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.op_code_len(); +} + +// Gets the number of operands +#[no_mangle] +pub unsafe extern "C" fn OpCodeInfo_OPCount( Code : u16 ) -> u32 { + let code : Code = transmute( Code as u16 ); + let info = code.op_code(); + + return info.op_count(); +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/OpCodeOperandKind.rs b/src/rust/iced-x86-c/src/OpCodeOperandKind.rs new file mode 100644 index 000000000..88385d1da --- /dev/null +++ b/src/rust/iced-x86-c/src/OpCodeOperandKind.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::OpCodeOperandKind; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn OpCodeOperandKind_AsString( OpCodeOperandKind : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: OpCodeOperandKind + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let opCodeOperandKind : OpCodeOperandKind = transmute( OpCodeOperandKind as u8 ); + let output = format!("{opCodeOperandKind:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/OpCodeTableKind.rs b/src/rust/iced-x86-c/src/OpCodeTableKind.rs new file mode 100644 index 000000000..7d620e99a --- /dev/null +++ b/src/rust/iced-x86-c/src/OpCodeTableKind.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::OpCodeTableKind; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn OpCodeTableKind_AsString( OpCodeTableKind : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: OpCodeTableKind + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let opCodeTableKind : OpCodeTableKind = transmute( OpCodeTableKind as u8 ); + let output = format!("{opCodeTableKind:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/OpKind.rs b/src/rust/iced-x86-c/src/OpKind.rs new file mode 100644 index 000000000..3016e8aff --- /dev/null +++ b/src/rust/iced-x86-c/src/OpKind.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::OpKind; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn OpKind_AsString( OpKind : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: OpKind + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let opKind : OpKind = transmute( OpKind as u8 ); + let output = format!("{opKind:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/OptionsProvider.rs b/src/rust/iced-x86-c/src/OptionsProvider.rs new file mode 100644 index 000000000..485b8ad2e --- /dev/null +++ b/src/rust/iced-x86-c/src/OptionsProvider.rs @@ -0,0 +1,112 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, NumberBase, NumberFormattingOptions, FormatterOperandOptions, FormatterOptionsProvider}; +use std::ptr::eq; +use std::{slice, str}; +use libc::{c_char, strlen}; +use std::ffi::CString; + +// Called by the formatter. The method can override any options before the formatter uses them. +// +// # Arguments +// - `instruction`: Instruction +// - `operand`: Operand number, 0-based. This is a formatter operand and isn't necessarily the same as an instruction operand. +// - `instruction_operand`: Instruction operand number, 0-based, or `None` if it's an operand created by the formatter. +// - `options`: Options. Only those options that will be used by the formatter are initialized. +// - `number_options`: Number formatting options +pub(crate)type + TFormatterOptionsProviderCallback = unsafe extern "C" fn( Instruction: &Instruction, Operand: u32, InstructionOperand: u32, Options: &mut FormatterOperandOptions, NumberOptions: &mut TNumberFormattingOptions, UserData : *const usize ); + + pub(crate) struct TFormatterOptionsProvider { + pub(crate) userData: *const usize, + pub(crate) callback: Option +} + +//#[repr(C)] +#[repr(packed)] +pub struct TNumberFormattingOptions { + /// Number prefix or an empty string + pub prefix: *const c_char, + /// Number suffix or an empty string + pub suffix: *const c_char, + /// Digit separator or an empty string to not use a digit separator + pub digit_separator: *const c_char, + /// Size of a digit group or 0 to not use a digit separator + pub digit_group_size: u8, + /// Number base + pub number_base: NumberBase, + /// Use uppercase hex digits + pub uppercase_hex: bool, + /// Small hex numbers ( -9 .. 9 ) are shown in decimal + pub small_hex_numbers_in_decimal: bool, + /// Add a leading zero to hex numbers if there's no prefix and the number starts with hex digits `A-F` + pub add_leading_zero_to_hex_numbers: bool, + /// If `true`, add leading zeros to numbers, eg. `1h` vs `00000001h` + pub leading_zeros: bool, + /// If `true`, the number is signed, and if `false` it's an unsigned number + pub signed_number: bool, + /// Add leading zeros to displacements + pub displacement_leading_zeros: bool, +} + +impl FormatterOptionsProvider for TFormatterOptionsProvider { + fn operand_options( &mut self, Instruction: &Instruction, Operand: u32, InstructionOperand: Option, Options: &mut FormatterOperandOptions, NumberOptions: &mut NumberFormattingOptions<'_> ) { + unsafe { + if !self.callback.is_none() { + let tprefix = CString::new( NumberOptions.prefix ).unwrap(); + let tsuffix = CString::new( NumberOptions.suffix ).unwrap(); + let tdigit_separator = CString::new( NumberOptions.digit_separator ).unwrap(); + + let pprefix = tprefix.as_ptr() as *const c_char; + let psuffix = tsuffix.as_ptr() as *const c_char; + let pdigit_separator = tdigit_separator.as_ptr() as *const c_char; + + let mut numberoptions = TNumberFormattingOptions { + prefix: pprefix, + suffix: psuffix, + digit_separator: pdigit_separator, + + digit_group_size : NumberOptions.digit_group_size, + number_base : NumberOptions.number_base, + uppercase_hex : NumberOptions.uppercase_hex, + small_hex_numbers_in_decimal : NumberOptions.small_hex_numbers_in_decimal, + add_leading_zero_to_hex_numbers : NumberOptions.add_leading_zero_to_hex_numbers, + leading_zeros : NumberOptions.leading_zeros, + signed_number : NumberOptions.signed_number, + displacement_leading_zeros : NumberOptions.displacement_leading_zeros + }; + + match InstructionOperand { + None => self.callback.unwrap()( Instruction, Operand, 0xFFFF_FFFF as u32, Options, &mut numberoptions, self.userData ), + _Some => self.callback.unwrap()( Instruction, Operand, InstructionOperand.unwrap(), Options, &mut numberoptions, self.userData ) + } + + if !eq(pprefix, numberoptions.prefix) { + NumberOptions.prefix = str::from_utf8_unchecked( slice::from_raw_parts( numberoptions.prefix as *const u8, strlen( numberoptions.prefix ) ) ); + } + + if !eq(psuffix, numberoptions.suffix) { + NumberOptions.suffix = str::from_utf8_unchecked( slice::from_raw_parts( numberoptions.suffix as *const u8, strlen( numberoptions.suffix ) ) ); + } + + if !eq(pdigit_separator, numberoptions.digit_separator) { + NumberOptions.digit_separator = str::from_utf8_unchecked( slice::from_raw_parts( numberoptions.digit_separator as *const u8, strlen( numberoptions.digit_separator ) ) ); + } + + NumberOptions.digit_group_size = numberoptions.digit_group_size; + NumberOptions.number_base = numberoptions.number_base; + NumberOptions.uppercase_hex = numberoptions.uppercase_hex; + NumberOptions.small_hex_numbers_in_decimal = numberoptions.small_hex_numbers_in_decimal; + NumberOptions.add_leading_zero_to_hex_numbers = numberoptions.add_leading_zero_to_hex_numbers; + NumberOptions.leading_zeros = numberoptions.leading_zeros; + NumberOptions.signed_number = numberoptions.signed_number; + NumberOptions.displacement_leading_zeros = numberoptions.displacement_leading_zeros; + } + }; + } +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/OutputCallback.rs b/src/rust/iced-x86-c/src/OutputCallback.rs new file mode 100644 index 000000000..e01125569 --- /dev/null +++ b/src/rust/iced-x86-c/src/OutputCallback.rs @@ -0,0 +1,45 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +//#![allow( non_snake_case )] +//extern crate libc; + +use iced_x86_rust::{FormatterOutput, FormatterTextKind}; +use std::{str, ptr::null_mut}; +use libc::c_char; +use std::ffi::CString; + +// Formatter Output Callback +// Used by a [`Formatter`] to write all text. `String` also implements this trait. +// +// The only method that must be implemented is [`write()`], all other methods call it if they're not overridden. +type + TFormatterOutputCallback = unsafe extern "C" fn( Text: *const c_char, Kind: u8 /*FormatterTextKind*/, UserData : *const usize ); + +pub struct TFormatterOutput { + pub(crate) userData : *const usize, + pub(crate) callback: Option +} + +impl FormatterOutput for TFormatterOutput { + fn write(&mut self, text: &str, kind: FormatterTextKind) { + let value = CString::new( text ).unwrap(); + unsafe { + self.callback.unwrap()( value.to_bytes().as_ptr() as *const i8, kind as u8, self.userData ); + } + } +} + +// Creates a formatter Output Callback +#[no_mangle] +pub extern "C" fn FormatterOutput_Create( Callback : Option, UserData : *const usize ) -> *mut TFormatterOutput { + if Callback.is_none() { + return null_mut(); + } + + Box::into_raw( Box::new( TFormatterOutput { callback:Callback, userData:UserData }) ) +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/Register.rs b/src/rust/iced-x86-c/src/Register.rs new file mode 100644 index 000000000..4818f868f --- /dev/null +++ b/src/rust/iced-x86-c/src/Register.rs @@ -0,0 +1,64 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::Register; +use std::mem::transmute;// Enum<->Int + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Register_Base( Register : u8 ) -> u8 { // FFI-Unsafe: Register + let register : Register = transmute( Register as u8 ); + transmute( register.base() as u8 ) +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Register_Number( Register : u8 ) -> usize { // FFI-Unsafe: Register + let register : Register = transmute( Register as u8 ); + register.number() +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Register_FullRegister( Register : u8 ) -> u8 { // FFI-Unsafe: Register + let register : Register = transmute( Register as u8 ); + transmute( register.full_register() as u8 ) +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Register_FullRegister32( Register : u8 ) -> u8 { // FFI-Unsafe: Register + let register : Register = transmute( Register as u8 ); + transmute( register.full_register32() as u8 ) +} + +#[cfg(feature = "instr_info")] +#[no_mangle] +pub unsafe extern "C" fn Register_Size( Register : u8 ) -> usize { // FFI-Unsafe: Register + let register : Register = transmute( Register as u8 ); + register.size() +} + +#[no_mangle] +pub unsafe extern "C" fn Register_AsString( Register : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: Register + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let register : Register = transmute( Register as u8 ); + let output = format!("{register:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/RepPrefixKind.rs b/src/rust/iced-x86-c/src/RepPrefixKind.rs new file mode 100644 index 000000000..6218957d4 --- /dev/null +++ b/src/rust/iced-x86-c/src/RepPrefixKind.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::RepPrefixKind; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn RepPrefixKind_AsString( RepPrefixKind : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: RepPrefixKind + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let RepPrefixKind : RepPrefixKind = transmute( RepPrefixKind as u8 ); + let output = format!("{RepPrefixKind:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/RoundingControl.rs b/src/rust/iced-x86-c/src/RoundingControl.rs new file mode 100644 index 000000000..49b47a70c --- /dev/null +++ b/src/rust/iced-x86-c/src/RoundingControl.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::RoundingControl; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn RoundingControl_AsString( RoundingControl : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: RoundingControl + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let RoundingControl : RoundingControl = transmute( RoundingControl as u8 ); + let output = format!("{RoundingControl:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/SpecializedFormatter.rs b/src/rust/iced-x86-c/src/SpecializedFormatter.rs new file mode 100644 index 000000000..3594cdc32 --- /dev/null +++ b/src/rust/iced-x86-c/src/SpecializedFormatter.rs @@ -0,0 +1,668 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, SpecializedFormatter, DefaultSpecializedFormatterTraitOptions}; +#[cfg(feature = "decoder")] +use iced_x86_rust::Decoder; +use crate::SymbolResolver::{TSymbolResolver, TSymbolResolverCallback}; +use crate::SpecializedFormatterTraitOptions::*; +#[cfg(feature = "decoder")] +use crate::Decoder::TDecoderFormatCallback; + +use std::ptr::null_mut; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Specialized-Formatter +pub(crate) type +TSpecializedFormatterDefault = SpecializedFormatter; + +pub(crate) struct TSpecializedFormatter { + pub Formatter : TSpecializedFormatterDefault, + pub Output : String, +} +// Creates a Specialized formatter +#[no_mangle] +pub extern "C" fn SpecializedFormatter_Create( SymbolResolver : Option, UserData : *const usize ) -> *mut TSpecializedFormatter { + if !SymbolResolver.is_none() { + let symbols = Box::new( TSymbolResolver { callback:SymbolResolver, userData:UserData }); + + match TSpecializedFormatterDefault::try_with_options( Some( symbols ) ) { + Ok( value ) => return Box::into_raw( Box::new( TSpecializedFormatter { Formatter: value, Output: String::new() } ) ), + Err( _e ) => return null_mut() + } + } else { + match TSpecializedFormatterDefault::try_with_options( None ) { + Ok( value ) => return Box::into_raw( Box::new( TSpecializedFormatter { Formatter: value, Output: String::new() } ) ), + Err( _e ) => return null_mut() + } + } +} + +// Format Instruction +/* +#[no_mangle] +pub unsafe extern "C" fn SpecializedFormatter_Format( Formatter: *mut TSpecializedFormatter, Options : u16, Instruction: *mut Instruction, Output : *mut u8, Size : usize ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); +} +*/ + +#[no_mangle] +pub unsafe extern "C" fn SpecializedFormatter_Format( Formatter: *mut TSpecializedFormatter, Options : u8, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + match Options { + 0 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter000); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 1 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter001); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 2 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter010); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + Box::into_raw(obj); + } + + 3 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter011); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 4 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter100); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 5 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter101); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 6 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter110); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 7 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter111); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + _ => { + //let mut obj = Box::from_raw( Formatter ); + //obj.Output.clear(); + //obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + //*obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + //Box::into_raw( obj ); + return; + } + } +} + +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn SpecializedFormatter_DecodeFormat( Decoder: *mut Decoder, Formatter: *mut TSpecializedFormatter, Options : u8, Instruction: *mut Instruction, Output : *mut *const u8, Size : *mut usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Instruction.is_null() { + return; + } + if Output.is_null() { + return; + } + if Size.is_null() { + return; + } + + // Decode + let mut obj = Box::from_raw( Decoder ); + obj.decode_out( Instruction.as_mut().unwrap() ); + Box::into_raw( obj ); + + // Format + match Options { + 0 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter000); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 1 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter001); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 2 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter010); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + Box::into_raw(obj); + } + + 3 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter011); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 4 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter100); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 5 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter101); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 6 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter110); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + 7 => { + let mut obj = Box::from_raw(Formatter as *mut TSpecializedFormatter111); + obj.Output.clear(); + obj.Formatter.format(Instruction.as_mut().unwrap(), &mut obj.Output); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw(obj); + } + + _ => { +/* + let mut obj = Box::from_raw( Formatter ); + obj.Output.clear(); + obj.Formatter.format( Instruction.as_mut().unwrap(), &mut obj.Output ); + if obj.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *obj.Output.as_mut_ptr().add(obj.Output.len()) = 0; + } else { + let newsize = obj.Output.len()+1; + obj.Output.as_mut_vec().resize( newsize, 0 ); + } + (*Output) = obj.Output.as_ptr(); + (*Size) = obj.Output.len(); + Box::into_raw( obj ); +*/ + return; + } + } +} + +#[cfg(feature = "decoder")] +#[no_mangle] +pub unsafe extern "C" fn SpecializedFormatter_DecodeFormatToEnd( Decoder: *mut Decoder, Formatter: *mut TSpecializedFormatter, Options : u8, Callback: Option, UserData : *const usize ) { + if Decoder.is_null() { + return; + } + if Formatter.is_null() { + return; + } + if Callback.is_none() { + return; + } + + let mut decoder = Box::from_raw( Decoder ); + let mut stop: bool = false; + let mut instruction: Instruction = Instruction::new(); + + match Options { + 0 => { + let mut formatter = Box::from_raw(Formatter as *mut TSpecializedFormatter000); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + if formatter.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *formatter.Output.as_mut_ptr().add(formatter.Output.len()) = 0; + } else { + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + } + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw(formatter); + } + + 1 => { + let mut formatter = Box::from_raw(Formatter as *mut TSpecializedFormatter001); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + if formatter.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *formatter.Output.as_mut_ptr().add(formatter.Output.len()) = 0; + } else { + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + } + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw(formatter); + } + + 2 => { + let mut formatter = Box::from_raw(Formatter as *mut TSpecializedFormatter010); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + if formatter.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *formatter.Output.as_mut_ptr().add(formatter.Output.len()) = 0; + } else { + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + } + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw(formatter); + } + + 3 => { + let mut formatter = Box::from_raw(Formatter as *mut TSpecializedFormatter011); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + if formatter.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *formatter.Output.as_mut_ptr().add(formatter.Output.len()) = 0; + } else { + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + } + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw(formatter); + } + + 4 => { + let mut formatter = Box::from_raw(Formatter as *mut TSpecializedFormatter100); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + if formatter.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *formatter.Output.as_mut_ptr().add(formatter.Output.len()) = 0; + } else { + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + } + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw(formatter); + } + + 5 => { + let mut formatter = Box::from_raw(Formatter as *mut TSpecializedFormatter101); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + if formatter.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *formatter.Output.as_mut_ptr().add(formatter.Output.len()) = 0; + } else { + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + } + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw(formatter); + } + + 6 => { + let mut formatter = Box::from_raw(Formatter as *mut TSpecializedFormatter110); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + if formatter.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *formatter.Output.as_mut_ptr().add(formatter.Output.len()) = 0; + } else { + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + } + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw(formatter); + } + + 7 => { + let mut formatter = Box::from_raw(Formatter as *mut TSpecializedFormatter111); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + if formatter.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *formatter.Output.as_mut_ptr().add(formatter.Output.len()) = 0; + } else { + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + } + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw(formatter); + } + + _ => { +/* + let mut formatter = Box::from_raw( Formatter ); + while decoder.can_decode() && !stop { + decoder.decode_out( &mut instruction ); + + formatter.Output.clear(); + formatter.Formatter.format( &instruction, &mut formatter.Output ); + if formatter.Output.len() < 315/*MAX_FMT_INSTR_LEN*/ { + *formatter.Output.as_mut_ptr().add(formatter.Output.len()) = 0; + } else { + let newsize = formatter.Output.len()+1; + formatter.Output.as_mut_vec().resize( newsize, 0 ); + } + + Callback.unwrap()( &mut instruction, formatter.Output.as_ptr(), formatter.Output.len(), &mut stop, UserData ); + } + Box::into_raw(formatter); + */ + //return; + } + } + + Box::into_raw( decoder ); +} + +// NOTE: Specialized Formatter only supports the following Options +// Options + +// Always show the size of memory operands +// +// Default | Value | Example | Example +// --------|-------|---------|-------- +// _ | `true` | `mov eax,dword ptr [ ebx ]` | `add byte ptr [ eax ],0x12` +// 👍 | `false` | `mov eax,[ ebx ]` | `add byte ptr [ eax ],0x12` +#[no_mangle] +pub unsafe extern "C" fn SpecializedFormatter_GetAlwaysShowMemorySize( Formatter: *mut TSpecializedFormatter ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + let value = obj.Formatter.options_mut().always_show_memory_size(); + + Box::into_raw( obj ); + + return value; +} + +// Always show the size of memory operands +// +// Default | Value | Example | Example +// --------|-------|---------|-------- +// _ | `true` | `mov eax,dword ptr [ ebx ]` | `add byte ptr [ eax ],0x12` +// 👍 | `false` | `mov eax,[ ebx ]` | `add byte ptr [ eax ],0x12` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn SpecializedFormatter_SetAlwaysShowMemorySize( Formatter: *mut TSpecializedFormatter, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + obj.Formatter.options_mut().set_always_show_memory_size( Value ); + + Box::into_raw( obj ); + + return true; +} + +// Use a hex prefix ( `0x` ) or a hex suffix ( `h` ) +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `0x5A` +// X | `false` | `5Ah` +#[no_mangle] +pub unsafe extern "C" fn SpecializedFormatter_GetUseHexPrefix( Formatter: *mut TSpecializedFormatter ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + let value = obj.Formatter.options_mut().use_hex_prefix(); + + Box::into_raw( obj ); + + return value; +} + +// Use a hex prefix ( `0x` ) or a hex suffix ( `h` ) +// +// Default | Value | Example +// --------|-------|-------- +// _ | `true` | `0x5A` +// X | `false` | `5Ah` +// +// # Arguments +// * `value`: New value +#[no_mangle] +pub unsafe extern "C" fn SpecializedFormatter_SetUseHexPrefix( Formatter: *mut TSpecializedFormatter, Value : bool ) -> bool { + if Formatter.is_null() { + return false; + } + let mut obj = Box::from_raw( Formatter ); + + obj.Formatter.options_mut().set_use_hex_prefix( Value ); + + Box::into_raw( obj ); + + return true; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/SpecializedFormatterTraitOptions.rs b/src/rust/iced-x86-c/src/SpecializedFormatterTraitOptions.rs new file mode 100644 index 000000000..3a95797b2 --- /dev/null +++ b/src/rust/iced-x86-c/src/SpecializedFormatterTraitOptions.rs @@ -0,0 +1,531 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{SpecializedFormatter, SpecializedFormatterTraitOptions, FastFormatterOptions}; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Specialized-Formatter Trait Combos +pub struct SpecializedFormatterTraitOptions000; +impl SpecializedFormatterTraitOptions for SpecializedFormatterTraitOptions000 { + const ENABLE_SYMBOL_RESOLVER: bool = false; + const ENABLE_DB_DW_DD_DQ: bool = false; + + #[must_use] + #[inline] + unsafe fn verify_output_has_enough_bytes_left() -> bool { + // It's not possible to create 'unsafe const' items so we use a fn here + false + } + + #[must_use] + #[inline] + fn space_after_operand_separator(_options: &FastFormatterOptions) -> bool { + _options.space_after_operand_separator() + } + + #[must_use] + #[inline] + fn rip_relative_addresses(_options: &FastFormatterOptions) -> bool { + _options.rip_relative_addresses() + } + + #[must_use] + #[inline] + fn use_pseudo_ops(_options: &FastFormatterOptions) -> bool { + _options.use_pseudo_ops() + } + + #[must_use] + #[inline] + fn show_symbol_address(_options: &FastFormatterOptions) -> bool { + _options.show_symbol_address() + } + + #[must_use] + #[inline] + fn always_show_segment_register(_options: &FastFormatterOptions) -> bool { + _options.always_show_segment_register() + } + + #[must_use] + #[inline] + fn always_show_memory_size(_options: &FastFormatterOptions) -> bool { + _options.always_show_memory_size() + } + + #[must_use] + #[inline] + fn uppercase_hex(_options: &FastFormatterOptions) -> bool { + _options.uppercase_hex() + } + + #[must_use] + #[inline] + fn use_hex_prefix(_options: &FastFormatterOptions) -> bool { + _options.use_hex_prefix() + } +} + +pub struct SpecializedFormatterTraitOptions100; +impl SpecializedFormatterTraitOptions for SpecializedFormatterTraitOptions100 { + const ENABLE_SYMBOL_RESOLVER: bool = true; + const ENABLE_DB_DW_DD_DQ: bool = false; + + #[must_use] + #[inline] + unsafe fn verify_output_has_enough_bytes_left() -> bool { + // It's not possible to create 'unsafe const' items so we use a fn here + false + } + + #[must_use] + #[inline] + fn space_after_operand_separator(_options: &FastFormatterOptions) -> bool { + _options.space_after_operand_separator() + } + + #[must_use] + #[inline] + fn rip_relative_addresses(_options: &FastFormatterOptions) -> bool { + _options.rip_relative_addresses() + } + + #[must_use] + #[inline] + fn use_pseudo_ops(_options: &FastFormatterOptions) -> bool { + _options.use_pseudo_ops() + } + + #[must_use] + #[inline] + fn show_symbol_address(_options: &FastFormatterOptions) -> bool { + _options.show_symbol_address() + } + + #[must_use] + #[inline] + fn always_show_segment_register(_options: &FastFormatterOptions) -> bool { + _options.always_show_segment_register() + } + + #[must_use] + #[inline] + fn always_show_memory_size(_options: &FastFormatterOptions) -> bool { + _options.always_show_memory_size() + } + + #[must_use] + #[inline] + fn uppercase_hex(_options: &FastFormatterOptions) -> bool { + _options.uppercase_hex() + } + + #[must_use] + #[inline] + fn use_hex_prefix(_options: &FastFormatterOptions) -> bool { + _options.use_hex_prefix() + } +} + +pub struct SpecializedFormatterTraitOptions010; +impl SpecializedFormatterTraitOptions for SpecializedFormatterTraitOptions010 { + const ENABLE_SYMBOL_RESOLVER: bool = false; + const ENABLE_DB_DW_DD_DQ: bool = true; + + #[must_use] + #[inline] + unsafe fn verify_output_has_enough_bytes_left() -> bool { + // It's not possible to create 'unsafe const' items so we use a fn here + false + } + + #[must_use] + #[inline] + fn space_after_operand_separator(_options: &FastFormatterOptions) -> bool { + _options.space_after_operand_separator() + } + + #[must_use] + #[inline] + fn rip_relative_addresses(_options: &FastFormatterOptions) -> bool { + _options.rip_relative_addresses() + } + + #[must_use] + #[inline] + fn use_pseudo_ops(_options: &FastFormatterOptions) -> bool { + _options.use_pseudo_ops() + } + + #[must_use] + #[inline] + fn show_symbol_address(_options: &FastFormatterOptions) -> bool { + _options.show_symbol_address() + } + + #[must_use] + #[inline] + fn always_show_segment_register(_options: &FastFormatterOptions) -> bool { + _options.always_show_segment_register() + } + + #[must_use] + #[inline] + fn always_show_memory_size(_options: &FastFormatterOptions) -> bool { + _options.always_show_memory_size() + } + + #[must_use] + #[inline] + fn uppercase_hex(_options: &FastFormatterOptions) -> bool { + _options.uppercase_hex() + } + + #[must_use] + #[inline] + fn use_hex_prefix(_options: &FastFormatterOptions) -> bool { + _options.use_hex_prefix() + } +} + +pub struct SpecializedFormatterTraitOptions001; +impl SpecializedFormatterTraitOptions for SpecializedFormatterTraitOptions001 { + const ENABLE_SYMBOL_RESOLVER: bool = false; + const ENABLE_DB_DW_DD_DQ: bool = false; + + #[must_use] + #[inline] + unsafe fn verify_output_has_enough_bytes_left() -> bool { + // It's not possible to create 'unsafe const' items so we use a fn here + true + } + + #[must_use] + #[inline] + fn space_after_operand_separator(_options: &FastFormatterOptions) -> bool { + _options.space_after_operand_separator() + } + + #[must_use] + #[inline] + fn rip_relative_addresses(_options: &FastFormatterOptions) -> bool { + _options.rip_relative_addresses() + } + + #[must_use] + #[inline] + fn use_pseudo_ops(_options: &FastFormatterOptions) -> bool { + _options.use_pseudo_ops() + } + + #[must_use] + #[inline] + fn show_symbol_address(_options: &FastFormatterOptions) -> bool { + _options.show_symbol_address() + } + + #[must_use] + #[inline] + fn always_show_segment_register(_options: &FastFormatterOptions) -> bool { + _options.always_show_segment_register() + } + + #[must_use] + #[inline] + fn always_show_memory_size(_options: &FastFormatterOptions) -> bool { + _options.always_show_memory_size() + } + + #[must_use] + #[inline] + fn uppercase_hex(_options: &FastFormatterOptions) -> bool { + _options.uppercase_hex() + } + + #[must_use] + #[inline] + fn use_hex_prefix(_options: &FastFormatterOptions) -> bool { + _options.use_hex_prefix() + } +} + +pub struct SpecializedFormatterTraitOptions011; +impl SpecializedFormatterTraitOptions for SpecializedFormatterTraitOptions011 { + const ENABLE_SYMBOL_RESOLVER: bool = false; + const ENABLE_DB_DW_DD_DQ: bool = true; + + #[must_use] + #[inline] + unsafe fn verify_output_has_enough_bytes_left() -> bool { + // It's not possible to create 'unsafe const' items so we use a fn here + true + } + + #[must_use] + #[inline] + fn space_after_operand_separator(_options: &FastFormatterOptions) -> bool { + _options.space_after_operand_separator() + } + + #[must_use] + #[inline] + fn rip_relative_addresses(_options: &FastFormatterOptions) -> bool { + _options.rip_relative_addresses() + } + + #[must_use] + #[inline] + fn use_pseudo_ops(_options: &FastFormatterOptions) -> bool { + _options.use_pseudo_ops() + } + + #[must_use] + #[inline] + fn show_symbol_address(_options: &FastFormatterOptions) -> bool { + _options.show_symbol_address() + } + + #[must_use] + #[inline] + fn always_show_segment_register(_options: &FastFormatterOptions) -> bool { + _options.always_show_segment_register() + } + + #[must_use] + #[inline] + fn always_show_memory_size(_options: &FastFormatterOptions) -> bool { + _options.always_show_memory_size() + } + + #[must_use] + #[inline] + fn uppercase_hex(_options: &FastFormatterOptions) -> bool { + _options.uppercase_hex() + } + + #[must_use] + #[inline] + fn use_hex_prefix(_options: &FastFormatterOptions) -> bool { + _options.use_hex_prefix() + } +} + +pub struct SpecializedFormatterTraitOptions111; +impl SpecializedFormatterTraitOptions for SpecializedFormatterTraitOptions111 { + const ENABLE_SYMBOL_RESOLVER: bool = true; + const ENABLE_DB_DW_DD_DQ: bool = true; + + #[must_use] + #[inline] + unsafe fn verify_output_has_enough_bytes_left() -> bool { + // It's not possible to create 'unsafe const' items so we use a fn here + true + } + + #[must_use] + #[inline] + fn space_after_operand_separator(_options: &FastFormatterOptions) -> bool { + _options.space_after_operand_separator() + } + + #[must_use] + #[inline] + fn rip_relative_addresses(_options: &FastFormatterOptions) -> bool { + _options.rip_relative_addresses() + } + + #[must_use] + #[inline] + fn use_pseudo_ops(_options: &FastFormatterOptions) -> bool { + _options.use_pseudo_ops() + } + + #[must_use] + #[inline] + fn show_symbol_address(_options: &FastFormatterOptions) -> bool { + _options.show_symbol_address() + } + + #[must_use] + #[inline] + fn always_show_segment_register(_options: &FastFormatterOptions) -> bool { + _options.always_show_segment_register() + } + + #[must_use] + #[inline] + fn always_show_memory_size(_options: &FastFormatterOptions) -> bool { + _options.always_show_memory_size() + } + + #[must_use] + #[inline] + fn uppercase_hex(_options: &FastFormatterOptions) -> bool { + _options.uppercase_hex() + } + + #[must_use] + #[inline] + fn use_hex_prefix(_options: &FastFormatterOptions) -> bool { + _options.use_hex_prefix() + } +} + +pub struct SpecializedFormatterTraitOptions101; +impl SpecializedFormatterTraitOptions for SpecializedFormatterTraitOptions101 { + const ENABLE_SYMBOL_RESOLVER: bool = true; + const ENABLE_DB_DW_DD_DQ: bool = false; + + #[must_use] + #[inline] + unsafe fn verify_output_has_enough_bytes_left() -> bool { + // It's not possible to create 'unsafe const' items so we use a fn here + true + } + + #[must_use] + #[inline] + fn space_after_operand_separator(_options: &FastFormatterOptions) -> bool { + _options.space_after_operand_separator() + } + + #[must_use] + #[inline] + fn rip_relative_addresses(_options: &FastFormatterOptions) -> bool { + _options.rip_relative_addresses() + } + + #[must_use] + #[inline] + fn use_pseudo_ops(_options: &FastFormatterOptions) -> bool { + _options.use_pseudo_ops() + } + + #[must_use] + #[inline] + fn show_symbol_address(_options: &FastFormatterOptions) -> bool { + _options.show_symbol_address() + } + + #[must_use] + #[inline] + fn always_show_segment_register(_options: &FastFormatterOptions) -> bool { + _options.always_show_segment_register() + } + + #[must_use] + #[inline] + fn always_show_memory_size(_options: &FastFormatterOptions) -> bool { + _options.always_show_memory_size() + } + + #[must_use] + #[inline] + fn uppercase_hex(_options: &FastFormatterOptions) -> bool { + _options.uppercase_hex() + } + + #[must_use] + #[inline] + fn use_hex_prefix(_options: &FastFormatterOptions) -> bool { + _options.use_hex_prefix() + } +} + +pub struct SpecializedFormatterTraitOptions110; +impl SpecializedFormatterTraitOptions for SpecializedFormatterTraitOptions110 { + const ENABLE_SYMBOL_RESOLVER: bool = true; + const ENABLE_DB_DW_DD_DQ: bool = true; + + #[must_use] + #[inline] + unsafe fn verify_output_has_enough_bytes_left() -> bool { + // It's not possible to create 'unsafe const' items so we use a fn here + false + } + + #[must_use] + #[inline] + fn space_after_operand_separator(_options: &FastFormatterOptions) -> bool { + _options.space_after_operand_separator() + } + + #[must_use] + #[inline] + fn rip_relative_addresses(_options: &FastFormatterOptions) -> bool { + _options.rip_relative_addresses() + } + + #[must_use] + #[inline] + fn use_pseudo_ops(_options: &FastFormatterOptions) -> bool { + _options.use_pseudo_ops() + } + + #[must_use] + #[inline] + fn show_symbol_address(_options: &FastFormatterOptions) -> bool { + _options.show_symbol_address() + } + + #[must_use] + #[inline] + fn always_show_segment_register(_options: &FastFormatterOptions) -> bool { + _options.always_show_segment_register() + } + + #[must_use] + #[inline] + fn always_show_memory_size(_options: &FastFormatterOptions) -> bool { + _options.always_show_memory_size() + } + + #[must_use] + #[inline] + fn uppercase_hex(_options: &FastFormatterOptions) -> bool { + _options.uppercase_hex() + } + + #[must_use] + #[inline] + fn use_hex_prefix(_options: &FastFormatterOptions) -> bool { + _options.use_hex_prefix() + } +} + +pub(crate) struct TSpecializedFormatter000 { + pub Formatter : SpecializedFormatter, + pub Output : String, +} +pub(crate) struct TSpecializedFormatter100 { + pub Formatter : SpecializedFormatter, + pub Output : String, +} +pub(crate) struct TSpecializedFormatter010 { + pub Formatter : SpecializedFormatter, + pub Output : String, +} +pub(crate) struct TSpecializedFormatter001 { + pub Formatter : SpecializedFormatter, + pub Output : String, +} +pub(crate) struct TSpecializedFormatter011 { + pub Formatter : SpecializedFormatter, + pub Output : String, +} +pub(crate) struct TSpecializedFormatter111 { + pub Formatter : SpecializedFormatter, + pub Output : String, +} +pub(crate) struct TSpecializedFormatter101 { + pub Formatter : SpecializedFormatter, + pub Output : String, +} +pub(crate) struct TSpecializedFormatter110 { + pub Formatter : SpecializedFormatter, + pub Output : String, +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/SymbolResolver.rs b/src/rust/iced-x86-c/src/SymbolResolver.rs new file mode 100644 index 000000000..1a7a2b7f2 --- /dev/null +++ b/src/rust/iced-x86-c/src/SymbolResolver.rs @@ -0,0 +1,81 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, SymbolResolver, SymbolResult}; +use std::{slice, str}; +use libc::{c_char, strlen}; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Callbacks + +// Tries to resolve a symbol +// +// # Arguments +// - `instruction`: Instruction +// - `operand`: Operand number, 0-based. This is a formatter operand and isn't necessarily the same as an instruction operand. +// - `instruction_operand`: Instruction operand number, 0-based, or `None` if it's an operand created by the formatter. +// - `address`: Address +// - `address_size`: Size of `address` in bytes ( eg. 1, 2, 4 or 8 ) +pub(crate) type + TSymbolResolverCallback = unsafe extern "C" fn( Instruction: *const Instruction, Operand: u32, InstructionOperand: u32, Address: u64, Size: u32, UserData : *const usize ) -> *const c_char; + + pub(crate) struct TSymbolResolver { + //map: HashMap, + pub(crate) userData: *const usize, + pub(crate) callback: Option +} + +impl SymbolResolver for TSymbolResolver { + fn symbol( &mut self, Instruction: &Instruction, Operand: u32, InstructionOperand: Option, Address: u64, Size: u32 ) -> Option { + unsafe { + if !self.callback.is_none() { + //let value = self.callback.unwrap()( &mut u as *mut u32, &mut i as *mut i32 );// Var-Parameter-Sample + + let instructionoperand: u32; + match InstructionOperand { + None => instructionoperand = 0xFFFF_FFFF, + _Some => instructionoperand = InstructionOperand.unwrap() + } + + let value = self.callback.unwrap()( Instruction, Operand, instructionoperand, Address, Size, self.userData ); + let symbol_string = str::from_utf8_unchecked( slice::from_raw_parts( value as *const u8, strlen( value ) ) ); + if !symbol_string.is_empty() { + // The 'Address' arg is the address of the symbol and doesn't have to be identical + // to the 'address' arg passed to symbol(). If it's different from the input + // address, the formatter will add +N or -N, eg. '[ rax+symbol+123 ]' + return Some( SymbolResult::with_str( Address, symbol_string ) ) + }else { + return None + /* + if let Some( symbol_string ) = self.map.get( &addr ) { + // The 'address' arg is the address of the symbol and doesn't have to be identical + // to the 'address' arg passed to symbol(). If it's different from the input + // address, the formatter will add +N or -N, eg. '[ rax+symbol+123 ]' + return Some( SymbolResult::with_str( addr, symbol_string.as_str() ) ) + //Some( SymbolResult::with_str( Address, symbol_string.as_str() ) ) + }else { + return None + } + */ + } + }else { + return None + /* + if let Some( symbol_string ) = self.map.get( &address ) { + // The 'address' arg is the address of the symbol and doesn't have to be identical + // to the 'address' arg passed to symbol(). If it's different from the input + // address, the formatter will add +N or -N, eg. '[ rax+symbol+123 ]' + return Some( SymbolResult::with_str( addr, symbol_string.as_str() ) ) + //return Some( SymbolResult::with_str( Address, symbol_string.as_str() ) ) + }else { + return None + } + */ + } + }; + } +} diff --git a/src/rust/iced-x86-c/src/TupleType.rs b/src/rust/iced-x86-c/src/TupleType.rs new file mode 100644 index 000000000..b1be96459 --- /dev/null +++ b/src/rust/iced-x86-c/src/TupleType.rs @@ -0,0 +1,29 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::TupleType; +use std::mem::transmute;// Enum<->Int + +#[no_mangle] +pub unsafe extern "C" fn TupleType_AsString( TupleType : u8, Output : *mut u8, Size : usize ) { // FFI-Unsafe: TupleType + if Output.is_null() { + return; + } + if Size <= 0 { + return; + } + + let tupleType : TupleType = transmute( TupleType as u8 ); + let output = format!("{tupleType:?}"); + + let aOutput = Output as *mut [u8;1024]; + let aSource = output.as_bytes(); + + let n = std::cmp::min( aSource.len(), Size/*(*aOutput).len()*/ ); + (*aOutput)[0..n].copy_from_slice(&aSource[0..n]); + (*aOutput)[n] = 0; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/VirtualAddressResolver.rs b/src/rust/iced-x86-c/src/VirtualAddressResolver.rs new file mode 100644 index 000000000..1217c4f87 --- /dev/null +++ b/src/rust/iced-x86-c/src/VirtualAddressResolver.rs @@ -0,0 +1,58 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +use iced_x86_rust::{Instruction, Register}; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// Virtual-Address Resolver +// Gets the virtual address of a memory operand +// +// # Arguments +// * `operand`: Operand number, 0-4, must be a memory operand +// * `element_index`: Only used if it's a vsib memory operand. This is the element index of the vector index register. +// * `get_register_value`: Function that returns the value of a register or the base address of a segment register, or `None` for unsupported +// registers. +// +// # Call-back function args +// * Arg 1: `register`: Register (GPR8, GPR16, GPR32, GPR64, XMM, YMM, ZMM, seg). If it's a segment register, the call-back function should return the segment's base address, not the segment's register value. +// * Arg 2: `element_index`: Only used if it's a vsib memory operand. This is the element index of the vector index register. +// * Arg 3: `element_size`: Only used if it's a vsib memory operand. Size in bytes of elements in vector index register (4 or 8). +type + TVirtualAddressResolverCallback = unsafe extern "C" fn( Register: u8/*Register*/, Index: usize, Size: usize, Address : *mut u64, UserData : *const usize ) -> bool;// FFI-Unsafe: Register + +#[no_mangle] +pub unsafe extern "C" fn Instruction_VirtualAddress( Instruction: *mut Instruction, Callback : Option, Operand : u32, Index : usize, UserData : *const usize ) -> u64 { + if Instruction.is_null() { + return 0 + } + if Callback.is_none() { + return 0 + } + + let va = Instruction.as_mut().unwrap().virtual_address(Operand, Index, + |Register, Index, Size| { + match Register { + Register::ES | Register::CS | Register::SS | Register::DS => Some( 0 ), // The base address of ES, CS, SS and DS is always 0 in 64-bit mode + _ => { + let mut value : u64 = 0; + if Callback.unwrap()( Register as u8, Index, Size, &mut value as *mut u64, UserData ) { + Some( value ) + }else { + None + } + } + } + } + ); + + let res: u64; + match va { + None => res = 0x0, + _ => res = va.unwrap() + } + return res; +} \ No newline at end of file diff --git a/src/rust/iced-x86-c/src/lib.rs b/src/rust/iced-x86-c/src/lib.rs new file mode 100644 index 000000000..e8273a15a --- /dev/null +++ b/src/rust/iced-x86-c/src/lib.rs @@ -0,0 +1,102 @@ +/* + Iced (Dis)Assembler + C-Compatible Exports + + TetzkatLipHoka 2022-2024 +*/ + +#![allow( non_snake_case )] +#![allow( dead_code )] // TFormatterType +extern crate libc; + +mod FreeMemory; +mod Mnemonic; +mod Code; +mod Register; +mod OpKind; +mod RoundingControl; +mod MemorySize; +mod CodeSize; +mod Instruction; + +#[cfg(feature = "op_code_info")] +mod OpCodeInfo; +#[cfg(feature = "op_code_info")] +mod MandatoryPrefix; +#[cfg(feature = "op_code_info")] +mod OpCodeOperandKind; +#[cfg(feature = "op_code_info")] +mod OpCodeTableKind; + +#[cfg(feature = "instr_info")] +mod CPUIdFeature; +#[cfg(feature = "instr_info")] +mod ConditionCode; +#[cfg(feature = "instr_info")] +mod FlowControl; +#[cfg(feature = "instr_info")] +mod OpAccess; +#[cfg(feature = "instr_info")] +mod InstructionInfoFactory; + +#[cfg(feature = "mvex")] +mod MvexEHBit; +#[cfg(feature = "mvex")] +mod MvexTupleTypeLutKind; +#[cfg(feature = "mvex")] +mod MvexConvFn; +#[cfg(feature = "mvex")] +mod MvexRegMemConv; + +#[cfg(feature = "instr_create")] +mod RepPrefixKind; +#[cfg(feature = "instr_create")] +mod InstructionWith; + +#[cfg(feature = "decoder")] +mod EncodingKind; +#[cfg(feature = "decoder")] +mod TupleType; +#[cfg(feature = "decoder")] +mod DecoderError; +#[cfg(feature = "decoder")] +mod Decoder; + +#[cfg(feature = "encoder")] +mod Encoder; + +#[cfg(feature = "block_encoder")] +mod BlockEncoder; + +#[cfg(feature = "formatter")] +mod FormatterTextKind; +#[cfg(feature = "formatter")] +mod NumberBase; +#[cfg(feature = "formatter")] +mod MemorySizeOptions; + +#[cfg(feature = "formatter")] +mod SymbolResolver; +#[cfg(feature = "formatter")] +mod OptionsProvider; +#[cfg(feature = "formatter")] +mod OutputCallback; +mod VirtualAddressResolver; + +#[cfg(feature = "formatter")] +mod Formatter; +#[cfg(feature = "masm")] +mod MasmFormatter; +#[cfg(feature = "nasm")] +mod NasmFormatter; +#[cfg(feature = "gas")] +mod GasFormatter; +#[cfg(feature = "intel")] +mod IntelFormatter; +#[cfg(feature = "fast_fmt")] +mod FastFormatter; +// ~100KB more +#[cfg(feature = "fast_fmt")] +mod SpecializedFormatterTraitOptions; +#[cfg(feature = "fast_fmt")] +mod SpecializedFormatter; \ No newline at end of file