{ "architecture": "x86", "instructions": [ { "mnemonic": "inc", "architecture": "x86", "full_name": "Increment", "summary": "Increments the operand by 1.", "syntax": "INC r/m", "encoding": { "format": "Legacy", "hex_opcode": "FF /0", "visual_parts": [], "binary_pattern": "FF | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Increments operand by 1 and stores result in operand. Sets OF, SF, ZF, AF, PF; does not affect CF. Supports 8/16/32/64-bit operand sizes in all modes. Useful for loop counters and pointer arithmetic.", "pseudocode": "result ← dest + 1; dest ← result; OF ← overflow; ZF ← (result == 0); SF ← (result < 0); AF ← (result & 0xF); PF ← parity(result)", "example": "INC rbx" }, { "mnemonic": "dec", "architecture": "x86", "full_name": "Decrement", "summary": "Decrements the operand by 1.", "syntax": "DEC r/m", "encoding": { "format": "Legacy", "hex_opcode": "FF /1", "visual_parts": [], "binary_pattern": "FF | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Decrements operand by 1 and stores result in operand. Sets OF, SF, ZF, AF, PF; does not affect CF. Supports 8/16/32/64-bit operand sizes in all modes. Commonly used in loop control.", "pseudocode": "result ← dest - 1; dest ← result; OF ← overflow; ZF ← (result == 0); SF ← (result < 0); AF ← (result & 0xF); PF ← parity(result)", "example": "DEC rbx" }, { "mnemonic": "mul", "architecture": "x86", "full_name": "Unsigned Multiply", "summary": "Unsigned multiply (AX = AL * src).", "syntax": "MUL r/m", "encoding": { "format": "Legacy", "hex_opcode": "F7 /4", "visual_parts": [], "binary_pattern": "F7 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Performs unsigned multiplication of accumulator (AL/AX/EAX/RAX) by operand, storing result in AX/DX:AX/EDX:EAX/RDX:RAX respectively. Sets CF and OF if product overflows accumulator width; other flags undefined. High byte/word/dword/qword of result goes into AH/DX/EDX/RDX.", "pseudocode": "if (operand_width == 8) { product ← AL * src; AX ← product; CF ← OF ← (AH != 0); } else if (operand_width == 16) { product ← AX * src; DX:AX ← product; CF ← OF ← (DX != 0); } else if (operand_width == 32) { product ← EAX * src; EDX:EAX ← product; CF ← OF ← (EDX != 0); } else { product ← RAX * src; RDX:RAX ← product; CF ← OF ← (RDX != 0); }", "example": "MUL rbx" }, { "mnemonic": "imul", "architecture": "x86", "full_name": "Signed Multiply", "summary": "Signed multiply.", "syntax": "IMUL r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F AF", "visual_parts": [], "binary_pattern": "0F | AF", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Performs signed multiplication of destination register by source operand, storing result in destination. Sets OF and CF if result overflows destination width; SF, ZF, AF, PF undefined. Two-operand form (dest ← dest * src) is commonly used for scalar multiplies; one-operand form multiplies into EDX:EAX.", "pseudocode": "result ← dest * src; dest ← result; if (result overflows dest width) { CF ← 1; OF ← 1; } else { CF ← 0; OF ← 0; }", "example": "IMUL rax, rbx" }, { "mnemonic": "div", "architecture": "x86", "full_name": "Unsigned Divide", "summary": "Unsigned divide (AX / src).", "syntax": "DIV r/m", "encoding": { "format": "Legacy", "hex_opcode": "F7 /6", "visual_parts": [], "binary_pattern": "F7 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Performs unsigned division of accumulator (AX/DX:AX/EDX:EAX/RDX:RAX) by operand, storing quotient in AL/AX/EAX/RAX and remainder in AH/DX/EDX/RDX respectively. All flags undefined after division. Raises #DE exception if divisor is zero or quotient overflows.", "pseudocode": "if (operand_width == 8) { quotient ← AX / src; remainder ← AX mod src; AL ← quotient; AH ← remainder; } else if (operand_width == 16) { quotient ← DX:AX / src; remainder ← DX:AX mod src; AX ← quotient; DX ← remainder; } else if (operand_width == 32) { quotient ← EDX:EAX / src; remainder ← EDX:EAX mod src; EAX ← quotient; EDX ← remainder; } else { quotient ← RDX:RAX / src; remainder ← RDX:RAX mod src; RAX ← quotient; RDX ← remainder; }", "example": "DIV rbx" }, { "mnemonic": "idiv", "architecture": "x86", "full_name": "Signed Divide", "summary": "Signed divide (AX / src).", "syntax": "IDIV r/m", "encoding": { "format": "Legacy", "hex_opcode": "F7 /7", "visual_parts": [], "binary_pattern": "F7 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Performs signed division of the implicit accumulator (EDX:EAX for 32-bit or RDX:RAX for 64-bit) by the specified operand; quotient is stored in EAX/RAX and remainder in EDX/RDX. Sets OF, SF, ZF, AF, CF, and PF to undefined values; raises #DE exception if divisor is zero or quotient overflows. Available in 8-bit (AX/AL:AH), 16-bit (DX:AX), 32-bit, and 64-bit variants.", "pseudocode": "if (src == 0) raise #DE;\ntemp_dividend = (src_size == 8) ? AX : ((src_size == 16) ? (DX:AX) : ((src_size == 32) ? (EDX:EAX) : (RDX:RAX)));\nif ((temp_dividend / src) > max_signed || (temp_dividend / src) < min_signed) raise #DE;\nquotient = temp_dividend / src;\nremainder = temp_dividend % src;\nif (src_size == 8) { AL ← quotient; AH ← remainder; }\nelse if (src_size == 16) { AX ← quotient; DX ← remainder; }\nelse if (src_size == 32) { EAX ← quotient; EDX ← remainder; }\nelse { RAX ← quotient; RDX ← remainder; }\nOF ← undefined; SF ← undefined; ZF ← undefined; AF ← undefined; CF ← undefined; PF ← undefined;", "example": "IDIV rbx" }, { "mnemonic": "not", "architecture": "x86", "full_name": "One's Complement Negation", "summary": "Reverses bits of operand.", "syntax": "NOT r/m", "encoding": { "format": "Legacy", "hex_opcode": "F7 /2", "visual_parts": [], "binary_pattern": "F7 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Performs one's complement (bitwise negation) on the operand, inverting all bits and storing the result back. Does not affect any flags. Available in 8/16/32/64-bit variants.", "pseudocode": "dest ← ~dest;", "example": "NOT rbx" }, { "mnemonic": "neg", "architecture": "x86", "full_name": "Two's Complement Negation", "summary": "Negates value (0 - operand).", "syntax": "NEG r/m", "encoding": { "format": "Legacy", "hex_opcode": "F7 /3", "visual_parts": [], "binary_pattern": "F7 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Performs two's complement negation (0 - operand), storing the result back in the operand. Sets/clears CF, OF, ZF, SF, AF, PF based on result; CF is set unless operand was zero. Available in 8/16/32/64-bit variants.", "pseudocode": "old_operand ← dest;\nresult ← 0 - dest;\ndest ← result;\nCF ← (old_operand != 0);\nOF ← (old_operand == (1 << (operand_size * 8 - 1)));\nZF ← (result == 0);\nSF ← (result & sign_bit) != 0;\nPF ← popcount(result & 0xFF) % 2 == 0;\nAF ← ((0 - old_operand) & 0x10) != (old_operand & 0x10);", "example": "NEG rbx" }, { "mnemonic": "shl", "architecture": "x86", "full_name": "Shift Logical Left", "summary": "Shifts bits left (same as SAL).", "syntax": "SHL r/m, imm8", "encoding": { "format": "Legacy", "hex_opcode": "C1 /4", "visual_parts": [], "binary_pattern": "C1 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts the bits of the destination operand left by the count specified in the immediate operand, filling vacated bits with zeros; leftmost bit is shifted into CF. Sets CF and OF based on shift; ZF, SF, PF reflect the result. Available in 8/16/32/64-bit variants; count is typically 1 or specified by imm8.", "pseudocode": "if (count == 0) return;\ntemp ← dest;\nCF ← (dest >> (operand_size * 8 - count)) & 1;\nresult ← dest << count;\nOF ← (result & sign_bit) != (temp & sign_bit);\nZF ← (result == 0);\nSF ← (result & sign_bit) != 0;\nPF ← popcount(result & 0xFF) % 2 == 0;\ndest ← result;", "example": "SHL rbx, 3" }, { "mnemonic": "shr", "architecture": "x86", "full_name": "Shift Logical Right", "summary": "Shifts bits right, filling with zeros.", "syntax": "SHR r/m, imm8", "encoding": { "format": "Legacy", "hex_opcode": "C1 /5", "visual_parts": [], "binary_pattern": "C1 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts the bits of the destination operand right by the count specified in the immediate operand, filling vacated bits with zeros; rightmost bit is shifted into CF. Sets CF and OF based on shift; ZF, SF, PF reflect the result. Available in 8/16/32/64-bit variants; count is typically 1 or specified by imm8.", "pseudocode": "if (count == 0) return;\ntemp ← dest;\nCF ← (dest >> (count - 1)) & 1;\nresult ← dest >> count;\nOF ← (temp & sign_bit);\nZF ← (result == 0);\nSF ← 0;\nPF ← popcount(result & 0xFF) % 2 == 0;\ndest ← result;", "example": "SHR rbx, 3" }, { "mnemonic": "sar", "architecture": "x86", "full_name": "Shift Arithmetic Right", "summary": "Shifts bits right, preserving sign bit.", "syntax": "SAR r/m, imm8", "encoding": { "format": "Legacy", "hex_opcode": "C1 /7", "visual_parts": [], "binary_pattern": "C1 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts the bits of the destination operand right by the number of bits specified in the source operand, with the sign bit (MSB) replicated into vacated positions, preserving the sign of the value. The Carry Flag is set to the last bit shifted out. Available in 8/16/32/64-bit variants; OF is undefined when count > 1.", "pseudocode": "shift_count ← src\ntemp ← dest\nfor i ← 0 to shift_count - 1 do\n CF ← temp[0]\n temp ← (sign_extend(temp[width-1]) << (width-1)) | (temp >> 1)\ndest ← temp\nif shift_count == 1 then\n OF ← 0\nelse if shift_count > 1 then\n OF ← undefined\nZF ← (dest == 0)\nSF ← dest[width-1]\nPF ← parity(dest)", "example": "SAR rbx, 3" }, { "mnemonic": "jmp", "architecture": "x86", "full_name": "Jump", "summary": "Unconditional jump to target.", "syntax": "JMP rel", "encoding": { "format": "Legacy", "hex_opcode": "EB CB", "visual_parts": [], "binary_pattern": "EB | E9", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Performs an unconditional jump by adding the sign-extended relative offset to the instruction pointer (EIP/RIP). Available in 8-bit relative (EB opcode, -128 to +127) and 32-bit relative (E9 opcode) variants. No flags are affected.", "pseudocode": "if operand_size == 8 then\n RIP ← RIP + sign_extend_8(rel8)\nelse if operand_size == 32 then\n RIP ← RIP + sign_extend_32(rel32)\n// In 64-bit mode, RIP is the canonical form of EIP", "example": "JMP 0x401000 ; Jump to address\nJMP label ; Jump to label" }, { "mnemonic": "je", "architecture": "x86", "full_name": "Jump if Equal", "summary": "Jump if ZF=1 (Same as JZ).", "syntax": "JE rel", "encoding": { "format": "Legacy", "hex_opcode": "74", "visual_parts": [], "binary_pattern": "74", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Jumps to the target if the Zero Flag is set (ZF=1), indicating the result of a prior comparison or arithmetic operation was zero. Available in 8-bit relative form (opcode 74). No flags are affected by the jump itself; the jump condition is determined by previously set flags.", "pseudocode": "if ZF == 1 then\n RIP ← RIP + sign_extend_8(rel8)\nelse\n RIP ← RIP + 1 // no jump, continue to next instruction", "example": "JE rel" }, { "mnemonic": "jne", "architecture": "x86", "full_name": "Jump if Not Equal", "summary": "Jump if ZF=0 (Same as JNZ).", "syntax": "JNE rel", "encoding": { "format": "Legacy", "hex_opcode": "75", "visual_parts": [], "binary_pattern": "75", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Jumps to the target if the Zero Flag is clear (ZF=0), indicating the result of a prior comparison or arithmetic operation was non-zero. Available in 8-bit relative form (opcode 75). No flags are affected by the jump itself; the jump condition is determined by previously set flags.", "pseudocode": "if ZF == 0 then\n RIP ← RIP + sign_extend_8(rel8)\nelse\n RIP ← RIP + 1 // no jump, continue to next instruction", "example": "JNE rel" }, { "mnemonic": "jg", "architecture": "x86", "full_name": "Jump if Greater", "summary": "Jump if ZF=0 and SF=OF (Signed >).", "syntax": "JG rel", "encoding": { "format": "Legacy", "hex_opcode": "7F", "visual_parts": [], "binary_pattern": "7F", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Jumps to the target if the Zero Flag is clear and Sign Flag equals Overflow Flag (ZF=0 AND SF=OF), indicating a signed arithmetic result is greater than zero. Available in 8-bit relative form (opcode 7F). No flags are affected by the jump itself; the jump condition depends on previously set flags.", "pseudocode": "if (ZF == 0) AND (SF == OF) then\n RIP ← RIP + sign_extend_8(rel8)\nelse\n RIP ← RIP + 1 // no jump, continue to next instruction", "example": "JG rel" }, { "mnemonic": "jl", "architecture": "x86", "full_name": "Jump if Less", "summary": "Jump if SF!=OF (Signed <).", "syntax": "JL rel", "encoding": { "format": "Legacy", "hex_opcode": "7C", "visual_parts": [], "binary_pattern": "7C", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Jumps to the target if Sign Flag does not equal Overflow Flag (SF≠OF), indicating a signed arithmetic result is less than zero. Available in 8-bit relative form (opcode 7C). No flags are affected by the jump itself; the jump condition depends on previously set flags.", "pseudocode": "if SF != OF then\n RIP ← RIP + sign_extend_8(rel8)\nelse\n RIP ← RIP + 1 // no jump, continue to next instruction", "example": "JL rel" }, { "mnemonic": "ja", "architecture": "x86", "full_name": "Jump if Above", "summary": "Jump if CF=0 and ZF=0 (Unsigned >).", "syntax": "JA rel", "encoding": { "format": "Legacy", "hex_opcode": "77", "visual_parts": [], "binary_pattern": "77", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Performs a conditional jump to the target address if the previous comparison or arithmetic operation resulted in an unsigned greater-than condition (CF=0 AND ZF=0). This instruction is commonly used after unsigned comparisons (CMP) to branch based on the above condition. No flags are modified by this instruction; it only reads CF and ZF to determine the jump condition.", "pseudocode": "if (CF == 0 && ZF == 0) { RIP ← RIP + sign_extend(rel); }", "example": "JA rel" }, { "mnemonic": "jb", "architecture": "x86", "full_name": "Jump if Below", "summary": "Jump if CF=1 (Unsigned <).", "syntax": "JB rel", "encoding": { "format": "Legacy", "hex_opcode": "72", "visual_parts": [], "binary_pattern": "72", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Performs a conditional jump to the target address if the carry flag is set (CF=1), indicating an unsigned less-than condition from the previous operation. Commonly used after unsigned CMP or arithmetic operations to branch on the below condition. No flags are modified; the instruction only reads CF.", "pseudocode": "if (CF == 1) { RIP ← RIP + sign_extend(rel); }", "example": "JB rel" }, { "mnemonic": "call", "architecture": "x86", "full_name": "Call Procedure", "summary": "Push EIP/RIP and jump to target.", "syntax": "CALL rel", "encoding": { "format": "Legacy", "hex_opcode": "E8", "visual_parts": [], "binary_pattern": "E8", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Pushes the return address (next instruction pointer) onto the stack and jumps to the target procedure. In 32-bit mode, EIP is pushed; in 64-bit mode, RIP is pushed. This instruction does not modify any arithmetic flags but causes implicit stack manipulation and memory writes. Control flow changes to the called procedure.", "pseudocode": "if (64-bit mode) { RSP ← RSP - 8; [RSP] ← RIP + instruction_length; RIP ← RIP + sign_extend(rel); } else { ESP ← ESP - 4; [ESP] ← EIP + instruction_length; EIP ← EIP + sign_extend(rel); }", "example": "CALL rel" }, { "mnemonic": "ret", "architecture": "x86", "full_name": "Return from Procedure", "summary": "Pop EIP/RIP and resume execution.", "syntax": "RET", "encoding": { "format": "Legacy", "hex_opcode": "C3", "visual_parts": [], "binary_pattern": "C3", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Pops the return address from the stack and resumes execution at that address, effectively returning from a procedure called with CALL. In 32-bit mode, EIP is popped; in 64-bit mode, RIP is popped. No flags are modified. This instruction performs implicit stack manipulation and a memory read.", "pseudocode": "if (64-bit mode) { RIP ← [RSP]; RSP ← RSP + 8; } else { EIP ← [ESP]; ESP ← ESP + 4; }", "example": "RET" }, { "mnemonic": "push", "architecture": "x86", "full_name": "Push Word/Doubleword/Quadword Onto Stack", "summary": "Decrements SP and stores operand on stack.", "syntax": "PUSH r/m", "encoding": { "format": "Legacy", "hex_opcode": "FF /6", "length": "2+", "visual_parts": [], "binary_pattern": "FF | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "src", "desc": "Reg/Mem" } ], "extension": "Base", "description": "Decrements the stack pointer (ESP in 32-bit mode, RSP in 64-bit mode) by the operand size and stores the operand value at the new stack pointer. The operand can be a register or memory location. No flags are modified; this instruction performs implicit stack pointer decrement and a memory write.", "pseudocode": "if (64-bit mode) { RSP ← RSP - 8; [RSP] ← src_value; } else { ESP ← ESP - 4; [ESP] ← src_value; }", "example": "PUSH rbx" }, { "mnemonic": "pop", "architecture": "x86", "full_name": "Pop Value from Stack", "summary": "Loads operand from stack and increments SP.", "syntax": "POP r/m", "encoding": { "format": "Legacy", "hex_opcode": "8F /0", "visual_parts": [], "binary_pattern": "8F | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Loads a value from the top of the stack into the destination operand and increments the stack pointer (ESP in 32-bit mode, RSP in 64-bit mode) by the operand size. The destination can be a register or memory location. No flags are modified; this instruction performs implicit stack pointer increment and a memory read.", "pseudocode": "if (64-bit mode) { dest_value ← [RSP]; RSP ← RSP + 8; } else { dest_value ← [ESP]; ESP ← ESP + 4; }", "example": "POP rbx" }, { "mnemonic": "lea", "architecture": "x86", "full_name": "Load Effective Address", "summary": "Computes effective address and stores in register.", "syntax": "LEA r, m", "encoding": { "format": "Legacy", "hex_opcode": "8D", "visual_parts": [], "binary_pattern": "8D", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Computes the effective address of the memory operand and stores it in the destination register without performing a memory access. This instruction is useful for address arithmetic and pointer calculations. No flags are modified by this instruction.", "pseudocode": "dest ← address_of(src)", "example": "LEA rax, [rbp-8]" }, { "mnemonic": "nop", "architecture": "x86", "full_name": "No Operation", "summary": "Does nothing (alias for XCHG EAX, EAX).", "syntax": "NOP", "encoding": { "format": "Legacy", "hex_opcode": "NP 90", "visual_parts": [], "binary_pattern": "90", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Performs no operation and consumes one clock cycle. The one-byte NOP (0x90) is functionally equivalent to XCHG EAX, EAX. Longer NOP sequences (multi-byte) are available on newer processors for code padding without pipeline stalls. No flags are modified.", "pseudocode": "// No operation (pipeline advance only)", "example": "NOP" }, { "mnemonic": "xchg", "architecture": "x86", "full_name": "Exchange Register/Memory with Register", "summary": "Exchanges content of two operands.", "syntax": "XCHG r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "87", "visual_parts": [], "binary_pattern": "87", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Atomically exchanges the contents of two operands (register and register/memory or vice versa). The operation is performed with implicit locking semantics when one operand is memory, ensuring atomic behavior on multiprocessor systems. No flags are affected by this instruction.", "pseudocode": "temp ← dest; dest ← src; src ← temp;", "example": "XCHG rbx, rax" }, { "mnemonic": "cpuid", "architecture": "x86", "full_name": "CPU Identification", "summary": "Returns processor information based on EAX value.", "syntax": "CPUID", "encoding": { "format": "Legacy", "hex_opcode": "0F A2", "visual_parts": [], "binary_pattern": "0F | A2", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [], "description": "Executes CPU identification, returning processor feature information and capabilities into EAX, EBX, ECX, and EDX based on the input value in EAX (and sometimes ECX). This is a privileged instruction in some contexts and causes a serializing event; it clears the pipeline and blocks out-of-order execution until completion. The exact output depends on the EAX input leaf and subleaf (ECX) values.", "pseudocode": "EAX, EBX, ECX, EDX ← cpuid_data[EAX, ECX];", "example": "CPUID" }, { "mnemonic": "rdtsc", "architecture": "x86", "full_name": "Read Time-Stamp Counter", "summary": "Reads the time-stamp counter into EDX:EAX.", "syntax": "RDTSC", "encoding": { "format": "Legacy", "hex_opcode": "0F 31", "visual_parts": [], "binary_pattern": "0F | 31", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [], "description": "Reads the 64-bit time-stamp counter (TSC) and places the result in EDX:EAX, with EDX holding bits 63-32 and EAX holding bits 31-0. No flags are modified. This instruction is a serializing operation in some CPU implementations and may have variable latency; it is commonly used for performance measurement and requires appropriate privilege level or user-space access controls (managed by CR4.TSD).", "pseudocode": "EDX:EAX ← TimeStampCounter;", "example": "RDTSC" }, { "mnemonic": "movsx", "architecture": "x86", "full_name": "Move with Sign-Extension", "summary": "Copies and sign-extends a smaller value to a larger register.", "syntax": "MOVSX r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F BE", "visual_parts": [], "binary_pattern": "0F | BE", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Moves a value from a smaller source operand (8, 16, or 32 bits) to a larger destination register, sign-extending the value to fill the destination width. The sign bit of the source is copied to all high-order bits of the destination. No flags are affected by this instruction. Supported size combinations: r16 ← r/m8, r32 ← r/m8, r32 ← r/m16, r64 ← r/m8, r64 ← r/m16, r64 ← r/m32.", "pseudocode": "sign_bit ← src[source_width - 1]; dest ← (source_width < dest_width) ? (sign_extend(src, sign_bit, dest_width)) : src;", "example": "MOVSX rax, rbx" }, { "mnemonic": "movzx", "architecture": "x86", "full_name": "Move with Zero-Extension", "summary": "Copies and zero-extends a smaller value to a larger register.", "syntax": "MOVZX r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F B6", "visual_parts": [], "binary_pattern": "0F | B6", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Moves a value from a smaller source operand (8 or 16 bits) to a larger destination register, zero-extending the value to fill the destination width. All high-order bits of the destination beyond the source width are cleared to zero. No flags are affected by this instruction. Supported size combinations: r16 ← r/m8, r32 ← r/m8, r32 ← r/m16, r64 ← r/m8, r64 ← r/m16.", "pseudocode": "dest ← (source_width < dest_width) ? (zero_extend(src, dest_width)) : src;", "example": "MOVZX rax, rbx" }, { "mnemonic": "cwtl", "architecture": "x86", "full_name": "Convert Word to Long", "summary": "Sign-extends AX into EAX (also CWDE).", "syntax": "CWTL", "encoding": { "format": "Legacy", "hex_opcode": "98", "visual_parts": [], "binary_pattern": "98", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Sign-extends the 16-bit value in AX into the 32-bit register EAX; the sign bit of AX (bit 15) is copied to all high-order bits (31-16) of EAX, and EAX's low 16 bits (AX) remain unchanged. This is a zero-operand instruction with no flags modified. In 64-bit mode, CWDE is the canonical mnemonic and has the same behavior.", "pseudocode": "EAX[31:16] ← (AX[15]) ? 0xFFFF : 0x0000;", "example": "CWTL" }, { "mnemonic": "cltd", "architecture": "x86", "full_name": "Convert Long to Double Long", "summary": "Sign-extends EAX into EDX:EAX (also CDQ).", "syntax": "CLTD", "encoding": { "format": "Legacy", "hex_opcode": "99", "visual_parts": [], "binary_pattern": "99", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Sign-extends the 32-bit value in EAX into the 64-bit pair EDX:EAX; the sign bit of EAX (bit 31) is copied to all bits of EDX (bits 63-32), and EAX remains unchanged. This is a zero-operand instruction with no flags modified. In 64-bit mode, CDQ is the canonical mnemonic and has the same behavior. Commonly used before IDIV to prepare the dividend.", "pseudocode": "EDX ← (EAX[31]) ? 0xFFFFFFFF : 0x00000000;", "example": "CLTD" }, { "mnemonic": "cqto", "architecture": "x86", "full_name": "Convert Quadword to Octoword", "summary": "Sign-extends RAX into RDX:RAX (also CQO).", "syntax": "CQTO", "encoding": { "format": "Legacy", "hex_opcode": "REX.W + 99", "visual_parts": [], "binary_pattern": "48 | 99", "bit_positions": "+0 | +1" }, "extension": "Base (64-bit)", "operands": [], "description": "Sign-extends the 64-bit value in RAX into the 128-bit pair RDX:RAX (64-bit mode only); the sign bit of RAX (bit 63) is copied to all bits of RDX, and RAX remains unchanged. This is a zero-operand instruction with no flags modified. CQO is the canonical mnemonic for this operation. Commonly used before IDIV (64-bit) to prepare the dividend.", "pseudocode": "RDX ← (RAX[63]) ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000;", "example": "CQTO" }, { "mnemonic": "bswap", "architecture": "x86", "full_name": "Byte Swap", "summary": "Reverses the byte order of a register (Endian swap).", "syntax": "BSWAP r32", "encoding": { "format": "Legacy", "hex_opcode": "0F C8+rd", "visual_parts": [], "binary_pattern": "0F | C8+reg", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Reverses the byte order of a 32-bit register, converting between little-endian and big-endian representations. No flags are affected. This instruction requires 386+ and operates on 32-bit operands in protected and 64-bit modes; in 64-bit mode, a REX.W prefix extends it to 64-bit operands.", "pseudocode": "temp ← dest[0:7] || dest[8:15] || dest[16:23] || dest[24:31]\ndest ← dest[24:31] || dest[16:23] || dest[8:15] || temp", "example": "BSWAP eax" }, { "mnemonic": "xadd", "architecture": "x86", "full_name": "Exchange and Add", "summary": "Exchanges dest and src, then loads sum into dest.", "syntax": "XADD r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "0F C1", "visual_parts": [], "binary_pattern": "0F | C1", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Exchanges the values of dest and src, then stores their sum into dest. Sets OF, SF, ZF, AF, CF, PF based on the addition result. Implicitly uses the accumulator (EAX/RAX) for implicit operand size determination. Available in 386+ with size variants 8/16/32/64-bit; used in multi-threaded code for atomic operations.", "pseudocode": "temp ← src\nsrc ← dest\ndest ← dest + temp\nflags ← set based on (dest + temp) result\nZF ← (dest == 0); CF ← carry_out; OF ← overflow; SF ← (dest & sign_bit) != 0; PF ← parity(dest); AF ← (((dest ^ temp) ^ result) & 0x10) != 0", "example": "XADD rbx, rax" }, { "mnemonic": "cmpxchg", "architecture": "x86", "full_name": "Compare and Exchange", "summary": "Compares accumulator with dest; if equal, dest = src; else accumulator = dest.", "syntax": "CMPXCHG r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "0F B1", "visual_parts": [], "binary_pattern": "0F | B1", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Compares an implicit accumulator (AL/AX/EAX/RAX) with dest; if equal, src is written to dest and ZF is set; otherwise dest is written to the accumulator and ZF is cleared. Sets OF, SF, ZF, AF, CF, PF based on the comparison. Available in 386+ with size variants 8/16/32/64-bit; used for atomic compare-and-swap operations in lock-free code.", "pseudocode": "if (size == 8) {\n if (AL == dest) { dest ← src; ZF ← 1; } else { AL ← dest; ZF ← 0; }\n} else if (size == 16) {\n if (AX == dest) { dest ← src; ZF ← 1; } else { AX ← dest; ZF ← 0; }\n} else if (size == 32) {\n if (EAX == dest) { dest ← src; ZF ← 1; } else { EAX ← dest; ZF ← 0; }\n} else { /* size == 64 */\n if (RAX == dest) { dest ← src; ZF ← 1; } else { RAX ← dest; ZF ← 0; }\n}\nOF, SF, AF, CF, PF ← undefined (or set by comparison result)", "example": "CMPXCHG rbx, rax" }, { "mnemonic": "cmovcc", "architecture": "x86", "full_name": "Conditional Move", "summary": "Moves data if condition code is met (e.g., CMOVE, CMOVNE).", "syntax": "CMOVcc r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F 40 /r", "visual_parts": [], "binary_pattern": "0F", "bit_positions": "+0" }, "extension": "CMOV", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Conditionally moves src to dest if the specified condition code (based on EFLAGS) is true; otherwise dest is unchanged. No flags are modified. Available in P6+ processors (CMOV extension) with size variants 16/32/64-bit; eliminates branch mispredictions in conditional data flow.", "pseudocode": "if (condition_code) {\n dest ← src\n}\n/* EFLAGS unchanged */", "example": "CMOVcc rax, rbx" }, { "mnemonic": "setcc", "architecture": "x86", "full_name": "Set Byte on Condition", "summary": "Sets byte to 1 if condition met, else 0 (e.g., SETE, SETZ).", "syntax": "SETcc r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 90", "visual_parts": [], "binary_pattern": "0F", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the byte at dest to 1 if the specified condition code (based on EFLAGS) is true, otherwise sets it to 0. No other flags are affected. Available in 386+ with 8-bit size only; condition codes include SETE, SETNE, SETL, SETG, SETA, SETB, etc.", "pseudocode": "if (condition_code) {\n dest[0:7] ← 0xFF\n} else {\n dest[0:7] ← 0x00\n}\n/* EFLAGS unchanged */", "example": "SETcc bl" }, { "mnemonic": "hlt", "architecture": "x86", "full_name": "Halt", "summary": "Stops instruction execution and places processor in HALT state.", "syntax": "HLT", "encoding": { "format": "Legacy", "hex_opcode": "F4", "visual_parts": [], "binary_pattern": "F4", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Stops instruction execution and places the processor in a HALT state, waiting for an external interrupt or reset. Requires privilege level 0 (kernel mode); attempting HLT in user mode raises a #GP exception. No flags are affected. Used in idle loops and system shutdown sequences.", "pseudocode": "halt_cpu()\n/* Wait for external interrupt or reset */", "example": "HLT" }, { "mnemonic": "int", "architecture": "x86", "full_name": "Interrupt", "summary": "Calls to interrupt procedure.", "syntax": "INT imm8", "encoding": { "format": "Legacy", "hex_opcode": "CD ib", "visual_parts": [], "binary_pattern": "CD", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Invokes an interrupt handler identified by the 8-bit vector. Pushes EFLAGS (or RFLAGS), CS, and EIP (or RIP) onto the stack, then transfers control to the interrupt handler. Privilege level checked; IF flag is cleared upon entry. Available in all modes with different stack/address behaviors in real vs. protected vs. 64-bit mode.", "pseudocode": "if (mode == 64) {\n RSP ← RSP - 8; [RSP] ← RFLAGS\n RSP ← RSP - 8; [RSP] ← CS\n RSP ← RSP - 8; [RSP] ← RIP\n} else {\n ESP ← ESP - 4; [ESP] ← EFLAGS\n ESP ← ESP - 4; [ESP] ← CS\n ESP ← ESP - 4; [ESP] ← EIP\n}\nCS:RIP ← IDT[imm8]\nIF ← 0\nTF ← 0", "example": "INT 3" }, { "mnemonic": "int3", "architecture": "x86", "full_name": "Breakpoint", "summary": "Calls to interrupt vector 3 (Debugger breakpoint).", "syntax": "INT3", "encoding": { "format": "Legacy", "hex_opcode": "CC", "visual_parts": [], "binary_pattern": "CC", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Invokes interrupt vector 3, which typically triggers a debugger breakpoint. Equivalent to INT 3 but encoded as a single byte (0xCC) for efficient inline breakpoint insertion. Pushes EFLAGS, CS, and EIP (or RFLAGS, CS, RIP in 64-bit mode) onto the stack. Available in all modes and privilege levels.", "pseudocode": "if (mode == 64) {\n RSP ← RSP - 8; [RSP] ← RFLAGS\n RSP ← RSP - 8; [RSP] ← CS\n RSP ← RSP - 8; [RSP] ← RIP\n} else {\n ESP ← ESP - 4; [ESP] ← EFLAGS\n ESP ← ESP - 4; [ESP] ← CS\n ESP ← ESP - 4; [ESP] ← EIP\n}\nCS:RIP ← IDT[3]\nIF ← 0\nTF ← 0", "example": "INT3" }, { "mnemonic": "ud2", "architecture": "x86", "full_name": "Undefined Instruction", "summary": "Generates an invalid opcode exception.", "syntax": "UD2", "encoding": { "format": "Legacy", "hex_opcode": "0F 0B", "visual_parts": [], "binary_pattern": "0F | 0B", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [], "description": "Generates an invalid opcode exception (#UD) unconditionally, causing the processor to raise a fault. This instruction has no operands and performs no other operation. It is commonly used for intentional traps, unreachable code markers, and testing exception handling.", "pseudocode": "raise InvalidOpcodeException()", "example": "UD2" }, { "mnemonic": "pause", "architecture": "x86", "full_name": "Spin Loop Hint", "summary": "Improves performance of spin-wait loops (alias for REP NOP).", "syntax": "PAUSE", "encoding": { "format": "Legacy", "hex_opcode": "F3 90", "visual_parts": [], "binary_pattern": "F3 | 90", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [], "description": "Provides a hint to the processor that the code is executing a spin-wait loop, improving power efficiency and reducing contention on shared memory buses without altering program logic. The instruction is semantically equivalent to REP NOP (F3 90 encoding) and executes as a very short delay; no flags are affected.", "pseudocode": "// Improves performance of spin-wait loops (alias for REP NOP)", "example": "PAUSE" }, { "mnemonic": "clc", "architecture": "x86", "full_name": "Clear Carry Flag", "summary": "Sets the CF flag to 0.", "syntax": "CLC", "encoding": { "format": "Legacy", "hex_opcode": "F8", "visual_parts": [], "binary_pattern": "F8", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Unconditionally clears the Carry Flag (CF) to 0. Only the CF flag is modified; all other flags and CPU state remain unchanged. Available in all modes (real, protected, and 64-bit).", "pseudocode": "CF ← 0", "example": "CLC" }, { "mnemonic": "stc", "architecture": "x86", "full_name": "Set Carry Flag", "summary": "Sets the CF flag to 1.", "syntax": "STC", "encoding": { "format": "Legacy", "hex_opcode": "F9", "visual_parts": [], "binary_pattern": "F9", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Unconditionally sets the Carry Flag (CF) to 1. Only the CF flag is modified; all other flags and CPU state remain unchanged. Available in all modes (real, protected, and 64-bit).", "pseudocode": "CF ← 1", "example": "STC" }, { "mnemonic": "cmc", "architecture": "x86", "full_name": "Complement Carry Flag", "summary": "Toggles the CF flag.", "syntax": "CMC", "encoding": { "format": "Legacy", "hex_opcode": "F5", "visual_parts": [], "binary_pattern": "F5", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Complements (toggles) the Carry Flag (CF): if CF=0 it becomes 1, and if CF=1 it becomes 0. Only the CF flag is modified; all other flags remain unchanged. Available in all modes (real, protected, and 64-bit).", "pseudocode": "CF ← NOT CF", "example": "CMC" }, { "mnemonic": "cld", "architecture": "x86", "full_name": "Clear Direction Flag", "summary": "Sets DF to 0 (String operations increment).", "syntax": "CLD", "encoding": { "format": "Legacy", "hex_opcode": "FC", "visual_parts": [], "binary_pattern": "FC", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Clears the Direction Flag (DF) to 0, causing string instructions (MOVS, SCAS, LODS, STOS, CMPS) to auto-increment the index registers (ESI/EDI or RSI/RDI) rather than decrement them. Only DF is modified; all other flags remain unchanged. Available in all modes.", "pseudocode": "DF ← 0", "example": "CLD" }, { "mnemonic": "std", "architecture": "x86", "full_name": "Set Direction Flag", "summary": "Sets DF to 1 (String operations decrement).", "syntax": "STD", "encoding": { "format": "Legacy", "hex_opcode": "FD", "visual_parts": [], "binary_pattern": "FD", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Sets the Direction Flag (DF) to 1, causing string instructions (MOVS, SCAS, LODS, STOS, CMPS) to auto-decrement the index registers (ESI/EDI or RSI/RDI) rather than increment them. Only DF is modified; all other flags remain unchanged. Available in all modes.", "pseudocode": "DF ← 1", "example": "STD" }, { "mnemonic": "cli", "architecture": "x86", "full_name": "Clear Interrupt Flag", "summary": "Disables maskable hardware interrupts.", "syntax": "CLI", "encoding": { "format": "Legacy", "hex_opcode": "FA", "visual_parts": [], "binary_pattern": "FA", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Clears the Interrupt Flag (IF) to 0, disabling maskable hardware interrupts (IRQ0-IRQ15) but not non-maskable interrupts (NMI) or exceptions. This instruction is privileged and requires CPL=0; execution in user mode raises a #GP exception. Available in protected and 64-bit modes.", "pseudocode": "IF ← 0 // Requires CPL = 0 (kernel mode)", "example": "CLI" }, { "mnemonic": "sti", "architecture": "x86", "full_name": "Set Interrupt Flag", "summary": "Enables maskable hardware interrupts.", "syntax": "STI", "encoding": { "format": "Legacy", "hex_opcode": "FB", "visual_parts": [], "binary_pattern": "FB", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Sets the Interrupt Flag (IF) in EFLAGS, enabling maskable hardware interrupts at the next instruction boundary. This is a privileged instruction that requires CPL=0 (kernel mode). The instruction takes effect after the next instruction executes, allowing one more instruction to complete before interrupts are actually serviced.", "pseudocode": "IF (CPL == 0) THEN IF ← 1; ELSE #GP(0); FI;", "example": "STI" }, { "mnemonic": "sahf", "architecture": "x86", "full_name": "Store AH into Flags", "summary": "Loads SF, ZF, AF, PF, and CF from AH.", "syntax": "SAHF", "encoding": { "format": "Legacy", "hex_opcode": "9E", "visual_parts": [], "binary_pattern": "9E", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Loads the lower byte of EFLAGS from the AH register, restoring flags CF, PF, AF, ZF, and SF. The upper bits of EFLAGS (IF, TF, DF, OF, NT, RF, VM, AC, VIF, VIP, ID) are unaffected. This is commonly used to restore previously saved flag state.", "pseudocode": "CF ← AH[0]; PF ← AH[2]; AF ← AH[4]; ZF ← AH[6]; SF ← AH[7];", "example": "SAHF" }, { "mnemonic": "lahf", "architecture": "x86", "full_name": "Load Flags into AH", "summary": "Loads bits 0, 2, 4, 6, and 7 of EFLAGS into AH.", "syntax": "LAHF", "encoding": { "format": "Legacy", "hex_opcode": "9F", "visual_parts": [], "binary_pattern": "9F", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Loads the lower byte of EFLAGS into the AH register, extracting flags CF, PF, AF, ZF, and SF. Bits 1, 3, and 5 are set to 0, bit 7 contains SF, and bits 0, 2, 4, 6 contain CF, PF, AF, ZF respectively. This is commonly used to save flag state for later restoration with SAHF.", "pseudocode": "AH ← 0; AH[0] ← CF; AH[2] ← PF; AH[4] ← AF; AH[6] ← ZF; AH[7] ← SF;", "example": "LAHF" }, { "mnemonic": "loop", "architecture": "x86", "full_name": "Loop", "summary": "Decrements ECX/RCX and jumps if not zero.", "syntax": "LOOP rel", "encoding": { "format": "Legacy", "hex_opcode": "E2", "visual_parts": [], "binary_pattern": "E2", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Decrements the count register (ECX in 32-bit mode, RCX in 64-bit mode) and jumps to the destination if the count is non-zero. Does not set any flags; it only reads the decremented value to determine branch condition. In 64-bit mode, LOOP with a 32-bit operand-size prefix uses ECX (with implicit ZX of RCX).", "pseudocode": "count ← (MODE64 ? RCX : ECX); count ← count - 1; IF (MODE64) RCX ← count; ELSE ECX ← count; IF (count != 0) THEN IP ← IP + sign_extend(rel8); FI;", "example": "LOOP rel" }, { "mnemonic": "loope", "architecture": "x86", "full_name": "Loop if Equal", "summary": "Decrements count; jumps if count!=0 and ZF=1.", "syntax": "LOOPE rel", "encoding": { "format": "Legacy", "hex_opcode": "E1", "visual_parts": [], "binary_pattern": "E1", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Decrements the count register (ECX/RCX) and jumps to destination if count is non-zero AND the Zero Flag is set. Combines loop counting with a zero-flag condition, useful for scanning arrays until an element matches or count exhausted. No flags are modified by this instruction.", "pseudocode": "count ← (MODE64 ? RCX : ECX); count ← count - 1; IF (MODE64) RCX ← count; ELSE ECX ← count; IF ((count != 0) ∧ (ZF == 1)) THEN IP ← IP + sign_extend(rel8); FI;", "example": "LOOPE rel" }, { "mnemonic": "loopne", "architecture": "x86", "full_name": "Loop if Not Equal", "summary": "Decrements count; jumps if count!=0 and ZF=0.", "syntax": "LOOPNE rel", "encoding": { "format": "Legacy", "hex_opcode": "E0", "visual_parts": [], "binary_pattern": "E0", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Decrements the count register (ECX/RCX) and jumps to destination if count is non-zero AND the Zero Flag is clear. Combines loop counting with a non-zero-flag condition, useful for scanning arrays until an element matches or count exhausted. No flags are modified by this instruction.", "pseudocode": "count ← (MODE64 ? RCX : ECX); count ← count - 1; IF (MODE64) RCX ← count; ELSE ECX ← count; IF ((count != 0) ∧ (ZF == 0)) THEN IP ← IP + sign_extend(rel8); FI;", "example": "LOOPNE rel" }, { "mnemonic": "jecxz", "architecture": "x86", "full_name": "Jump if ECX is Zero", "summary": "Jumps if ECX register is 0.", "syntax": "JECXZ rel", "encoding": { "format": "Legacy", "hex_opcode": "E3", "visual_parts": [], "binary_pattern": "E3", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Jumps to the destination if ECX register is zero (or RCX in 64-bit mode when used with REX.W). Unlike LOOP variants, this instruction does not modify any register or flag; it only tests the count value. In 64-bit mode, the non-REX.W form still checks ECX (32-bit).", "pseudocode": "IF (MODE64 ∧ REX.W) THEN IF (RCX == 0) THEN IP ← IP + sign_extend(rel8); FI; ELSE IF (ECX == 0) THEN IP ← IP + sign_extend(rel8); FI; FI;", "example": "JECXZ rel" }, { "mnemonic": "enter", "architecture": "x86", "full_name": "Make Stack Frame", "summary": "Creates a stack frame for procedure parameters.", "syntax": "ENTER imm16, imm8", "encoding": { "format": "Legacy", "hex_opcode": "C8", "visual_parts": [], "binary_pattern": "C8", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "imm16", "desc": "16-bit immediate" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Creates a stack frame for a procedure call by pushing RBP/EBP and allocating local variable space, supporting nested frames via the nesting level (imm8). The size (imm16) specifies bytes to allocate; nesting level controls how many prior frame pointers are copied. No flags are affected. High nesting levels serialize execution due to repeated memory operations.", "pseudocode": "push_size ← (OPSIZE == 16 ? 2 : 8); level ← imm8 & 0x1F; size ← imm16; SP ← SP - push_size; [SP] ← BP; frame_ptr ← SP; IF (level > 0) THEN FOR i ← 1 TO level-1 DO BP ← BP - push_size; SP ← SP - push_size; [SP] ← [BP]; OD; SP ← SP - push_size; [SP] ← frame_ptr; FI; BP ← frame_ptr; SP ← SP - size;", "example": "ENTER 0x100, 3" }, { "mnemonic": "leave", "architecture": "x86", "full_name": "High Level Procedure Exit", "summary": "Releases stack frame (MOV ESP, EBP; POP EBP).", "syntax": "LEAVE", "encoding": { "format": "Legacy", "hex_opcode": "C9", "visual_parts": [], "binary_pattern": "C9", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Releases the current stack frame by copying the base pointer (EBP/RBP) to the stack pointer (ESP/RSP), then pops the saved base pointer from the stack. This is the inverse of ENTER and restores the caller's frame pointer. No flags are affected. Valid in 16/32/64-bit modes; in 64-bit mode it operates on RBP/RSP.", "pseudocode": "if (OperandSize == 64) {\n RSP ← RBP;\n RBP ← [RSP];\n RSP ← RSP + 8;\n} else if (OperandSize == 32) {\n ESP ← EBP;\n EBP ← [ESP];\n ESP ← ESP + 4;\n} else {\n SP ← BP;\n BP ← [SP];\n SP ← SP + 2;\n}", "example": "LEAVE" }, { "mnemonic": "rep movs", "architecture": "x86", "full_name": "Repeat Move String", "summary": "Moves ECX bytes/words from [ESI] to [EDI].", "syntax": "REP MOVS m, m", "encoding": { "format": "Legacy", "hex_opcode": "F3 A4", "visual_parts": [], "binary_pattern": "F3", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "MOVS m", "desc": "Implicit memory for MOVS: ES:[DI] destination, DS:[SI] source" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Copies ECX/RCX bytes or words from the memory location at DS:[ESI/RSI] to ES:[EDI/RDI], decrementing or incrementing the pointers based on the Direction Flag (DF), and decrementing the counter. Repeats until RCX=0 or an interrupt occurs. No flags are modified by the instruction itself, though DF controls direction. The REP prefix causes automatic looping at the microarchitectural level.", "pseudocode": "while (RCX != 0) {\n if (OperandSize == 8) {\n [RDI] ← [RSI];\n if (DF == 0) { RSI ← RSI + 1; RDI ← RDI + 1; } else { RSI ← RSI - 1; RDI ← RDI - 1; }\n } else if (OperandSize == 16) {\n [RDI] ← [RSI];\n if (DF == 0) { RSI ← RSI + 2; RDI ← RDI + 2; } else { RSI ← RSI - 2; RDI ← RDI - 2; }\n } else {\n [RDI] ← [RSI];\n if (DF == 0) { RSI ← RSI + 4; RDI ← RDI + 4; } else { RSI ← RSI - 4; RDI ← RDI - 4; }\n }\n RCX ← RCX - 1;\n}", "example": "REP MOVS m, [rbp-8]" }, { "mnemonic": "rep stos", "architecture": "x86", "full_name": "Repeat Store String", "summary": "Fills [EDI] with AL/AX/EAX for ECX repeats.", "syntax": "REP STOS m", "encoding": { "format": "Legacy", "hex_opcode": "F3 AA", "visual_parts": [], "binary_pattern": "F3", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "STOS m", "desc": "Implicit memory destination for STOS (ES:[DI])" } ], "description": "Stores the value in AL/AX/EAX/RAX into memory at ES:[RDI] repeatedly, incrementing or decrementing RDI based on the Direction Flag, and decrementing RCX until the counter reaches zero. No flags are modified. The REP prefix enables automatic looping in hardware.", "pseudocode": "while (RCX != 0) {\n if (OperandSize == 8) {\n [RDI] ← AL;\n if (DF == 0) { RDI ← RDI + 1; } else { RDI ← RDI - 1; }\n } else if (OperandSize == 16) {\n [RDI] ← AX;\n if (DF == 0) { RDI ← RDI + 2; } else { RDI ← RDI - 2; }\n } else if (OperandSize == 32) {\n [RDI] ← EAX;\n if (DF == 0) { RDI ← RDI + 4; } else { RDI ← RDI - 4; }\n } else {\n [RDI] ← RAX;\n if (DF == 0) { RDI ← RDI + 8; } else { RDI ← RDI - 8; }\n }\n RCX ← RCX - 1;\n}", "example": "REP STOS m" }, { "mnemonic": "repe cmps", "architecture": "x86", "full_name": "Repeat Compare String Equal", "summary": "Compares [ESI] and [EDI] until mismatch or ECX=0.", "syntax": "REPE CMPS m, m", "encoding": { "format": "Legacy", "hex_opcode": "F3 A6", "visual_parts": [], "binary_pattern": "F3", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "CMPS m", "desc": "Implicit memory for CMPS string compare (DS:[SI] vs ES:[DI])" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Compares bytes or words at DS:[RSI] with ES:[RDI], setting flags as if by a SUB instruction, and repeats while the Zero Flag is set (operands equal) and RCX > 0. Stops on mismatch, RCX=0, or interrupt. Flags OF, SF, ZF, AF, CF, PF are set based on the comparison result.", "pseudocode": "while (RCX != 0) {\n if (OperandSize == 8) {\n result ← [RSI] - [RDI];\n if (DF == 0) { RSI ← RSI + 1; RDI ← RDI + 1; } else { RSI ← RSI - 1; RDI ← RDI - 1; }\n } else if (OperandSize == 16) {\n result ← [RSI] - [RDI];\n if (DF == 0) { RSI ← RSI + 2; RDI ← RDI + 2; } else { RSI ← RSI - 2; RDI ← RDI - 2; }\n } else {\n result ← [RSI] - [RDI];\n if (DF == 0) { RSI ← RSI + 4; RDI ← RDI + 4; } else { RSI ← RSI - 4; RDI ← RDI - 4; }\n }\n RCX ← RCX - 1;\n OF ← OverflowFlag(result); SF ← SignBit(result); ZF ← (result == 0); AF ← AuxiliaryFlag(result); CF ← CarryFlag(result); PF ← ParityFlag(result);\n if (ZF == 0) break;\n}", "example": "REPE CMPS m, [rbp-8]" }, { "mnemonic": "repne scas", "architecture": "x86", "full_name": "Repeat Scan String Not Equal", "summary": "Scans [EDI] for AL/AX/EAX until match or ECX=0.", "syntax": "REPNE SCAS m", "encoding": { "format": "Legacy", "hex_opcode": "F2 AE", "visual_parts": [], "binary_pattern": "F2", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "SCAS m", "desc": "Implicit memory for SCAS (compare accumulator with ES:[DI])" } ], "description": "Scans memory at ES:[RDI] for a match with AL/AX/EAX/RAX, setting flags by subtraction, and repeats while the Zero Flag is clear (no match) and RCX > 0. Stops on a match, RCX=0, or interrupt. Flags OF, SF, ZF, AF, CF, PF are set based on the comparison.", "pseudocode": "while (RCX != 0) {\n if (OperandSize == 8) {\n result ← AL - [RDI];\n if (DF == 0) { RDI ← RDI + 1; } else { RDI ← RDI - 1; }\n } else if (OperandSize == 16) {\n result ← AX - [RDI];\n if (DF == 0) { RDI ← RDI + 2; } else { RDI ← RDI - 2; }\n } else if (OperandSize == 32) {\n result ← EAX - [RDI];\n if (DF == 0) { RDI ← RDI + 4; } else { RDI ← RDI - 4; }\n } else {\n result ← RAX - [RDI];\n if (DF == 0) { RDI ← RDI + 8; } else { RDI ← RDI - 8; }\n }\n RCX ← RCX - 1;\n OF ← OverflowFlag(result); SF ← SignBit(result); ZF ← (result == 0); AF ← AuxiliaryFlag(result); CF ← CarryFlag(result); PF ← ParityFlag(result);\n if (ZF == 1) break;\n}", "example": "REPNE SCAS m" }, { "mnemonic": "rol", "architecture": "x86", "full_name": "Rotate Left", "summary": "Rotates bits left.", "syntax": "ROL r/m, imm8", "encoding": { "format": "Legacy", "hex_opcode": "C1 /0", "visual_parts": [], "binary_pattern": "C1 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rotates the bits in the destination operand left by the number of bit positions specified in the source (immediate or CL register), with the leftmost bit wrapping to the rightmost position. The Carry Flag is set to the bit shifted out; Overflow Flag is set only if the operation rotates by 1 and the sign bit changed. No other flags are affected for rotations > 1.", "pseudocode": "shift_count ← src & ((OperandSize * 8) - 1);\nif (shift_count == 0) { CF ← undefined; OF ← undefined; }\nelse {\n for (i = 0; i < shift_count; i++) {\n CF ← MSB(dest);\n dest ← (dest << 1) | CF;\n }\n if (shift_count == 1) {\n OF ← MSB_before_rotation XOR MSB_after_rotation;\n } else {\n OF ← undefined;\n }\n}", "example": "ROL rbx, 3" }, { "mnemonic": "ror", "architecture": "x86", "full_name": "Rotate Right", "summary": "Rotates bits right.", "syntax": "ROR r/m, imm8", "encoding": { "format": "Legacy", "hex_opcode": "C1 /1", "visual_parts": [], "binary_pattern": "C1 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rotates the bits in the destination operand right by the number of bit positions specified in the source, with the rightmost bit wrapping to the leftmost position. The Carry Flag is set to the bit shifted out; Overflow Flag is set only if rotating by 1 and the sign bit changed. No other flags are affected for rotations > 1.", "pseudocode": "shift_count ← src & ((OperandSize * 8) - 1);\nif (shift_count == 0) { CF ← undefined; OF ← undefined; }\nelse {\n for (i = 0; i < shift_count; i++) {\n CF ← LSB(dest);\n dest ← (dest >> 1) | (CF << (OperandSize * 8 - 1));\n }\n if (shift_count == 1) {\n OF ← MSB_before_rotation XOR (MSB_before_rotation >> 1);\n } else {\n OF ← undefined;\n }\n}", "example": "ROR rbx, 3" }, { "mnemonic": "rcl", "architecture": "x86", "full_name": "Rotate Carry Left", "summary": "Rotates bits left through Carry Flag.", "syntax": "RCL r/m, imm8", "encoding": { "format": "Legacy", "hex_opcode": "C1 /2", "visual_parts": [], "binary_pattern": "C1 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rotates the bits in the destination operand left through the Carry Flag by the number of bit positions specified in the source, treating CF as an additional bit position between the MSB and LSB. The CF is set to the bit shifted out. Overflow Flag is set if rotating by 1 and the MSB changed sign. For shifts > 1, OF is undefined. Other flags unchanged.", "pseudocode": "shift_count ← src & ((OperandSize * 8) - 1);\nif (shift_count == 0) { CF ← undefined; OF ← undefined; }\nelse if (shift_count == 1) {\n temp_CF ← MSB(dest);\n dest ← (dest << 1) | CF;\n CF ← temp_CF;\n OF ← MSB_before XOR MSB_after;\n}\nelse {\n for (i = 0; i < shift_count; i++) {\n temp_CF ← MSB(dest);\n dest ← (dest << 1) | CF;\n CF ← temp_CF;\n }\n OF ← undefined;\n}", "example": "RCL rbx, 3" }, { "mnemonic": "rcr", "architecture": "x86", "full_name": "Rotate Carry Right", "summary": "Rotates bits right through Carry Flag.", "syntax": "RCR r/m, imm8", "encoding": { "format": "Legacy", "hex_opcode": "C1 /3", "visual_parts": [], "binary_pattern": "C1 | ModRM", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rotates the bits of the destination operand right by the number of positions specified in the count operand, with the carry flag inserted at the high end and the low bit shifted into the carry flag. The rotation is through the carry flag, making it part of the rotating chain. All bits including CF participate in a circular rotate. The OF flag is set/cleared based on the most significant bit change on a single-bit rotate; CF is updated to the last bit shifted out.", "pseudocode": "count ← (src == 0) ? 1 : src & 0x1F;\ntemp_cf ← CF;\nfor i ← 0 to count - 1:\n new_cf ← dest & 1;\n dest ← (dest >> 1) | (temp_cf << (width - 1));\n temp_cf ← new_cf;\nCF ← temp_cf;\nif count == 1:\n OF ← MSB_before_rotate XOR CF;", "example": "RCR rbx, 3" }, { "mnemonic": "bt", "architecture": "x86", "full_name": "Bit Test", "summary": "Selects a bit and stores it in CF.", "syntax": "BT r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "0F A3", "visual_parts": [], "binary_pattern": "0F | A3", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Tests a bit in the destination operand at the position specified by the source operand and stores the selected bit value in the carry flag. The destination is not modified. The source operand specifies which bit to test (bit position is source value modulo operand size). OF, SF, ZF, AF, PF flags are undefined; only CF is set to the tested bit value.", "pseudocode": "bit_position ← src MOD (width of dest);\nCF ← (dest >> bit_position) & 1;\nOF ← undefined;\nSF ← undefined;\nZF ← undefined;\nAF ← undefined;\nPF ← undefined;", "example": "BT rbx, rax" }, { "mnemonic": "bts", "architecture": "x86", "full_name": "Bit Test and Set", "summary": "Stores bit in CF and sets bit to 1.", "syntax": "BTS r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "0F AB", "visual_parts": [], "binary_pattern": "0F | AB", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Tests a bit in the destination operand at the position specified by the source operand, stores the selected bit value in the carry flag, and then sets that bit to 1. The destination is modified atomically with respect to memory accesses. CF receives the original bit value before it is set. OF, SF, ZF, AF, PF flags are undefined.", "pseudocode": "bit_position ← src MOD (width of dest);\nCF ← (dest >> bit_position) & 1;\ndest ← dest | (1 << bit_position);\nOF ← undefined;\nSF ← undefined;\nZF ← undefined;\nAF ← undefined;\nPF ← undefined;", "example": "BTS rbx, rax" }, { "mnemonic": "btr", "architecture": "x86", "full_name": "Bit Test and Reset", "summary": "Stores bit in CF and clears bit to 0.", "syntax": "BTR r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "0F B3", "visual_parts": [], "binary_pattern": "0F | B3", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Tests a bit in the destination operand at the position specified by the source operand, stores the selected bit value in the carry flag, and then clears that bit to 0. The destination is modified atomically with respect to memory accesses. CF receives the original bit value before it is cleared. OF, SF, ZF, AF, PF flags are undefined.", "pseudocode": "bit_position ← src MOD (width of dest);\nCF ← (dest >> bit_position) & 1;\ndest ← dest & ~(1 << bit_position);\nOF ← undefined;\nSF ← undefined;\nZF ← undefined;\nAF ← undefined;\nPF ← undefined;", "example": "BTR rbx, rax" }, { "mnemonic": "btc", "architecture": "x86", "full_name": "Bit Test and Complement", "summary": "Stores bit in CF and complements the bit.", "syntax": "BTC r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "0F BB", "visual_parts": [], "binary_pattern": "0F | BB", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Tests a bit in the destination operand at the position specified by the source operand, stores the selected bit value in the carry flag, and then complements (inverts) that bit. The destination is modified atomically with respect to memory accesses. CF receives the original bit value before it is complemented. OF, SF, ZF, AF, PF flags are undefined.", "pseudocode": "bit_position ← src MOD (width of dest);\nCF ← (dest >> bit_position) & 1;\ndest ← dest XOR (1 << bit_position);\nOF ← undefined;\nSF ← undefined;\nZF ← undefined;\nAF ← undefined;\nPF ← undefined;", "example": "BTC rbx, rax" }, { "mnemonic": "bsf", "architecture": "x86", "full_name": "Bit Scan Forward", "summary": "Scans for LSB set to 1.", "syntax": "BSF r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F BC", "visual_parts": [], "binary_pattern": "0F | BC", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Scans the source operand from the least significant bit (LSB) forward to locate the first set bit, and stores the bit position in the destination register. If no set bit is found, the zero flag is set and the destination register is undefined. This instruction is commonly used to find the index of the lowest set bit in a value.", "pseudocode": "for i ← 0 to (width - 1):\n if (src >> i) & 1 == 1:\n dest ← i;\n ZF ← 0;\n return;\nZF ← 1;\ndest ← undefined;", "example": "BSF rax, rbx" }, { "mnemonic": "bsr", "architecture": "x86", "full_name": "Bit Scan Reverse", "summary": "Scans for MSB set to 1.", "syntax": "BSR r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F BD", "visual_parts": [], "binary_pattern": "0F | BD", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Scans the source operand from the most significant bit (MSB) backward to locate the first set bit, and stores the bit position in the destination register. If no set bit is found, the zero flag is set and the destination register is undefined. This instruction is commonly used to find the index of the highest set bit in a value.", "pseudocode": "for i ← (width - 1) down to 0:\n if (src >> i) & 1 == 1:\n dest ← i;\n ZF ← 0;\n return;\nZF ← 1;\ndest ← undefined;", "example": "BSR rax, rbx" }, { "mnemonic": "lzcnt", "architecture": "x86", "full_name": "Count Leading Zeros", "summary": "Counts number of leading zeros.", "syntax": "LZCNT r, r/m", "encoding": { "format": "VEX", "hex_opcode": "F3 0F BD", "visual_parts": [], "binary_pattern": "F3 | 0F | BD", "bit_positions": "+0 | +1 | +2" }, "extension": "ABM/BMI", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Counts the number of leading zero bits in the source operand and stores the result in the destination register. This is an ABM (Advanced Bit Manipulation) instruction that sets the zero flag if the source is zero (result is operand width) and clears it otherwise. Unlike BSR, this always produces a result without undefined behavior, making it safer for leading zero counting.", "pseudocode": "count ← 0;\nfor i ← (width - 1) down to 0:\n if (src >> i) & 1 == 1:\n break;\n count ← count + 1;\nif src == 0:\n dest ← width;\n ZF ← 1;\nelse:\n dest ← count;\n ZF ← 0;", "example": "LZCNT rax, rbx" }, { "mnemonic": "popcnt", "architecture": "x86", "full_name": "Population Count", "summary": "Counts number of bits set to 1.", "syntax": "POPCNT r, r/m", "encoding": { "format": "VEX", "hex_opcode": "F3 0F B8", "visual_parts": [], "binary_pattern": "F3 | 0F | B8", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE4.2", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Counts the number of set bits (1s) in the source operand and stores the result in the destination register. This instruction requires the SSE4.2 extension and is available in 16/32/64-bit variants. No flags are affected by this instruction, making it useful for bit-counting operations in high-performance code.", "pseudocode": "dest ← count_set_bits(src)", "example": "POPCNT rax, rbx" }, { "mnemonic": "xlat", "architecture": "x86", "full_name": "Table Look-up Translation", "summary": "Replaces AL with byte from table at [EBX+AL].", "syntax": "XLAT m8", "encoding": { "format": "Legacy", "hex_opcode": "D7", "visual_parts": [], "binary_pattern": "D7", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "m8", "desc": "8-bit memory operand" } ], "description": "Translates the byte in AL using a table in memory located at address EBX + AL (or RBX + AL in 64-bit mode), replacing AL with the byte from the table. The base address is determined by EBX/RBX, and the offset is the current value of AL. No flags are affected. This instruction is useful for character translation and lookup tables.", "pseudocode": "AL ← [EBX + zero_extend(AL)]", "example": "XLAT [rbp-1]" }, { "mnemonic": "pushf", "architecture": "x86", "full_name": "Push Flags", "summary": "Pushes EFLAGS onto stack.", "syntax": "PUSHF", "encoding": { "format": "Legacy", "hex_opcode": "9C", "visual_parts": [], "binary_pattern": "9C", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Pushes the EFLAGS register (or FLAGS register in 16-bit mode) onto the stack, decrementing the stack pointer. In 64-bit mode, PUSHF pushes the lower 32 bits of RFLAGS. All flag states are preserved on the stack. This instruction is commonly used to save the current processor state before modifying flags.", "pseudocode": "ESP ← ESP - 4; [ESP] ← EFLAGS", "example": "PUSHF" }, { "mnemonic": "popf", "architecture": "x86", "full_name": "Pop Flags", "summary": "Pops stack into EFLAGS.", "syntax": "POPF", "encoding": { "format": "Legacy", "hex_opcode": "9D", "visual_parts": [], "binary_pattern": "9D", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Pops a value from the stack into the EFLAGS register (or FLAGS in 16-bit mode), restoring previously saved flag states. This instruction restores OF, SF, ZF, AF, PF, and CF flags from the popped value. POPF also increments the stack pointer. Certain flags may be restricted based on the current privilege level.", "pseudocode": "EFLAGS ← [ESP]; ESP ← ESP + 4", "example": "POPF" }, { "mnemonic": "pusha", "architecture": "x86", "full_name": "Push All General-Purpose Registers", "summary": "Pushes AX, CX, DX, BX, SP, BP, SI, DI (Invalid in 64-bit).", "syntax": "PUSHA", "encoding": { "format": "Legacy", "hex_opcode": "60", "visual_parts": [], "binary_pattern": "60", "bit_positions": "+0" }, "extension": "Base (32-bit only)", "operands": [], "description": "Pushes all eight general-purpose 16-bit or 32-bit registers (AX/EAX, CX/ECX, DX/EDX, BX/EBX, SP/ESP, BP/EBP, SI/ESI, DI/EDI) onto the stack in that order. The SP/ESP value pushed is the value before the first push. This instruction is invalid in 64-bit mode and is primarily a legacy instruction. No flags are affected.", "pseudocode": "temp ← SP; SP ← SP - 16; [SP+0] ← AX; [SP+2] ← CX; [SP+4] ← DX; [SP+6] ← BX; [SP+8] ← temp; [SP+10] ← BP; [SP+12] ← SI; [SP+14] ← DI", "example": "PUSHA" }, { "mnemonic": "popa", "architecture": "x86", "full_name": "Pop All General-Purpose Registers", "summary": "Pops into DI, SI, BP, SP, BX, DX, CX, AX (Invalid in 64-bit).", "syntax": "POPA", "encoding": { "format": "Legacy", "hex_opcode": "61", "visual_parts": [], "binary_pattern": "61", "bit_positions": "+0" }, "extension": "Base (32-bit only)", "operands": [], "description": "Pops eight values from the stack into the general-purpose registers in reverse order of PUSHA (DI, SI, BP, SP, BX, DX, CX, AX), restoring a previously saved register state. The SP/ESP value is automatically popped and discarded. This instruction is invalid in 64-bit mode. No flags are affected.", "pseudocode": "DI ← [SP+0]; SI ← [SP+2]; BP ← [SP+4]; SP ← SP + 6; BX ← [SP+0]; DX ← [SP+2]; CX ← [SP+4]; AX ← [SP+6]; SP ← SP + 8", "example": "POPA" }, { "mnemonic": "bound", "architecture": "x86", "full_name": "Check Array Index Against Bounds", "summary": "Checks if operand is within bounds defined in memory.", "syntax": "BOUND r, m", "encoding": { "format": "Legacy", "hex_opcode": "62", "visual_parts": [], "binary_pattern": "62", "bit_positions": "+0" }, "extension": "Base (32-bit only)", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Checks whether the signed value in the register operand is within the bounds specified by two signed integers in memory (lower bound at m, upper bound at m+size). If the value is outside the bounds, a #BR (BOUND Range Exceeded) exception is generated. This instruction is invalid in 64-bit mode. No flags are affected if no exception occurs.", "pseudocode": "lower ← [mem]; upper ← [mem + operand_size]; if (register < lower || register > upper) { raise BR_exception }", "example": "BOUND rax, [rbp-8]" }, { "mnemonic": "aaa", "architecture": "x86", "full_name": "ASCII Adjust After Addition", "summary": "Adjusts AL after addition for unpacked BCD.", "syntax": "AAA", "encoding": { "format": "Legacy", "hex_opcode": "37", "visual_parts": [], "binary_pattern": "37", "bit_positions": "+0" }, "extension": "Base (Legacy)", "operands": [], "description": "Adjusts AL after addition of two unpacked BCD (Binary Coded Decimal) digits, correcting the result to ensure valid BCD. If the lower nibble of AL is greater than 9 or the AF flag is set, AL is adjusted by adding 6 to the lower nibble and 1 is added to AH. The AF and CF flags are set or cleared accordingly. This instruction is invalid in 64-bit mode and is primarily legacy.", "pseudocode": "if ((AL & 0x0F) > 9 || AF == 1) { AL ← (AL + 6) & 0xFF; AH ← AH + 1; AF ← 1; CF ← 1 } else { AF ← 0; CF ← 0 }; AL ← AL & 0x0F", "example": "AAA" }, { "mnemonic": "aas", "architecture": "x86", "full_name": "ASCII Adjust After Subtraction", "summary": "Adjusts AL after subtraction for unpacked BCD.", "syntax": "AAS", "encoding": { "format": "Legacy", "hex_opcode": "3F", "visual_parts": [], "binary_pattern": "3F", "bit_positions": "+0" }, "extension": "Base (Legacy)", "operands": [], "description": "Adjusts the value in AL after a subtraction operation to make it a valid unpacked BCD digit (0-9 in the lower nibble). If the lower nibble of AL is greater than 9 or the auxiliary carry flag is set, AL is decremented by 6 and AH is decremented by 1; otherwise no adjustment occurs. Sets or clears AF and CF based on whether an adjustment was made; other flags are undefined.", "pseudocode": "if ((AL & 0x0F) > 9) || (AF == 1) {\n AL ← AL - 6;\n AH ← AH - 1;\n AF ← 1;\n CF ← 1;\n} else {\n AF ← 0;\n CF ← 0;\n}\nAL ← AL & 0x0F;", "example": "AAS" }, { "mnemonic": "daa", "architecture": "x86", "full_name": "Decimal Adjust After Addition", "summary": "Adjusts AL after addition for packed BCD.", "syntax": "DAA", "encoding": { "format": "Legacy", "hex_opcode": "27", "visual_parts": [], "binary_pattern": "27", "bit_positions": "+0" }, "extension": "Base (Legacy)", "operands": [], "description": "Adjusts AL after addition of two packed BCD values. If the lower nibble exceeds 9 or AF is set, adds 6 to AL; if the upper nibble then exceeds 9 or CF is set, adds 0x60 to AL. Sets CF and AF as needed; OF is undefined; SF, ZF, PF are computed on the result.", "pseudocode": "old_AL ← AL;\nif ((AL & 0x0F) > 9) || (AF == 1) {\n AL ← AL + 6;\n AF ← 1;\n} else {\n AF ← 0;\n}\nif (old_AL > 0x99) || (CF == 1) {\n AL ← AL + 0x60;\n CF ← 1;\n} else {\n CF ← 0;\n}\nZF ← (AL == 0);\nSF ← (AL[7] == 1);\nPF ← parity(AL);", "example": "DAA" }, { "mnemonic": "das", "architecture": "x86", "full_name": "Decimal Adjust After Subtraction", "summary": "Adjusts AL after subtraction for packed BCD.", "syntax": "DAS", "encoding": { "format": "Legacy", "hex_opcode": "2F", "visual_parts": [], "binary_pattern": "2F", "bit_positions": "+0" }, "extension": "Base (Legacy)", "operands": [], "description": "Adjusts AL after subtraction of two packed BCD values. If the lower nibble exceeds 9 or AF is set, subtracts 6 from AL; if the upper nibble then exceeds 9 or CF is set, subtracts 0x60 from AL. Sets CF and AF as needed; OF is undefined; SF, ZF, PF are computed on the result.", "pseudocode": "old_AL ← AL;\nif ((AL & 0x0F) > 9) || (AF == 1) {\n AL ← AL - 6;\n AF ← 1;\n} else {\n AF ← 0;\n}\nif (old_AL > 0x99) || (CF == 1) {\n AL ← AL - 0x60;\n CF ← 1;\n} else {\n CF ← 0;\n}\nZF ← (AL == 0);\nSF ← (AL[7] == 1);\nPF ← parity(AL);", "example": "DAS" }, { "mnemonic": "aam", "architecture": "x86", "full_name": "ASCII Adjust After Multiply", "summary": "Adjusts AX after multiply for unpacked BCD.", "syntax": "AAM imm8", "encoding": { "format": "Legacy", "hex_opcode": "D4", "visual_parts": [], "binary_pattern": "D4", "bit_positions": "+0" }, "extension": "Base (Legacy)", "operands": [ { "name": "dest", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Adjusts AX after a multiply operation on unpacked BCD operands (imm8 specifies the radix, typically 10). Divides AL by the immediate operand, placing the quotient in AH and remainder in AL. Sets SF, ZF, PF based on the result in AL; CF and OF are undefined; AF is undefined.", "pseudocode": "AH ← AL / imm8;\nAL ← AL % imm8;\nZF ← (AL == 0);\nSF ← (AL[7] == 1);\nPF ← parity(AL);", "example": "AAM 3" }, { "mnemonic": "aad", "architecture": "x86", "full_name": "ASCII Adjust Before Division", "summary": "Adjusts AX before division for unpacked BCD.", "syntax": "AAD imm8", "encoding": { "format": "Legacy", "hex_opcode": "D5", "visual_parts": [], "binary_pattern": "D5", "bit_positions": "+0" }, "extension": "Base (Legacy)", "operands": [ { "name": "dest", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Adjusts AX before a division operation on unpacked BCD operands (imm8 specifies the radix, typically 10). Multiplies AH by the immediate operand and adds to AL, placing the result in AL with AH cleared to 0. Sets SF, ZF, PF based on the result; CF and OF are undefined; AF is undefined.", "pseudocode": "AL ← (AH * imm8) + AL;\nAH ← 0;\nZF ← (AL == 0);\nSF ← (AL[7] == 1);\nPF ← parity(AL);", "example": "AAD 3" }, { "mnemonic": "cbw", "architecture": "x86", "full_name": "Convert Byte to Word", "summary": "Sign-extends AL into AX.", "syntax": "CBW", "encoding": { "format": "Legacy", "hex_opcode": "98", "visual_parts": [], "binary_pattern": "98", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Sign-extends the byte value in AL to a word in AX by copying bit 7 of AL to all bits 8-15 of AX. No flags are affected. In 64-bit mode, only the lower word of RAX is modified.", "pseudocode": "AX ← sign_extend_byte_to_word(AL);", "example": "CBW" }, { "mnemonic": "cwd", "architecture": "x86", "full_name": "Convert Word to Doubleword", "summary": "Sign-extends AX into DX:AX.", "syntax": "CWD", "encoding": { "format": "Legacy", "hex_opcode": "99", "visual_parts": [], "binary_pattern": "99", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Sign-extends the word value in AX to a doubleword across DX:AX by copying bit 15 of AX to all bits of DX. No flags are affected. In 64-bit mode, this is typically replaced by CDQE or CQO for larger sign extensions.", "pseudocode": "DX ← (AX[15] == 1) ? 0xFFFF : 0x0000;", "example": "CWD" }, { "mnemonic": "wait", "architecture": "x86", "full_name": "Wait", "summary": "Wait for FPU (same as FWAIT).", "syntax": "WAIT", "encoding": { "format": "Legacy", "hex_opcode": "9B", "visual_parts": [], "binary_pattern": "9B", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Waits for pending FPU operations to complete by checking the FPU busy flag; execution stalls until the FPU signals completion. Commonly used to synchronize between x87 floating-point and integer units. No flags are modified.", "pseudocode": "while (FPU_busy_flag == 1) {\n stall();\n}", "example": "WAIT" }, { "mnemonic": "ldtilecfg", "architecture": "x86", "full_name": "Load Tile Configuration", "summary": "Loads AMX tile configuration from memory.", "syntax": "LDTILECFG m512", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.NP.0F38.W0 49 !(11):000:bbb", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AMX-TILE", "operands": [ { "name": "dest", "type": "m512", "desc": "512-bit memory operand" } ], "description": "Loads a 512-bit tile configuration structure from memory into the AMX tile configuration state, enabling subsequent AMX tile operations. The memory operand must be 64-byte aligned. This instruction is a serializing operation that flushes pending tile operations and updates the internal tile geometry metadata (rows and columns for each tile). Requires AMX-TILE extension support; raises #UD if AMX is not enabled or memory is misaligned.", "pseudocode": "tilecfg_state ← load_512bits_from_memory(m512); tile_config_valid ← 1;", "example": "LDTILECFG [rbp-64]" }, { "mnemonic": "sttilecfg", "architecture": "x86", "full_name": "Store Tile Configuration", "summary": "Stores AMX tile configuration to memory.", "syntax": "STTILECFG m512", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.66.0F38.W0 49 !(11):000:bbb", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AMX-TILE", "operands": [ { "name": "dest", "type": "m512", "desc": "512-bit memory operand" } ], "description": "Stores the current AMX tile configuration state to a 512-bit memory location. Writes the internal tile dimensions and configuration metadata that was previously loaded via LDTILECFG. The memory operand must be 64-byte aligned. This is a serializing operation that ensures all pending tile operations complete before the store. Requires AMX-TILE extension support.", "pseudocode": "m512 ← store_512bits_to_memory(tilecfg_state);", "example": "STTILECFG [rbp-64]" }, { "mnemonic": "tileloadd", "architecture": "x86", "full_name": "Load Tile Data", "summary": "Loads data into an AMX tile register.", "syntax": "TILELOADD tmm1, m", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.F2.0F38.W0 4B !(11):rrr:100", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AMX-TILE", "operands": [ { "name": "dest", "type": "tmm1", "desc": "AMX tile register" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Loads a rectangular block of 32-bit doubleword elements from memory into an AMX tile register according to the current tile configuration. The memory layout is row-major; the memory address is typically formed from a base register and a stride register. This is a non-faulting instruction that respects the tile row/column dimensions set by LDTILECFG. Requires AMX-TILE extension and valid tile configuration.", "pseudocode": "stride ← (addressing mode determines memory stride); rows ← tilecfg_state.rows[tmm1]; cols ← tilecfg_state.cols[tmm1]; for (i = 0; i < rows; i++) { for (j = 0; j < cols; j++) { tmm1[i, j] ← m[base + i*stride + j*4]; } }", "example": "TILELOADD tmm1, [rbp-8]" }, { "mnemonic": "tilestored", "architecture": "x86", "full_name": "Store Tile Data", "summary": "Stores data from an AMX tile register to memory.", "syntax": "TILESTORED m, tmm1", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.F3.0F38.W0 4B !(11):rrr:100", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AMX-TILE", "operands": [ { "name": "dest", "type": "m", "desc": "Memory operand" }, { "name": "src", "type": "tmm1", "desc": "AMX tile register" } ], "description": "Stores a rectangular block of 32-bit doubleword elements from an AMX tile register to memory in row-major order, respecting the tile configuration dimensions. The destination memory address is typically formed from a base register and a stride register. This is a non-faulting instruction that outputs only the configured rows and columns. Requires AMX-TILE extension and valid tile configuration.", "pseudocode": "stride ← (addressing mode determines memory stride); rows ← tilecfg_state.rows[tmm_src]; cols ← tilecfg_state.cols[tmm_src]; for (i = 0; i < rows; i++) { for (j = 0; j < cols; j++) { m[base + i*stride + j*4] ← tmm_src[i, j]; } }", "example": "TILESTORED [rbp-8], tmm1" }, { "mnemonic": "tilezero", "architecture": "x86", "full_name": "Zero Tile", "summary": "Clears an AMX tile register.", "syntax": "TILEZERO tmm1", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.F2.0F38.W0 49 11:rrr:000", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AMX-TILE", "operands": [ { "name": "dest", "type": "tmm1", "desc": "AMX tile register" } ], "description": "Clears all elements of an AMX tile register to zero. The tile retains its configured dimensions; only the data elements are zeroed. This instruction is a common initialization step for accumulator tiles before performing matrix operations. Requires AMX-TILE extension and valid tile configuration. No flags are affected.", "pseudocode": "rows ← tilecfg_state.rows[tmm1]; cols ← tilecfg_state.cols[tmm1]; for (i = 0; i < rows; i++) { for (j = 0; j < cols; j++) { tmm1[i, j] ← 0; } }", "example": "TILEZERO tmm1" }, { "mnemonic": "tdpbssd", "architecture": "x86", "full_name": "Tile Dot Product Byte Signed Signed Doubleword", "summary": "Matrix multiply (Signed Int8 * Signed Int8) accumulating to Int32.", "syntax": "TDPBSSD tmm1, tmm2, tmm3", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.F2.0F38.W0 5E 11:rrr:bbb", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AMX-INT8", "operands": [ { "name": "dest", "type": "tmm1", "desc": "AMX tile register" }, { "name": "src1", "type": "tmm2", "desc": "AMX tile register" }, { "name": "src2", "type": "tmm3", "desc": "AMX tile register" } ], "description": "Performs a tile matrix multiply-accumulate operation: multiplies signed 8-bit elements from two source tiles and accumulates the 32-bit signed products into a 32-bit destination tile. Computes dest[i,k] += sum(src1[i,j] * src2[j,k]) for all j over the configured row/column ranges. The operation respects the tile configuration for all three operands. Requires AMX-INT8 extension. No EFLAGS are modified.", "pseudocode": "rows_dest ← tilecfg_state.rows[tmm1]; cols_dest ← tilecfg_state.cols[tmm1]; cols_src1 ← tilecfg_state.cols[tmm2]; for (i = 0; i < rows_dest; i++) { for (k = 0; k < cols_dest; k++) { for (j = 0; j < cols_src1; j++) { product ← (int32_t)(int8_t)src1[i,j] * (int32_t)(int8_t)src2[j,k]; tmm1[i,k] ← (int32_t)tmm1[i,k] + product; } } }", "example": "TDPBSSD tmm1, tmm2, tmm3" }, { "mnemonic": "tdpbsud", "architecture": "x86", "full_name": "Tile Dot Product Byte Signed Unsigned Doubleword", "summary": "Matrix multiply (Signed * Unsigned) accumulating to Int32.", "syntax": "TDPBSUD tmm1, tmm2, tmm3", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.F3.0F38.W0 5E 11:rrr:bbb", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AMX-INT8", "operands": [ { "name": "dest", "type": "tmm1", "desc": "AMX tile register" }, { "name": "src1", "type": "tmm2", "desc": "AMX tile register" }, { "name": "src2", "type": "tmm3", "desc": "AMX tile register" } ], "description": "Performs a tile matrix multiply-accumulate operation: multiplies signed 8-bit elements from the first source by unsigned 8-bit elements from the second source, accumulating 32-bit signed results into the destination tile. Computes dest[i,k] += sum(src1[i,j] * src2[j,k]) for all j, with src1 treated as signed and src2 as unsigned. Respects tile configuration dimensions. Requires AMX-INT8 extension. No EFLAGS are modified.", "pseudocode": "rows_dest ← tilecfg_state.rows[tmm1]; cols_dest ← tilecfg_state.cols[tmm1]; cols_src1 ← tilecfg_state.cols[tmm2]; for (i = 0; i < rows_dest; i++) { for (k = 0; k < cols_dest; k++) { for (j = 0; j < cols_src1; j++) { product ← (int32_t)(int8_t)src1[i,j] * (int32_t)(uint8_t)src2[j,k]; tmm1[i,k] ← (int32_t)tmm1[i,k] + product; } } }", "example": "TDPBSUD tmm1, tmm2, tmm3" }, { "mnemonic": "tdpbf16ps", "architecture": "x86", "full_name": "Tile Dot Product BFloat16 Packed Single", "summary": "Matrix multiply (BFloat16) accumulating to Float32.", "syntax": "TDPBF16PS tmm1, tmm2, tmm3", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.F3.0F38.W0 5C 11:rrr:bbb", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AMX-BF16", "operands": [ { "name": "dest", "type": "tmm1", "desc": "AMX tile register" }, { "name": "src1", "type": "tmm2", "desc": "AMX tile register" }, { "name": "src2", "type": "tmm3", "desc": "AMX tile register" } ], "description": "Performs a tile matrix multiply-accumulate operation on BFloat16 (16-bit brain float) elements, accumulating 32-bit floating-point results into the destination tile. Computes dest[i,k] += sum(src1[i,j] * src2[j,k]) for all j using BFloat16 multiplication and single-precision floating-point accumulation. Respects tile configuration for row/column dimensions. Requires AMX-BF16 extension. No EFLAGS are modified.", "pseudocode": "rows_dest ← tilecfg_state.rows[tmm1]; cols_dest ← tilecfg_state.cols[tmm1]; cols_src1 ← tilecfg_state.cols[tmm2]; for (i = 0; i < rows_dest; i++) { for (k = 0; k < cols_dest; k++) { for (j = 0; j < cols_src1; j++) { product ← convert_bf16_to_fp32(src1[i,j]) * convert_bf16_to_fp32(src2[j,k]); tmm1[i,k] ← (float32)tmm1[i,k] + product; } } }", "example": "TDPBF16PS tmm1, tmm2, tmm3" }, { "mnemonic": "endbr64", "architecture": "x86", "full_name": "End Branch 64-bit", "summary": "Marker instruction for Indirect Branch Tracking (IBT).", "syntax": "ENDBR64", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 1E FA", "visual_parts": [], "binary_pattern": "F3 | 0F | 1E | FA", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "CET-IBT", "operands": [], "description": "End Branch 64-bit marker for Control Flow Enforcement Technology (CET) Indirect Branch Tracking. This is a NOP-like instruction that marks valid target points for indirect branches in 64-bit mode; it is consumed by hardware when CET-IBT is enabled and causes a control-flow exception (#CP) if an indirect branch lands on a non-ENDBR64/ENDBR32 location. No flags are affected. Requires CET-IBT capability.", "pseudocode": "// Marker instruction for Indirect Branch Tracking (IBT)", "example": "ENDBR64" }, { "mnemonic": "endbr32", "architecture": "x86", "full_name": "End Branch 32-bit", "summary": "Marker instruction for Indirect Branch Tracking (IBT).", "syntax": "ENDBR32", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 1E FB", "visual_parts": [], "binary_pattern": "F3 | 0F | 1E | FB", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "CET-IBT", "operands": [], "description": "End Branch 32-bit marker for Control Flow Enforcement Technology (CET) Indirect Branch Tracking. Similar to ENDBR64, this marks valid indirect branch targets in 32-bit or compat mode; enforces CET-IBT policy when enabled. No flags are affected. Requires CET-IBT capability.", "pseudocode": "// Marker instruction for Indirect Branch Tracking (IBT)", "example": "ENDBR32" }, { "mnemonic": "rdsspq", "architecture": "x86", "full_name": "Read Shadow Stack Pointer (Quadword)", "summary": "Reads the current shadow stack pointer into a register.", "syntax": "RDSSPQ r64", "encoding": { "format": "Legacy", "hex_opcode": "F3 REX.W 0F 1E /1", "visual_parts": [], "binary_pattern": "F3 | 0F | 1E | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "CET-SS", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" } ], "description": "Read Shadow Stack Pointer into a 64-bit register. Reads the current shadow stack pointer (SSP) maintained by CET-SS hardware and stores it in the destination register. No flags are affected. Requires CET-SS (Control Flow Enforcement Technology-Shadow Stack) capability; 64-bit mode only.", "pseudocode": "dest ← SSP", "example": "RDSSPQ rax" }, { "mnemonic": "incsspq", "architecture": "x86", "full_name": "Increment Shadow Stack Pointer (Quadword)", "summary": "Adjusts the shadow stack pointer.", "syntax": "INCSSPQ r64", "encoding": { "format": "Legacy", "hex_opcode": "F3 REX.W 0F AE /5", "visual_parts": [], "binary_pattern": "F3 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "CET-SS", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" } ], "description": "Increment Shadow Stack Pointer by the value in a 64-bit register. Adjusts the shadow stack pointer (SSP) forward by the count specified in the source register, typically used to skip multiple shadow stack entries or adjust SSP during context switching. No flags are affected. Requires CET-SS capability; 64-bit mode only.", "pseudocode": "SSP ← SSP + src", "example": "INCSSPQ rax" }, { "mnemonic": "rstorssp", "architecture": "x86", "full_name": "Restore Shadow Stack Pointer", "summary": "Restores SSP from memory token.", "syntax": "RSTORSSP m64", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 01 /5", "visual_parts": [], "binary_pattern": "F3 | 0F | 01 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "CET-SS", "operands": [ { "name": "dest", "type": "m64", "desc": "64-bit memory operand (quadword)" } ], "description": "Restore Shadow Stack Pointer from a 64-bit memory token. Reads a restoration token from memory and updates the shadow stack pointer (SSP); validates the token format and raises #CP if invalid. Used during context restoration or privilege transitions with CET-SS. No flags are affected. Requires CET-SS capability; 64-bit mode only.", "pseudocode": "token ← [src]\n// Validate token format; if invalid raise #CP\nSSP ← token", "example": "RSTORSSP [rbp-8]" }, { "mnemonic": "saveprevssp", "architecture": "x86", "full_name": "Save Previous Shadow Stack Pointer", "summary": "Saves the previous SSP to the shadow stack token.", "syntax": "SAVEPREVSSP", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 01 EA", "visual_parts": [], "binary_pattern": "F3 | 0F | 01 | EA", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "CET-SS", "operands": [], "description": "Save the previous Shadow Stack Pointer to the top of the shadow stack. Writes the previous SSP value (stored in a CET control register) as a token to the current shadow stack location and typically increments SSP. Used to preserve SSP across context switches or privilege transitions. No flags are affected. Requires CET-SS capability; 64-bit mode only.", "pseudocode": "[SSP] ← previous_SSP\nSSP ← SSP + 8", "example": "SAVEPREVSSP" }, { "mnemonic": "clwb", "architecture": "x86", "full_name": "Cache Line Write Back", "summary": "Writes back modified cache line without flushing (Persistent Memory).", "syntax": "CLWB m8", "encoding": { "format": "Legacy", "hex_opcode": "66 0F AE !(11):110:bbb", "visual_parts": [], "binary_pattern": "66 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "CLWB", "operands": [ { "name": "dest", "type": "m8", "desc": "8-bit memory operand" } ], "description": "Cache Line Write Back to memory without invalidation. Writes back a modified cache line to memory (coherent with other agents) but does not invalidate it from the cache hierarchy; optimized for persistent memory workloads. No flags are affected. Serialization and memory ordering depend on surrounding instructions. Requires CLWB capability.", "pseudocode": "// Write back cache line containing [m8] to memory\n// Cache line remains in cache after writeback\nwrite_back_cache_line(address(m8))", "example": "CLWB [rbp-1]" }, { "mnemonic": "clflushopt", "architecture": "x86", "full_name": "Optimized Cache Line Flush", "summary": "Optimized version of CLFLUSH (Higher throughput).", "syntax": "CLFLUSHOPT m8", "encoding": { "format": "Legacy", "hex_opcode": "NFx 66 0F AE /7", "visual_parts": [], "binary_pattern": "66 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "CLFLUSHOPT", "operands": [ { "name": "dest", "type": "m8", "desc": "8-bit memory operand" } ], "description": "Optimized Cache Line Flush with higher throughput than CLFLUSH. Invalidates a cache line from all levels of the cache hierarchy and writes it back to memory if modified. No flags are affected. Provides better pipelining and throughput characteristics than legacy CLFLUSH. Requires CLFLUSHOPT capability.", "pseudocode": "// Invalidate and writeback cache line containing [m8]\ninvalidate_writeback_cache_line(address(m8))", "example": "CLFLUSHOPT [rbp-1]" }, { "mnemonic": "cldemote", "architecture": "x86", "full_name": "Cache Line Demote", "summary": "Hints to move cache line to lower cache level.", "syntax": "CLDEMOTE m8", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 1C /0", "visual_parts": [], "binary_pattern": "0F | 1C | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "CLDEMOTE", "operands": [ { "name": "dest", "type": "m8", "desc": "8-bit memory operand" } ], "description": "Provides a hint to demote a cache line to a lower cache level (L2 or L3) without invalidating it. The instruction has no architectural effect on cache state and does not modify flags; it is a performance hint that may improve system throughput by reducing cache coherency traffic. Requires CLDEMOTE instruction extension; available in 64-bit mode.", "pseudocode": "// Hint to demote cache line at m8\n// No architectural registers or flags are modified\nDemoteHint([m8])", "example": "CLDEMOTE [rbp-1]" }, { "mnemonic": "movdiri", "architecture": "x86", "full_name": "Move Direct Store Integer", "summary": "Moves 32/64-bit data avoiding cache pollution (Direct IO).", "syntax": "MOVDIRI m, r", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 38 F9 /r", "visual_parts": [], "binary_pattern": "0F | 38 | F9", "bit_positions": "+0 | +1 | +2" }, "extension": "MOVDIRI", "operands": [ { "name": "dest", "type": "m", "desc": "Memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Moves 32-bit or 64-bit data from a general-purpose register directly to memory, bypassing the cache hierarchy to avoid cache pollution (Direct I/O store). The instruction writes directly to memory without allocating or updating cache lines. No flags are affected; requires MOVDIRI instruction extension and is intended for low-latency memory-mapped I/O operations.", "pseudocode": "if (src is r32) {\n [dest] ← src[31:0];\n} else if (src is r64) {\n [dest] ← src[63:0];\n}\n// No cache line allocated; bypasses cache hierarchy\n// No flags modified", "example": "MOVDIRI [rbp-8], rax" }, { "mnemonic": "movdir64b", "architecture": "x86", "full_name": "Move Direct Store 64-Bytes", "summary": "Atomically moves 64-byte block avoiding cache pollution.", "syntax": "MOVDIR64B m512, m512", "encoding": { "format": "Legacy", "hex_opcode": "66 0F 38 F8", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | F8", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "MOVDIR64B", "operands": [ { "name": "dest", "type": "m512", "desc": "512-bit memory operand" }, { "name": "src", "type": "m512", "desc": "512-bit memory operand" } ], "description": "Atomically moves a 64-byte block from memory to memory using a Direct I/O store, bypassing the cache hierarchy without allocating cache lines. The operation is atomic with respect to other MOVDIR64B operations and ensures the destination cache line is not allocated. No flags are affected; requires MOVDIR64B extension and 64-byte alignment of both operands.", "pseudocode": "// Atomically copy 64 bytes from src to dest, bypassing cache\nfor (i = 0; i < 64; i++) {\n [dest + i] ← [src + i];\n}\n// Destination cache line not allocated\n// Operation is atomic and serializing\n// No flags modified", "example": "MOVDIR64B [rbp-64], [rbp-64]" }, { "mnemonic": "xbegin", "architecture": "x86", "full_name": "Transaction Begin", "summary": "Specifies start of Restricted Transactional Memory region.", "syntax": "XBEGIN rel", "encoding": { "format": "Legacy", "hex_opcode": "C7 F8", "visual_parts": [], "binary_pattern": "C7 | F8", "bit_positions": "+0 | +1" }, "extension": "RTM (TSX)", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Specifies the entry point into a Restricted Transactional Memory (RTM) region; execution begins optimistically buffering memory updates. If the transaction aborts, execution branches to the fallback address (rel32); if successful, the transaction commits on XEND. The ZF flag is cleared on successful entry and set on abort; EAX contains a non-zero abort code if a transaction fails.", "pseudocode": "if (RTM_EntryAllowed) {\n RTM_TransactionActive ← 1;\n ZF ← 0;\n // Speculatively execute instructions; buffer memory modifications\n} else {\n // Transaction abort\n ZF ← 1;\n EAX ← abort_code;\n RIP ← RIP + rel32; // Branch to fallback address\n}", "example": "XBEGIN rel" }, { "mnemonic": "xend", "architecture": "x86", "full_name": "Transaction End", "summary": "Specifies end of RTM region.", "syntax": "XEND", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 D5", "visual_parts": [], "binary_pattern": "0F | 01 | D5", "bit_positions": "+0 | +1 | +2" }, "extension": "RTM (TSX)", "operands": [], "description": "Marks the end of a Restricted Transactional Memory (RTM) region and commits all buffered memory writes if the transaction succeeds. If the transaction has been aborted prior, XEND is a no-op; no flags are modified. Requires RTM extension and must be paired with XBEGIN.", "pseudocode": "if (RTM_TransactionActive) {\n if (RTMAborted) {\n // No-op; abort already occurred\n } else {\n // Commit buffered writes atomically\n CommitBufferedWrites();\n RTM_TransactionActive ← 0;\n }\n // No flags modified\n}", "example": "XEND" }, { "mnemonic": "xabort", "architecture": "x86", "full_name": "Transaction Abort", "summary": "Forces an RTM abort.", "syntax": "XABORT imm8", "encoding": { "format": "Legacy", "hex_opcode": "C6 F8", "visual_parts": [], "binary_pattern": "C6 | F8", "bit_positions": "+0 | +1" }, "extension": "RTM (TSX)", "operands": [ { "name": "dest", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Forces an explicit abort of the current Restricted Transactional Memory (RTM) transaction, causing execution to branch to the XBEGIN fallback address. The 8-bit immediate value is encoded in the low byte of EAX to indicate the abort reason. No flags are modified by XABORT itself; control flow branches via the RTM abort mechanism.", "pseudocode": "if (RTM_TransactionActive) {\n // Abort transaction\n EAX[7:0] ← imm8;\n RTM_TransactionActive ← 0;\n RIP ← XBEGINFallbackAddress; // Branch to XBEGIN offset\n} else {\n // Outside transaction; XABORT is a no-op\n}", "example": "XABORT 3" }, { "mnemonic": "xtest", "architecture": "x86", "full_name": "Test If In Transaction", "summary": "Sets ZF if processor is in transactional region.", "syntax": "XTEST", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 D6", "visual_parts": [], "binary_pattern": "0F | 01 | D6", "bit_positions": "+0 | +1 | +2" }, "extension": "TSX", "operands": [], "description": "Tests whether the processor is currently executing within a Restricted Transactional Memory (RTM) region by setting the Zero Flag (ZF) to 1 if inside a transaction, or clearing it (ZF = 0) if outside. No other flags or registers are modified; useful for conditional logic in fallback code paths.", "pseudocode": "if (RTM_TransactionActive) {\n ZF ← 1; // Inside transaction\n} else {\n ZF ← 0; // Outside transaction\n}\n// All other flags unchanged", "example": "XTEST" }, { "mnemonic": "umonitor", "architecture": "x86", "full_name": "User Level Monitor", "summary": "Sets up a monitor address for User Wait instructions.", "syntax": "UMONITOR r64", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F AE 11:110:bbb", "visual_parts": [], "binary_pattern": "F3 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "WAITPKG", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" } ], "description": "Sets up a monitor address for User Wait instructions (UMWAIT, TPAUSE) by storing the linear address from the source register in the hardware monitor. The monitor watches for writes to the address range to arm the wait condition. No flags are modified; requires WAITPKG extension and 64-bit mode.", "pseudocode": "// Load monitor address from r64\nMonitorAddress ← src;\nMonitorState ← ARMED;\n// Monitor watches for writes to this address\n// No flags modified", "example": "UMONITOR rax" }, { "mnemonic": "umwait", "architecture": "x86", "full_name": "User Level Monitor Wait", "summary": "Waits for store to monitored address (Low power state).", "syntax": "UMWAIT r32", "encoding": { "format": "Legacy", "hex_opcode": "F2 0F AE /6", "visual_parts": [], "binary_pattern": "F2 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "WAITPKG", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Enters a low-power wait state and monitors the address specified in EDX:EAX until a store occurs to that monitored address or a timeout expires. The timeout value in ECX specifies the deadline. This instruction requires WAITPKG support and operates only in protected/64-bit mode at privilege level 0 (CPL=0). No flags are modified by this instruction.", "pseudocode": "if (WAITPKG not supported) raise #UD;\nif (CPL != 0) raise #GP(0);\nmonitor_address ← EDX:EAX;\ntimeout_value ← ECX;\nenter_low_power_state();\nwhile (monitored_address not written && current_time < timeout_value) {\n // CPU stays in low-power state\n}\nexit_low_power_state();\nEAX ← status_code;", "example": "UMWAIT eax" }, { "mnemonic": "tpause", "architecture": "x86", "full_name": "Timed Pause", "summary": "Pauses execution for a specified time or until trigger.", "syntax": "TPAUSE r32", "encoding": { "format": "Legacy", "hex_opcode": "66 0F AE 11:110:bbb", "visual_parts": [], "binary_pattern": "66 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "WAITPKG", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Pauses execution for a specified time interval (in TSC cycles) or until an external interrupt/event occurs, whichever comes first. The pause duration is specified in EDX:EAX and source operand controls pause type. This instruction requires WAITPKG support and operates only in protected/64-bit modes. No flags are modified; EAX contains a status code on completion.", "pseudocode": "if (WAITPKG not supported) raise #UD;\npause_type ← r32 & 0xF;\nduration ← EDX:EAX;\nif (pause_type == 0) {\n // Absolute TSC deadline\n while (current_tsc < duration && no_interrupt) pause_cycle();\n} else if (pause_type == 1) {\n // Relative delay\n end_time ← current_tsc + duration;\n while (current_tsc < end_time && no_interrupt) pause_cycle();\n}\nEAX ← status_code;", "example": "TPAUSE eax" }, { "mnemonic": "vaddph", "architecture": "x86", "full_name": "Add Packed FP16 Values", "summary": "Adds half-precision floating-point values.", "syntax": "VADDPH zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.NP.MAP5.W0 58 /r", "visual_parts": [], "binary_pattern": "EVEX | 58", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Adds 32 pairs of half-precision (FP16) floating-point values from zmm2 and zmm3/m512, storing the result in zmm1 with optional write masking via k1. The operation follows IEEE 754 semantics for FP16 arithmetic, supporting rounding modes from MXCSR. Requires AVX-512-FP16 extension. Denormal operands may trigger exceptions per MXCSR exception mask settings.", "pseudocode": "for i ← 0 to 31 do\n if (k1[i] or no_mask) then\n zmm1[16*i+15:16*i] ← FP16_ADD(zmm2[16*i+15:16*i], zmm3[16*i+15:16*i]);\n else if (zeroing_mask)\n zmm1[16*i+15:16*i] ← 0;\nendfor;\n// MXCSR exception flags updated per result", "example": "VADDPH zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vsubph", "architecture": "x86", "full_name": "Subtract Packed FP16 Values", "summary": "Subtracts half-precision floating-point values.", "syntax": "VSUBPH zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.NP.MAP5.W0 5C /r", "visual_parts": [], "binary_pattern": "EVEX | 5C", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Subtracts 32 pairs of half-precision (FP16) floating-point values (zmm3/m512 from zmm2), storing the result in zmm1 with optional write masking via k1. The operation follows IEEE 754 semantics for FP16 arithmetic with configurable rounding modes from MXCSR. Requires AVX-512-FP16 extension. Exception behavior depends on MXCSR exception mask and denormal handling.", "pseudocode": "for i ← 0 to 31 do\n if (k1[i] or no_mask) then\n zmm1[16*i+15:16*i] ← FP16_SUB(zmm2[16*i+15:16*i], zmm3[16*i+15:16*i]);\n else if (zeroing_mask)\n zmm1[16*i+15:16*i] ← 0;\nendfor;\n// MXCSR exception flags updated per result", "example": "VSUBPH zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vmulph", "architecture": "x86", "full_name": "Multiply Packed FP16 Values", "summary": "Multiplies half-precision floating-point values.", "syntax": "VMULPH zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.NP.MAP5.W0 59 /r", "visual_parts": [], "binary_pattern": "EVEX | 59", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Multiplies 32 pairs of half-precision (FP16) floating-point values from zmm2 and zmm3/m512, storing the result in zmm1 with optional write masking via k1. Follows IEEE 754 semantics with rounding controlled by MXCSR. Requires AVX-512-FP16 extension. Exception flags in MXCSR are set per IEEE 754 rules (underflow, overflow, precision, invalid operation).", "pseudocode": "for i ← 0 to 31 do\n if (k1[i] or no_mask) then\n zmm1[16*i+15:16*i] ← FP16_MUL(zmm2[16*i+15:16*i], zmm3[16*i+15:16*i]);\n else if (zeroing_mask)\n zmm1[16*i+15:16*i] ← 0;\nendfor;\n// MXCSR exception flags updated per result", "example": "VMULPH zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vdivph", "architecture": "x86", "full_name": "Divide Packed FP16 Values", "summary": "Divides half-precision floating-point values.", "syntax": "VDIVPH zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.NP.MAP5.W0 5E /r", "visual_parts": [], "binary_pattern": "EVEX | 5E", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Divides 32 half-precision (FP16) floating-point values in zmm2 by corresponding values in zmm3/m512, storing the result in zmm1 with optional write masking via k1. Division follows IEEE 754 semantics with configurable rounding from MXCSR. Requires AVX-512-FP16 extension. Division-by-zero, invalid operations, and underflow/overflow exceptions are reported via MXCSR.", "pseudocode": "for i ← 0 to 31 do\n if (k1[i] or no_mask) then\n zmm1[16*i+15:16*i] ← FP16_DIV(zmm2[16*i+15:16*i], zmm3[16*i+15:16*i]);\n else if (zeroing_mask)\n zmm1[16*i+15:16*i] ← 0;\nendfor;\n// MXCSR exception flags updated per result (division-by-zero, etc.)", "example": "VDIVPH zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vsqrtph", "architecture": "x86", "full_name": "Square Root Packed FP16 Values", "summary": "Square root of half-precision values.", "syntax": "VSQRTPH zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.NP.MAP5.W0 51 /r", "visual_parts": [], "binary_pattern": "EVEX | 51", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Computes the square root of 32 half-precision (FP16) floating-point values from zmm2/m512, storing the result in zmm1 with optional write masking via k1. Square root follows IEEE 754 semantics with rounding controlled by MXCSR. Requires AVX-512-FP16 extension. Invalid operation (negative non-zero operand) and underflow/precision exceptions are reported via MXCSR.", "pseudocode": "for i ← 0 to 31 do\n if (k1[i] or no_mask) then\n zmm1[16*i+15:16*i] ← FP16_SQRT(zmm2[16*i+15:16*i]);\n else if (zeroing_mask)\n zmm1[16*i+15:16*i] ← 0;\nendfor;\n// MXCSR exception flags updated per result (invalid operation, underflow, etc.)", "example": "VSQRTPH zmm1, zmm2/m512" }, { "mnemonic": "vminph", "architecture": "x86", "full_name": "Minimum Packed FP16 Values", "summary": "Minimum of half-precision values.", "syntax": "VMINPH zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.NP.MAP5.W0 5D /r", "visual_parts": [], "binary_pattern": "EVEX | 5D", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Computes element-wise minimum of 32 half-precision (FP16) floating-point values from zmm2 and zmm3/m512, storing the result in zmm1 with optional write masking via k1. Comparison follows IEEE 754 minimum semantics: NaN handling returns non-NaN operand when possible; equal values return zmm2. Requires AVX-512-FP16 extension. No exception flags are modified by comparison.", "pseudocode": "for i ← 0 to 31 do\n if (k1[i] or no_mask) then\n a ← zmm2[16*i+15:16*i];\n b ← zmm3[16*i+15:16*i];\n if (is_nan(a) && not is_nan(b)) zmm1[16*i+15:16*i] ← b;\n else if (is_nan(b) && not is_nan(a)) zmm1[16*i+15:16*i] ← a;\n else zmm1[16*i+15:16*i] ← (a < b) ? a : b;\n else if (zeroing_mask)\n zmm1[16*i+15:16*i] ← 0;\nendfor;", "example": "VMINPH zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vmaxph", "architecture": "x86", "full_name": "Maximum Packed FP16 Values", "summary": "Maximum of half-precision values.", "syntax": "VMAXPH zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.NP.MAP5.W0 5F /r", "visual_parts": [], "binary_pattern": "EVEX | 5F", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Computes the maximum of packed half-precision (FP16) values from two 512-bit sources, writing results to a 512-bit ZMM register under EVEX mask control. The instruction performs element-wise comparison following IEEE 754 semantics, with special handling for NaN and signed zero. No arithmetic flags are modified; this is a masked operation requiring AVX-512-FP16 support.", "pseudocode": "for i = 0 to 31:\n if (k1[i] == 1):\n zmm1[16*i:16*i+15] ← max_fp16(zmm2[16*i:16*i+15], zmm3/m512[16*i:16*i+15])\n else if (EVEX.z == 1):\n zmm1[16*i:16*i+15] ← 0\n // else zmm1[16*i:16*i+15] unchanged", "example": "VMAXPH zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vfmadd132ph", "architecture": "x86", "full_name": "Fused Multiply-Add (132) Packed FP16", "summary": "Computes (Dest * Src2) + Src1 in half-precision.", "syntax": "VFMADD132PH zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.MAP6.W0 98 /r", "visual_parts": [], "binary_pattern": "EVEX | 98", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Fused multiply-add instruction computing (zmm1 × zmm3/m512) + zmm2 in FP16 precision with a single rounding operation, improving accuracy and performance. The operand order (132) indicates zmm1 is the first multiplier, zmm3/m512 is the second, and zmm2 is the addend. Requires AVX-512-FP16; no arithmetic flags are modified; results are written to zmm1 under EVEX mask control.", "pseudocode": "for i = 0 to 31:\n if (k1[i] == 1):\n zmm1[16*i:16*i+15] ← fma_fp16(zmm1[16*i:16*i+15], zmm3/m512[16*i:16*i+15], zmm2[16*i:16*i+15])\n else if (EVEX.z == 1):\n zmm1[16*i:16*i+15] ← 0\n // else zmm1[16*i:16*i+15] unchanged", "example": "VFMADD132PH zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vfmadd213ph", "architecture": "x86", "full_name": "Fused Multiply-Add (213) Packed FP16", "summary": "Computes (Src1 * Dest) + Src2 in half-precision.", "syntax": "VFMADD213PH zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.MAP6.W0 A8 /r", "visual_parts": [], "binary_pattern": "EVEX | A8", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Fused multiply-add instruction computing (zmm2 × zmm1) + zmm3/m512 in FP16 precision with a single rounding operation. The operand order (213) indicates zmm2 is the first multiplier, zmm1 is the second, and zmm3/m512 is the addend. Requires AVX-512-FP16; no arithmetic flags are modified; results are written to zmm1 under EVEX mask control.", "pseudocode": "for i = 0 to 31:\n if (k1[i] == 1):\n zmm1[16*i:16*i+15] ← fma_fp16(zmm2[16*i:16*i+15], zmm1[16*i:16*i+15], zmm3/m512[16*i:16*i+15])\n else if (EVEX.z == 1):\n zmm1[16*i:16*i+15] ← 0\n // else zmm1[16*i:16*i+15] unchanged", "example": "VFMADD213PH zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vfmadd231ph", "architecture": "x86", "full_name": "Fused Multiply-Add (231) Packed FP16", "summary": "Computes (Src1 * Src2) + Dest in half-precision.", "syntax": "VFMADD231PH zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.MAP6.W0 B8 /r", "visual_parts": [], "binary_pattern": "EVEX | B8", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Fused multiply-add instruction computing (zmm2 × zmm3/m512) + zmm1 in FP16 precision with a single rounding operation. The operand order (231) indicates zmm2 is the first multiplier, zmm3/m512 is the second, and zmm1 is the addend. Requires AVX-512-FP16; no arithmetic flags are modified; results are written to zmm1 under EVEX mask control.", "pseudocode": "for i = 0 to 31:\n if (k1[i] == 1):\n zmm1[16*i:16*i+15] ← fma_fp16(zmm2[16*i:16*i+15], zmm3/m512[16*i:16*i+15], zmm1[16*i:16*i+15])\n else if (EVEX.z == 1):\n zmm1[16*i:16*i+15] ← 0\n // else zmm1[16*i:16*i+15] unchanged", "example": "VFMADD231PH zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vcvtne2ps2bf16", "architecture": "x86", "full_name": "Convert Two Packed Single to Packed BFloat16", "summary": "Converts two float vectors to one BFloat16 vector.", "syntax": "VCVTNE2PS2BF16 zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F2.0F38.W0 72 /r", "visual_parts": [], "binary_pattern": "EVEX | 72", "bit_positions": "+0 | +4" }, "extension": "AVX-512-BF16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Converts two packed single-precision (FP32) vectors into one packed bfloat16 vector by interleaving and rounding, producing 32 bfloat16 values in the destination ZMM register. The 'ne2' notation indicates two inputs are consumed to produce one output with truncation-based rounding (not MXCSR-controlled). Requires AVX-512-BF16; results are written under EVEX mask control; no arithmetic flags are modified.", "pseudocode": "for i = 0 to 15:\n if (k1[2*i] == 1 or k1[2*i+1] == 1):\n fp32_val1 ← zmm2[32*i:32*i+31]\n fp32_val2 ← zmm3/m512[32*i:32*i+31]\n zmm1[16*(2*i):16*(2*i)+15] ← convert_to_bf16_truncate(fp32_val1)\n zmm1[16*(2*i+1):16*(2*i+1)+15] ← convert_to_bf16_truncate(fp32_val2)\n else if (EVEX.z == 1):\n zmm1[16*(2*i):16*(2*i)+31] ← 0\n // else zmm1 unchanged", "example": "VCVTNE2PS2BF16 zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vdpbf16ps", "architecture": "x86", "full_name": "Dot Product BFloat16 to Packed Single", "summary": "BFloat16 dot product accumulating to Float32.", "syntax": "VDPBF16PS zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W0 52 /r", "visual_parts": [], "binary_pattern": "EVEX | 52", "bit_positions": "+0 | +4" }, "extension": "AVX-512-BF16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Dot product instruction that multiplies pairs of bfloat16 elements from two sources and accumulates the products into FP32 results, with 32-bit precision accumulation improving accuracy for neural network operations. Each 512-bit register holds 8 groups of 4 bfloat16 values (32 elements total) producing 8 FP32 sums. Requires AVX-512-BF16; no arithmetic flags are modified; results are written to zmm1 under EVEX mask control.", "pseudocode": "for i = 0 to 7:\n if (k1[i] == 1):\n sum_fp32 ← zmm1[32*i:32*i+31] // accumulation value\n for j = 0 to 3:\n bf16_a ← zmm2[16*(4*i+j):16*(4*i+j)+15]\n bf16_b ← zmm3/m512[16*(4*i+j):16*(4*i+j)+15]\n fp32_a ← convert_bf16_to_fp32(bf16_a)\n fp32_b ← convert_bf16_to_fp32(bf16_b)\n sum_fp32 ← sum_fp32 + (fp32_a * fp32_b)\n zmm1[32*i:32*i+31] ← sum_fp32\n else if (EVEX.z == 1):\n zmm1[32*i:32*i+31] ← 0\n // else zmm1[32*i:32*i+31] unchanged", "example": "VDPBF16PS zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vaesenc", "architecture": "x86", "full_name": "Vector AES Encrypt (AVX512)", "summary": "AES Encrypt on 512-bit vector.", "syntax": "VAESENC zmm1, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.WIG DC /r", "visual_parts": [], "binary_pattern": "EVEX | DC", "bit_positions": "+0 | +4" }, "extension": "AVX-512-VAES", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Performs AES single-round encryption on 512-bit data, applying SubBytes, ShiftRows, MixColumns, and AddRoundKey operations to four independent 128-bit AES blocks in parallel. The instruction treats the 512-bit register as four consecutive 128-bit AES state blocks and applies the round key (zmm3/m512) element-wise. Requires AVX-512-VAES; no arithmetic flags are modified; results are written to zmm1.", "pseudocode": "for block = 0 to 3:\n state_128 ← zmm2[128*block:128*block+127]\n round_key_128 ← zmm3/m512[128*block:128*block+127]\n state_128 ← AES_SubBytes(state_128)\n state_128 ← AES_ShiftRows(state_128)\n state_128 ← AES_MixColumns(state_128)\n state_128 ← state_128 XOR round_key_128\n zmm1[128*block:128*block+127] ← state_128", "example": "VAESENC zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vaesdec", "architecture": "x86", "full_name": "Vector AES Decrypt (AVX512)", "summary": "AES Decrypt on 512-bit vector.", "syntax": "VAESDEC zmm1, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.WIG DE /r", "visual_parts": [], "binary_pattern": "EVEX | DE", "bit_positions": "+0 | +4" }, "extension": "AVX-512-VAES", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Performs AES single-round decryption on 512-bit data, applying InvSubBytes, InvShiftRows, InvMixColumns, and AddRoundKey operations to four independent 128-bit AES blocks in parallel. The instruction treats the 512-bit register as four consecutive 128-bit AES state blocks and applies the round key (zmm3/m512) element-wise. Requires AVX-512-VAES; no arithmetic flags are modified; results are written to zmm1.", "pseudocode": "for block = 0 to 3:\n state_128 ← zmm2[128*block:128*block+127]\n round_key_128 ← zmm3/m512[128*block:128*block+127]\n state_128 ← AES_InvSubBytes(state_128)\n state_128 ← AES_InvShiftRows(state_128)\n state_128 ← AES_InvMixColumns(state_128)\n state_128 ← state_128 XOR round_key_128\n zmm1[128*block:128*block+127] ← state_128", "example": "VAESDEC zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpclmulqdq", "architecture": "x86", "full_name": "Vector Carry-Less Multiplication (AVX512)", "summary": "Carry-less multiply on 512-bit vector.", "syntax": "VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "VEX.128.66.0F3A.WIG 44 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 44", "bit_positions": "+0 | +4" }, "extension": "AVX-512-VPCLMULQDQ", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs carry-less multiplication of 64-bit elements from two 512-bit vectors, producing 128-bit results that are stored in the destination ZMM register. The imm8 field selects which 64-bit quadwords from the source operands participate in the multiplication. No flags are affected; this is a cryptographic primitive used in GCM and other authenticated encryption modes.", "pseudocode": "for i in 0 to 3:\n qw1 = (imm8[0] == 0) ? zmm2[i*64..i*64+63] : zmm2[i*64+64..i*64+127]\n qw2 = (imm8[4] == 0) ? zmm3[i*64..i*64+63] : zmm3[i*64+64..i*64+127]\n zmm1[i*128..i*128+127] ← carryless_multiply(qw1, qw2)", "example": "VPCLMULQDQ zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vsha512msg1", "architecture": "x86", "full_name": "SHA512 Message Schedule 1", "summary": "SHA512 intermediate calculation (AVX512).", "syntax": "VSHA512MSG1 ymm1, xmm2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.256.F2.0F38.W0 CC 11:rrr:bbb", "visual_parts": [], "binary_pattern": "CC", "bit_positions": "+0" }, "extension": "SHA512", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src", "type": "xmm2", "desc": "128-bit XMM SIMD register" } ], "description": "Computes SHA-512 message schedule expansion for the first message schedule instruction, operating on a 128-bit XMM source and producing a 256-bit YMM result. This instruction is part of the SHA-512 cryptographic hash computation pipeline and requires AVX-512 or SHA512 extension support. No EFLAGS are modified.", "pseudocode": "W[0..3] ← xmm2[64*i..64*i+63] for i in 0 to 1\nW[4..7] ← expand_sha512_msg_schedule(W[0..3])\nymm1[256 bits] ← W[4..7]", "example": "VSHA512MSG1 ymm1, xmm2" }, { "mnemonic": "vsha512msg2", "architecture": "x86", "full_name": "SHA512 Message Schedule 2", "summary": "SHA512 final calculation (AVX512).", "syntax": "VSHA512MSG2 ymm1, ymm2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.256.F2.0F38.W0 CD 11:rrr:bbb", "visual_parts": [], "binary_pattern": "CD", "bit_positions": "+0" }, "extension": "SHA512", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src", "type": "ymm2", "desc": "256-bit YMM AVX register" } ], "description": "Computes the second stage of SHA-512 message schedule expansion, combining two 256-bit YMM inputs to produce a 256-bit result. This instruction is used after VSHA512MSG1 to complete the message schedule preparation for SHA-512 block processing. No EFLAGS are modified.", "pseudocode": "W[0..3] ← ymm1[64*i..64*i+63] for i in 0 to 3\nW[4..7] ← ymm2[64*i..64*i+63] for i in 0 to 3\nresult ← sha512_msg2_schedule(W[0..3], W[4..7])\nymm1[256 bits] ← result", "example": "VSHA512MSG2 ymm1, ymm2" }, { "mnemonic": "vsha512rnds2", "architecture": "x86", "full_name": "SHA512 Rounds 2", "summary": "SHA512 2 rounds calculation (AVX512).", "syntax": "VSHA512RNDS2 ymm1, ymm2, xmm3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.256.F2.0F38.W0 CB 11:rrr:bbb", "visual_parts": [], "binary_pattern": "CB", "bit_positions": "+0" }, "extension": "SHA512", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "xmm3", "desc": "128-bit XMM SIMD register" } ], "description": "Executes two rounds of SHA-512 compression function, processing a 256-bit working variable vector (ymm1) using a 256-bit state operand (ymm2) and round constants from a 128-bit XMM register. This instruction performs the core iterative hash compression and does not modify EFLAGS.", "pseudocode": "A_B[0..1] ← ymm1[128*i..128*i+127] for i in 0 to 1\nC_D_E_F_G_H[0..3] ← ymm2[64*i..64*i+63] for i in 0 to 3\nRK[0..1] ← xmm3[64*i..64*i+63] for i in 0 to 1\nfor round in 0 to 1:\n temp ← sha512_compress_round(A_B, C_D_E_F_G_H, RK[round])\n A_B, C_D_E_F_G_H ← temp\nymm1[256 bits] ← A_B[0..1]", "example": "VSHA512RNDS2 ymm1, ymm2, xmm3" }, { "mnemonic": "vsm3msg1", "architecture": "x86", "full_name": "SM3 Message Schedule 1", "summary": "SM3 crypto message schedule part 1.", "syntax": "VSM3MSG1 xmm1, xmm2, xmm3", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.NP.0F38.W0 DA /r", "visual_parts": [], "binary_pattern": "DA", "bit_positions": "+0" }, "extension": "SM3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3", "desc": "128-bit XMM SIMD register" } ], "description": "Performs the first stage of SM3 (Chinese cryptographic hash standard) message schedule computation on 128-bit inputs, producing a 128-bit expanded message word. This instruction combines three XMM operands using SM3-specific expansion logic and does not modify EFLAGS.", "pseudocode": "W ← xmm2[32*i..32*i+31] for i in 0 to 3\nW_prime ← xmm3[32*i..32*i+31] for i in 0 to 3\nW_new ← sm3_msg1_expand(W, W_prime)\nxmm1[128 bits] ← W_new", "example": "VSM3MSG1 xmm1, xmm2, xmm3" }, { "mnemonic": "vsm3rnds2", "architecture": "x86", "full_name": "SM3 Rounds 2", "summary": "SM3 crypto 2 rounds.", "syntax": "VSM3RNDS2 xmm1, xmm2, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.66.0F3A.W0 DE /r /ib", "visual_parts": [], "binary_pattern": "DE", "bit_positions": "+0" }, "extension": "SM3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Executes two rounds of SM3 compression function using a 128-bit working variable XMM register and an immediate value specifying round constants and control flow. The instruction applies SM3-specific round transformations and does not modify EFLAGS.", "pseudocode": "A_B_C_D ← xmm1[32*i..32*i+31] for i in 0 to 3\nE_F_G_H ← xmm2[32*i..32*i+31] for i in 0 to 3\nround_sel ← imm8[7..0]\nfor round in 0 to 1:\n RK ← sm3_round_constant(round_sel + round)\n temp ← sm3_compress_round(A_B_C_D, E_F_G_H, RK)\n A_B_C_D, E_F_G_H ← temp\nxmm1[128 bits] ← A_B_C_D", "example": "VSM3RNDS2 xmm1, xmm2, 3" }, { "mnemonic": "vsm4rnds4", "architecture": "x86", "full_name": "SM4 Four Rounds Encryption", "summary": "Performs four rounds of SM4 encryption.", "syntax": "VSM4RNDS4 xmm1, xmm2, xmm3/m128", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.F2.0F38.W0 DA /r", "visual_parts": [], "binary_pattern": "DA", "bit_positions": "+0" }, "extension": "SM4", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m128", "desc": "128-bit XMM SIMD register or 128-bit memory operand" } ], "description": "Performs one round of SM4 block cipher encryption on 128-bit data, applying the SM4 S-box substitution and linear transformation using round key material from the source XMM register. This instruction is used iteratively to encrypt 32 rounds of the SM4 algorithm and does not modify EFLAGS.", "pseudocode": "plaintext ← xmm1[32*i..32*i+31] for i in 0 to 3\nRK ← xmm2[32*i..32*i+31] for i in 0 to 3\nfor i in 0 to 3:\n X ← plaintext[0..3]\n X ← SM4_F(X, RK[i])\n plaintext ← rotate_left(X, 1)\nxmm1[128 bits] ← plaintext", "example": "VSM4RNDS4 xmm1, xmm2, xmm3" }, { "mnemonic": "vsm4key4", "architecture": "x86", "full_name": "SM4 Key Generation", "summary": "SM4 key generation.", "syntax": "VSM4KEY4 xmm1, xmm2, xmm3/m128", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.F3.0F38.W0 DA /r", "visual_parts": [], "binary_pattern": "DA", "bit_positions": "+0" }, "extension": "SM4", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m128", "desc": "128-bit XMM SIMD register or 128-bit memory operand" } ], "description": "Performs key schedule expansion for SM4 block cipher, deriving round keys from a 128-bit key material input and producing expanded key words in the destination XMM register. This instruction is used during SM4 key setup to generate all required round keys and does not modify EFLAGS.", "pseudocode": "key ← xmm2[32*i..32*i+31] for i in 0 to 3\nexpanded_key ← SM4_KEY_SCHEDULE(key)\nxmm1[128 bits] ← expanded_key[0..3]", "example": "VSM4KEY4 xmm1, xmm2, xmm3" }, { "mnemonic": "loadiwkey", "architecture": "x86", "full_name": "Load Internal Wrapping Key", "summary": "Loads the Key Locker internal wrapping key.", "syntax": "LOADIWKEY xmm1, xmm2", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 DC", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | DC", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "KEYLOCKER", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2", "desc": "128-bit XMM SIMD register" } ], "description": "Loads the Key Locker internal wrapping key from xmm2 into the processor's internal state, using xmm1 as a control operand. This instruction requires the KEYLOCKER CPU feature and is a privileged operation. No flags are modified; the instruction serializes execution and may cause a general-protection exception (#GP) if the key material is invalid or the CPL is not 0.", "pseudocode": "IF CPL != 0 THEN #GP(0) FI;\nif CPUID.KEYLOCKER = 0 THEN #UD FI;\nINTERNAL_WRAPPING_KEY ← xmm2[127:0];\nCONTROL ← xmm1[127:0];", "example": "LOADIWKEY xmm1, xmm2" }, { "mnemonic": "encodekey128", "architecture": "x86", "full_name": "Encode 128-bit Key", "summary": "Wraps a 128-bit AES key into a handle.", "syntax": "ENCODEKEY128 r32, r32", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 FA", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | FA", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "KEYLOCKER", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Wraps a 128-bit AES key into an encoded Key Locker handle, where the second r32 operand contains the key and the first r32 receives status/handle information. The ZF flag is set to indicate success (ZF=0) or failure (ZF=1). This instruction requires KEYLOCKER support and uses the internal wrapping key loaded by LOADIWKEY.", "pseudocode": "IF CPUID.KEYLOCKER = 0 THEN #UD FI;\nkey_material ← src[31:0];\nhandle_out ← AES_WRAP_128(key_material, INTERNAL_WRAPPING_KEY);\ndest[31:0] ← handle_out;\nZF ← 0;", "example": "ENCODEKEY128 eax, eax" }, { "mnemonic": "aesenc128kl", "architecture": "x86", "full_name": "AES Encrypt 128-bit Key Locker", "summary": "Encrypts data using Key Locker handle.", "syntax": "AESENC128KL m128, xmm", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 DC !(11):rrr:bbb", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | DD", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "KEYLOCKER", "operands": [ { "name": "dest", "type": "m128", "desc": "128-bit memory operand" }, { "name": "src", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" } ], "description": "Performs AES encryption on 128-bit data in the XMM register using a Key Locker handle stored in memory. The encrypted result is written back to the XMM register, and ZF is set to indicate success or failure of the operation. This instruction requires KEYLOCKER support and performs the operation using the internal wrapping key.", "pseudocode": "IF CPUID.KEYLOCKER = 0 THEN #UD FI;\nhandle ← [dest][127:0];\nplaintext ← src[127:0];\nciphertext ← AES_ENCRYPT_128(plaintext, UNWRAP_KEY_128(handle, INTERNAL_WRAPPING_KEY));\nsrc[127:0] ← ciphertext;\nZF ← 0;", "example": "AESENC128KL [rbp-16], xmm0" }, { "mnemonic": "aesdec128kl", "architecture": "x86", "full_name": "AES Decrypt 128-bit Key Locker", "summary": "Decrypts data using Key Locker handle.", "syntax": "AESDEC128KL m128, xmm", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 DD !(11):rrr:bbb", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | DE", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "KEYLOCKER", "operands": [ { "name": "dest", "type": "m128", "desc": "128-bit memory operand" }, { "name": "src", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" } ], "description": "Performs AES decryption on 128-bit data in the XMM register using a Key Locker handle stored in memory. The decrypted result is written back to the XMM register, and ZF is set to indicate success or failure. This instruction requires KEYLOCKER support and unwraps the key using the internal wrapping key.", "pseudocode": "IF CPUID.KEYLOCKER = 0 THEN #UD FI;\nhandle ← [dest][127:0];\nciphertext ← src[127:0];\nplaintext ← AES_DECRYPT_128(ciphertext, UNWRAP_KEY_128(handle, INTERNAL_WRAPPING_KEY));\nsrc[127:0] ← plaintext;\nZF ← 0;", "example": "AESDEC128KL [rbp-16], xmm0" }, { "mnemonic": "hreset", "architecture": "x86", "full_name": "History Reset", "summary": "Resets processor history (prediction) structures.", "syntax": "HRESET imm8", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 3A F0 C0 ib", "visual_parts": [], "binary_pattern": "F3 | 0F | 3A | F0", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "HRESET", "operands": [ { "name": "dest", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Resets selected processor prediction/history structures (BTB, TLB, or other micro-architectural caches) as specified by the 8-bit immediate operand. The instruction may serialize the execution pipeline and is typically used to mitigate side-channel attacks. No EFLAGS are modified; the instruction requires HRESET CPU feature support.", "pseudocode": "IF CPUID.HRESET = 0 THEN #UD FI;\nselect_bits ← imm8[7:0];\nIF select_bits & 0x01 THEN RESET_BTB() FI;\nIF select_bits & 0x02 THEN RESET_TLB() FI;\nIF select_bits & 0x04 THEN RESET_RSB() FI;", "example": "HRESET 3" }, { "mnemonic": "serialize", "architecture": "x86", "full_name": "Serialize Instruction Execution", "summary": "Forces serialization of instruction fetch/execution.", "syntax": "SERIALIZE", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 E8", "visual_parts": [], "binary_pattern": "0F | 01 | E8", "bit_positions": "+0 | +1 | +2" }, "extension": "SERIALIZE", "operands": [], "description": "Serializes instruction execution by ensuring all prior instructions have completed and all memory operations are ordered before subsequent instructions execute. This instruction blocks out-of-order execution, flushes the pipeline, and may have significant performance impact. No flags are modified; the instruction requires SERIALIZE CPU feature and may incur substantial latency.", "pseudocode": "IF CPUID.SERIALIZE = 0 THEN #UD FI;\nWAIT_FOR_ALL_PRIOR_INSTRUCTIONS();\nFLUSH_EXECUTION_PIPELINE();\nCLEAR_OUT_OF_ORDER_BUFFERS();", "example": "SERIALIZE" }, { "mnemonic": "rdpid", "architecture": "x86", "full_name": "Read Processor ID", "summary": "Reads the processor ID (TSC_AUX) into register.", "syntax": "RDPID r32", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F C7 /7", "visual_parts": [], "binary_pattern": "F3 | 0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "RDPID", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Reads the processor ID (IA32_TSC_AUX MSR value) into the destination 32-bit register, providing thread/core identification information. This is a fast operation compared to RDMSR and requires the RDPID CPU feature. No flags are modified; the instruction can execute in user mode if IA32_TSC_AUX is readable.", "pseudocode": "IF CPUID.RDPID = 0 THEN #UD FI;\ndest[31:0] ← IA32_TSC_AUX[31:0];\ndest[63:32] ← 0;", "example": "RDPID eax" }, { "mnemonic": "xsaves", "architecture": "x86", "full_name": "Save Supervisor States", "summary": "Saves supervisor state components to memory (Compact).", "syntax": "XSAVES m", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F C7 /5", "visual_parts": [], "binary_pattern": "0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "XSAVES", "operands": [ { "name": "dest", "type": "m", "desc": "Memory operand" } ], "description": "Saves processor extended state components (both user and supervisor states) to memory in compact form, controlled by the XCR0 and IA32_XSS MSRs and a mask in EDX:EAX. This instruction is a supervisor-mode only operation requiring CPL=0 and XSAVES feature support. No EFLAGS are modified; memory layout is compact and may trigger #GP if state is invalid.", "pseudocode": "IF CPL != 0 THEN #GP(0) FI;\nIF CPUID.XSAVES = 0 THEN #UD FI;\nmask ← (EDX << 32) | EAX;\nsave_regions ← GET_SAVE_REGIONS_MASKED(XCR0, IA32_XSS, mask);\nCOMPACT_SAVE_STATE(dest, save_regions);", "example": "XSAVES [rbp-8]" }, { "mnemonic": "xrstors", "architecture": "x86", "full_name": "Restore Supervisor States", "summary": "Restores supervisor state components from memory (Compact).", "syntax": "XRSTORS m", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F C7 /3", "visual_parts": [], "binary_pattern": "0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "XSAVES", "operands": [ { "name": "dest", "type": "m", "desc": "Memory operand" } ], "description": "Restores processor extended state components (XMM, YMM, ZMM, and other state) from memory in compact form, using the state bitmap in EDX:EAX to determine which components to restore. This instruction is privileged (ring 0 only) and requires the XSAVES extension. Requires XSAVE feature enabled and XSAVES support; no flags are affected.", "pseudocode": "IF (CR4.OSXSAVE == 0 || CPL != 0) THEN #UD;\nIF (m is not 64-byte aligned) THEN #GP(0);\nstate_bitmap ← EDX:EAX;\nrestore_xsave_state_from_memory(m, state_bitmap, supervisor=true);", "example": "XRSTORS [rbp-8]" }, { "mnemonic": "ptwrite", "architecture": "x86", "full_name": "Write Data to Processor Trace", "summary": "Writes data to the Intel Processor Trace stream.", "syntax": "PTWRITE r32/r64", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F AE /4", "visual_parts": [], "binary_pattern": "F3 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "PTWRITE", "operands": [ { "name": "dest", "type": "r32/r64", "desc": "General-purpose register or General-purpose register" } ], "description": "Writes a 32-bit or 64-bit value from a general-purpose register into the Intel Processor Trace output stream, if PT is enabled and PT.PTW is set. The write is non-blocking and does not modify CPU flags. Requires PTWRITE extension support; operation has no effect if Processor Trace is disabled.", "pseudocode": "IF (CPL > 0 && IA32_RTIT_CTL.CR3Filter == 1) THEN #GP(0);\nIF (PT_enabled && PT.PTW) THEN {\n trace_output ← operand;\n generate_ptw_packet(operand);\n}\nELSE {\n // No effect if PT disabled or PTW not set\n}", "example": "PTWRITE r32/r64" }, { "mnemonic": "uiret", "architecture": "x86", "full_name": "User Interrupt Return", "summary": "Returns from a User Interrupt handler.", "syntax": "UIRET", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 01 EC", "visual_parts": [], "binary_pattern": "F3 | 0F | 01 | EC", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "UINTR", "operands": [], "description": "Returns from a User Interrupt handler to user code, restoring the previously saved user context (RIP, RFLAGS) from the User Interrupt Stack Table (UIST). This is a privileged operation (executed only in the UIRET target code path) and requires UINTR extension support. No flags are affected by the instruction itself; user flags are restored from the saved context.", "pseudocode": "IF (!UINTR_enabled) THEN #UD;\ntemp_rip ← read_from_UIST();\ntemp_rflags ← read_from_UIST();\nRIP ← temp_rip;\nRFLAGS ← temp_rflags;\nRETURN_TO_USER_MODE();", "example": "UIRET" }, { "mnemonic": "senduipi", "architecture": "x86", "full_name": "Send User Inter-Processor Interrupt", "summary": "Sends a User IPI to another processor.", "syntax": "SENDUIPI r64", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F C7 11:110:bbb", "visual_parts": [], "binary_pattern": "F3 | 0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "UINTR", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" } ], "description": "Sends a User Inter-Processor Interrupt (User IPI) to another processor identified by the UIPI index stored in the source 64-bit register. The source register contains an UPID (User IPI Posting Descriptor) index that identifies the target thread. Requires UINTR extension support; operation may be serializing and updates the target processor's interrupt state.", "pseudocode": "IF (!UINTR_enabled) THEN #UD;\nuipi_index ← src_reg[63:0];\nupid ← retrieve_UPID_from_index(uipi_index);\npost_user_interrupt_to_target(upid);\nSEND_IPI_TO_TARGET_CPU();", "example": "SENDUIPI rax" }, { "mnemonic": "in", "architecture": "x86", "full_name": "Input from Port", "summary": "Reads data from an I/O port into AL/AX/EAX.", "syntax": "IN AL, imm8", "encoding": { "format": "Legacy", "hex_opcode": "E4", "visual_parts": [], "binary_pattern": "E4", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "AL", "desc": "Implicit AL register (8-bit accumulator)" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Reads a byte from an I/O port (specified by the immediate 8-bit operand) and stores the result in AL. If IOPL permits, this instruction can be used in user mode; otherwise it requires ring 0. No flags are affected. The port number is zero-extended to 16 bits for I/O address calculation.", "pseudocode": "IF (CPL > IOPL && !V86_mode) THEN #GP(0);\nAL ← I/O_port[imm8];", "example": "IN AL, 3" }, { "mnemonic": "out", "architecture": "x86", "full_name": "Output to Port", "summary": "Writes data from AL/AX/EAX to an I/O port.", "syntax": "OUT imm8, AL", "encoding": { "format": "Legacy", "hex_opcode": "E6", "visual_parts": [], "binary_pattern": "E6", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "imm8", "desc": "8-bit signed immediate" }, { "name": "src", "type": "AL", "desc": "Implicit AL register (8-bit accumulator)" } ], "description": "Writes a byte from AL to an I/O port (specified by the immediate 8-bit operand). If IOPL permits, this instruction can be used in user mode; otherwise it requires ring 0. No flags are affected. The port number is zero-extended to 16 bits for I/O address calculation.", "pseudocode": "IF (CPL > IOPL && !V86_mode) THEN #GP(0);\nI/O_port[imm8] ← AL;", "example": "OUT 3, AL" }, { "mnemonic": "ins", "architecture": "x86", "full_name": "Input String from Port", "summary": "Reads string from I/O port to memory at [EDI].", "syntax": "INSB", "encoding": { "format": "Legacy", "hex_opcode": "6C", "visual_parts": [], "binary_pattern": "6C", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Reads a byte from the I/O port specified in DX and writes it to memory at the address [RDI/EDI/DI] (selected by address-size override). The destination address pointer is incremented or decremented by 1 based on the direction flag (DF). This is a string instruction often used with REP prefix; no flags are affected directly by INS itself.", "pseudocode": "IF (CPL > IOPL && !V86_mode) THEN #GP(0);\ntempByte ← I/O_port[DX];\n[RDI] ← tempByte;\nIF (DF == 0) THEN RDI ← RDI + 1;\nELSE RDI ← RDI - 1;", "example": "INSB" }, { "mnemonic": "outs", "architecture": "x86", "full_name": "Output String to Port", "summary": "Writes string from memory at [ESI] to I/O port.", "syntax": "OUTSB", "encoding": { "format": "Legacy", "hex_opcode": "6E", "visual_parts": [], "binary_pattern": "6E", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Reads a byte from memory at the address [RSI/ESI/SI] (selected by address-size override) and writes it to the I/O port specified in DX. The source address pointer is incremented or decremented by 1 based on the direction flag (DF). This is a string instruction often used with REP prefix; no flags are affected directly by OUTS itself.", "pseudocode": "IF (CPL > IOPL && !V86_mode) THEN #GP(0);\ntempByte ← [RSI];\nI/O_port[DX] ← tempByte;\nIF (DF == 0) THEN RSI ← RSI + 1;\nELSE RSI ← RSI - 1;", "example": "OUTSB" }, { "mnemonic": "lods", "architecture": "x86", "full_name": "Load String", "summary": "Loads byte/word/dword from [ESI] into AL/AX/EAX.", "syntax": "LODSB", "encoding": { "format": "Legacy", "hex_opcode": "AC", "visual_parts": [], "binary_pattern": "AC", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Loads a byte, word, or doubleword from memory at address DS:[ESI] (or RSI in 64-bit mode) into the accumulator (AL, AX, or EAX respectively), then increments or decrements ESI/RSI by the operand size based on the direction flag (DF). No flags are affected by this instruction.", "pseudocode": "if (DF == 0) {\n ESI ← ESI + operand_size;\n} else {\n ESI ← ESI - operand_size;\n}\nAL/AX/EAX ← [DS:ESI];", "example": "LODSB" }, { "mnemonic": "stos", "architecture": "x86", "full_name": "Store String", "summary": "Stores AL/AX/EAX to memory at [EDI].", "syntax": "STOSB", "encoding": { "format": "Legacy", "hex_opcode": "AA", "visual_parts": [], "binary_pattern": "AA", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Stores the contents of the accumulator (AL, AX, or EAX) into memory at address ES:[EDI] (or RDI in 64-bit mode), then increments or decrements EDI/RDI by the operand size based on the direction flag (DF). No flags are affected. This instruction is commonly used with REP prefix for bulk memory fills.", "pseudocode": "[ES:EDI] ← AL/AX/EAX;\nif (DF == 0) {\n EDI ← EDI + operand_size;\n} else {\n EDI ← EDI - operand_size;\n}", "example": "STOSB" }, { "mnemonic": "scas", "architecture": "x86", "full_name": "Scan String", "summary": "Compares AL/AX/EAX with memory at [EDI].", "syntax": "SCASB", "encoding": { "format": "Legacy", "hex_opcode": "AE", "visual_parts": [], "binary_pattern": "AE", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Compares the accumulator (AL, AX, or EAX) with a byte, word, or doubleword in memory at address ES:[EDI], setting EFLAGS as if by subtraction, then increments or decrements EDI/RDI by the operand size based on DF. ZF, CF, OF, SF, AF, and PF are set according to the comparison result.", "pseudocode": "temp ← AL/AX/EAX - [ES:EDI];\nZF ← (temp == 0);\nCF ← (AL/AX/EAX < [ES:EDI]);\nOF ← overflow_from_subtraction;\nSF ← sign_bit_of(temp);\nAF ← auxiliary_carry_from_subtraction;\nPF ← parity_of(temp);\nif (DF == 0) {\n EDI ← EDI + operand_size;\n} else {\n EDI ← EDI - operand_size;\n}", "example": "SCASB" }, { "mnemonic": "cmps", "architecture": "x86", "full_name": "Compare String", "summary": "Compares byte/word at [ESI] with [EDI].", "syntax": "CMPSB", "encoding": { "format": "Legacy", "hex_opcode": "A6", "visual_parts": [], "binary_pattern": "A6", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Compares a byte, word, or doubleword at memory address DS:[ESI] with the value at ES:[EDI], setting EFLAGS as if by subtraction, then increments or decrements both ESI/RSI and EDI/RDI by the operand size based on DF. ZF, CF, OF, SF, AF, and PF reflect the comparison result.", "pseudocode": "temp ← [DS:ESI] - [ES:EDI];\nZF ← (temp == 0);\nCF ← ([DS:ESI] < [ES:EDI]);\nOF ← overflow_from_subtraction;\nSF ← sign_bit_of(temp);\nAF ← auxiliary_carry_from_subtraction;\nPF ← parity_of(temp);\nif (DF == 0) {\n ESI ← ESI + operand_size;\n EDI ← EDI + operand_size;\n} else {\n ESI ← ESI - operand_size;\n EDI ← EDI - operand_size;\n}", "example": "CMPSB" }, { "mnemonic": "lds", "architecture": "x86", "full_name": "Load Far Pointer using DS", "summary": "Loads pointer into DS and register.", "syntax": "LDS r, m", "encoding": { "format": "Legacy", "hex_opcode": "C5", "visual_parts": [], "binary_pattern": "C5", "bit_positions": "+0" }, "extension": "Base (Legacy)", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Loads a far pointer from memory into a general-purpose register and the DS segment register. The memory operand contains a 32-bit pointer (16-bit offset and 16-bit segment) in 16/32-bit modes. Not available in 64-bit mode. No flags are affected.", "pseudocode": "dest ← [src];\nDS ← [src + operand_size];", "example": "LDS rax, [rbp-8]" }, { "mnemonic": "les", "architecture": "x86", "full_name": "Load Far Pointer using ES", "summary": "Loads pointer into ES and register.", "syntax": "LES r, m", "encoding": { "format": "Legacy", "hex_opcode": "C4", "visual_parts": [], "binary_pattern": "C4", "bit_positions": "+0" }, "extension": "Base (Legacy)", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Loads a far pointer from memory into a general-purpose register and the ES segment register. The memory operand contains a 32-bit pointer (16-bit offset and 16-bit segment) in 16/32-bit modes. Not available in 64-bit mode. No flags are affected.", "pseudocode": "dest ← [src];\nES ← [src + operand_size];", "example": "LES rax, [rbp-8]" }, { "mnemonic": "lfs", "architecture": "x86", "full_name": "Load Far Pointer using FS", "summary": "Loads pointer into FS and register.", "syntax": "LFS r, m", "encoding": { "format": "Legacy", "hex_opcode": "0F B4", "visual_parts": [], "binary_pattern": "0F | B4", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Loads a far pointer from memory into a general-purpose register and the FS segment register. The memory operand contains a 32-bit or 48-bit pointer (16/32-bit offset and 16-bit segment). Available in 32-bit and 64-bit modes. No flags are affected.", "pseudocode": "dest ← [src];\nFS ← [src + operand_size];", "example": "LFS rax, [rbp-8]" }, { "mnemonic": "lgs", "architecture": "x86", "full_name": "Load Far Pointer using GS", "summary": "Loads pointer into GS and register.", "syntax": "LGS r, m", "encoding": { "format": "Legacy", "hex_opcode": "0F B5", "visual_parts": [], "binary_pattern": "0F | B5", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Loads a far pointer from memory into a general-purpose register and the GS segment register. The memory operand contains a 32-bit or 48-bit pointer (16/32-bit offset and 16-bit segment). Available in 32-bit and 64-bit modes. No flags are affected.", "pseudocode": "dest ← [src];\nGS ← [src + operand_size];", "example": "LGS rax, [rbp-8]" }, { "mnemonic": "lss", "architecture": "x86", "full_name": "Load Far Pointer using SS", "summary": "Loads pointer into SS and register.", "syntax": "LSS r, m", "encoding": { "format": "Legacy", "hex_opcode": "0F B2", "visual_parts": [], "binary_pattern": "0F | B2", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Loads a 48-bit or 80-bit far pointer from memory into SS and a general-purpose register, updating the stack segment base address and register value simultaneously. The memory operand contains the offset and segment selector; the segment is loaded into SS and the offset into the destination register. This instruction does not modify any flags and is available in real, protected, and 64-bit modes.", "pseudocode": "if (operand_size == 32) {\n offset ← [src];\n SS ← [src + 4];\n dest ← offset;\n} else if (operand_size == 64) {\n offset ← [src];\n SS ← [src + 8];\n dest ← offset;\n}", "example": "LSS rax, [rbp-8]" }, { "mnemonic": "swapgs", "architecture": "x86", "full_name": "Swap GS Base Register", "summary": "Swaps user/kernel GS base address (System).", "syntax": "SWAPGS", "encoding": { "format": "Legacy", "hex_opcode": "0F 01 F8", "visual_parts": [], "binary_pattern": "0F | 01 | F8", "bit_positions": "+0 | +1 | +2" }, "extension": "Base (64-bit System)", "operands": [], "description": "Atomically exchanges the user-mode and kernel-mode FS base register values by swapping the contents of the MSR_FS_BASE and MSR_KERNEL_FS_BASE model-specific registers. This is a 64-bit only instruction used for efficient user/kernel context switching in system software. No flags are modified, and the operation serializes the instruction pipeline.", "pseudocode": "if (CODESIZE == 64 && CPL == 0) {\n temp ← MSR_FS_BASE;\n MSR_FS_BASE ← MSR_KERNEL_FS_BASE;\n MSR_KERNEL_FS_BASE ← temp;\n}", "example": "SWAPGS" }, { "mnemonic": "rdfsbase", "architecture": "x86", "full_name": "Read FS Base", "summary": "Reads the FS base address into a register.", "syntax": "RDFSBASE r64", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F AE /0", "visual_parts": [], "binary_pattern": "F3 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "FSGSBASE", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" } ], "description": "Reads the current FS segment base address (from MSR_FS_BASE) into a 64-bit general-purpose register. Available only in 64-bit mode and requires the FSGSBASE CPU feature to be enabled. No flags are modified; the instruction executes with serialization semantics to ensure consistency of segment-base state.", "pseudocode": "if (FSGSBASE_enabled) {\n dest ← MSR_FS_BASE;\n} else {\n raise(UD_EXCEPTION);\n}", "example": "RDFSBASE rax" }, { "mnemonic": "rdgsbase", "architecture": "x86", "full_name": "Read GS Base", "summary": "Reads the GS base address into a register.", "syntax": "RDGSBASE r64", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F AE /1", "visual_parts": [], "binary_pattern": "F3 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "FSGSBASE", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" } ], "description": "Reads the current GS segment base address (from MSR_GS_BASE) into a 64-bit general-purpose register. Available only in 64-bit mode and requires the FSGSBASE CPU feature to be enabled. No flags are modified; the instruction executes with serialization semantics to ensure consistency of segment-base state.", "pseudocode": "if (FSGSBASE_enabled) {\n dest ← MSR_GS_BASE;\n} else {\n raise(UD_EXCEPTION);\n}", "example": "RDGSBASE rax" }, { "mnemonic": "wrfsbase", "architecture": "x86", "full_name": "Write FS Base", "summary": "Writes a register to the FS base address.", "syntax": "WRFSBASE r64", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F AE /2", "visual_parts": [], "binary_pattern": "F3 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "FSGSBASE", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" } ], "description": "Writes the value from a 64-bit general-purpose register into the FS segment base address (MSR_FS_BASE). Available only in 64-bit mode and requires the FSGSBASE CPU feature to be enabled. No flags are modified; the instruction executes with serialization semantics to ensure consistency of segment-base state.", "pseudocode": "if (FSGSBASE_enabled) {\n MSR_FS_BASE ← dest;\n} else {\n raise(UD_EXCEPTION);\n}", "example": "WRFSBASE rax" }, { "mnemonic": "wrgsbase", "architecture": "x86", "full_name": "Write GS Base", "summary": "Writes a register to the GS base address.", "syntax": "WRGSBASE r64", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F AE /3", "visual_parts": [], "binary_pattern": "F3 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "FSGSBASE", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" } ], "description": "Writes the value from a 64-bit general-purpose register into the GS segment base address (MSR_GS_BASE). Available only in 64-bit mode and requires the FSGSBASE CPU feature to be enabled. No flags are modified; the instruction executes with serialization semantics to ensure consistency of segment-base state.", "pseudocode": "if (FSGSBASE_enabled) {\n MSR_GS_BASE ← src;\n} else {\n raise(UD_EXCEPTION);\n}", "example": "WRGSBASE rax" }, { "mnemonic": "monitor", "architecture": "x86", "full_name": "Monitor", "summary": "Sets up a linear address range to be monitored.", "syntax": "MONITOR", "encoding": { "format": "Legacy", "hex_opcode": "0F 01 C8", "visual_parts": [], "binary_pattern": "0F | 01 | C8", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE3", "operands": [], "description": "Establishes a linear address range starting at [RAX] with a size specified by ECX (in bytes) to be monitored for writes by the CPU. The EAX and ECX registers supply the monitor address and size; EDX supplies optional extensions. No flags are modified. This instruction typically requires CPL ≤ 1 (ring 0/1) and is used with MWAIT for efficient polling.", "pseudocode": "if (CPL <= 1 || (CR4.MONITOR_BIT && CPL == 3)) {\n MONITOR_ADDR ← RAX;\n MONITOR_SIZE ← ECX;\n MONITOR_EXT ← EDX;\n set_up_address_range_monitoring();\n} else {\n raise(GP_EXCEPTION);\n}", "example": "MONITOR" }, { "mnemonic": "mwait", "architecture": "x86", "full_name": "Monitor Wait", "summary": "Waits for a write to a monitored address.", "syntax": "MWAIT", "encoding": { "format": "Legacy", "hex_opcode": "0F 01 C9", "visual_parts": [], "binary_pattern": "0F | 01 | C9", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE3", "operands": [], "description": "Suspends CPU execution and waits for a write to an address range that was previously set up by MONITOR, or waits for an interrupt or other wake event. The EAX register specifies the monitor sub-C-state (low byte) and optional extensions (high bytes); EBX may specify additional parameters depending on CPU model. No flags are modified. This instruction serializes the processor and is typically restricted to CPL ≤ 1.", "pseudocode": "if (CPL <= 1 || (CR4.MONITOR_BIT && CPL == 3)) {\n substate ← EAX[7:0];\n extensions ← EAX[31:8];\n enter_monitor_wait(substate, extensions);\n wait_for_wakeup_or_interrupt();\n} else {\n raise(GP_EXCEPTION);\n}", "example": "MWAIT" }, { "mnemonic": "getsec", "architecture": "x86", "full_name": "Get Security Extensions", "summary": "Entry point for Safer Mode Extensions (Trusted Execution).", "syntax": "GETSEC", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 37", "visual_parts": [], "binary_pattern": "0F | 37", "bit_positions": "+0 | +1" }, "extension": "SMX", "operands": [], "description": "Entry point for Safer Mode Extensions (SMX), allowing software to invoke security functions in trusted execution mode. The specific function is determined by the EAX register at execution time. This instruction serializes the pipeline, disables interrupts during execution, and requires either SMX mode to be enabled or execution from authenticated code. On success, control returns to the instruction following GETSEC; on failure or security violation, a #UD or system reset may occur.", "pseudocode": "// EAX contains function code (e.g., GETSEC.CAPABILITIES=0, GETSEC.ENTERACCS=2, etc.)\n// Execution is serialized; interrupts disabled during SMX operation\nIF (SMX_mode_enabled OR authenticated_code_execution_mode) THEN\n Invoke_SMX_function(EAX);\n // Control returns here on success\nELSE\n #UD; // Undefined Opcode fault\nEND;", "example": "GETSEC" }, { "mnemonic": "bndmk", "architecture": "x86", "full_name": "Make Bounds", "summary": "Creates bounds data for MPX.", "syntax": "BNDMK b, m", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 1B", "visual_parts": [], "binary_pattern": "F3 | 0F | 1B", "bit_positions": "+0 | +1 | +2" }, "extension": "MPX", "operands": [ { "name": "dest", "type": "b", "desc": "MPX bounds register (bnd0-bnd3)" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Creates a bounds pair from a memory address range, storing the lower bound and upper bound in the destination bounds register (bnd0-bnd3). The source memory operand specifies an address; the instruction computes bounds from memory operand addressing. No flags are set. This instruction is part of Memory Protection Extensions (MPX) and is deprecated on modern processors.", "pseudocode": "// Compute bounds from memory operand m\n// The bounds are derived from the addressing operation itself\nlower_bound ← compute_lower_bound(m);\nupper_bound ← compute_upper_bound(m);\n// Store in 128-bit bounds register (2×64-bit values)\nbndN.lower ← lower_bound;\nbndN.upper ← upper_bound;", "example": "BNDMK b, [rbp-8]" }, { "mnemonic": "bndcl", "architecture": "x86", "full_name": "Check Lower Bound", "summary": "Checks if address is within lower bound.", "syntax": "BNDCL b, r/m", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 1A", "visual_parts": [], "binary_pattern": "F3 | 0F | 1A", "bit_positions": "+0 | +1 | +2" }, "extension": "MPX", "operands": [ { "name": "dest", "type": "b", "desc": "MPX bounds register (bnd0-bnd3)" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Checks if an address or value is greater than or equal to the lower bound stored in the bounds register; if not, a bounds exception (#BR) is signaled. The source operand (register or memory) contains the address to be checked against bndN.lower. No flags are modified; an out-of-bounds condition triggers exception delivery. This instruction is part of deprecated Memory Protection Extensions (MPX).", "pseudocode": "address ← (src is memory) ? load_from_memory(src) : src;\nIF (address < bndN.lower) THEN\n #BR; // Bounds Range Exceeded exception\nEND;\n// No flags modified; execution continues on success", "example": "BNDCL b, rbx" }, { "mnemonic": "bndcu", "architecture": "x86", "full_name": "Check Upper Bound", "summary": "Checks if address is within upper bound.", "syntax": "BNDCU b, r/m", "encoding": { "format": "Legacy", "hex_opcode": "F2 0F 1A", "visual_parts": [], "binary_pattern": "F2 | 0F | 1A", "bit_positions": "+0 | +1 | +2" }, "extension": "MPX", "operands": [ { "name": "dest", "type": "b", "desc": "MPX bounds register (bnd0-bnd3)" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Checks if an address or value is less than or equal to the upper bound stored in the bounds register; if not, a bounds exception (#BR) is signaled. The source operand (register or memory) contains the address to be checked against bndN.upper. No flags are modified; an out-of-bounds condition triggers exception delivery. This instruction is part of deprecated Memory Protection Extensions (MPX).", "pseudocode": "address ← (src is memory) ? load_from_memory(src) : src;\nIF (address > bndN.upper) THEN\n #BR; // Bounds Range Exceeded exception\nEND;\n// No flags modified; execution continues on success", "example": "BNDCU b, rbx" }, { "mnemonic": "bndmov", "architecture": "x86", "full_name": "Move Bounds", "summary": "Moves MPX bounds data.", "syntax": "BNDMOV b, b/m", "encoding": { "format": "Legacy", "hex_opcode": "66 0F 1A", "visual_parts": [], "binary_pattern": "66 | 0F | 1A", "bit_positions": "+0 | +1 | +2" }, "extension": "MPX", "operands": [ { "name": "dest", "type": "b", "desc": "MPX bounds register (bnd0-bnd3)" }, { "name": "src", "type": "b/m", "desc": "Memory operand" } ], "description": "Moves a 128-bit bounds pair from source (bounds register or memory) to destination (bounds register). The bounds pair consists of two 64-bit values (lower and upper bounds). No flags are set or modified. This instruction is part of deprecated Memory Protection Extensions (MPX) and is one of the few instructions that operate directly on bounds data.", "pseudocode": "// Source can be bounds register or 16 bytes of memory\nIF (src is bounds register) THEN\n bndN.lower ← src.lower;\n bndN.upper ← src.upper;\nELSE\n bndN.lower ← [src];\n bndN.upper ← [src + 8];\nEND;\n// No flags modified", "example": "BNDMOV b, b/m" }, { "mnemonic": "rdpkru", "architecture": "x86", "full_name": "Read Protection Key Rights", "summary": "Reads PKRU register into EAX (User-mode pages).", "syntax": "RDPKRU", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 EE", "visual_parts": [], "binary_pattern": "0F | 01 | EE", "bit_positions": "+0 | +1 | +2" }, "extension": "PKU", "operands": [], "description": "Reads the Protection Key Rights User register (PKRU) into EAX; EDX is zeroed. PKRU controls read and write access permissions for pages marked with a protection key (0-15). This instruction is a serializing operation at the architectural level and is only available in 64-bit mode and user mode (CPL=3). No flags are modified by this instruction.", "pseudocode": "// Read PKRU into EAX, zero EDX\nEAX ← PKRU;\nEDX ← 0;\n// No flags modified; instruction is serializing", "example": "RDPKRU" }, { "mnemonic": "wrpkru", "architecture": "x86", "full_name": "Write Protection Key Rights", "summary": "Writes EAX/EDX to PKRU register.", "syntax": "WRPKRU", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 EF", "visual_parts": [], "binary_pattern": "0F | 01 | EF", "bit_positions": "+0 | +1 | +2" }, "extension": "PKU", "operands": [], "description": "Writes the value in EAX to the Protection Key Rights User register (PKRU); EDX must be zero. PKRU controls read/write access permissions for pages with protection keys (0-15). This instruction is a serializing operation and is available only in 64-bit mode at user mode (CPL=3). No flags are set; if EDX is nonzero, #GP(0) is raised.", "pseudocode": "// Write EAX to PKRU, EDX must be zero\nIF (EDX ≠ 0) THEN\n #GP(0); // General Protection Fault\nELSE\n PKRU ← EAX;\nEND;\n// No flags modified; instruction is serializing", "example": "WRPKRU" }, { "mnemonic": "vpdpbusd", "architecture": "x86", "full_name": "Multiply and Add Unsigned and Signed Bytes", "summary": "Dot product of unsigned/signed bytes, accum to dword.", "syntax": "VPDPBUSD zmm1, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 50 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 50", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VNNI", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Performs a dot product of unsigned 8-bit and signed 8-bit integers across multiple pairs, accumulating the results into 32-bit dwords. Processes 512 bits (64 bytes) with 16 sets of 4-byte dot products (zmm2[31:0] × zmm3[31:0] + zmm1[31:0]), with masking and rounding support via EVEX encoding. ZF, PF, CF, OF, SF, AF are undefined after execution; no integer flags are modified.", "pseudocode": "// VPDPBUSD zmm1{k1}{z}, zmm2, zmm3/m512\n// Signed 8×4 dot products with 32-bit accumulation\nFOR i ← 0 TO 15 DO // 16 dwords in 512-bit vector\n prod0 ← (unsigned int8) zmm2[i*32 + 7:0] × (signed int8) zmm3[i*32 + 7:0];\n prod1 ← (unsigned int8) zmm2[i*32 + 15:8] × (signed int8) zmm3[i*32 + 15:8];\n prod2 ← (unsigned int8) zmm2[i*32 + 23:16] × (signed int8) zmm3[i*32 + 23:16];\n prod3 ← (unsigned int8) zmm2[i*32 + 31:24] × (signed int8) zmm3[i*32 + 31:24];\n sum ← prod0 + prod1 + prod2 + prod3;\n zmm1[i*32 + 31:0] ← zmm1[i*32 + 31:0] + sum; // Accumulate\nEND;\n// Masking and zeroing applied per EVEX encoding; no flags modified", "example": "VPDPBUSD zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpdpbusds", "architecture": "x86", "full_name": "Multiply and Add Unsigned and Signed Bytes with Saturation", "summary": "Dot product of unsigned/signed bytes, accum to dword (Saturate).", "syntax": "VPDPBUSDS zmm1, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 51 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 51", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VNNI", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Computes dot product of unsigned and signed bytes, accumulating results into 32-bit signed integers with saturation. Processes 16 pairs of (unsigned byte × signed byte) products per 512-bit vector, summing each group of 4 products and saturating the result to the signed 32-bit range. No flags are affected; operates only on vector registers and memory.", "pseudocode": "for i in 0 to 15 {\n prod0 = ZeroExtend(src1[i*32+0:7]) * SignExtend(src2[i*32+0:7]);\n prod1 = ZeroExtend(src1[i*32+8:15]) * SignExtend(src2[i*32+8:15]);\n prod2 = ZeroExtend(src1[i*32+16:23]) * SignExtend(src2[i*32+16:23]);\n prod3 = ZeroExtend(src1[i*32+24:31]) * SignExtend(src2[i*32+24:31]);\n sum = prod0 + prod1 + prod2 + prod3;\n dest[i*32:31] ← SaturateSignedToS32(sum);\n}", "example": "VPDPBUSDS zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpdpwssd", "architecture": "x86", "full_name": "Multiply and Add Signed Words", "summary": "Dot product of signed words, accum to dword.", "syntax": "VPDPWSSD zmm1, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 52 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 52", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VNNI", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Computes dot product of signed 16-bit words, accumulating results into 32-bit signed integers without saturation. Processes 8 pairs of signed word products per 512-bit vector, summing each group of 2 products and storing the result to the destination. No flags are affected; operates only on vector registers and memory.", "pseudocode": "for i in 0 to 7 {\n prod0 = SignExtend(src1[i*32+0:15]) * SignExtend(src2[i*32+0:15]);\n prod1 = SignExtend(src1[i*32+16:31]) * SignExtend(src2[i*32+16:31]);\n sum = prod0 + prod1;\n dest[i*32:31] ← sum;\n}", "example": "VPDPWSSD zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpdpwssds", "architecture": "x86", "full_name": "Multiply and Add Signed Words with Saturation", "summary": "Dot product of signed words, accum to dword (Saturate).", "syntax": "VPDPWSSDS zmm1, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 53 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 53", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VNNI", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Computes dot product of signed 16-bit words, accumulating results into 32-bit signed integers with saturation. Processes 8 pairs of signed word products per 512-bit vector, summing each group of 2 products and saturating the result to the signed 32-bit range. No flags are affected; operates only on vector registers and memory.", "pseudocode": "for i in 0 to 7 {\n prod0 = SignExtend(src1[i*32+0:15]) * SignExtend(src2[i*32+0:15]);\n prod1 = SignExtend(src1[i*32+16:31]) * SignExtend(src2[i*32+16:31]);\n sum = prod0 + prod1;\n dest[i*32:31] ← SaturateSignedToS32(sum);\n}", "example": "VPDPWSSDS zmm1, zmm2, zmm3/m512" }, { "mnemonic": "gf2p8affineinvqb", "architecture": "x86", "full_name": "Galois Field Affine Transformation Inverse", "summary": "Computes inverse affine transformation in GF(2^8).", "syntax": "GF2P8AFFINEINVQB xmm1, xmm2/m128, imm8", "encoding": { "format": "VEX", "hex_opcode": "66 0F 3A CF /r ib", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | CF", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "GFNI", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs inverse affine transformation in the Galois Field GF(2^8) on 128-bit packed bytes. Each byte is transformed by computing b × src1 ⊕ imm8 where operations are in GF(2^8), with b from the first operand. The immediate byte controls the constant term of the affine transformation. No flags are affected; operates only on vector registers and memory.", "pseudocode": "for i in 0 to 15 {\n byte_val = dest[i*8:7];\n gf_prod = GF2P8_MultiplyInverse(byte_val, src1[i*8:7]);\n dest[i*8:7] ← gf_prod ⊕ imm8;\n}", "example": "GF2P8AFFINEINVQB xmm1, xmm2/m128, 3" }, { "mnemonic": "prefetchw", "architecture": "x86", "full_name": "Prefetch Data into Caches in Anticipation of a Write", "summary": "Prefetches data with intent to write (RFO).", "syntax": "PREFETCHW m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 0D /1", "visual_parts": [], "binary_pattern": "0F | 0D | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "PREFETCHW", "operands": [ { "name": "dest", "type": "m8", "desc": "8-bit memory operand" } ], "description": "Prefetches a cache line from memory with intent to write, requesting read-for-ownership (RFO) semantics. Brings the data into the lowest-level private cache (typically L1D) in exclusive or modified state to optimize subsequent write operations. This instruction is a hint and has no architectural effect on registers, flags, or memory contents.", "pseudocode": "// Prefetch memory address for writing (RFO semantics)\nCachePrefetchForWrite([mem_address]);", "example": "PREFETCHW [rbp-1]" }, { "mnemonic": "prefetchwt1", "architecture": "x86", "full_name": "Prefetch Hint T1 with Intent to Write", "summary": "Prefetches data to L2 (T1 hint) with intent to write.", "syntax": "PREFETCHWT1 m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 0D /2", "visual_parts": [], "binary_pattern": "0F | 0D | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "PREFETCHWT1", "operands": [ { "name": "dest", "type": "m8", "desc": "8-bit memory operand" } ], "description": "Prefetches a cache line from memory with intent to write into the L2 cache (T1 hint). Optimizes for temporal locality by loading data into the mid-level cache hierarchy rather than L1, reducing contention when multiple cores are writing to different addresses. This instruction is a hint and has no architectural effect on registers, flags, or memory contents.", "pseudocode": "// Prefetch memory address to L2 (T1 hint) with write intent\nCachePrefetchToL2ForWrite([mem_address]);", "example": "PREFETCHWT1 [rbp-1]" }, { "mnemonic": "vscatterdps", "architecture": "x86", "full_name": "Scatter Packed Single Precision", "summary": "Stores floats to non-contiguous memory locations.", "syntax": "VSCATTERDPS [base+zmm_idx*scale] {k1}, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 A2 /vsib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | A2", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "[base+zmm_idx*scale]", "desc": "AVX-512 scatter: base register + scaled ZMM vector index" }, { "name": "src", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Stores 16 packed single-precision floats (32-bit each) to non-contiguous memory locations determined by a base register and 32-bit ZMM index vector with optional scaling. Each element is stored to memory[base + index[i] × scale] where the index is zero-extended from the low 32 bits of each 64-bit ZMM element. The operation is masked via the k1 writemask; no flags are affected.", "pseudocode": "for i in 0 to 15 {\n if k1[i] {\n addr = base_reg + ZeroExtend(src2_idx[i*32:31]) * scale;\n [addr] ← src1[i*32:31];\n }\n}", "example": "VSCATTERDPS [base+zmm_idx*scale], zmm1" }, { "mnemonic": "vscatterdpd", "architecture": "x86", "full_name": "Scatter Packed Double Precision", "summary": "Stores doubles to non-contiguous memory locations.", "syntax": "VSCATTERDPD [base+zmm_idx*scale] {k1}, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 A2 /vsib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | A2", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "[base+zmm_idx*scale]", "desc": "AVX-512 scatter: base register + scaled ZMM vector index" }, { "name": "src", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Stores 8 packed double-precision floats (64-bit each) to non-contiguous memory locations determined by a base register and 64-bit ZMM index vector with optional scaling. Each element is stored to memory[base + index[i] × scale] where the index comes from the corresponding 64-bit ZMM element. The operation is masked via the k1 writemask; no flags are affected.", "pseudocode": "for i in 0 to 7 {\n if k1[i] {\n addr = base_reg + src2_idx[i*64:63] * scale;\n [addr] ← src1[i*64:63];\n }\n}", "example": "VSCATTERDPD [base+zmm_idx*scale], zmm1" }, { "mnemonic": "vscatterqps", "architecture": "x86", "full_name": "Scatter Packed Single Precision (Quadword Indices)", "summary": "Stores floats using 64-bit indices.", "syntax": "VSCATTERQPS [base+zmm_idx*scale] {k1}, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 A3 /vsib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | A3", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "[base+zmm_idx*scale]", "desc": "AVX-512 scatter: base register + scaled ZMM vector index" }, { "name": "src", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Scatters packed single-precision (32-bit) floating-point values from a ZMM register to memory using 64-bit quadword indices with optional scaling. Each element in the source ZMM is written to a memory location computed as [base + index[i]*scale], with write masking controlled by the opmask register k1. This is a non-temporal scatter operation that does not update CPU flags.", "pseudocode": "for i in 0 to 7:\n if k1[i] == 1:\n addr ← base + sign_extend(zmm_idx[i]) * scale\n [addr] ← src.f32[i]", "example": "VSCATTERQPS [base+zmm_idx*scale], zmm1" }, { "mnemonic": "vscatterqpd", "architecture": "x86", "full_name": "Scatter Packed Double Precision (Quadword Indices)", "summary": "Stores doubles using 64-bit indices.", "syntax": "VSCATTERQPD [base+zmm_idx*scale] {k1}, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 A3 /vsib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | A3", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "[base+zmm_idx*scale]", "desc": "AVX-512 scatter: base register + scaled ZMM vector index" }, { "name": "src", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Scatters packed double-precision (64-bit) floating-point values from a ZMM register to memory using 64-bit quadword indices with optional scaling. Each element in the source ZMM is written to a memory location computed as [base + index[i]*scale], with write masking controlled by the opmask register k1. This is a non-temporal scatter operation that does not update CPU flags.", "pseudocode": "for i in 0 to 3:\n if k1[i] == 1:\n addr ← base + sign_extend(zmm_idx[i]) * scale\n [addr] ← src.f64[i]", "example": "VSCATTERQPD [base+zmm_idx*scale], zmm1" }, { "mnemonic": "vfpclassps", "architecture": "x86", "full_name": "Floating-Point Class Single", "summary": "Tests for category (NaN, Inf, Denormal) for floats.", "syntax": "VFPCLASSPS k1 {k2}, zmm2/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 66 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 66", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Tests each single-precision float in the source operand against a class mask (imm8) and sets the corresponding bit in the destination opmask register. The mask specifies FP classes: positive/negative zero, denormal, normal, infinity, and quiet/signaling NaN. The operation is merged or zeroed based on the opmask k2; no arithmetic flags are affected.", "pseudocode": "for i in 0 to 15:\n if k2[i] == 1 or k2_merge_mode == 0:\n class_bits ← classify_fp32(src[i])\n k1[i] ← (imm8 & (1 << class_bits)) != 0\n else:\n k1[i] ← 0", "example": "VFPCLASSPS k1, zmm2/m512, 3" }, { "mnemonic": "vfpclasspd", "architecture": "x86", "full_name": "Floating-Point Class Double", "summary": "Tests for category (NaN, Inf, Denormal) for doubles.", "syntax": "VFPCLASSPD k1 {k2}, zmm2/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 66 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 67", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Tests each double-precision float in the source operand against a class mask (imm8) and sets the corresponding bit in the destination opmask register. The mask specifies FP classes: positive/negative zero, denormal, normal, infinity, and quiet/signaling NaN. The operation is merged or zeroed based on the opmask k2; no arithmetic flags are affected.", "pseudocode": "for i in 0 to 7:\n if k2[i] == 1 or k2_merge_mode == 0:\n class_bits ← classify_fp64(src[i])\n k1[i] ← (imm8 & (1 << class_bits)) != 0\n else:\n k1[i] ← 0", "example": "VFPCLASSPD k1, zmm2/m512, 3" }, { "mnemonic": "vrangeps", "architecture": "x86", "full_name": "Range Restriction Calculation Packed Single", "summary": "Calculates range (min/max/abs) of float values.", "syntax": "VRANGEPS zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 50 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 50", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Computes range restrictions on packed single-precision floats by selecting minimum, maximum, or absolute value operations controlled by an immediate operand. The result is the restricted range of two input operands after applying the imm8-controlled transformation. Results are merged or zeroed to the destination based on the opmask k1; no arithmetic flags are set.", "pseudocode": "for i in 0 to 15:\n if k1[i] == 1 or k1_merge_mode == 0:\n val1 ← src1.f32[i]\n val2 ← src2.f32[i]\n transformed ← apply_range_transform(val1, val2, imm8[2:0])\n dest.f32[i] ← transformed\n else:\n dest.f32[i] ← 0", "example": "VRANGEPS zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vreduceps", "architecture": "x86", "full_name": "Perform Reduction Transformation Packed Single", "summary": "Performs reduction on floats (e.g. range reduction for trig).", "syntax": "VREDUCEPS zmm1 {k1}, zmm2/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 56 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 56", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs reduction transformations (e.g., range reduction for trigonometric functions) on packed single-precision floats. The imm8 operand selects the reduction mode and rounding behavior. The transformed values are written to the destination with masking controlled by opmask k1; no arithmetic flags are affected.", "pseudocode": "for i in 0 to 15:\n if k1[i] == 1 or k1_merge_mode == 0:\n result ← apply_reduction(src.f32[i], imm8[2:0])\n dest.f32[i] ← result_with_rounding(result, imm8[7:4])\n else:\n dest.f32[i] ← 0", "example": "VREDUCEPS zmm1, zmm2/m512, 3" }, { "mnemonic": "vfixupimmps", "architecture": "x86", "full_name": "Fix Up Special Packed Float32 Values", "summary": "Fixes special cases (NaN, Inf) using a table (Float32).", "syntax": "VFIXUPIMMPS zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 54 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 54", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Fixes special floating-point cases (NaN, infinity, denormal) in packed single-precision data using a lookup table indexed by the immediate operand. The first source operand provides the primary value, the second provides a backup value for special cases, and the imm8 configures the fixup behavior. Results are masked by k1; no arithmetic flags are affected.", "pseudocode": "for i in 0 to 15:\n if k1[i] == 1 or k1_merge_mode == 0:\n primary ← src1.f32[i]\n backup ← src2.f32[i]\n fixup_class ← classify_special_fp32(primary)\n if is_special(fixup_class):\n dest.f32[i] ← lookup_fixup_table(backup, fixup_class, imm8)\n else:\n dest.f32[i] ← primary\n else:\n dest.f32[i] ← 0", "example": "VFIXUPIMMPS zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vrsqrt14ps", "architecture": "x86", "full_name": "Compute Approximate Reciprocal Square Root (14-bit)", "summary": "Approximate 1/sqrt(x) with 2^-14 error.", "syntax": "VRSQRT14PS zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 4E /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 4E", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Computes approximate reciprocal square root (1/√x) with 2^-14 relative error for packed single-precision floats. This fast approximation is suitable for iterative refinement or low-precision applications. Results are merged or zeroed to the destination based on opmask k1; no arithmetic flags are affected.", "pseudocode": "for i in 0 to 15:\n if k1[i] == 1 or k1_merge_mode == 0:\n dest.f32[i] ← approx_rsqrt14(src.f32[i])\n else:\n dest.f32[i] ← 0", "example": "VRSQRT14PS zmm1, zmm2/m512" }, { "mnemonic": "vrcp14ps", "architecture": "x86", "full_name": "Compute Approximate Reciprocal (14-bit)", "summary": "Approximate 1/x with 2^-14 error.", "syntax": "VRCP14PS zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 4C /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 4C", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Computes a 14-bit reciprocal approximation (1/x) for each single-precision float in the source operand, writing results to the destination with a maximum relative error of 2^-14. The instruction operates on 512-bit vectors (16 × 32-bit floats) in AVX-512, supports writemask control via k1, and sets no CPU flags. Denormalized inputs produce denormalized outputs; NaN, zero, and infinity operands behave according to IEEE 754 semantics.", "pseudocode": "for i = 0 to 15:\n if k1[i] or no mask:\n zmm1[32*i+31:32*i] ← approximate_reciprocal_14bit(zmm2/m512[32*i+31:32*i])\n else if zeroing:\n zmm1[32*i+31:32*i] ← 0", "example": "VRCP14PS zmm1, zmm2/m512" }, { "mnemonic": "clui", "architecture": "x86", "full_name": "Clear User Interrupt Flag", "summary": "Clears the User Interrupt Flag (UIF).", "syntax": "CLUI", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 01 EE", "visual_parts": [], "binary_pattern": "F3 | 0F | 01 | EE", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "UINTR", "operands": [], "description": "Clears the User Interrupt Flag (UIF) in the UINTR register, preventing delivery of user-level interrupts to the current process. This is a privileged-equivalent instruction that requires the UINTR CPU feature and operates only in user mode; it has no effect on standard CPU flags or other processor state. Execution in a context where UINTR is unavailable causes a #UD exception.", "pseudocode": "UINTR.UIF ← 0", "example": "CLUI" }, { "mnemonic": "stui", "architecture": "x86", "full_name": "Set User Interrupt Flag", "summary": "Sets the User Interrupt Flag (UIF).", "syntax": "STUI", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 01 EF", "visual_parts": [], "binary_pattern": "F3 | 0F | 01 | EF", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "UINTR", "operands": [], "description": "Sets the User Interrupt Flag (UIF) in the UINTR register, enabling delivery of user-level interrupts to the current process. This is a privileged-equivalent instruction that requires the UINTR CPU feature and operates only in user mode; it modifies no standard CPU flags. Execution in a context where UINTR is unavailable causes a #UD exception.", "pseudocode": "UINTR.UIF ← 1", "example": "STUI" }, { "mnemonic": "testui", "architecture": "x86", "full_name": "Test User Interrupt", "summary": "Sets CF if UIF is 1, ZF if User Interrupt Pending.", "syntax": "TESTUI", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 01 ED", "visual_parts": [], "binary_pattern": "F3 | 0F | 01 | ED", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "UINTR", "operands": [], "description": "Tests the User Interrupt Flag (UIF) and User Interrupt Pending (UIP) status, setting CF if UIF is 1 and ZF if a user interrupt is pending. This instruction requires the UINTR CPU feature and operates only in user mode; it does not modify other flags. Execution without UINTR support causes a #UD exception.", "pseudocode": "CF ← UINTR.UIF\nZF ← UINTR.UIP\nOF ← 0\nSF ← 0\nAF ← 0\nPF ← 0", "example": "TESTUI" }, { "mnemonic": "fld", "architecture": "x86", "full_name": "Load Floating Point Value", "summary": "Pushes a floating-point value onto the FPU register stack (ST0).", "syntax": "FLD m32fp/m64fp/m80fp", "encoding": { "format": "Legacy", "hex_opcode": "D9 /0", "length": "2+", "visual_parts": [], "binary_pattern": "D9 | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "src", "desc": "Memory" } ], "extension": "x87 FPU", "description": "Loads a floating-point value (32-bit single, 64-bit double, or 80-bit extended precision) from memory, converts if necessary to 80-bit extended precision, and pushes it onto the x87 FPU register stack (ST(0)). Stack pointer (TOP) is decremented by one; overflow to an invalid slot raises #IS (stack fault). No CPU flags are modified; the instruction may set x87 exception flags (PE, UE, OE, IE) in the x87 status word.", "pseudocode": "ST(0) ← load_and_convert(memory)\nTOP ← TOP - 1\nif TOP underflow: raise x87_stack_fault", "example": "FLD m32fp/m64fp/m80fp" }, { "mnemonic": "fst", "architecture": "x86", "full_name": "Store Floating Point Value", "summary": "Copies the value in ST(0) to memory or another register.", "syntax": "FST m32fp/m64fp", "encoding": { "format": "Legacy", "hex_opcode": "D9 /2", "length": "2+", "visual_parts": [], "binary_pattern": "D9 | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "dest", "desc": "Memory" } ], "extension": "x87 FPU", "description": "Stores the value in ST(0) to memory as either 32-bit single or 64-bit double precision (converting from 80-bit extended if necessary), without popping the stack. The source remains in ST(0); floating-point exceptions (PE, UE, OE) may be raised in the x87 status word if conversion underflows, overflows, or loses precision. No CPU flags are modified.", "pseudocode": "memory ← convert_to_32or64bit(ST(0))\nif conversion_error: raise x87_exception", "example": "FST m32fp/m64fp" }, { "mnemonic": "fstp", "architecture": "x86", "full_name": "Store Floating Point Value and Pop", "summary": "Copies ST(0) to destination and pops the register stack.", "syntax": "FSTP m32fp/m64fp/m80fp", "encoding": { "format": "Legacy", "hex_opcode": "D9 /3", "length": "2+", "visual_parts": [], "binary_pattern": "D9 | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "dest", "desc": "Memory" } ], "extension": "x87 FPU", "description": "Stores the value in ST(0) to memory (as 32-bit single, 64-bit double, or 80-bit extended precision, converting if necessary), then pops the register stack by incrementing TOP. The source register is invalidated after the pop; floating-point exceptions may be raised in the x87 status word during conversion. No CPU flags are modified.", "pseudocode": "memory ← convert_and_store(ST(0))\nTOP ← TOP + 1\nif conversion_error: raise x87_exception", "example": "FSTP m32fp/m64fp/m80fp" }, { "mnemonic": "fild", "architecture": "x86", "full_name": "Load Integer", "summary": "Converts integer in memory to double-extended-precision float and pushes to ST(0).", "syntax": "FILD m16int/m32int/m64int", "encoding": { "format": "Legacy", "hex_opcode": "DF /0", "length": "2+", "visual_parts": [], "binary_pattern": "DF | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "src", "desc": "Integer Memory" } ], "extension": "x87 FPU", "description": "Loads a signed integer (16-bit, 32-bit, or 64-bit) from memory, converts it to 80-bit extended precision floating-point, and pushes onto the x87 register stack (ST(0)). Stack pointer is decremented; conversion is exact and raises no precision or rounding exceptions unless stack overflow occurs. No CPU flags are modified.", "pseudocode": "ST(0) ← convert_integer_to_fp80(memory)\nTOP ← TOP - 1\nif TOP underflow: raise x87_stack_fault", "example": "FILD m16int/m32int/m64int" }, { "mnemonic": "fist", "architecture": "x86", "full_name": "Store Integer", "summary": "Converts ST(0) to integer and stores in memory.", "syntax": "FIST m16int/m32int", "encoding": { "format": "Legacy", "hex_opcode": "DF /2", "length": "2+", "visual_parts": [], "binary_pattern": "DF | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "dest", "desc": "Integer Memory" } ], "extension": "x87 FPU", "description": "Converts the floating-point value in ST(0) to a signed integer using the current rounding mode and stores the result in the specified 16-bit or 32-bit memory location. The x87 FPU status flags (C0, C1, C2, C3) may be set depending on rounding or overflow conditions. The stack top (ST(0)) remains unchanged after the operation.", "pseudocode": "dest ← convert_to_integer(ST(0), rounding_mode);\nupdate_x87_status_flags();", "example": "FIST m16int/m32int" }, { "mnemonic": "fistp", "architecture": "x86", "full_name": "Store Integer and Pop", "summary": "Converts ST(0) to integer, stores in memory, and pops stack.", "syntax": "FISTP m16int/m32int/m64int", "encoding": { "format": "Legacy", "hex_opcode": "DF /3", "length": "2+", "visual_parts": [], "binary_pattern": "DF | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "dest", "desc": "Integer Memory" } ], "extension": "x87 FPU", "description": "Converts the floating-point value in ST(0) to a signed integer using the current rounding mode, stores the result in the specified 16-bit, 32-bit, or 64-bit memory location, and then pops the FPU stack. The x87 status flags may be updated based on rounding or overflow conditions. The stack top pointer is decremented after the operation.", "pseudocode": "dest ← convert_to_integer(ST(0), rounding_mode);\nupdate_x87_status_flags();\nST(0) is popped; stack_top ← stack_top - 1;", "example": "FISTP m16int/m32int/m64int" }, { "mnemonic": "fadd", "architecture": "x86", "full_name": "Add Floating Point", "summary": "Adds src to dest (ST(0) += src).", "syntax": "FADD m32fp/m64fp", "encoding": { "format": "Legacy", "hex_opcode": "D8 /0", "length": "2+", "visual_parts": [], "binary_pattern": "D8 | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "src", "desc": "Memory/Reg" } ], "extension": "x87 FPU", "description": "Adds the floating-point operand in memory (m32fp or m64fp) to ST(0) and stores the result in ST(0). The operation follows IEEE 754 semantics with the current rounding mode. The x87 FPU status flags (C0, C1, C2, C3) are updated based on the result; invalid operation, underflow, overflow, or precision exceptions may be raised.", "pseudocode": "src_value ← load_from_memory(src);\nST(0) ← ST(0) + src_value;\nupdate_x87_status_flags();", "example": "FADD m32fp/m64fp" }, { "mnemonic": "fsub", "architecture": "x86", "full_name": "Subtract Floating Point", "summary": "Subtracts src from dest.", "syntax": "FSUB m32fp/m64fp", "encoding": { "format": "Legacy", "hex_opcode": "D8 /4", "length": "2+", "visual_parts": [], "binary_pattern": "D8 | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "src", "desc": "Memory/Reg" } ], "extension": "x87 FPU", "description": "Subtracts the floating-point operand in memory (m32fp or m64fp) from ST(0) and stores the result in ST(0). The operation follows IEEE 754 semantics with the current rounding mode. The x87 FPU status flags (C0, C1, C2, C3) are updated; invalid operation, underflow, overflow, or precision exceptions may be raised.", "pseudocode": "src_value ← load_from_memory(src);\nST(0) ← ST(0) - src_value;\nupdate_x87_status_flags();", "example": "FSUB m32fp/m64fp" }, { "mnemonic": "fmul", "architecture": "x86", "full_name": "Multiply Floating Point", "summary": "Multiplies dest by src.", "syntax": "FMUL m32fp/m64fp", "encoding": { "format": "Legacy", "hex_opcode": "D8 /1", "length": "2+", "visual_parts": [], "binary_pattern": "D8 | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "src", "desc": "Memory/Reg" } ], "extension": "x87 FPU", "description": "Multiplies ST(0) by the floating-point operand in memory (m32fp or m64fp) and stores the result in ST(0). The operation follows IEEE 754 semantics with the current rounding mode. The x87 FPU status flags (C0, C1, C2, C3) are updated; invalid operation, underflow, overflow, or precision exceptions may be raised.", "pseudocode": "src_value ← load_from_memory(src);\nST(0) ← ST(0) × src_value;\nupdate_x87_status_flags();", "example": "FMUL m32fp/m64fp" }, { "mnemonic": "fdiv", "architecture": "x86", "full_name": "Divide Floating Point", "summary": "Divides dest by src.", "syntax": "FDIV m32fp/m64fp", "encoding": { "format": "Legacy", "hex_opcode": "D8 /6", "length": "2+", "visual_parts": [], "binary_pattern": "D8 | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "src", "desc": "Memory/Reg" } ], "extension": "x87 FPU", "description": "Divides ST(0) by the floating-point operand in memory (m32fp or m64fp) and stores the result in ST(0). The operation follows IEEE 754 semantics with the current rounding mode. The x87 FPU status flags (C0, C1, C2, C3) are updated; division-by-zero, invalid operation, underflow, overflow, or precision exceptions may be raised.", "pseudocode": "src_value ← load_from_memory(src);\nST(0) ← ST(0) ÷ src_value;\nupdate_x87_status_flags();", "example": "FDIV m32fp/m64fp" }, { "mnemonic": "fprem", "architecture": "x86", "full_name": "Partial Remainder", "summary": "Computes remainder of ST(0) / ST(1).", "syntax": "FPREM", "encoding": { "format": "Legacy", "hex_opcode": "D9 F8", "visual_parts": [], "binary_pattern": "D9 | F8", "bit_positions": "+0 | +1" }, "extension": "x87 FPU", "operands": [], "description": "Computes the IEEE partial remainder of ST(0) divided by ST(1), storing the result in ST(0). This instruction performs an iterative reduction and may require multiple iterations to complete; the C2 flag indicates whether the result is incomplete (more iterations needed). The x87 status flags (C0, C1, C2, C3) encode the sign and partial quotient information.", "pseudocode": "quotient ← ST(0) ÷ ST(1);\nremainder ← ST(0) - (rounded_quotient × ST(1));\nST(0) ← remainder;\nC0, C1, C2, C3 ← encode_quotient_and_status(quotient, remainder);", "example": "FPREM" }, { "mnemonic": "fabs", "architecture": "x86", "full_name": "Absolute Value", "summary": "Replaces ST(0) with its absolute value.", "syntax": "FABS", "encoding": { "format": "Legacy", "hex_opcode": "D9 E1", "visual_parts": [], "binary_pattern": "D9 | E1", "bit_positions": "+0 | +1" }, "extension": "x87 FPU", "operands": [], "description": "Replaces the value in ST(0) with its absolute value by clearing the sign bit. The operation does not modify the x87 status flags and does not raise exceptions. This is a fast unary operation that operates solely on the register stack.", "pseudocode": "ST(0) ← |ST(0)|;", "example": "FABS" }, { "mnemonic": "fchs", "architecture": "x86", "full_name": "Change Sign", "summary": "Reverses the sign of ST(0).", "syntax": "FCHS", "encoding": { "format": "Legacy", "hex_opcode": "D9 E0", "visual_parts": [], "binary_pattern": "D9 | E0", "bit_positions": "+0 | +1" }, "extension": "x87 FPU", "operands": [], "description": "Reverses the sign bit of the value in ST(0), converting positive to negative and vice versa. This is a single-bit operation on the sign bit of the extended-precision floating-point format. No flags are affected; the instruction operates entirely within the x87 FPU stack.", "pseudocode": "ST(0) ← -ST(0)", "example": "FCHS" }, { "mnemonic": "fsqrt", "architecture": "x86", "full_name": "Square Root", "summary": "Computes square root of ST(0).", "syntax": "FSQRT", "encoding": { "format": "Legacy", "hex_opcode": "D9 FA", "visual_parts": [], "binary_pattern": "D9 | FA", "bit_positions": "+0 | +1" }, "extension": "x87 FPU", "operands": [], "description": "Computes the square root of ST(0) and replaces ST(0) with the result using extended-precision floating-point arithmetic. The x87 FPU C1 flag may be set based on stack conditions; other x87 status flags (C0, C2, C3) are updated according to the result. This is a transcendental operation with typical latency of 70-100 cycles.", "pseudocode": "ST(0) ← sqrt(ST(0))", "example": "FSQRT" }, { "mnemonic": "fsin", "architecture": "x86", "full_name": "Sine", "summary": "Computes sine of ST(0) (in radians).", "syntax": "FSIN", "encoding": { "format": "Legacy", "hex_opcode": "D9 FE", "visual_parts": [], "binary_pattern": "D9 | FE", "bit_positions": "+0 | +1" }, "extension": "x87 FPU", "operands": [], "description": "Computes the sine of ST(0), where the argument is interpreted as an angle in radians. The result replaces ST(0); the x87 FPU status flags are updated. This transcendental instruction has high latency and may trigger a C2 flag if the argument is outside the acceptable range (roughly ±2^63).", "pseudocode": "ST(0) ← sin(ST(0))", "example": "FSIN" }, { "mnemonic": "fcos", "architecture": "x86", "full_name": "Cosine", "summary": "Computes cosine of ST(0) (in radians).", "syntax": "FCOS", "encoding": { "format": "Legacy", "hex_opcode": "D9 FF", "visual_parts": [], "binary_pattern": "D9 | FF", "bit_positions": "+0 | +1" }, "extension": "x87 FPU", "operands": [], "description": "Computes the cosine of ST(0), where the argument is interpreted as an angle in radians. The result replaces ST(0); the x87 FPU status flags are updated. This transcendental instruction may set the C2 flag if the argument exceeds the acceptable range.", "pseudocode": "ST(0) ← cos(ST(0))", "example": "FCOS" }, { "mnemonic": "fsincos", "architecture": "x86", "full_name": "Sine and Cosine", "summary": "Computes sine and cosine of ST(0), pushing both to stack.", "syntax": "FSINCOS", "encoding": { "format": "Legacy", "hex_opcode": "D9 FB", "visual_parts": [], "binary_pattern": "D9 | FB", "bit_positions": "+0 | +1" }, "extension": "x87 FPU", "operands": [], "description": "Computes both sine and cosine of ST(0) in a single operation, pushing the cosine result onto the stack and leaving the sine in ST(0). The stack pointer is incremented after the push, so the sine ends up in ST(0) and cosine in ST(1). The x87 status flags are updated; C2 may be set if the argument is out of range.", "pseudocode": "temp ← ST(0); ST(0) ← sin(temp); push(cos(temp)); TOS ← TOS + 1", "example": "FSINCOS" }, { "mnemonic": "fptan", "architecture": "x86", "full_name": "Partial Tangent", "summary": "Computes tangent of ST(0) and pushes 1.0.", "syntax": "FPTAN", "encoding": { "format": "Legacy", "hex_opcode": "D9 F2", "visual_parts": [], "binary_pattern": "D9 | F2", "bit_positions": "+0 | +1" }, "extension": "x87 FPU", "operands": [], "description": "Computes the tangent of ST(0) and then pushes 1.0 onto the stack, so ST(0) becomes tan(original ST(0)) and the constant 1.0 moves to ST(1). The x87 status flags are updated; C2 may be set if the argument is out of the acceptable range. This is used in conjuction with FPATAN to compute arctangent.", "pseudocode": "temp ← ST(0); ST(0) ← tan(temp); push(1.0); TOS ← TOS + 1", "example": "FPTAN" }, { "mnemonic": "fpatan", "architecture": "x86", "full_name": "Partial Arctangent", "summary": "Computes arctan(ST(1)/ST(0)).", "syntax": "FPATAN", "encoding": { "format": "Legacy", "hex_opcode": "D9 F3", "visual_parts": [], "binary_pattern": "D9 | F3", "bit_positions": "+0 | +1" }, "extension": "x87 FPU", "operands": [], "description": "Computes the two-argument arctangent of ST(1)/ST(0) and replaces both stack entries with the result in ST(0); the stack pointer is decremented. The result is in the range [-π/2, π/2] or [-π, π] depending on the signs of ST(1) and ST(0). The x87 status flags are updated accordingly.", "pseudocode": "ST(0) ← atan2(ST(1), ST(0)); pop(); TOS ← TOS - 1", "example": "FPATAN" }, { "mnemonic": "fyl2x", "architecture": "x86", "full_name": "Y * log2(X)", "summary": "Computes ST(1) * log2(ST(0)).", "syntax": "FYL2X", "encoding": { "format": "Legacy", "hex_opcode": "D9 F1", "visual_parts": [], "binary_pattern": "D9 | F1", "bit_positions": "+0 | +1" }, "extension": "x87 FPU", "operands": [], "description": "Computes ST(1) * log₂(ST(0)) and replaces both stack entries with the result in ST(0); the stack pointer is decremented. ST(0) must be strictly positive; the result is typically used for computing logarithmic and exponential functions. The x87 status flags are updated; C2 may be set for out-of-range arguments.", "pseudocode": "ST(0) ← ST(1) * log2(ST(0)); pop(); TOS ← TOS - 1", "example": "FYL2X" }, { "mnemonic": "fxch", "architecture": "x86", "full_name": "Exchange Register", "summary": "Exchanges contents of ST(0) and ST(i).", "syntax": "FXCH ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "D9 C8+i", "visual_parts": [], "binary_pattern": "D9", "bit_positions": "+0" }, "extension": "x87 FPU", "operands": [ { "name": "dest", "type": "ST(i)", "desc": "x87 FPU stack register ST(i)" } ], "description": "Exchanges the contents of ST(0) and ST(i), swapping the top of the x87 FPU stack with another stack register. This is a register-only operation with no impact on EFLAGS. The instruction is part of the x87 FPU instruction set and does not cause pipeline serialization.", "pseudocode": "temp ← ST(0);\nST(0) ← ST(i);\nST(i) ← temp;", "example": "FXCH st(1)" }, { "mnemonic": "fcom", "architecture": "x86", "full_name": "Compare Real", "summary": "Compares ST(0) with source.", "syntax": "FCOM m32fp/m64fp", "encoding": { "format": "Legacy", "hex_opcode": "D8 /2", "length": "2+", "visual_parts": [], "binary_pattern": "D8 | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "src", "desc": "Memory/Reg" } ], "extension": "x87 FPU", "description": "Compares ST(0) with a single-precision (m32fp) or double-precision (m64fp) floating-point memory operand and sets the FPU condition code flags (C0, C2, C3) in the status word. The comparison result is reflected only in FPU flags, not in CPU EFLAGS. This instruction does not modify the stack.", "pseudocode": "src_value ← [memory];\nif (ST(0) > src_value) { C0←0; C2←0; C3←0; }\nelse if (ST(0) < src_value) { C0←1; C2←0; C3←0; }\nelse if (ST(0) == src_value) { C0←0; C2←0; C3←1; }\nelse { C0←1; C2←1; C3←1; }", "example": "FCOM m32fp/m64fp" }, { "mnemonic": "fcomi", "architecture": "x86", "full_name": "Compare Real and Set EFLAGS", "summary": "Compares ST(0) with ST(i) and sets CPU EFLAGS directly.", "syntax": "FCOMI ST(0), ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "DB F0+i", "visual_parts": [], "binary_pattern": "DB", "bit_positions": "+0" }, "extension": "x87 FPU (P6+)", "operands": [ { "name": "dest", "type": "ST(0)", "desc": "x87 FPU top-of-stack register ST(0)" }, { "name": "src", "type": "ST(i)", "desc": "x87 FPU stack register ST(i)" } ], "description": "Compares ST(0) with ST(i) and directly sets the CPU EFLAGS (ZF, PF, CF) to reflect the comparison result, enabling use of standard conditional jumps without FSTSW. Available on P6 and later processors. The comparison does not pop the stack and affects CPU flags rather than FPU condition codes.", "pseudocode": "if (ST(0) > ST(i)) { ZF←0; PF←0; CF←0; }\nelse if (ST(0) < ST(i)) { ZF←0; PF←0; CF←1; }\nelse if (ST(0) == ST(i)) { ZF←1; PF←0; CF←0; }\nelse { ZF←1; PF←1; CF←1; }", "example": "FCOMI st(0), st(1)" }, { "mnemonic": "finit", "architecture": "x86", "full_name": "Initialize FPU", "summary": "Resets FPU to default state.", "syntax": "FINIT", "encoding": { "format": "Legacy", "hex_opcode": "9B DB E3", "visual_parts": [], "binary_pattern": "9B | DB | E3", "bit_positions": "+0 | +1 | +2" }, "extension": "x87 FPU", "operands": [], "description": "Initializes the x87 FPU to its default state, clearing the stack, setting control word to 0x037F (round to nearest, all exceptions masked), and clearing all status flags and exception flags. The instruction is preceded by FWAIT (0x9B) to ensure any pending FPU operations complete before reinitializing. This causes full FPU state reset with no impact on integer registers or EFLAGS.", "pseudocode": "FPU_Control_Word ← 0x037F;\nFPU_Status_Word ← 0x0000;\nFPU_Tag_Word ← 0xFFFF;\nfor (i = 0; i < 8; i++) ST(i) ← 0.0;\nFPU_Exception_Flags ← 0;", "example": "FINIT" }, { "mnemonic": "fclex", "architecture": "x86", "full_name": "Clear Exceptions", "summary": "Clears floating-point exception flags.", "syntax": "FCLEX", "encoding": { "format": "Legacy", "hex_opcode": "9B DB E2", "visual_parts": [], "binary_pattern": "9B | DB | E2", "bit_positions": "+0 | +1 | +2" }, "extension": "x87 FPU", "operands": [], "description": "Clears all floating-point exception flags (IE, DE, ZE, OE, UE, PE) in the FPU status word without clearing the condition codes or the stack. The instruction is preceded by FWAIT (0x9B) to synchronize with any pending FPU operations. Does not affect CPU EFLAGS or FPU control/tag words.", "pseudocode": "FPU_Status_Word.IE ← 0;\nFPU_Status_Word.DE ← 0;\nFPU_Status_Word.ZE ← 0;\nFPU_Status_Word.OE ← 0;\nFPU_Status_Word.UE ← 0;\nFPU_Status_Word.PE ← 0;", "example": "FCLEX" }, { "mnemonic": "fstsw", "architecture": "x86", "full_name": "Store Status Word", "summary": "Stores FPU status word to AX or memory.", "syntax": "FSTSW AX", "encoding": { "format": "Legacy", "hex_opcode": "9B DF E0", "length": "3", "visual_parts": [], "binary_pattern": "9B | DF | E0", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "AX/Mem" } ], "extension": "x87 FPU", "description": "Stores the FPU status word (16-bit value containing exception flags, condition codes, stack pointer, and busy bit) into AX or memory. When destination is AX, the instruction may be used to examine FPU state from integer code without memory operands. The encoding shown (9B DF E0) uses FWAIT prefix and stores to AX; memory forms use D9 /7.", "pseudocode": "if (destination == AX) {\n AX ← FPU_Status_Word;\n} else {\n [memory] ← FPU_Status_Word;\n}", "example": "FSTSW AX" }, { "mnemonic": "fldcw", "architecture": "x86", "full_name": "Load Control Word", "summary": "Loads FPU control word from memory.", "syntax": "FLDCW m2byte", "encoding": { "format": "Legacy", "hex_opcode": "D9 /5", "length": "2+", "visual_parts": [], "binary_pattern": "D9 | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "src", "desc": "Memory" } ], "extension": "x87 FPU", "description": "Loads a 16-bit control word from memory into the FPU control word register, affecting rounding mode, exception masks, precision control, and other FPU operating parameters. This instruction does not require FWAIT and takes effect immediately on subsequent FPU instructions. Changes to rounding mode and exception masks apply only to future floating-point operations.", "pseudocode": "FPU_Control_Word ← [memory];", "example": "FLDCW m2byte" }, { "mnemonic": "fstcw", "architecture": "x86", "full_name": "Store Control Word", "summary": "Stores FPU control word to memory.", "syntax": "FSTCW m2byte", "encoding": { "format": "Legacy", "hex_opcode": "9B D9 /7", "length": "3+", "visual_parts": [], "binary_pattern": "9B | D9 | ModRM", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "Memory" } ], "extension": "x87 FPU", "description": "Stores the current FPU control word (16-bit value) to memory, preserving rounding mode, exception mask bits, precision control, and infinity control settings. The instruction is preceded by FWAIT (0x9B) to ensure any pending FPU operations complete before the store. Does not affect CPU EFLAGS or FPU stack contents.", "pseudocode": "[memory] ← FPU_Control_Word;", "example": "FSTCW m2byte" }, { "mnemonic": "frstor", "architecture": "x86", "full_name": "Restore FPU State", "summary": "Loads FPU state from memory.", "syntax": "FRSTOR m108byte", "encoding": { "format": "Legacy", "hex_opcode": "DD /4", "length": "2+", "visual_parts": [], "binary_pattern": "DD | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "src", "desc": "Memory" } ], "extension": "x87 FPU", "description": "Loads the complete x87 FPU state (108 bytes) from memory, including all eight floating-point registers, control word, status word, tag word, instruction pointer, and data pointer. This instruction does not set any CPU flags and is not serializing. It is available in all CPU modes (real, protected, 64-bit) and requires memory operand addressing.", "pseudocode": "FPU_state ← [m108byte]\n// Restores: FPR0-FPR7, CW, SW, TW, IP, DP, DS, opcode", "example": "FRSTOR m108byte" }, { "mnemonic": "fsave", "architecture": "x86", "full_name": "Save FPU State", "summary": "Stores FPU state to memory and re-initializes FPU.", "syntax": "FSAVE m108byte", "encoding": { "format": "Legacy", "hex_opcode": "9B DD /6", "length": "3+", "visual_parts": [], "binary_pattern": "9B | DD | ModRM", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "Memory" } ], "extension": "x87 FPU", "description": "Saves the entire x87 FPU state (108 bytes) to memory and reinitializes the FPU to its default state. The instruction issues an implicit FWAIT (0x9B prefix) to ensure prior floating-point operations complete before saving. No CPU flags are set; the instruction is serializing with respect to x87 operations. Available in all modes.", "pseudocode": "[m108byte] ← FPU_state\n// Saves: FPR0-FPR7, CW, SW, TW, IP, DP, DS, opcode\nFPU_state ← initial_state", "example": "FSAVE m108byte" }, { "mnemonic": "lgdt", "architecture": "x86", "full_name": "Load Global Descriptor Table Register", "summary": "Loads the GDT register (Privileged).", "syntax": "LGDT m16&32", "encoding": { "format": "System", "hex_opcode": "0F 01 /2", "length": "3+", "visual_parts": [], "binary_pattern": "0F | 01 | ModRM", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "src", "desc": "Memory" } ], "extension": "System", "description": "Loads the Global Descriptor Table (GDT) register with a limit (16 bits) and base address (32 bits in 32-bit mode, 64 bits in 64-bit mode) from a 6-byte or 10-byte memory operand. This is a privileged instruction (requires CPL=0) and causes a pipeline flush. No flags are affected. In 64-bit mode, the operand is 10 bytes (16-bit limit + 64-bit base).", "pseudocode": "GDTR.limit ← [m16&32 + 0:1]\nGDTR.base ← [m16&32 + 2:5] // 32-bit or 64-bit depending on mode", "example": "LGDT m16&32" }, { "mnemonic": "lidt", "architecture": "x86", "full_name": "Load Interrupt Descriptor Table Register", "summary": "Loads the IDT register (Privileged).", "syntax": "LIDT m16&32", "encoding": { "format": "System", "hex_opcode": "0F 01 /3", "length": "3+", "visual_parts": [], "binary_pattern": "0F | 01 | ModRM", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "src", "desc": "Memory" } ], "extension": "System", "description": "Loads the Interrupt Descriptor Table (IDT) register with a limit (16 bits) and base address (32 bits in 32-bit mode, 64 bits in 64-bit mode) from a 6-byte or 10-byte memory operand. This is a privileged instruction (requires CPL=0) and causes a pipeline flush. No flags are affected. In 64-bit mode, the operand is 10 bytes (16-bit limit + 64-bit base).", "pseudocode": "IDTR.limit ← [m16&32 + 0:1]\nIDTR.base ← [m16&32 + 2:5] // 32-bit or 64-bit depending on mode", "example": "LIDT m16&32" }, { "mnemonic": "sgdt", "architecture": "x86", "full_name": "Store Global Descriptor Table Register", "summary": "Stores GDT limit and base address to memory.", "syntax": "SGDT m", "encoding": { "format": "System", "hex_opcode": "0F 01 /0", "visual_parts": [], "binary_pattern": "0F | 01 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "System", "operands": [ { "name": "dest", "type": "m", "desc": "Memory operand" } ], "description": "Stores the current Global Descriptor Table (GDT) register contents (limit and base address) to memory. The format is 2-byte limit followed by 4-byte base in 32-bit mode, or 2-byte limit followed by 8-byte base in 64-bit mode. No flags are affected. This instruction is not privileged and can be executed at any CPL.", "pseudocode": "[m + 0:1] ← GDTR.limit\n[m + 2:5] ← GDTR.base // 4 or 8 bytes depending on mode", "example": "SGDT [rbp-8]" }, { "mnemonic": "sidt", "architecture": "x86", "full_name": "Store Interrupt Descriptor Table Register", "summary": "Stores IDT limit and base address to memory.", "syntax": "SIDT m", "encoding": { "format": "System", "hex_opcode": "0F 01 /1", "visual_parts": [], "binary_pattern": "0F | 01 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "System", "operands": [ { "name": "dest", "type": "m", "desc": "Memory operand" } ], "description": "Stores the current Interrupt Descriptor Table (IDT) register contents (limit and base address) to memory. The format is 2-byte limit followed by 4-byte base in 32-bit mode, or 2-byte limit followed by 8-byte base in 64-bit mode. No flags are affected. This instruction is not privileged and can be executed at any CPL.", "pseudocode": "[m + 0:1] ← IDTR.limit\n[m + 2:5] ← IDTR.base // 4 or 8 bytes depending on mode", "example": "SIDT [rbp-8]" }, { "mnemonic": "lldt", "architecture": "x86", "full_name": "Load Local Descriptor Table Register", "summary": "Loads LDT segment selector (Privileged).", "syntax": "LLDT r/m16", "encoding": { "format": "System", "hex_opcode": "0F 00 /2", "visual_parts": [], "binary_pattern": "0F | 00 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "System", "operands": [ { "name": "dest", "type": "r/m16", "desc": "16-bit register or memory" } ], "description": "Loads the Local Descriptor Table (LDT) register with a 16-bit segment selector from a register or memory. This is a privileged instruction (requires CPL=0) and causes a pipeline flush. The selector must reference a valid LDT descriptor in the GDT; an invalid selector clears the LDT register. No flags are affected.", "pseudocode": "LDTR ← r/m16\n// Selector is validated; if invalid, LDTR is cleared", "example": "LLDT bx" }, { "mnemonic": "sldt", "architecture": "x86", "full_name": "Store Local Descriptor Table Register", "summary": "Stores LDT segment selector.", "syntax": "SLDT r/m16", "encoding": { "format": "System", "hex_opcode": "0F 00 /0", "visual_parts": [], "binary_pattern": "0F | 00 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "System", "operands": [ { "name": "dest", "type": "r/m16", "desc": "16-bit register or memory" } ], "description": "Stores the current Local Descriptor Table (LDT) register contents (16-bit segment selector) into a register or memory. If the destination is a 32-bit or 64-bit register, the selector is zero-extended. No flags are affected. This instruction is not privileged and can be executed at any CPL.", "pseudocode": "r/m16 ← LDTR // For 32/64-bit dest: zero-extended", "example": "SLDT bx" }, { "mnemonic": "ltr", "architecture": "x86", "full_name": "Load Task Register", "summary": "Loads Task Register (Privileged).", "syntax": "LTR r/m16", "encoding": { "format": "System", "hex_opcode": "0F 00 /3", "visual_parts": [], "binary_pattern": "0F | 00 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "System", "operands": [ { "name": "dest", "type": "r/m16", "desc": "16-bit register or memory" } ], "description": "Loads a 16-bit Task Register selector from a register or memory operand. This privileged instruction (CPL=0 only) loads the TR register with a task gate descriptor selector, initiating task switching if the selector points to a valid TSS descriptor. No flags are affected.", "pseudocode": "TR ← source[15:0]; (task switch occurs if source is valid TSS selector)", "example": "LTR bx" }, { "mnemonic": "str", "architecture": "x86", "full_name": "Store Task Register", "summary": "Stores Task Register.", "syntax": "STR r/m16", "encoding": { "format": "System", "hex_opcode": "0F 00 /1", "visual_parts": [], "binary_pattern": "0F | 00 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "System", "operands": [ { "name": "dest", "type": "r/m16", "desc": "16-bit register or memory" } ], "description": "Stores the current Task Register selector into a 16-bit register or memory operand. This non-privileged instruction reads the TR register and writes its selector value; it operates in all modes and does not affect any flags.", "pseudocode": "dest ← TR[15:0]", "example": "STR bx" }, { "mnemonic": "mov cr", "architecture": "x86", "full_name": "Move Control Register", "summary": "Moves data to/from Control Registers (CR0, CR3, etc.) (Privileged).", "syntax": "MOV CRn, r", "encoding": { "format": "System", "hex_opcode": "0F 22 /r", "length": "3", "visual_parts": [], "binary_pattern": "0F | 22 | ModRM", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "CRn" }, { "name": "src", "desc": "Reg" } ], "extension": "System", "description": "Moves a 32-bit or 64-bit value from a general-purpose register to a control register (CR0, CR2, CR3, CR4, CR8 in 64-bit mode). This privileged instruction (CPL=0 only) performs hardware state modification with potential serialization effects; certain CR writes invalidate TLBs or flush caches. No arithmetic flags are affected.", "pseudocode": "CRn ← r (where n ∈ {0,2,3,4,8}); TLB and cache invalidation may occur", "example": "MOV CRn, rax" }, { "mnemonic": "mov dr", "architecture": "x86", "full_name": "Move Debug Register", "summary": "Moves data to/from Debug Registers (DR0-DR7) (Privileged).", "syntax": "MOV DRn, r", "encoding": { "format": "System", "hex_opcode": "0F 23 /r", "length": "3", "visual_parts": [], "binary_pattern": "0F | 23 | ModRM", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "DRn" }, { "name": "src", "desc": "Reg" } ], "extension": "System", "description": "Moves a 32-bit or 64-bit value from a general-purpose register to a debug register (DR0-DR7). This privileged instruction (CPL=0 only) performs hardware debug state modification; writes to DR6 and DR7 may clear breakpoint conditions and alter breakpoint control. No arithmetic flags are affected.", "pseudocode": "DRn ← r (where n ∈ {0,1,2,3,6,7}); breakpoint state may change", "example": "MOV DRn, rax" }, { "mnemonic": "lmsw", "architecture": "x86", "full_name": "Load Machine Status Word", "summary": "Loads Machine Status Word (Legacy CR0 modification).", "syntax": "LMSW r/m16", "encoding": { "format": "System", "hex_opcode": "0F 01 /6", "visual_parts": [], "binary_pattern": "0F | 01 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "System", "operands": [ { "name": "dest", "type": "r/m16", "desc": "16-bit register or memory" } ], "description": "Loads the lower 4 bits of a 16-bit operand into the lower 4 bits of CR0 (the machine status word: PE, MP, EM, TS). This privileged instruction (CPL=0 only) affects processor mode and FPU handling; it can enable protected mode but cannot disable it or modify higher CR0 bits. No flags are affected.", "pseudocode": "CR0[3:0] ← source[3:0]; (legacy CR0 access, cannot clear PE or modify bits 31:4)", "example": "LMSW bx" }, { "mnemonic": "smsw", "architecture": "x86", "full_name": "Store Machine Status Word", "summary": "Stores Machine Status Word.", "syntax": "SMSW r/m16", "encoding": { "format": "System", "hex_opcode": "0F 01 /4", "visual_parts": [], "binary_pattern": "0F | 01 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "System", "operands": [ { "name": "dest", "type": "r/m16", "desc": "16-bit register or memory" } ], "description": "Stores the lower 16 bits of CR0 (the machine status word: PE, MP, EM, TS, and reserved bits) into a 16-bit register or memory operand. This non-privileged instruction reads CR0[15:0]; in 64-bit mode, a 32-bit destination is zero-extended to 64 bits. No flags are affected.", "pseudocode": "dest ← CR0[15:0]; (in 64-bit with r64 operand: dest ← CR0[15:0] zero-extended to 64 bits)", "example": "SMSW bx" }, { "mnemonic": "clts", "architecture": "x86", "full_name": "Clear Task-Switched Flag", "summary": "Clears the TS flag in CR0 (Privileged).", "syntax": "CLTS", "encoding": { "format": "System", "hex_opcode": "0F 06", "visual_parts": [], "binary_pattern": "0F | 06", "bit_positions": "+0 | +1" }, "extension": "System", "operands": [], "description": "Clears the Task-Switched flag (TS, bit 3) in CR0. This privileged instruction (CPL=0 only) allows the processor to use the FPU without raising a #NM exception; it is typically executed after an FPU context save. No flags are affected.", "pseudocode": "CR0[3] ← 0", "example": "CLTS" }, { "mnemonic": "invd", "architecture": "x86", "full_name": "Invalidate Internal Caches", "summary": "Flushes internal caches without writing back data (Privileged).", "syntax": "INVD", "encoding": { "format": "System", "hex_opcode": "0F 08", "visual_parts": [], "binary_pattern": "0F | 08", "bit_positions": "+0 | +1" }, "extension": "System", "operands": [], "description": "Invalidates all internal cache lines without writing back modified data to memory. This privileged instruction (CPL=0 only) causes a complete pipeline flush and memory ordering barrier; dirty cache lines are discarded, potentially losing uncommitted writes, making it dangerous for general use. No flags are affected.", "pseudocode": "invalidate_all_cache_lines(); flush_pipeline(); memory_barrier()", "example": "INVD" }, { "mnemonic": "wbinvd", "architecture": "x86", "full_name": "Write Back and Invalidate Cache", "summary": "Writes back modified data and invalidates caches (Privileged).", "syntax": "WBINVD", "encoding": { "format": "System", "hex_opcode": "0F 09", "visual_parts": [], "binary_pattern": "0F | 09", "bit_positions": "+0 | +1" }, "extension": "System", "operands": [], "description": "Writes back all modified cache lines to memory and invalidates all internal caches, ensuring cache coherency across the system. This is a privileged instruction (CPL 0 only) that serializes the pipeline and may take hundreds of cycles. No flags are affected.", "pseudocode": "for each cache line in all caches:\n if (cache_line.modified) write_to_memory(cache_line);\n invalidate(cache_line);\nPipeline_Serialization();", "example": "WBINVD" }, { "mnemonic": "invlpg", "architecture": "x86", "full_name": "Invalidate TLB Entry", "summary": "Invalidates a specific TLB entry (Privileged).", "syntax": "INVLPG m", "encoding": { "format": "System", "hex_opcode": "0F 01/7", "visual_parts": [], "binary_pattern": "0F | 01 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "System", "operands": [ { "name": "dest", "type": "m", "desc": "Memory operand" } ], "description": "Invalidates the TLB entry for the linear address specified by the memory operand, forcing a TLB reload on next access. This is a privileged instruction (CPL 0 only) used after page table modifications. No flags are affected; pipeline serialization may occur depending on implementation.", "pseudocode": "linear_address ← address_of(m);\nTLB[linear_address].valid ← 0;", "example": "INVLPG [rbp-8]" }, { "mnemonic": "rdmsr", "architecture": "x86", "full_name": "Read Model Specific Register", "summary": "Reads MSR specified by ECX into EDX:EAX (Privileged).", "syntax": "RDMSR", "encoding": { "format": "System", "hex_opcode": "0F 32", "visual_parts": [], "binary_pattern": "0F | 32", "bit_positions": "+0 | +1" }, "extension": "System", "operands": [], "description": "Reads a 64-bit Model Specific Register (MSR) whose index is in ECX and stores the result in EDX:EAX (EDX holds bits 63-32, EAX holds bits 31-0). This is a privileged instruction (CPL 0 only) that may cause a general protection fault if ECX selects an invalid or inaccessible MSR. No EFLAGS are modified.", "pseudocode": "msr_index ← ECX;\nmsr_value ← MSR[msr_index];\nEAX ← msr_value[31:0];\nEDX ← msr_value[63:32];", "example": "RDMSR" }, { "mnemonic": "wrmsr", "architecture": "x86", "full_name": "Write Model Specific Register", "summary": "Writes EDX:EAX to MSR specified by ECX (Privileged).", "syntax": "WRMSR", "encoding": { "format": "System", "hex_opcode": "0F 30", "visual_parts": [], "binary_pattern": "0F | 30", "bit_positions": "+0 | +1" }, "extension": "System", "operands": [], "description": "Writes a 64-bit value from EDX:EAX to the Model Specific Register (MSR) whose index is in ECX (EDX holds bits 63-32, EAX holds bits 31-0). This is a privileged instruction (CPL 0 only) that serializes execution and may cause a general protection fault if ECX selects an invalid or write-protected MSR. No EFLAGS are modified.", "pseudocode": "msr_index ← ECX;\nmsr_value ← (EDX << 32) | EAX;\nMSR[msr_index] ← msr_value;\nPipeline_Serialization();", "example": "WRMSR" }, { "mnemonic": "rdpmc", "architecture": "x86", "full_name": "Read Performance-Monitoring Counters", "summary": "Reads performance counter specified by ECX into EDX:EAX.", "syntax": "RDPMC", "encoding": { "format": "System", "hex_opcode": "0F 33", "visual_parts": [], "binary_pattern": "0F | 33", "bit_positions": "+0 | +1" }, "extension": "System", "operands": [], "description": "Reads a 40-bit performance monitoring counter whose index is in ECX and stores the result in EDX:EAX (EDX holds bits 39-32, EAX holds bits 31-0). User-mode execution may be permitted depending on RDPMC flag in CR4; a general protection fault occurs if not allowed. No EFLAGS are modified.", "pseudocode": "counter_index ← ECX;\ncounter_value ← PMC[counter_index];\nEAX ← counter_value[31:0];\nEDX ← counter_value[39:32] & 0xFF;", "example": "RDPMC" }, { "mnemonic": "sysenter", "architecture": "x86", "full_name": "Fast System Call", "summary": "Fast call to level 0 system procedures.", "syntax": "SYSENTER", "encoding": { "format": "System", "hex_opcode": "0F 34", "visual_parts": [], "binary_pattern": "0F | 34", "bit_positions": "+0 | +1" }, "extension": "System", "operands": [], "description": "Fast transition from user mode (CPL 3) to kernel mode (CPL 0) by loading CS, SS, EIP, and ESP from IA32_SYSENTER_* MSRs. This instruction serializes the pipeline, disables interrupts, and clears EFLAGS.IF. It is the fast-path alternative to INT for system calls.", "pseudocode": "if (CPL != 3) raise_exception(INVALID_OPCODE);\nCS ← IA32_SYSENTER_CS & ~3; // load kernel code segment\nSS ← (IA32_SYSENTER_CS + 8) | 0; // load kernel stack segment\nEIP ← IA32_SYSENTER_EIP;\nESP ← IA32_SYSENTER_ESP;\nEFLAGS.IF ← 0;\nPipeline_Serialization();", "example": "SYSENTER" }, { "mnemonic": "sysexit", "architecture": "x86", "full_name": "Fast Return from System Call", "summary": "Fast return to level 3 user code.", "syntax": "SYSEXIT", "encoding": { "format": "System", "hex_opcode": "0F 35", "visual_parts": [], "binary_pattern": "0F | 35", "bit_positions": "+0 | +1" }, "extension": "System", "operands": [], "description": "Fast return from kernel mode (CPL 0) to user mode (CPL 3) by restoring CS, SS, EIP, and ESP from implicit registers or operands. This instruction serializes the pipeline and re-enables interrupts. It complements SYSENTER for rapid system call returns.", "pseudocode": "if (CPL != 0) raise_exception(INVALID_OPCODE);\nCS ← (IA32_SYSENTER_CS + 16) | 3; // load user code segment\nSS ← (IA32_SYSENTER_CS + 24) | 3; // load user stack segment\nEIP ← ECX;\nESP ← EDX;\nEFLAGS.IF ← 1;\nPipeline_Serialization();", "example": "SYSEXIT" }, { "mnemonic": "lar", "architecture": "x86", "full_name": "Load Access Rights Byte", "summary": "Reads access rights from segment descriptor.", "syntax": "LAR r, r/m16", "encoding": { "format": "System", "hex_opcode": "0F 02", "visual_parts": [], "binary_pattern": "0F | 02", "bit_positions": "+0 | +1" }, "extension": "System", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m16", "desc": "16-bit register or memory" } ], "description": "Loads the access rights byte from the segment descriptor referenced by the 16-bit selector in r/m16 into the destination general-purpose register (zero-extended to 32 or 64 bits). The ZF flag is cleared if the selector is invalid or references a data segment; ZF is set if successful. No other flags are modified.", "pseudocode": "selector ← r/m16;\nif (selector is invalid || descriptor_type(selector) != code_segment) {\n ZF ← 0;\n} else {\n dest ← zero_extend(descriptor_access_rights_byte(selector));\n ZF ← 1;\n}", "example": "LAR rax, bx" }, { "mnemonic": "lsl", "architecture": "x86", "full_name": "Load Segment Limit", "summary": "Reads segment limit from descriptor.", "syntax": "LSL r, r/m16", "encoding": { "format": "System", "hex_opcode": "0F 03", "visual_parts": [], "binary_pattern": "0F | 03", "bit_positions": "+0 | +1" }, "extension": "System", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m16", "desc": "16-bit register or memory" } ], "description": "Loads the segment limit from the descriptor table entry referenced by the source selector into the destination register. The instruction reads the descriptor from the GDT or LDT, extracts the limit field, and writes it to the destination. The ZF flag is cleared if the selector is valid and the descriptor is accessible; ZF is set if the selector is invalid or the descriptor type is unsuitable. This instruction is privileged and operates only in protected mode or 64-bit mode.", "pseudocode": "selector ← src[15:0];\ndescriptor ← load_descriptor(selector);\nif (descriptor is valid AND descriptor.type in {code, data, tss, gate}) {\n dest ← descriptor.limit;\n ZF ← 0;\n} else {\n ZF ← 1;\n}", "example": "LSL rax, bx" }, { "mnemonic": "verr", "architecture": "x86", "full_name": "Verify Segment for Reading", "summary": "Checks if segment can be read; sets ZF.", "syntax": "VERR r/m16", "encoding": { "format": "System", "hex_opcode": "0F 00 /4", "visual_parts": [], "binary_pattern": "0F | 00 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "System", "operands": [ { "name": "dest", "type": "r/m16", "desc": "16-bit register or memory" } ], "description": "Verifies that the segment referenced by the selector can be read by the current code. The instruction loads the descriptor table entry and checks the segment type and privilege level. ZF is set to 1 if the selector is valid and readable at the current privilege level; ZF is cleared if the selector is invalid, the descriptor type is unsuitable, or privilege checks fail. This instruction is privileged and operates only in protected or 64-bit mode.", "pseudocode": "selector ← src[15:0];\ndescriptor ← load_descriptor(selector);\nif (descriptor is valid AND descriptor.type in {data, code-readable} AND cpl_check_passes) {\n ZF ← 1;\n} else {\n ZF ← 0;\n}", "example": "VERR bx" }, { "mnemonic": "verw", "architecture": "x86", "full_name": "Verify Segment for Writing", "summary": "Checks if segment can be written; sets ZF.", "syntax": "VERW r/m16", "encoding": { "format": "System", "hex_opcode": "0F 00 /5", "visual_parts": [], "binary_pattern": "0F | 00 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "System", "operands": [ { "name": "dest", "type": "r/m16", "desc": "16-bit register or memory" } ], "description": "Verifies that the segment referenced by the selector can be written by the current code. The instruction loads the descriptor table entry and checks the segment type and privilege level. ZF is set to 1 if the selector is valid and writable at the current privilege level; ZF is cleared if the selector is invalid, the descriptor type is unsuitable (e.g., code segment or read-only data), or privilege checks fail. This instruction is privileged and operates only in protected or 64-bit mode.", "pseudocode": "selector ← src[15:0];\ndescriptor ← load_descriptor(selector);\nif (descriptor is valid AND descriptor.type in {data-writable} AND cpl_check_passes) {\n ZF ← 1;\n} else {\n ZF ← 0;\n}", "example": "VERW bx" }, { "mnemonic": "arpl", "architecture": "x86", "full_name": "Adjust Requested Privilege Level", "summary": "Adjusts RPL of selector to match current CPL (Legacy).", "syntax": "ARPL r/m16, r16", "encoding": { "format": "System", "hex_opcode": "63", "visual_parts": [], "binary_pattern": "63", "bit_positions": "+0" }, "extension": "System (32-bit)", "operands": [ { "name": "dest", "type": "r/m16", "desc": "16-bit register or memory" }, { "name": "src", "type": "r16", "desc": "16-bit general-purpose register" } ], "description": "Adjusts the Requested Privilege Level (RPL) field of a selector to match the current Code Privilege Level (CPL) if the selector's current RPL is less privileged than CPL. If the adjustment occurs, ZF is set; otherwise ZF is cleared. This is a legacy instruction used in 32-bit protected mode to enforce privilege level consistency; it is not supported in 64-bit mode. All flags except ZF are unchanged.", "pseudocode": "selector ← dest[15:0];\nrpl ← selector[1:0];\ncpl ← current_cpl;\nif (rpl < cpl) {\n selector[1:0] ← cpl;\n dest ← selector;\n ZF ← 1;\n} else {\n ZF ← 0;\n}", "example": "ARPL bx, ax" }, { "mnemonic": "rsm", "architecture": "x86", "full_name": "Resume from System Management Mode", "summary": "Exits SMM and returns to previous state (Privileged).", "syntax": "RSM", "encoding": { "format": "System", "hex_opcode": "0F AA", "visual_parts": [], "binary_pattern": "0F | AA", "bit_positions": "+0 | +1" }, "extension": "System (SMM)", "operands": [], "description": "Resumes normal CPU operation from System Management Mode (SMM), restoring processor state from the SMM state save area and resuming execution at the return instruction pointer saved at SMM entry. This instruction is privileged and can only be executed inside SMM. The CPU context (all registers, segment descriptors, and memory-type ranges) is restored atomically, and control flow returns to the interrupted code or handler.", "pseudocode": "restore_cpu_state_from_smm_save_area();\nreturn_eip ← SMM_SAVE_AREA[return_address_offset];\njump(return_eip);", "example": "RSM" }, { "mnemonic": "bswap", "architecture": "x86", "full_name": "Byte Swap", "summary": "Reverses the byte order of a 32/64-bit register.", "syntax": "BSWAP r", "encoding": { "format": "Legacy", "hex_opcode": "0F C8", "visual_parts": [], "binary_pattern": "0F | C8", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" } ], "description": "Reverses the byte order within a 32-bit or 64-bit general-purpose register. In 32-bit mode, bits [7:0] swap with [31:24] and bits [15:8] swap with [23:16]. In 64-bit mode, all 8 bytes are reversed. No flags are modified. For 16-bit operands, the instruction is undefined on modern processors.", "pseudocode": "if (operand_size == 32) {\n dest ← {dest[7:0], dest[15:8], dest[23:16], dest[31:24]};\n} else if (operand_size == 64) {\n dest ← {dest[7:0], dest[15:8], dest[23:16], dest[31:24], dest[39:32], dest[47:40], dest[55:48], dest[63:56]};\n}", "example": "BSWAP rax" }, { "mnemonic": "cmpxchg8b", "architecture": "x86", "full_name": "Compare and Exchange 8 Bytes", "summary": "Atomically compares EDX:EAX with memory; swaps if equal.", "syntax": "CMPXCHG8B m64", "encoding": { "format": "Legacy", "hex_opcode": "0F C7 /1", "visual_parts": [], "binary_pattern": "0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "Base", "operands": [ { "name": "dest", "type": "m64", "desc": "64-bit memory operand (quadword)" } ], "description": "Atomically compares the 64-bit value in EDX:EAX with the 64-bit memory operand; if equal, the instruction exchanges the value in ECX:EBX with memory and clears ZF, otherwise it loads memory into EDX:EAX and sets ZF. The operation is atomic at the memory bus level on single-processor systems and uses locked semantics on multiprocessor systems. All arithmetic flags (OF, SF, ZF, AF, CF, PF) are updated based on the compare result; other flags are undefined.", "pseudocode": "value_memory ← [dest];\nif (EDX:EAX == value_memory) {\n [dest] ← ECX:EBX;\n ZF ← 1;\n} else {\n EDX:EAX ← value_memory;\n ZF ← 0;\n}\nOF, SF, AF, CF, PF undefined;", "example": "CMPXCHG8B [rbp-8]" }, { "mnemonic": "addsubps", "architecture": "x86", "full_name": "Packed Single-FP Add/Subtract", "summary": "Adds odd elements, subtracts even elements (Complex Math).", "syntax": "ADDSUBPS xmm1, xmm2/m128", "encoding": { "format": "SSE3", "hex_opcode": "F2 0F D0", "visual_parts": [], "binary_pattern": "F2 | 0F | D0", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs packed single-precision floating-point addition on odd-indexed elements (1, 3) and subtraction on even-indexed elements (0, 2) within 128-bit XMM operands. The first operand is destination and implicitly source; the second operand is source from register or memory. Exceptions are not masked and follow standard SIMD exception handling. No flags are modified; denormalized inputs may generate exceptions depending on MXCSR settings.", "pseudocode": "dest[31:0] ← dest[31:0] - src[31:0];\ndest[63:32] ← dest[63:32] + src[63:32];\ndest[95:64] ← dest[95:64] - src[95:64];\ndest[127:96] ← dest[127:96] + src[127:96];", "example": "ADDSUBPS xmm1, xmm2/m128" }, { "mnemonic": "haddps", "architecture": "x86", "full_name": "Horizontal Add Packed Single-Precision", "summary": "Adds adjacent float elements horizontally.", "syntax": "HADDPS xmm1, xmm2/m128", "encoding": { "format": "SSE3", "hex_opcode": "F2 0F 7C", "visual_parts": [], "binary_pattern": "F2 | 0F | 7C", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Adds adjacent pairs of single-precision floating-point values horizontally within 128-bit XMM registers. The instruction pairs elements from the destination and source operands, computing the sum of adjacent elements and storing results in the destination. No CPU flags are affected by this instruction.", "pseudocode": "dest[0:31] ← dest[0:31] + dest[32:63]\ndest[32:63] ← src[0:31] + src[32:63]\ndest[64:95] ← dest[64:95] + dest[96:127]\ndest[96:127] ← src[64:65] + src[96:127]", "example": "HADDPS xmm1, xmm2/m128" }, { "mnemonic": "movddup", "architecture": "x86", "full_name": "Move One Double-FP and Duplicate", "summary": "Loads 64-bit double and duplicates it to fill 128-bit register.", "syntax": "MOVDDUP xmm1, xmm2/m64", "encoding": { "format": "SSE3", "hex_opcode": "F2 0F 12", "visual_parts": [], "binary_pattern": "F2 | 0F | 12", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Loads a 64-bit double-precision floating-point value from the source operand and duplicates it to fill the entire 128-bit XMM register destination. The lower 64 bits of the source are replicated to both the lower and upper 64 bits of the destination. No CPU flags are affected by this instruction.", "pseudocode": "temp64 ← src[0:63]\ndest[0:63] ← temp64\ndest[64:127] ← temp64", "example": "MOVDDUP xmm1, xmm2/m64" }, { "mnemonic": "lddqu", "architecture": "x86", "full_name": "Load Unaligned Integer 128-bit", "summary": "Loads unaligned data avoiding split-line penalties.", "syntax": "LDDQU xmm1, m128", "encoding": { "format": "SSE3", "hex_opcode": "F2 0F F0", "visual_parts": [], "binary_pattern": "F2 | 0F | F0", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Loads 128 bits of unaligned integer data from memory into an XMM register without causing split-cache-line penalties on processors that support this instruction. This instruction provides better performance than MOVDQU for certain memory alignments. No CPU flags are affected by this instruction.", "pseudocode": "dest[0:127] ← mem[addr:addr+15]", "example": "LDDQU xmm1, [rbp-16]" }, { "mnemonic": "pshufb", "architecture": "x86", "full_name": "Packed Shuffle Bytes", "summary": "Shuffles bytes according to indices in source operand.", "syntax": "PSHUFB xmm1, xmm2/m128", "encoding": { "format": "SSSE3", "hex_opcode": "66 0F 38 00", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 00", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Shuffles bytes within 128-bit operands using a shuffle control mask in the source operand. For each byte in the destination, the corresponding control byte in the source specifies which byte from the destination is placed in that position; if bit 7 of the control byte is set, the result byte is zeroed. No CPU flags are affected by this instruction.", "pseudocode": "for i ← 0 to 15 do\n if src[i*8+7] == 1 then\n dest[i*8:i*8+7] ← 0\n else\n j ← src[i*8:i*8+3]\n dest[i*8:i*8+7] ← dest[j*8:j*8+7]\n end if\nend for", "example": "PSHUFB xmm1, xmm2/m128" }, { "mnemonic": "phaddw", "architecture": "x86", "full_name": "Packed Horizontal Add Word", "summary": "Adds adjacent 16-bit integers horizontally.", "syntax": "PHADDW xmm1, xmm2/m128", "encoding": { "format": "SSSE3", "hex_opcode": "66 0F 38 01", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 01", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Adds adjacent pairs of signed 16-bit integer values horizontally within 128-bit XMM registers. Two pairs are summed from the destination operand and two pairs from the source operand, with results placed in the lower and upper halves of the destination. No CPU flags are affected by this instruction.", "pseudocode": "dest[0:15] ← dest[0:15] + dest[16:31]\ndest[16:31] ← dest[32:47] + dest[48:63]\ndest[32:47] ← src[0:15] + src[16:31]\ndest[48:63] ← src[32:47] + src[48:63]\ndest[64:79] ← dest[64:79] + dest[80:95]\ndest[80:95] ← dest[96:111] + dest[112:127]\ndest[96:111] ← src[64:79] + src[80:95]\ndest[112:127] ← src[96:111] + src[112:127]", "example": "PHADDW xmm1, xmm2/m128" }, { "mnemonic": "palignr", "architecture": "x86", "full_name": "Packed Align Right", "summary": "Concatenates dest and src, extracts 128 bits byte-aligned.", "syntax": "PALIGNR xmm1, xmm2/m128, imm8", "encoding": { "format": "SSSE3", "hex_opcode": "66 0F 3A 0F", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 0F", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Concatenates the 128-bit destination and 128-bit source operands into a 256-bit intermediate value, then extracts a 128-bit aligned region starting at a byte offset specified by an 8-bit immediate value. The result is stored in the destination operand. No CPU flags are affected by this instruction.", "pseudocode": "concat[0:255] ← (src[0:127] << 128) | dest[0:127]\nshift_amount ← imm8 * 8\nif shift_amount >= 128 then\n result ← 0\nelse\n result ← concat[shift_amount:shift_amount+127]\nend if\ndest[0:127] ← result", "example": "PALIGNR xmm1, xmm2/m128, 3" }, { "mnemonic": "pmulhrsw", "architecture": "x86", "full_name": "Packed Multiply High with Round and Scale", "summary": "Multiplies signed 16-bit words, rounds, and scales.", "syntax": "PMULHRSW xmm1, xmm2/m128", "encoding": { "format": "SSSE3", "hex_opcode": "66 0F 38 0B", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 0B", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Multiplies signed 16-bit integers from destination and source operands, returning the scaled and rounded high 16 bits of the 32-bit product (result = (product + 0x4000) >> 15). Saturation occurs if the result exceeds the signed 16-bit range. No CPU flags are affected by this instruction.", "pseudocode": "for i ← 0 to 7 do\n product[i] ← dest[i*16:i*16+15] * src[i*16:i*16+15]\n intermediate[i] ← product[i] + 0x4000\n result[i] ← intermediate[i] >> 15\n if result[i] > 32767 then\n dest[i*16:i*16+15] ← 32767\n else if result[i] < -32768 then\n dest[i*16:i*16+15] ← -32768\n else\n dest[i*16:i*16+15] ← result[i]\n end if\nend for", "example": "PMULHRSW xmm1, xmm2/m128" }, { "mnemonic": "psignb", "architecture": "x86", "full_name": "Packed Sign Byte", "summary": "Negates/Zeroes bytes in dest based on sign of src.", "syntax": "PSIGNB xmm1, xmm2/m128", "encoding": { "format": "SSSE3", "hex_opcode": "66 0F 38 08", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 08", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Negates or zeros bytes in the destination operand based on the sign of corresponding bytes in the source operand. If the source byte is negative, the destination byte is negated; if zero, the destination byte is zeroed; if positive, the destination byte is unchanged. No CPU flags are affected by this instruction.", "pseudocode": "for i ← 0 to 15 do\n if src[i*8:i*8+7] < 0 then\n dest[i*8:i*8+7] ← -dest[i*8:i*8+7]\n else if src[i*8:i*8+7] == 0 then\n dest[i*8:i*8+7] ← 0\n else\n dest[i*8:i*8+7] ← dest[i*8:i*8+7]\n end if\nend for", "example": "PSIGNB xmm1, xmm2/m128" }, { "mnemonic": "pabsb", "architecture": "x86", "full_name": "Packed Absolute Value Byte", "summary": "Computes absolute value of bytes.", "syntax": "PABSB xmm1, xmm2/m128", "encoding": { "format": "SSSE3", "hex_opcode": "66 0F 38 1C", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 1C", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Computes the absolute value of each signed byte in the source operand and stores the result in the destination XMM register. All 16 bytes are processed in parallel; the value 0x80 (-128) is handled specially and remains 0x80. No flags are affected by this instruction.", "pseudocode": "for i = 0 to 15:\n byte = src[i]\n if byte == 0x80:\n dest[i] ← 0x80\n else if byte < 0:\n dest[i] ← -byte\n else:\n dest[i] ← byte", "example": "PABSB xmm1, xmm2/m128" }, { "mnemonic": "blendps", "architecture": "x86", "full_name": "Blend Packed Single-Precision", "summary": "Selects floats from two sources based on immediate mask.", "syntax": "BLENDPS xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 0C", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 0C", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Selects single-precision floating-point values from two sources based on bit positions in an 8-bit immediate; bits 0-3 each control selection of one 32-bit element (0 selects dest, 1 selects src). Requires SSE4.1. No flags are affected.", "pseudocode": "for i = 0 to 3:\n bit_pos = i\n if (imm8 >> bit_pos) & 1:\n dest[i*32 : i*32+31] ← src[i*32 : i*32+31]\n else:\n dest[i*32 : i*32+31] ← dest[i*32 : i*32+31]", "example": "BLENDPS xmm1, xmm2/m128, 3" }, { "mnemonic": "pblendw", "architecture": "x86", "full_name": "Packed Blend Words", "summary": "Selects words from two sources based on immediate mask.", "syntax": "PBLENDW xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 0E", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 0E", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Selects 16-bit word values from two sources based on bit positions in an 8-bit immediate; bits 0-7 each control selection of one 16-bit word element (0 selects dest, 1 selects src). Requires SSE4.1. No flags are affected.", "pseudocode": "for i = 0 to 7:\n bit_pos = i\n if (imm8 >> bit_pos) & 1:\n dest[i*16 : i*16+15] ← src[i*16 : i*16+15]\n else:\n dest[i*16 : i*16+15] ← dest[i*16 : i*16+15]", "example": "PBLENDW xmm1, xmm2/m128, 3" }, { "mnemonic": "adc", "architecture": "x86", "full_name": "Add with Carry", "summary": "Adds operands and the Carry Flag (CF).", "syntax": "ADC r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "11", "length": "2+", "visual_parts": [], "binary_pattern": "11", "bit_positions": "+0" }, "operands": [ { "name": "dest", "desc": "Reg/Mem" }, { "name": "src", "desc": "Reg" } ], "extension": "Base", "description": "Adds the source operand and the Carry Flag (CF) to the destination operand, storing the result in the destination. Supports 8/16/32/64-bit sizes (64-bit in long mode only). Sets CF on unsigned overflow, SF/ZF/AF/OF/PF based on result; CF is critical for multi-precision arithmetic chains.", "pseudocode": "result ← dest + src + CF\ndest ← result\nCF ← unsigned_overflow(dest_old, src, CF)\nOF ← signed_overflow(dest_old, src, result)\nZF ← (result == 0)\nSF ← (result_sign_bit == 1)\nAF ← ((dest_old & 0xF) + (src & 0xF) + CF) > 0xF\nPF ← popcount(result & 0xFF) is even", "example": "ADC rbx, rax" }, { "mnemonic": "sbb", "architecture": "x86", "full_name": "Subtract with Borrow", "summary": "Subtracts operands and the Carry Flag (CF).", "syntax": "SBB r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "19", "length": "2+", "visual_parts": [], "binary_pattern": "19", "bit_positions": "+0" }, "operands": [ { "name": "dest", "desc": "Reg/Mem" }, { "name": "src", "desc": "Reg" } ], "extension": "Base", "description": "Subtracts the source operand and the Carry Flag (CF) from the destination operand, storing the result in the destination. Supports 8/16/32/64-bit sizes (64-bit in long mode only). Sets CF on unsigned borrow, SF/ZF/AF/OF/PF based on result; CF enables multi-precision subtraction chains.", "pseudocode": "result ← dest - src - CF\ndest ← result\nCF ← unsigned_borrow(dest_old, src, CF)\nOF ← signed_overflow(dest_old, src, result)\nZF ← (result == 0)\nSF ← (result_sign_bit == 1)\nAF ← ((dest_old & 0xF) - (src & 0xF) - CF) has unsigned borrow\nPF ← popcount(result & 0xFF) is even", "example": "SBB rbx, rax" }, { "mnemonic": "shld", "architecture": "x86", "full_name": "Double Precision Shift Left", "summary": "Shifts dest left, filling with bits from src.", "syntax": "SHLD r/m, r, imm8", "encoding": { "format": "Legacy", "hex_opcode": "0F A4", "length": "4+", "visual_parts": [], "binary_pattern": "0F | A4", "bit_positions": "+0 | +1" }, "operands": [ { "name": "dest", "desc": "Reg/Mem" }, { "name": "fill", "desc": "Reg" }, { "name": "count", "desc": "Imm" } ], "extension": "Base", "description": "Shifts the destination operand left by a count, filling the vacated bits from the most-significant bits of the source operand. Supports 16/32/64-bit operands; count comes from the immediate or implicitly from CL. Sets CF to the last bit shifted out, OF if count=1, SF/ZF/PF based on the result.", "pseudocode": "if count > operand_width:\n count ← count mod (operand_width + 1)\nif count == 0:\n skip\nelse:\n CF ← bit_shifted_out_from_left\n dest ← (dest << count) | (src >> (operand_width - count))\n if count == 1:\n OF ← (dest_sign_bit_after != CF)\n else:\n OF ← undefined\n ZF ← (dest == 0)\n SF ← (dest_sign_bit == 1)\n PF ← popcount(dest & 0xFF) is even", "example": "SHLD rbx, rax, 3" }, { "mnemonic": "shrd", "architecture": "x86", "full_name": "Double Precision Shift Right", "summary": "Shifts dest right, filling with bits from src.", "syntax": "SHRD r/m, r, imm8", "encoding": { "format": "Legacy", "hex_opcode": "0F AC", "length": "4+", "visual_parts": [], "binary_pattern": "0F | AC", "bit_positions": "+0 | +1" }, "operands": [ { "name": "dest", "desc": "Reg/Mem" }, { "name": "fill", "desc": "Reg" }, { "name": "count", "desc": "Imm" } ], "extension": "Base", "description": "Shifts the destination operand right by a count, filling the vacated bits from the least-significant bits of the source operand. Supports 16/32/64-bit operands; count comes from the immediate or implicitly from CL. Sets CF to the last bit shifted out, OF if count=1, SF/ZF/PF based on the result.", "pseudocode": "if count > operand_width:\n count ← count mod (operand_width + 1)\nif count == 0:\n skip\nelse:\n CF ← bit_shifted_out_from_right\n dest ← (dest >> count) | (src << (operand_width - count))\n if count == 1:\n OF ← (dest_sign_bit_after != bit_was_at_position_width_1)\n else:\n OF ← undefined\n ZF ← (dest == 0)\n SF ← (dest_sign_bit == 1)\n PF ← popcount(dest & 0xFF) is even", "example": "SHRD rbx, rax, 3" }, { "mnemonic": "vpermb", "architecture": "x86", "full_name": "Permute Packed Bytes", "summary": "Permutes bytes in ZMM based on index vector.", "syntax": "VPERMB zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 8D /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 8D", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "idx", "desc": "ZMM" }, { "name": "src", "desc": "ZMM/Mem" } ], "extension": "AVX-512-VBMI", "description": "Permutes bytes within 64-byte blocks of a ZMM register using a 512-bit index vector; each byte in the index selects a source byte (bits 3-0 select lane, bits 6-4 select byte within 64-byte lane). Requires AVX-512-VBMI. Supports write-masking via {k1}. No flags are affected.", "pseudocode": "for lane = 0 to 7:\n for byte_in_lane = 0 to 63:\n idx_byte = zmm2[lane*64 + byte_in_lane]\n src_lane = idx_byte & 0x7\n src_byte_offset = idx_byte >> 3\n if src_byte_offset < 64:\n selected = zmm3[src_lane*64 + src_byte_offset]\n else:\n selected = 0\n if k1[byte_in_lane] or k1 is not used:\n zmm1[lane*64 + byte_in_lane] ← selected", "example": "VPERMB zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpermi2b", "architecture": "x86", "full_name": "Permute Two-Source Bytes", "summary": "Shuffles bytes from two ZMM registers into destination.", "syntax": "VPERMI2B zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 75 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 75", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "idx", "desc": "ZMM" }, { "name": "src", "desc": "ZMM/Mem" } ], "extension": "AVX-512-VBMI", "description": "Permutes bytes from two ZMM registers (destination and source) using byte indices in the second source, storing results in the destination. The instruction performs a gather-like operation where each byte index selects from either the destination or source register based on the high bit. No flags are modified; the operation is masked by the opmask register k1, with zeroing or merging semantics.", "pseudocode": "for i = 0 to 63:\n idx = zmm2[8*i:8*i+7]\n if idx[7] == 0:\n zmm1[8*i:8*i+7] ← zmm1[8*(idx[6:0]):8*(idx[6:0])+7]\n else:\n zmm1[8*i:8*i+7] ← zmm3[8*(idx[6:0]):8*(idx[6:0])+7]\n zmm1[8*i:8*i+7] ← zmm1[8*i:8*i+7] & k1_mask[i]", "example": "VPERMI2B zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpermt2b", "architecture": "x86", "full_name": "Permute Two-Source Bytes (Overwrite)", "summary": "Shuffles bytes from two sources, overwriting index.", "syntax": "VPERMT2B zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 7D /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 7D", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "idx", "desc": "ZMM" }, { "name": "src", "desc": "ZMM/Mem" } ], "extension": "AVX-512-VBMI", "description": "Permutes bytes from two sources using indices in the destination register (which is overwritten), selecting from either the index register or the second source based on the index's high bit. This is the two-operand form where indices reside in what becomes the output. No flags are modified; masking via k1 applies to the result with optional zeroing.", "pseudocode": "for i = 0 to 63:\n idx = zmm1[8*i:8*i+7]\n if idx[7] == 0:\n result[8*i:8*i+7] ← zmm2[8*(idx[6:0]):8*(idx[6:0])+7]\n else:\n result[8*i:8*i+7] ← zmm3[8*(idx[6:0]):8*(idx[6:0])+7]\n zmm1[8*i:8*i+7] ← result[8*i:8*i+7] & k1_mask[i]", "example": "VPERMT2B zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpmultishiftqb", "architecture": "x86", "full_name": "Select Packed Unaligned Bytes from Quadword Sources", "summary": "Selects bytes from each 64-bit element based on shift control.", "syntax": "VPMULTISHIFTQB zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 83 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 83", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "ctrl", "desc": "ZMM" }, { "name": "src", "desc": "ZMM/Mem" } ], "extension": "AVX-512-VBMI", "description": "Selects bytes from each 64-bit element by using 4-bit shift control values extracted from the control ZMM register. Each 8-bit control field specifies which of 8 bytes within its 64-bit source element to extract into each output byte. No flags are modified; the operation respects the opmask k1 for selective writing.", "pseudocode": "for i = 0 to 7: // 8 quadwords (64-bit elements)\n for j = 0 to 7: // 8 bytes within each quadword\n shift_val = zmm2[64*i+4*j+3:64*i+4*j]\n zmm1[64*i+8*j+7:64*i+8*j] ← zmm3[64*i + 8*shift_val + 7 : 64*i + 8*shift_val]\n zmm1[64*i+8*j+7:64*i+8*j] ← zmm1[64*i+8*j+7:64*i+8*j] & k1_mask[64*i+8*j:64*i+8*j+7]", "example": "VPMULTISHIFTQB zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpshldd", "architecture": "x86", "full_name": "Packed Shift Left Double Concatenate", "summary": "Funnel shift left of doublewords.", "syntax": "VPSHLDD zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 71 /r /ib", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 71", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src1", "desc": "ZMM" }, { "name": "src2", "desc": "ZMM/Mem" }, { "name": "cnt", "desc": "Imm" } ], "extension": "AVX-512-VBMI2", "description": "Performs a funnel left-shift (double concatenate) on 32-bit doublewords: each output doubleword is the logical left-shift result of concatenating src2 into src1, shifted left by the immediate count. Bits shifted out on the left are discarded; bits from src2 fill in on the right. No arithmetic flags are modified; the operation is EVEX-encoded with masking support via k1.", "pseudocode": "for i = 0 to 15: // 16 doublewords\n concatenated = (zmm2[32*i+31:32*i] << 32) | zmm3[32*i+31:32*i]\n shift_amount = cnt & 0x1F\n zmm1[32*i+31:32*i] ← (concatenated >> (32 - shift_amount)) & 0xFFFFFFFF\n zmm1[32*i+31:32*i] ← zmm1[32*i+31:32*i] & k1_mask[i]", "example": "VPSHLDD zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpshrdd", "architecture": "x86", "full_name": "Packed Shift Right Double Concatenate", "summary": "Funnel shift right of doublewords.", "syntax": "VPSHRDD zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 73 /r /ib", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 73", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src1", "desc": "ZMM" }, { "name": "src2", "desc": "ZMM/Mem" }, { "name": "cnt", "desc": "Imm" } ], "extension": "AVX-512-VBMI2", "description": "Performs a funnel right-shift (double concatenate) on 32-bit doublewords: each output doubleword is the logical right-shift result of concatenating src1 and src2, shifted right by the immediate count. Bits shifted out on the right are discarded; bits from src1 fill in on the left. No arithmetic flags are modified; masking via k1 applies to the result.", "pseudocode": "for i = 0 to 15: // 16 doublewords\n concatenated = (zmm2[32*i+31:32*i] << 32) | zmm3[32*i+31:32*i]\n shift_amount = cnt & 0x1F\n zmm1[32*i+31:32*i] ← (concatenated >> shift_amount) & 0xFFFFFFFF\n zmm1[32*i+31:32*i] ← zmm1[32*i+31:32*i] & k1_mask[i]", "example": "VPSHRDD zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpcompressb", "architecture": "x86", "full_name": "Store Sparse Packed Byte Integer Values", "summary": "Compresses active bytes from ZMM to memory.", "syntax": "VPCOMPRESSB m512 {k1}, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 63 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 63", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "Mem" }, { "name": "src", "desc": "ZMM" } ], "extension": "AVX-512-VBMI2", "description": "Stores bytes from ZMM into memory at sparse, mask-selected positions: only bytes where the corresponding opmask bit k1 is set are written to consecutive memory locations. The instruction performs a contiguous write of active bytes while maintaining their relative order. No flags are modified; this is a memory write operation with variable length determined by the popcount of the mask.", "pseudocode": "byte_count = 0\nfor i = 0 to 63:\n if k1_mask[i] == 1:\n mem[byte_count] ← zmm1[8*i+7:8*i]\n byte_count += 1", "example": "VPCOMPRESSB [rbp-64], zmm1" }, { "mnemonic": "vpexpandb", "architecture": "x86", "full_name": "Load Sparse Packed Byte Integer Values", "summary": "Expands bytes from memory into sparse locations in ZMM.", "syntax": "VPEXPANDB zmm1 {k1}, m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 62 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 62", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src", "desc": "Mem" } ], "extension": "AVX-512-VBMI2", "description": "Loads bytes from memory into sparse, mask-selected positions in ZMM: bytes at consecutive memory locations are placed into ZMM positions where the opmask k1 is set, with unmasked positions remaining zero or unchanged. This is the inverse of compress. No flags are modified; the operation fills a sparse vector from compact memory data.", "pseudocode": "byte_count = 0\nfor i = 0 to 63:\n if k1_mask[i] == 1:\n zmm1[8*i+7:8*i] ← mem[byte_count]\n byte_count += 1\n else:\n zmm1[8*i+7:8*i] ← 0 // or unchanged if merging mode", "example": "VPEXPANDB zmm1, [rbp-64]" }, { "mnemonic": "vpopcntb", "architecture": "x86", "full_name": "Packed Population Count Byte", "summary": "Counts set bits in each byte.", "syntax": "VPOPCNTB zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 54 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 54", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src", "desc": "ZMM/Mem" } ], "extension": "AVX-512-BITALG", "description": "Counts the number of set bits (population count) in each byte of the source, writing the count (0-8) into the corresponding byte of the destination. This operates independently on each of 64 bytes in the ZMM register. No arithmetic flags are modified; the instruction is part of AVX-512-BITALG and supports masking via k1.", "pseudocode": "for i = 0 to 63:\n count = 0\n byte_val = zmm2[8*i+7:8*i]\n for bit = 0 to 7:\n if byte_val[bit] == 1:\n count += 1\n zmm1[8*i+7:8*i] ← count & k1_mask[i]", "example": "VPOPCNTB zmm1, zmm2/m512" }, { "mnemonic": "vpshufbitqmb", "architecture": "x86", "full_name": "Shuffle Bits from Quadword Elements to Mask", "summary": "Extracts bits from bytes and packs into a mask register.", "syntax": "VPSHUFBITQMB k1 {k2}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 8F /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 8F", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "k-reg" }, { "name": "src1", "desc": "ZMM" }, { "name": "src2", "desc": "ZMM/Mem" } ], "extension": "AVX-512-BITALG", "description": "Extracts bits from quadword elements using a shuffle pattern and packs them into a mask register. The operation uses zmm3/m512 as a bit-select control for each bit position in zmm2, extracting one bit per control byte and combining results into an 8-bit or 16-bit mask. This is a non-SIMD operation that produces only a mask output; no arithmetic flags are modified.", "pseudocode": "for (i = 0; i < 64; i++) {\n byte_idx = zmm3[8*i : 8*i+7];\n if (byte_idx < 64) {\n bit = zmm2[byte_idx];\n } else {\n bit = 0;\n }\n k1[i] = bit;\n}\nk1 = k1 & k2;", "example": "VPSHUFBITQMB k1, zmm2, zmm3/m512" }, { "mnemonic": "vp2intersectd", "architecture": "x86", "full_name": "Compute Intersection Pair Doublewords", "summary": "Computes intersection of two ZMM registers into mask pair.", "syntax": "VP2INTERSECTD k1+1, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.NDS.512.F2.0F38.W0 68 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | F2 | 0F | 38 | 68", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "kdest", "desc": "k-pair" }, { "name": "src1", "desc": "ZMM" }, { "name": "src2", "desc": "ZMM/Mem" } ], "extension": "AVX-512-VP2INTERSECT", "description": "Computes the intersection of two sets of doublewords and produces a pair of mask registers (k1 and k1+1). Each 32-bit element in zmm2 is compared against all elements in zmm3/m512; k1 contains matches at each position, and k1+1 contains match counts or indices. No arithmetic flags are modified; results are written only to the mask pair.", "pseudocode": "match_mask = 0;\nmatch_count = 0;\nfor (i = 0; i < 16; i++) {\n matches = 0;\n for (j = 0; j < 16; j++) {\n if (zmm2[32*i : 32*i+31] == zmm3[32*j : 32*j+31]) {\n matches = 1;\n break;\n }\n }\n match_mask = match_mask | (matches << i);\n if (matches) match_count++;\n}\nk1 = match_mask;\nk2 = match_count;", "example": "VP2INTERSECTD k1+1, zmm2, zmm3/m512" }, { "mnemonic": "vpmadd52luq", "architecture": "x86", "full_name": "Packed Multiply-Add Unsigned 52-bit Integers (Low)", "summary": "Fused multiply-add for 52-bit integers (Low 52 bits).", "syntax": "VPMADD52LUQ zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 B4 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | B4", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src1", "desc": "ZMM" }, { "name": "src2", "desc": "ZMM/Mem" } ], "extension": "AVX-512-IFMA", "description": "Performs a fused multiply-add operation on 52-bit unsigned integers, extracting the lower 52 bits of the 104-bit product and accumulating into the destination. For each 64-bit lane: compute (zmm2[63:0] * zmm3[63:0]) + (zmm1[63:0]), extract bits [51:0], and write back to zmm1. Supports masking via k1; no arithmetic flags are modified.", "pseudocode": "for (i = 0; i < 8; i++) {\n idx = 64*i;\n product = zmm2[idx+63 : idx] * zmm3[idx+63 : idx];\n sum = (product + zmm1[idx+63 : idx]);\n result = sum & 0xFFFFFFFFFFFFF; // 52 bits\n zmm1[idx+63 : idx] = result;\n if (k1[i]) zmm1[idx+63 : idx] = result;\n}", "example": "VPMADD52LUQ zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpmadd52huq", "architecture": "x86", "full_name": "Packed Multiply-Add Unsigned 52-bit Integers (High)", "summary": "Fused multiply-add for 52-bit integers (High 52 bits).", "syntax": "VPMADD52HUQ zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 B5 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | B5", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src1", "desc": "ZMM" }, { "name": "src2", "desc": "ZMM/Mem" } ], "extension": "AVX-512-IFMA", "description": "Performs a fused multiply-add operation on 52-bit unsigned integers, extracting the upper 52 bits of the 104-bit product and accumulating into the destination. For each 64-bit lane: compute (zmm2[63:0] * zmm3[63:0]) + (zmm1[63:0]), extract bits [103:52], and write back to zmm1. Supports masking via k1; no arithmetic flags are modified.", "pseudocode": "for (i = 0; i < 8; i++) {\n idx = 64*i;\n product = zmm2[idx+63 : idx] * zmm3[idx+63 : idx];\n sum = (product + zmm1[idx+63 : idx]);\n result = (sum >> 52) & 0xFFFFFFFFFFFFF; // upper 52 bits\n if (k1[i]) zmm1[idx+63 : idx] = result;\n}", "example": "VPMADD52HUQ zmm1, zmm2, zmm3/m512" }, { "mnemonic": "aadd", "architecture": "x86", "full_name": "Atomically Add", "summary": "Atomically adds a value to a remote memory location.", "syntax": "AADD m32, r32", "encoding": { "format": "VEX", "hex_opcode": "NP 0F 38 FC !(11):rrr:bbb", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | FC", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "Mem" }, { "name": "src", "desc": "Reg" } ], "extension": "RAO-INT", "description": "Atomically adds a 32-bit register value to a memory location without acquiring a lock and without returning the old value. This is a remote atomic operation that guarantees atomicity at the hardware level via cache coherency; the instruction does not serialize the entire pipeline but may have store ordering implications. No flags are modified; this is a write-only operation to memory.", "pseudocode": "atomic_add([dest], src);\n// Semantically: [dest] ← [dest] + src", "example": "AADD [rbp-4], eax" }, { "mnemonic": "aand", "architecture": "x86", "full_name": "Atomically AND", "summary": "Atomically ANDs a value to a remote memory location.", "syntax": "AAND m32, r32", "encoding": { "format": "VEX", "hex_opcode": "66 0F 38 FC !(11):rrr:bbb", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | FC | ModRM", "bit_positions": "+0 | +1 | +2 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "Mem" }, { "name": "src", "desc": "Reg" } ], "extension": "RAO-INT", "description": "Atomically ANDs a 32-bit register value with a memory location without acquiring a lock and without returning the old value. This remote atomic operation guarantees atomicity via cache coherency mechanisms; it does not serialize the entire pipeline but provides store-ordering guarantees. No flags are modified.", "pseudocode": "atomic_and([dest], src);\n// Semantically: [dest] ← [dest] & src", "example": "AAND [rbp-4], eax" }, { "mnemonic": "aor", "architecture": "x86", "full_name": "Atomically OR", "summary": "Atomically ORs a value to a remote memory location.", "syntax": "AOR m32, r32", "encoding": { "format": "VEX", "hex_opcode": "F2 0F 38 FC !(11):rrr:bbb", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | FC | ModRM", "bit_positions": "+0 | +1 | +2 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "Mem" }, { "name": "src", "desc": "Reg" } ], "extension": "RAO-INT", "description": "Atomically ORs a 32-bit register value with a memory location without acquiring a lock and without returning the old value. This remote atomic operation uses cache coherency to guarantee atomicity; it does not serialize the full pipeline but enforces store ordering. No flags are modified.", "pseudocode": "atomic_or([dest], src);\n// Semantically: [dest] ← [dest] | src", "example": "AOR [rbp-4], eax" }, { "mnemonic": "axor", "architecture": "x86", "full_name": "Atomically XOR", "summary": "Atomically XORs a value to a remote memory location.", "syntax": "AXOR m32, r32", "encoding": { "format": "VEX", "hex_opcode": "F3 0F 38 FC !(11):rrr:bbb", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | FC | ModRM", "bit_positions": "+0 | +1 | +2 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "Mem" }, { "name": "src", "desc": "Reg" } ], "extension": "RAO-INT", "description": "Atomically XORs a 32-bit register value with a memory location without acquiring a lock and without returning the old value. This remote atomic operation guarantees atomicity through cache coherency; it does not serialize the entire pipeline but maintains store-ordering properties. No flags are modified.", "pseudocode": "atomic_xor([dest], src);\n// Semantically: [dest] ← [dest] ^ src", "example": "AXOR [rbp-4], eax" }, { "mnemonic": "cmpccxadd", "architecture": "x86", "full_name": "Compare and Add if Condition is Met", "summary": "Atomically adds if condition is met.", "syntax": "CMPccXADD m32, r32, r32", "encoding": { "format": "EVEX", "hex_opcode": "VEX.128.66.0F38.W0 E0 /r", "length": "6+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | E0", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "Mem" }, { "name": "src1", "desc": "Reg" }, { "name": "src2", "desc": "Reg" } ], "extension": "CMPccXADD", "description": "Atomically compares a value in memory with an operand and adds a second operand to memory if the condition is met. This instruction is part of the APX (Advanced Performance eXtensions) and operates under EVEX encoding with implicit condition code selection via the embedded immediate. The instruction performs a compare-and-add loop at the CPU microarchitecture level, setting ZF based on the comparison result and CF/OF/SF based on the add operation if executed.", "pseudocode": "temp ← [dest]; ZF ← (temp == src1); if (condition_met) { [dest] ← [dest] + src2; CF ← carry_from_add; OF ← overflow_from_add; SF ← sign_of_result; } src1 ← temp;", "example": "CMPccXADD [rbp-4], eax, eax" }, { "mnemonic": "erets", "architecture": "x86", "full_name": "Event Return Supervisor", "summary": "Returns from an event handler to supervisor mode (FRED).", "syntax": "ERETS", "encoding": { "format": "Legacy", "hex_opcode": "F2 0F 01 CA", "length": "4", "visual_parts": [], "binary_pattern": "F2 | 0F | 01 | CA", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [], "extension": "FRED", "description": "Returns from a FRED (Flexible Return and Event Delivery) event handler in supervisor mode, restoring the interrupted execution context from the event stack. This instruction is part of the FRED extension and performs implicit stack unwinding and privilege level restoration. No flags are modified; this is a serializing instruction that also flushes the instruction cache.", "pseudocode": "// Returns from an event handler to supervisor mode (FRED)", "example": "ERETS" }, { "mnemonic": "eretu", "architecture": "x86", "full_name": "Event Return User", "summary": "Returns from an event handler to user mode (FRED).", "syntax": "ERETU", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 01 CA", "length": "4", "visual_parts": [], "binary_pattern": "F3 | 0F | 01 | CA", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [], "extension": "FRED", "description": "Returns from a FRED (Flexible Return and Event Delivery) event handler to user mode, restoring the interrupted user-level execution context from the event stack. This instruction is part of the FRED extension and performs implicit stack unwinding with privilege level transition. No flags are modified; this is a serializing instruction that flushes the instruction cache and clears sensitive state.", "pseudocode": "// Returns from an event handler to user mode (FRED)", "example": "ERETU" }, { "mnemonic": "lkgs", "architecture": "x86", "full_name": "Load Kernel GS Base", "summary": "Loads the kernel GS base address (FRED support).", "syntax": "LKGS r16", "encoding": { "format": "Legacy", "hex_opcode": "F2 0F 00 /6", "length": "4+", "visual_parts": [], "binary_pattern": "F2 | 0F | 00 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "src", "desc": "Reg" } ], "extension": "LKGS", "description": "Loads a 16-bit selector or handle into the kernel GS base register, supporting FRED event delivery. The instruction reads from the specified register and updates the MSR-backed kernel GS base, used for exception handler context. This is a privileged instruction (CPL = 0) and does not modify any flags.", "pseudocode": "IA32_KERNEL_GS_BASE ← src;", "example": "LKGS ax" }, { "mnemonic": "enqcmd", "architecture": "x86", "full_name": "Enqueue Command", "summary": "Writes a command to a device (DSA/IAA accelerator).", "syntax": "ENQCMD r32, m512", "encoding": { "format": "Legacy", "hex_opcode": "F2 0F 38 F8", "length": "5+", "visual_parts": [], "binary_pattern": "F2 | 0F | 38 | F8", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "Reg" }, { "name": "src", "desc": "Mem" } ], "extension": "ENQCMD", "description": "Atomically enqueues a 512-bit command descriptor from memory to a device queue (DSA/IAA accelerator), writing a doorbell or status register via the destination register. The instruction performs an atomic write to the device, and ZF is set to indicate success or failure of the enqueue operation. This is a non-temporal memory operation and does not cache the 512-bit data.", "pseudocode": "// Writes a command to a device (DSA/IAA accelerator)", "example": "ENQCMD eax, [rbp-64]" }, { "mnemonic": "pconfig", "architecture": "x86", "full_name": "Platform Configuration", "summary": "Configures platform features like MKTME (Memory Encryption).", "syntax": "PCONFIG", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 C5", "length": "3", "visual_parts": [], "binary_pattern": "0F | 01 | C5", "bit_positions": "+0 | +1 | +2" }, "operands": [], "extension": "PCONFIG", "description": "Performs platform configuration operations such as MKTME (Memory Key Total Memory Encryption) setup, with the operation type specified implicitly via EAX. This is a privileged instruction (CPL = 0) that modifies platform encryption keys and memory encryption metadata. The instruction may serialize the pipeline and has implementation-dependent effects on cache coherency.", "pseudocode": "// Configures platform features like MKTME (Memory Encryption)", "example": "PCONFIG" }, { "mnemonic": "wbnoinvd", "architecture": "x86", "full_name": "Write Back and Do Not Invalidate Cache", "summary": "Writes back modified lines but keeps them valid in cache.", "syntax": "WBNOINVD", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 09", "length": "3", "visual_parts": [], "binary_pattern": "F3 | 0F | 09", "bit_positions": "+0 | +1 | +2" }, "operands": [], "extension": "WBNOINVD", "description": "Writes back all modified cache lines to memory but keeps them valid in the L3 cache, improving performance compared to WBINVD which invalidates. This instruction is non-privileged and does not modify any flags. It provides write-back semantics without the full cache flush, useful for cache coherency operations while maintaining data locality.", "pseudocode": "// Writes back modified lines but keeps them valid in cache", "example": "WBNOINVD" }, { "mnemonic": "aesencwide128kl", "architecture": "x86", "full_name": "AES Encrypt Wide 128-bit Key Locker", "summary": "Encrypts 8 blocks using 128-bit Key Locker handle.", "syntax": "AESENCWIDE128KL m128", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 D8 !(11):000:bbb", "length": "5+", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | D8", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "handle", "desc": "Mem" } ], "extension": "KEYLOCKER_WIDE", "description": "Encrypts eight 128-bit blocks in parallel using a 128-bit Key Locker handle, performing wide-block AES encryption for high-throughput scenarios. The handle is loaded from memory and used to derive keys without exposing them, setting ZF to indicate success. This instruction operates on XMM0-XMM7 implicitly as input and output blocks, and clears sensitive key material after use.", "pseudocode": "handle ← [handle_mem]; if (valid_handle) { XMM0-XMM7 ← AES_ENC_WIDE_128(XMM0-XMM7, handle); ZF ← 0; } else { ZF ← 1; }", "example": "AESENCWIDE128KL [rbp-16]" }, { "mnemonic": "aesencwide256kl", "architecture": "x86", "full_name": "AES Encrypt Wide 256-bit Key Locker", "summary": "Encrypts 8 blocks using 256-bit Key Locker handle.", "syntax": "AESENCWIDE256KL m128", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 D8 !(11):010:bbb", "length": "5+", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | D8 | ModRM", "bit_positions": "+0 | +1 | +2 | +3 | +4" }, "operands": [ { "name": "handle", "desc": "Mem" } ], "extension": "KEYLOCKER_WIDE", "description": "Encrypts 8 consecutive 128-bit blocks using AES in ECB mode with a 256-bit key loaded from a Key Locker handle. This instruction is part of the Key Locker extension and requires the handle at the memory operand to be a valid, initialized 512-bit Key Locker structure. The instruction reads plaintext from XMM0-XMM7, encrypts all blocks in parallel, and writes ciphertext back to XMM0-XMM7; ZF is set to 0 on success or 1 if the handle is invalid or key usage limit exceeded.", "pseudocode": "handle ← [mem128]\nif (handle is invalid or usage_limit_exceeded) {\n ZF ← 1\n} else {\n for i = 0 to 7:\n XMM[i] ← AES_Encrypt_256(XMM[i], key_from_handle)\n ZF ← 0\n}", "example": "AESENCWIDE256KL [rbp-16]" }, { "mnemonic": "fucom", "architecture": "x86", "full_name": "Unordered Compare Real", "summary": "Compares ST(0) with source (supports NaNs).", "syntax": "FUCOM ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "DD E0+i", "length": "2", "visual_parts": [], "binary_pattern": "DD", "bit_positions": "+0" }, "operands": [ { "name": "src", "desc": "Reg" } ], "extension": "x87 FPU", "description": "Compares the top of the x87 FPU stack (ST(0)) with an operand (ST(i) by default) and sets condition code bits in the FPU status word. Unlike FCOM, FUCOM treats QNaN operands as comparable rather than signaling. The C3, C2, and C0 bits are set based on the comparison result (unordered, greater than, less than, or equal), and C1 is cleared.", "pseudocode": "if (is_unordered(ST(0), ST(i))) {\n C3 ← 1; C2 ← 1; C0 ← 1\n} else if (ST(0) > ST(i)) {\n C3 ← 0; C2 ← 0; C0 ← 0\n} else if (ST(0) < ST(i)) {\n C3 ← 0; C2 ← 0; C0 ← 1\n} else {\n C3 ← 1; C2 ← 0; C0 ← 0\n}\nC1 ← 0", "example": "FUCOM st(1)" }, { "mnemonic": "frndint", "architecture": "x86", "full_name": "Round to Integer", "summary": "Rounds ST(0) to integer according to RC field.", "syntax": "FRNDINT", "encoding": { "format": "Legacy", "hex_opcode": "D9 FC", "length": "2", "visual_parts": [], "binary_pattern": "D9 | FC", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Rounds the value in ST(0) to an integer according to the rounding control (RC) field in the FPU control word (bits 10-11). The result remains in ST(0) as a floating-point number with zero fractional part. This instruction does not pop the stack and does not set exception flags.", "pseudocode": "ST(0) ← round_to_integer(ST(0), RC_field)", "example": "FRNDINT" }, { "mnemonic": "fscale", "architecture": "x86", "full_name": "Scale", "summary": "Scales ST(0) by ST(1) (ST(0) * 2^ST(1)).", "syntax": "FSCALE", "encoding": { "format": "Legacy", "hex_opcode": "D9 FD", "length": "2", "visual_parts": [], "binary_pattern": "D9 | FD", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Scales ST(0) by raising 2 to the power of ST(1): ST(0) ← ST(0) × 2^ST(1). ST(1) must be an integer within the range [-2^31, 2^31-1]; if out of range or NaN, an invalid-operation exception is generated. The stack is not popped; ST(0) is replaced with the scaled result.", "pseudocode": "if (ST(1) is not integer or out_of_range) {\n raise_exception(invalid_operation)\n} else {\n ST(0) ← ST(0) * (2 ^ trunc(ST(1)))\n}", "example": "FSCALE" }, { "mnemonic": "fxtract", "architecture": "x86", "full_name": "Extract Exponent and Significand", "summary": "Separates exponent and significand of ST(0).", "syntax": "FXTRACT", "encoding": { "format": "Legacy", "hex_opcode": "D9 F4", "length": "2", "visual_parts": [], "binary_pattern": "D9 | F4", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Separates ST(0) into its exponent (as an integer) and significand (as a number in [1, 2) or [0, ∞) for special values). The exponent is pushed onto the stack, and ST(0) is replaced with the significand, so the original value can be recovered as significand × 2^exponent. This operation logically duplicates and replaces ST(0), increasing stack depth.", "pseudocode": "exponent ← extract_exponent(ST(0))\nsignificand ← extract_significand(ST(0))\nFPU_stack_push(exponent)\nST(0) ← significand", "example": "FXTRACT" }, { "mnemonic": "f2xm1", "architecture": "x86", "full_name": "Compute 2^x - 1", "summary": "Computes (2^ST(0)) - 1.", "syntax": "F2XM1", "encoding": { "format": "Legacy", "hex_opcode": "D9 F0", "length": "2", "visual_parts": [], "binary_pattern": "D9 | F0", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Computes 2^ST(0) - 1 and stores the result back in ST(0). ST(0) must be in the range [-1, 1] for accurate results; values outside this range produce undefined behavior or reduced accuracy. This instruction is used as part of logarithm and exponential function approximations in transcendental math libraries.", "pseudocode": "if (ST(0) < -1 or ST(0) > 1) {\n undefined_behavior()\n} else {\n ST(0) ← (2 ^ ST(0)) - 1\n}", "example": "F2XM1" }, { "mnemonic": "fyl2xp1", "architecture": "x86", "full_name": "Compute y * log2(x + 1)", "summary": "Computes ST(1) * log2(ST(0) + 1).", "syntax": "FYL2XP1", "encoding": { "format": "Legacy", "hex_opcode": "D9 F9", "length": "2", "visual_parts": [], "binary_pattern": "D9 | F9", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Computes ST(1) × log₂(ST(0) + 1) and stores the result in ST(1), then pops ST(0). ST(0) must be in the range (-1, 1) for full accuracy. This instruction is optimized for computing logarithms of numbers close to 1 and is used in transcendental function implementations to reduce rounding error.", "pseudocode": "if (ST(0) <= -1 or ST(0) >= 1) {\n undefined_behavior()\n} else {\n result ← ST(1) * log2(ST(0) + 1)\n FPU_stack_pop()\n ST(0) ← result\n}", "example": "FYL2XP1" }, { "mnemonic": "clrssbsy", "architecture": "x86", "full_name": "Clear Shadow Stack Busy Flag", "summary": "Clears the busy flag in the shadow stack token.", "syntax": "CLRSSBSY m64", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F AE !(11):110:bbb", "length": "4+", "visual_parts": [], "binary_pattern": "F3 | 0F | AE | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "token", "desc": "Mem" } ], "extension": "CET-SS", "description": "Clears the busy flag (bit 0) of a shadow stack token located at the memory address specified by the operand. This instruction is part of Control-flow Enforcement Technology (CET) Shadow Stack and is used to mark a shadow stack token as no longer busy (e.g., after an exception handler has completed). ZF is set to 0 on success or 1 if the token address is misaligned or the token is invalid.", "pseudocode": "token_addr ← m64\nif (token_addr is misaligned or not_valid_token) {\n ZF ← 1\n} else {\n [token_addr] ← [token_addr] & ~(1) // Clear bit 0\n ZF ← 0\n}", "example": "CLRSSBSY [rbp-8]" }, { "mnemonic": "tdpfp16ps", "architecture": "x86", "full_name": "Tile Dot Product FP16 Packed Single", "summary": "Matrix multiply (FP16 * FP16) accumulating to Float32.", "syntax": "TDPFP16PS tmm1, tmm2, tmm3", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.F2.0F38.W0 5C 11:rrr:bbb", "length": "6+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "TMM" }, { "name": "src1", "desc": "TMM" }, { "name": "src2", "desc": "TMM" } ], "extension": "AMX-FP16", "description": "Performs a tile matrix multiply-accumulate operation where two FP16 matrices (tmm2 and tmm3) are multiplied element-wise and accumulated into tmm1 as FP32 results. This is a specialized AMX instruction that leverages tile registers for high-throughput matrix operations. No standard CPU flags are affected; results that overflow to infinity or underflow to zero follow IEEE 754 semantics.", "pseudocode": "tmm1 ← tmm1 + (tmm2 * tmm3) // FP16 × FP16 → FP32 accumulation, per tile dimensions", "example": "TDPFP16PS tmm1, tmm2, tmm3" }, { "mnemonic": "movss", "architecture": "x86", "full_name": "Move Scalar Single-Precision", "summary": "Moves a single float (low 32 bits) between XMM/Memory.", "syntax": "MOVSS xmm1, xmm2/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 10", "visual_parts": [], "binary_pattern": "F3 | 0F | 10", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Moves a scalar single-precision (32-bit) floating-point value from the source to the low 32 bits of the destination XMM register. The upper 96 bits of the destination XMM register are preserved. No CPU flags are modified. This instruction operates in 32-bit mode or higher.", "pseudocode": "dest[31:0] ← src[31:0]\n// dest[127:32] unchanged", "example": "MOVSS xmm1, xmm2/m32" }, { "mnemonic": "movsd", "architecture": "x86", "full_name": "Move Scalar Double-Precision", "summary": "Moves a single double (low 64 bits) between XMM/Memory.", "syntax": "MOVSD xmm1, xmm2/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 10", "visual_parts": [], "binary_pattern": "F2 | 0F | 10", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Moves a scalar double-precision (64-bit) floating-point value from the source to the low 64 bits of the destination XMM register. The upper 64 bits of the destination XMM register are preserved. No CPU flags are modified. This instruction operates in 32-bit mode or higher.", "pseudocode": "dest[63:0] ← src[63:0]\n// dest[127:64] unchanged", "example": "MOVSD xmm1, xmm2/m64" }, { "mnemonic": "cvtdq2pd", "architecture": "x86", "full_name": "Convert Packed Doubleword to Packed Double-Precision", "summary": "Converts two 32-bit integers to two 64-bit doubles.", "syntax": "CVTDQ2PD xmm1, xmm2/m64", "encoding": { "format": "SSE2", "hex_opcode": "F3 0F E6", "visual_parts": [], "binary_pattern": "F3 | 0F | E6", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Converts the lower two 32-bit signed doublewords from the source to two 64-bit IEEE 754 double-precision floating-point values in the destination XMM register. The conversion is exact (no rounding error for representable integers). No CPU flags are modified. Operates in 32-bit mode or higher with SSE2 support.", "pseudocode": "dest[63:0] ← CVTF64(src[31:0]) // lower 32-bit int to double\ndest[127:64] ← CVTF64(src[63:32]) // upper 32-bit int to double", "example": "CVTDQ2PD xmm1, xmm2/m64" }, { "mnemonic": "cvtpd2dq", "architecture": "x86", "full_name": "Convert Packed Double-Precision to Packed Doubleword", "summary": "Converts two doubles to two 32-bit integers (Rounded).", "syntax": "CVTPD2DQ xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F E6", "visual_parts": [], "binary_pattern": "F2 | 0F | E6", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Converts two 64-bit double-precision floating-point values from the source to two 32-bit signed doublewords in the destination XMM register, using the rounding mode specified by MXCSR. Overflow results are saturated to 0x80000000 (INT32_MIN) or 0x7FFFFFFF (INT32_MAX); invalid/NaN inputs produce 0x80000000. The upper 64 bits of the destination are zeroed. No CPU flags are modified.", "pseudocode": "rounding_mode ← MXCSR[13:11]\ndest[31:0] ← CVTI32(src[63:0], rounding_mode) // lower double to 32-bit int\ndest[63:32] ← CVTI32(src[127:64], rounding_mode) // upper double to 32-bit int\ndest[127:64] ← 0", "example": "CVTPD2DQ xmm1, xmm2/m128" }, { "mnemonic": "cvttpd2dq", "architecture": "x86", "full_name": "Convert with Truncation Packed Double to Packed Doubleword", "summary": "Converts two doubles to two 32-bit integers (Truncated).", "syntax": "CVTTPD2DQ xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F E6", "visual_parts": [], "binary_pattern": "66 | 0F | E6", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Converts two 64-bit double-precision floating-point values from the source to two 32-bit signed doublewords in the destination XMM register, always using truncation (rounding towards zero), ignoring MXCSR. Overflow results are saturated to 0x80000000 (INT32_MIN) or 0x7FFFFFFF (INT32_MAX); invalid/NaN inputs produce 0x80000000. The upper 64 bits of the destination are zeroed. No CPU flags are modified.", "pseudocode": "dest[31:0] ← CVTI32_TRUNC(src[63:0]) // lower double to 32-bit int (truncate)\ndest[63:32] ← CVTI32_TRUNC(src[127:64]) // upper double to 32-bit int (truncate)\ndest[127:64] ← 0", "example": "CVTTPD2DQ xmm1, xmm2/m128" }, { "mnemonic": "cvtss2si", "architecture": "x86", "full_name": "Convert Scalar Single to Integer", "summary": "Converts low float to integer (Rounded according to MXCSR).", "syntax": "CVTSS2SI r32, xmm/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 2D", "visual_parts": [], "binary_pattern": "F3 | 0F | 2D", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "xmm/m32", "desc": "128-bit XMM register or 32-bit memory" } ], "description": "Converts the low 32-bit single-precision floating-point value from the source to a 32-bit signed integer in the destination general-purpose register, using the rounding mode specified by MXCSR. Overflow and invalid/NaN inputs produce 0x80000000 (INT32_MIN). In 64-bit mode, the destination register is zero-extended to 64 bits. No CPU flags are modified.", "pseudocode": "rounding_mode ← MXCSR[13:11]\ndest[31:0] ← CVTI32(src[31:0], rounding_mode)\n// In 64-bit mode: dest[63:32] ← 0", "example": "CVTSS2SI eax, xmm1" }, { "mnemonic": "cvtsd2si", "architecture": "x86", "full_name": "Convert Scalar Double to Integer", "summary": "Converts low double to integer (Rounded according to MXCSR).", "syntax": "CVTSD2SI r32, xmm/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 2D", "visual_parts": [], "binary_pattern": "F2 | 0F | 2D", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "xmm/m64", "desc": "128-bit XMM register or 64-bit memory" } ], "description": "Converts the low 64-bit double-precision floating-point value from the source to a 32-bit signed integer in the destination general-purpose register, using the rounding mode specified by MXCSR. Overflow and invalid/NaN inputs produce 0x80000000 (INT32_MIN). In 64-bit mode, the destination register is zero-extended to 64 bits. No CPU flags are modified.", "pseudocode": "rounding_mode ← MXCSR[13:11]\ndest[31:0] ← CVTI32(src[63:0], rounding_mode)\n// In 64-bit mode: dest[63:32] ← 0", "example": "CVTSD2SI eax, xmm1" }, { "mnemonic": "vcvtph2ps", "architecture": "x86", "full_name": "Convert 16-bit FP to 32-bit FP", "summary": "Converts half-precision floats to single-precision.", "syntax": "VCVTPH2PS xmm1, xmm2/m64", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.66.0F38.W0 13 /r", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 13", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "F16C", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Converts four 16-bit half-precision floating-point values to four 32-bit single-precision floating-point values. The source contains up to four FP16 values packed in the lower 64 bits; the destination receives four FP32 results in a 128-bit XMM register. No flags are modified; this is a data conversion instruction.", "pseudocode": "dest[127:0] ← CONVERT_FP16_TO_FP32(src[63:0]); // upper 64 bits of dest are zeroed", "example": "VCVTPH2PS xmm1, xmm2/m64" }, { "mnemonic": "vcvtps2ph", "architecture": "x86", "full_name": "Convert 32-bit FP to 16-bit FP", "summary": "Converts single-precision floats to half-precision.", "syntax": "VCVTPS2PH xmm1/m64, xmm2, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.66.0F3A.W0 1D /r ib", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 1D", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "F16C", "operands": [ { "name": "dest", "type": "xmm1/m64", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Converts four 32-bit single-precision floating-point values to four 16-bit half-precision floating-point values using a rounding mode specified by imm8[2:0]. Results are packed into the lower 64 bits of the destination (register or memory); the upper 64 bits are cleared if destination is XMM. No flags are modified.", "pseudocode": "rounding_mode ← imm8[2:0]; dest[63:0] ← CONVERT_FP32_TO_FP16(src1[127:0], rounding_mode); dest[127:64] ← 0;", "example": "VCVTPS2PH xmm1/m64, xmm2, 3" }, { "mnemonic": "vtestps", "architecture": "x86", "full_name": "Packed Bit Test Single-Precision", "summary": "Sets ZF/CF based on sign bit comparisons of floats.", "syntax": "VTESTPS xmm1, xmm2/m128", "encoding": { "format": "AVX", "hex_opcode": "VEX.128.66.0F38.W0 0E /r", "visual_parts": [], "binary_pattern": "VEX | 66 | 0F | 38 | 0E", "bit_positions": "+0 | +3 | +4 | +5 | +6" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs a bitwise AND of two packed single-precision float vectors and sets ZF based on whether all result bits are zero, and CF based on whether all sign bits are set. No other flags are modified; OF, SF, AF, PF are undefined after execution.", "pseudocode": "temp ← dest[127:0] AND src[127:0]; ZF ← (temp == 0); CF ← ((dest[127] AND src[127]) AND (dest[95] AND src[95]) AND (dest[63] AND src[63]) AND (dest[31] AND src[31]));", "example": "VTESTPS xmm1, xmm2/m128" }, { "mnemonic": "vtestpd", "architecture": "x86", "full_name": "Packed Bit Test Double-Precision", "summary": "Sets ZF/CF based on sign bit comparisons of doubles.", "syntax": "VTESTPD xmm1, xmm2/m128", "encoding": { "format": "AVX", "hex_opcode": "VEX.128.66.0F38.W0 0F /r", "visual_parts": [], "binary_pattern": "VEX | 66 | 0F | 38 | 0F", "bit_positions": "+0 | +3 | +4 | +5 | +6" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs a bitwise AND of two packed double-precision float vectors and sets ZF based on whether all result bits are zero, and CF based on whether both sign bits are set. No other flags are modified; OF, SF, AF, PF are undefined after execution.", "pseudocode": "temp ← dest[127:0] AND src[127:0]; ZF ← (temp == 0); CF ← ((dest[127] AND src[127]) AND (dest[63] AND src[63]));", "example": "VTESTPD xmm1, xmm2/m128" }, { "mnemonic": "vperm2f128", "architecture": "x86", "full_name": "Permute Floating-Point 128-bit Blocks", "summary": "Shuffles 128-bit float lanes between YMM registers.", "syntax": "VPERM2F128 ymm1, ymm2, ymm3/m256, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F3A.W0 06 /r ib", "visual_parts": [], "binary_pattern": "VEX | 66 | 0F | 3A | 06", "bit_positions": "+0 | +3 | +4 | +5 | +6" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rearranges two 128-bit blocks from two 256-bit YMM operands into the destination 256-bit YMM register according to an 8-bit immediate selector. Bits [3:0] select which 128-bit half goes to the low 128 bits, bits [7:4] select the high 128 bits; bit 3 can zero-out the selected half. No flags are modified.", "pseudocode": "imm8 ← src3; x ← imm8[3:0]; y ← imm8[7:4]; if (imm8[3]) { dest[127:0] ← 0; } else { dest[127:0] ← (x[2:0]==0) ? src1[127:0] : (x[2:0]==1) ? src1[255:128] : (x[2:0]==2) ? src2[127:0] : src2[255:128]; } if (imm8[7]) { dest[255:128] ← 0; } else { dest[255:128] ← (y[2:0]==0) ? src1[127:0] : (y[2:0]==1) ? src1[255:128] : (y[2:0]==2) ? src2[127:0] : src2[255:128]; }", "example": "VPERM2F128 ymm1, ymm2, ymm3/m256, 3" }, { "mnemonic": "prefetcht1", "architecture": "x86", "full_name": "Prefetch Data to L2 Cache", "summary": "Hints to fetch data to L2 and L3 caches.", "syntax": "PREFETCHT1 m8", "encoding": { "format": "SSE", "hex_opcode": "0F 18 /2", "visual_parts": [], "binary_pattern": "0F | 18 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "m8", "desc": "8-bit memory operand" } ], "description": "Non-binding hint to the memory system to fetch the byte at the given address into the L2 and L3 caches. The instruction is a no-op to program semantics; it has no effect on registers, flags, or memory, and serves only as a performance hint to reduce cache misses.", "pseudocode": "// Hints to fetch data to L2 and L3 caches", "example": "PREFETCHT1 [rbp-1]" }, { "mnemonic": "prefetcht2", "architecture": "x86", "full_name": "Prefetch Data to L3 Cache", "summary": "Hints to fetch data to L3 cache only.", "syntax": "PREFETCHT2 m8", "encoding": { "format": "SSE", "hex_opcode": "0F 18 /3", "visual_parts": [], "binary_pattern": "0F | 18 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "m8", "desc": "8-bit memory operand" } ], "description": "Non-binding hint to the memory system to fetch the byte at the given address into the L3 cache. The instruction is a no-op to program semantics; it has no effect on registers, flags, or memory, and serves only as a performance hint.", "pseudocode": "// Hints to fetch data to L3 cache only", "example": "PREFETCHT2 [rbp-1]" }, { "mnemonic": "movsxd", "architecture": "x86", "full_name": "Move with Sign-Extension Doubleword", "summary": "Sign-extends 32-bit register to 64-bit.", "syntax": "MOVSXD r64, r/m32", "encoding": { "format": "Base (64-bit)", "hex_opcode": "63", "visual_parts": [], "binary_pattern": "63", "bit_positions": "+0" }, "extension": "Base (64-bit)", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Sign-extends a 32-bit value from a register or memory location to a 64-bit value and stores it in a 64-bit destination register. Only valid in 64-bit mode; the upper 32 bits of the destination are filled with sign-extended copies of bit 31 of the source. No flags are modified.", "pseudocode": "dest[63:0] ← SIGN_EXTEND_32_TO_64(src[31:0]);", "example": "MOVSXD rax, ebx" }, { "mnemonic": "int1", "architecture": "x86", "full_name": "ICE Breakpoint", "summary": "Single byte opcode (0xF1) used for In-Circuit Emulation.", "syntax": "INT1", "encoding": { "format": "Legacy", "hex_opcode": "F1", "visual_parts": [], "binary_pattern": "F1", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Raises a single-byte breakpoint exception (SIMD debugger breakpoint) with opcode 0xF1, used primarily for In-Circuit Emulation (ICE) debugging. This instruction generates an INT 1 exception (vector 1) immediately without privilege level change. The instruction does not set or clear EFLAGS; it is a synchronous trap that suspends execution and invokes the debugger.", "pseudocode": "push_to_stack(EIP + 1);\npush_to_stack(EFLAGS);\njump_to_IDT_entry(1);", "example": "INT1" }, { "mnemonic": "vpcmov", "architecture": "x86", "full_name": "Vector Packed Conditional Move", "summary": "Bitwise conditional move based on selector.", "syntax": "VPCMOV xmm1, xmm2, xmm3, xmm4", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.08.W0 A2 /r ib", "visual_parts": [], "binary_pattern": "08 | A2", "bit_positions": "+0 | +1" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3", "desc": "128-bit XMM SIMD register" }, { "name": "src3", "type": "xmm4", "desc": "128-bit XMM SIMD register" } ], "description": "Performs bitwise conditional move on packed 128-bit XMM data using a selector register. For each bit in the selector (xmm4), if the bit is set (1), the corresponding bit from xmm3 is selected; otherwise, the bit from xmm2 is selected. Result is stored in xmm1. No flags are modified.", "pseudocode": "for i in 0 to 127:\n if (xmm4[i] == 1):\n xmm1[i] ← xmm3[i]\n else:\n xmm1[i] ← xmm2[i]", "example": "VPCMOV xmm1, xmm2, xmm3, xmm4" }, { "mnemonic": "vpcomb", "architecture": "x86", "full_name": "Vector Packed Compare Byte", "summary": "Compares bytes using immediate condition.", "syntax": "VPCOMB xmm1, xmm2, xmm3/m128, imm8", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.08.W0 CC /r ib", "visual_parts": [], "binary_pattern": "08 | CC", "bit_positions": "+0 | +1" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Compares 16 packed bytes in xmm2 and xmm3/m128 using the condition specified in imm8, storing comparison results (all-1s or all-0s per byte) in xmm1. Supports eight comparison predicates (EQ, LT, LE, etc.). No EFLAGS are modified; results are encoded as packed byte masks.", "pseudocode": "for i in 0 to 15:\n byte_a ← xmm2[i*8 : i*8+7]\n byte_b ← xmm3[i*8 : i*8+7]\n result ← evaluate_condition(byte_a, byte_b, imm8)\n xmm1[i*8 : i*8+7] ← result ? 0xFF : 0x00", "example": "VPCOMB xmm1, xmm2, xmm3/m128, 3" }, { "mnemonic": "blcfill", "architecture": "x86", "full_name": "Fill From Lowest Clear Bit", "summary": "Sets all bits below the lowest clear bit (x & (x+1)).", "syntax": "BLCFILL r32, r/m32", "encoding": { "format": "TBM", "hex_opcode": "XOP.L0.09.W0 01 /1", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "TBM", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Fills all bits from the lowest clear bit position downward; computes (src & (src+1)) and stores the result in dest. This sets all bits below and including the position of the lowest 0-bit in the source. No flags are modified by this TBM instruction.", "pseudocode": "result ← src & (src + 1)\ndest ← result", "example": "BLCFILL eax, ebx" }, { "mnemonic": "vgetexpss", "architecture": "x86", "full_name": "Get Exponent Scalar Single", "summary": "Extracts exponent from low float.", "syntax": "VGETEXPSS xmm1 {k1}, xmm2, xmm3/m32", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.66.0F38.W0 43 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 43", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Extracts the biased exponent from the low 32-bit single-precision floating-point element of xmm3/m32 and stores the result as a float in xmm1. The exponent is converted to a normalized floating-point representation. Supports EVEX masking and rounding modes; other three 32-bit elements in xmm1 are preserved from xmm2.", "pseudocode": "float32 src_val ← xmm3[0:31]\nint32 exponent ← extract_biased_exponent(src_val)\nxmm1[0:31] ← convert_exponent_to_float(exponent)\nxmm1[32:127] ← xmm2[32:127]", "example": "VGETEXPSS xmm1, xmm2, xmm3/m32" }, { "mnemonic": "vgetmantsd", "architecture": "x86", "full_name": "Get Mantissa Scalar Double", "summary": "Extracts mantissa from low double.", "syntax": "VGETMANTSD xmm1 {k1}, xmm2, xmm3/m64, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.66.0F3A.W1 27 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 27", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m64", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Extracts the mantissa (significand) from the low 64-bit double-precision floating-point element of xmm3/m64 using the normalization mode in imm8, storing the result as a double in xmm1. Supports EVEX masking and rounding modes; the high 64 bits of xmm1 are preserved from xmm2.", "pseudocode": "float64 src_val ← xmm3[0:63]\nint8 mode ← imm8\nfloat64 mantissa ← extract_mantissa(src_val, mode)\nxmm1[0:63] ← mantissa\nxmm1[64:127] ← xmm2[64:127]", "example": "VGETMANTSD xmm1, xmm2, xmm3/m64, 3" }, { "mnemonic": "movq", "architecture": "x86", "full_name": "Move Quadword (MMX)", "summary": "Moves 64-bit data between MMX registers/memory.", "syntax": "MOVQ mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F 6F /r", "visual_parts": [], "binary_pattern": "0F | 6F", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Moves a 64-bit quadword from an MMX register or memory location to an MMX register. This instruction clears the upper 64 bits of the 128-bit XMM register if used with XMM operands (SSE variant). No flags are modified.", "pseudocode": "dest ← src", "example": "MOVQ mm, mm/m64" }, { "mnemonic": "paddusb", "architecture": "x86", "full_name": "Packed Add Unsigned Saturate Byte (MMX)", "summary": "Adds 8 unsigned bytes with saturation (MMX).", "syntax": "PADDUSB mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F DC /r1", "visual_parts": [], "binary_pattern": "0F | DC", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Adds 8 pairs of packed unsigned 8-bit integers from the MMX register and memory/register source with saturation. If the sum exceeds 255, the result is saturated to 255. No flags are modified; the 64-bit result is stored in the destination MMX register.", "pseudocode": "for i in 0 to 7:\n byte_a ← dest[i*8 : i*8+7]\n byte_b ← src[i*8 : i*8+7]\n sum ← byte_a + byte_b\n dest[i*8 : i*8+7] ← min(sum, 255)", "example": "PADDUSB mm, mm/m64" }, { "mnemonic": "paddsb", "architecture": "x86", "full_name": "Packed Add Signed Saturate Byte (MMX)", "summary": "Adds 8 signed bytes with saturation (MMX).", "syntax": "PADDSB mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F EC /r1", "visual_parts": [], "binary_pattern": "0F | EC", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Adds 8 signed byte pairs in parallel with saturation; if the result overflows (exceeds 127) or underflows (below -128), the result saturates to 127 or -128 respectively. This MMX instruction does not modify any EFLAGS; it operates entirely within the 64-bit MMX register or memory operand.", "pseudocode": "for i = 0 to 7:\n temp ← (signed8)dest[i*8+7:i*8] + (signed8)src[i*8+7:i*8]\n if temp > 127:\n dest[i*8+7:i*8] ← 127\n else if temp < -128:\n dest[i*8+7:i*8] ← -128\n else:\n dest[i*8+7:i*8] ← temp", "example": "PADDSB mm, mm/m64" }, { "mnemonic": "paddusw", "architecture": "x86", "full_name": "Packed Add Unsigned Saturate Word (MMX)", "summary": "Adds 4 unsigned words with saturation (MMX).", "syntax": "PADDUSW mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F DD /r1", "visual_parts": [], "binary_pattern": "0F | DD", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Adds 4 unsigned word pairs in parallel with saturation; overflow is clamped to 65535 (0xFFFF). This MMX instruction does not modify any EFLAGS and operates entirely within the 64-bit MMX register or memory operand.", "pseudocode": "for i = 0 to 3:\n temp ← (unsigned16)dest[i*16+15:i*16] + (unsigned16)src[i*16+15:i*16]\n if temp > 65535:\n dest[i*16+15:i*16] ← 65535\n else:\n dest[i*16+15:i*16] ← temp", "example": "PADDUSW mm, mm/m64" }, { "mnemonic": "paddsw", "architecture": "x86", "full_name": "Packed Add Signed Saturate Word (MMX)", "summary": "Adds 4 signed words with saturation (MMX).", "syntax": "PADDSW mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F ED /r1", "visual_parts": [], "binary_pattern": "0F | ED", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Adds 4 signed word pairs in parallel with saturation; overflow saturates to 32767 and underflow to -32768. This MMX instruction does not modify any EFLAGS and operates entirely within the 64-bit MMX register or memory operand.", "pseudocode": "for i = 0 to 3:\n temp ← (signed16)dest[i*16+15:i*16] + (signed16)src[i*16+15:i*16]\n if temp > 32767:\n dest[i*16+15:i*16] ← 32767\n else if temp < -32768:\n dest[i*16+15:i*16] ← -32768\n else:\n dest[i*16+15:i*16] ← temp", "example": "PADDSW mm, mm/m64" }, { "mnemonic": "psubusb", "architecture": "x86", "full_name": "Packed Subtract Unsigned Saturate Byte (MMX)", "summary": "Subtracts 8 unsigned bytes with saturation (MMX).", "syntax": "PSUBUSB mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F D8 /r1", "visual_parts": [], "binary_pattern": "0F | D8", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Subtracts 8 unsigned byte pairs in parallel with saturation; underflow is clamped to 0. This MMX instruction does not modify any EFLAGS and operates entirely within the 64-bit MMX register or memory operand.", "pseudocode": "for i = 0 to 7:\n if (unsigned8)dest[i*8+7:i*8] < (unsigned8)src[i*8+7:i*8]:\n dest[i*8+7:i*8] ← 0\n else:\n dest[i*8+7:i*8] ← (unsigned8)dest[i*8+7:i*8] - (unsigned8)src[i*8+7:i*8]", "example": "PSUBUSB mm, mm/m64" }, { "mnemonic": "psubsb", "architecture": "x86", "full_name": "Packed Subtract Signed Saturate Byte (MMX)", "summary": "Subtracts 8 signed bytes with saturation (MMX).", "syntax": "PSUBSB mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F E8 /r1", "visual_parts": [], "binary_pattern": "0F | E8", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Subtracts 8 signed byte pairs in parallel with saturation; underflow saturates to -128 and overflow to 127. This MMX instruction does not modify any EFLAGS and operates entirely within the 64-bit MMX register or memory operand.", "pseudocode": "for i = 0 to 7:\n temp ← (signed8)dest[i*8+7:i*8] - (signed8)src[i*8+7:i*8]\n if temp > 127:\n dest[i*8+7:i*8] ← 127\n else if temp < -128:\n dest[i*8+7:i*8] ← -128\n else:\n dest[i*8+7:i*8] ← temp", "example": "PSUBSB mm, mm/m64" }, { "mnemonic": "psubusw", "architecture": "x86", "full_name": "Packed Subtract Unsigned Saturate Word (MMX)", "summary": "Subtracts 4 unsigned words with saturation (MMX).", "syntax": "PSUBUSW mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F D9 /r1", "visual_parts": [], "binary_pattern": "0F | D9", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Subtracts 4 unsigned word pairs in parallel with saturation; underflow is clamped to 0. This MMX instruction does not modify any EFLAGS and operates entirely within the 64-bit MMX register or memory operand.", "pseudocode": "for i = 0 to 3:\n if (unsigned16)dest[i*16+15:i*16] < (unsigned16)src[i*16+15:i*16]:\n dest[i*16+15:i*16] ← 0\n else:\n dest[i*16+15:i*16] ← (unsigned16)dest[i*16+15:i*16] - (unsigned16)src[i*16+15:i*16]", "example": "PSUBUSW mm, mm/m64" }, { "mnemonic": "psubsw", "architecture": "x86", "full_name": "Packed Subtract Signed Saturate Word (MMX)", "summary": "Subtracts 4 signed words with saturation (MMX).", "syntax": "PSUBSW mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F E9 /r1", "visual_parts": [], "binary_pattern": "0F | E9", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Subtracts 4 signed word pairs in parallel with saturation; underflow saturates to -32768 and overflow to 32767. This MMX instruction does not modify any EFLAGS and operates entirely within the 64-bit MMX register or memory operand.", "pseudocode": "for i = 0 to 3:\n temp ← (signed16)dest[i*16+15:i*16] - (signed16)src[i*16+15:i*16]\n if temp > 32767:\n dest[i*16+15:i*16] ← 32767\n else if temp < -32768:\n dest[i*16+15:i*16] ← -32768\n else:\n dest[i*16+15:i*16] ← temp", "example": "PSUBSW mm, mm/m64" }, { "mnemonic": "pmullw", "architecture": "x86", "full_name": "Packed Multiply Low Word (MMX)", "summary": "Multiplies 4 words and stores low 16 bits (MMX).", "syntax": "PMULLW mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F D5 /r1", "visual_parts": [], "binary_pattern": "0F | D5", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Multiplies 4 word pairs in parallel and stores the low 16 bits of each product; the high 16 bits are discarded. This MMX instruction does not modify any EFLAGS and operates entirely within the 64-bit MMX register or memory operand.", "pseudocode": "for i = 0 to 3:\n product ← (signed16)dest[i*16+15:i*16] × (signed16)src[i*16+15:i*16]\n dest[i*16+15:i*16] ← product[15:0]", "example": "PMULLW mm, mm/m64" }, { "mnemonic": "pmulhw", "architecture": "x86", "full_name": "Packed Multiply High Word (MMX)", "summary": "Multiplies 4 signed words and stores high 16 bits (MMX).", "syntax": "PMULHW mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F E5 /r1", "visual_parts": [], "binary_pattern": "0F | E5", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Multiplies four signed 16-bit words in the destination MMX register by four signed 16-bit words in the source operand, and stores the high 16 bits of each 32-bit product in the destination register. This instruction operates on packed 16-bit signed integers and does not affect any flags. It requires MMX support and is commonly used in multimedia and DSP applications.", "pseudocode": "dest[0:15] ← ((INT32(dest[0:15]) * INT32(src[0:15])) >> 16)[0:15];\ndest[16:31] ← ((INT32(dest[16:31]) * INT32(src[16:31])) >> 16)[0:15];\ndest[32:47] ← ((INT32(dest[32:47]) * INT32(src[32:47])) >> 16)[0:15];\ndest[48:63] ← ((INT32(dest[48:63]) * INT32(src[48:63])) >> 16)[0:15];", "example": "PMULHW mm, mm/m64" }, { "mnemonic": "pmaddwd", "architecture": "x86", "full_name": "Packed Multiply Add Word to Doubleword (MMX)", "summary": "Multiplies words and adds adjacent pairs (MMX).", "syntax": "PMADDWD mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F F5 /r1", "visual_parts": [], "binary_pattern": "0F | F5", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Multiplies four pairs of signed 16-bit words, then adds the high and low results of adjacent pairs to produce two signed 32-bit doublewords. The destination MMX register receives the two packed 32-bit sums. This instruction does not affect any flags and is frequently used in audio/video processing and convolution operations.", "pseudocode": "prod[0] ← INT32(dest[0:15]) * INT32(src[0:15]);\nprod[1] ← INT32(dest[16:31]) * INT32(src[16:31]);\nprod[2] ← INT32(dest[32:47]) * INT32(src[32:47]);\nprod[3] ← INT32(dest[48:63]) * INT32(src[48:63]);\ndest[0:31] ← prod[0] + prod[1];\ndest[32:63] ← prod[2] + prod[3];", "example": "PMADDWD mm, mm/m64" }, { "mnemonic": "pand", "architecture": "x86", "full_name": "Packed Logical AND (MMX)", "summary": "Bitwise AND of 64-bit MMX registers.", "syntax": "PAND mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F DB /r1", "visual_parts": [], "binary_pattern": "0F | DB", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Performs a bitwise AND of the 64-bit destination MMX register and a 64-bit source operand, storing the result in the destination. All 64 bits are treated as a single operand; no flag bits are affected. This instruction has no size variants and is available in all processors with MMX support.", "pseudocode": "dest[0:63] ← dest[0:63] & src[0:63];", "example": "PAND mm, mm/m64" }, { "mnemonic": "por", "architecture": "x86", "full_name": "Packed Logical OR (MMX)", "summary": "Bitwise OR of 64-bit MMX registers.", "syntax": "POR mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F EB /r1", "visual_parts": [], "binary_pattern": "0F | EB", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Performs a bitwise OR of the 64-bit destination MMX register and a 64-bit source operand, storing the result in the destination. All 64 bits participate in the operation as a single unit; no flags are affected. This instruction is available on all MMX-capable processors and has no size variants.", "pseudocode": "dest[0:63] ← dest[0:63] | src[0:63];", "example": "POR mm, mm/m64" }, { "mnemonic": "pxor", "architecture": "x86", "full_name": "Packed Logical XOR (MMX)", "summary": "Bitwise XOR of 64-bit MMX registers.", "syntax": "PXOR mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F EF /r1", "visual_parts": [], "binary_pattern": "0F | EF", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Performs a bitwise XOR of the 64-bit destination MMX register and a 64-bit source operand, storing the result in the destination. The operation treats all 64 bits as a single logical unit and does not affect any flags. Notably, PXOR with the same register as both operands can be used to zero a register in one cycle.", "pseudocode": "dest[0:63] ← dest[0:63] ^ src[0:63];", "example": "PXOR mm, mm/m64" }, { "mnemonic": "pandn", "architecture": "x86", "full_name": "Packed Logical AND NOT (MMX)", "summary": "Bitwise AND NOT of 64-bit MMX registers.", "syntax": "PANDN mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F DF /r1", "visual_parts": [], "binary_pattern": "0F | DF", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Performs a bitwise AND NOT operation: the destination is AND'ed with the bitwise complement of the source, storing the result in the destination. Equivalent to (dest & ~src). No flags are modified and the operation processes all 64 bits in a single cycle on MMX-capable processors.", "pseudocode": "dest[0:63] ← dest[0:63] & (~src[0:63]);", "example": "PANDN mm, mm/m64" }, { "mnemonic": "pcmpgtb", "architecture": "x86", "full_name": "Packed Compare Greater Than Byte (MMX)", "summary": "Compares bytes for greater than (MMX).", "syntax": "PCMPGTB mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F 64 /r1", "visual_parts": [], "binary_pattern": "0F | 64", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Compares four signed 8-bit bytes in the destination MMX register with four signed 8-bit bytes in the source operand. Each byte position in the destination is set to 0xFF if the destination byte is greater than the source byte, or 0x00 otherwise. No EFLAGS are affected by this comparison; results are returned as a packed mask in the MMX register.", "pseudocode": "FOR i = 0 TO 7 STEP 8:\n IF INT8(dest[i:i+7]) > INT8(src[i:i+7]) THEN\n dest[i:i+7] ← 0xFF;\n ELSE\n dest[i:i+7] ← 0x00;\n ENDIF;\nENDFOR;", "example": "PCMPGTB mm, mm/m64" }, { "mnemonic": "pcmpgtw", "architecture": "x86", "full_name": "Packed Compare Greater Than Word (MMX)", "summary": "Compares words for greater than (MMX).", "syntax": "PCMPGTW mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F 65 /r1", "visual_parts": [], "binary_pattern": "0F | 65", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Compares two signed 16-bit words in the destination MMX register with two signed 16-bit words in the source operand. Each word position in the destination is set to 0xFFFF if the destination word is greater than the source word, or 0x0000 otherwise. No EFLAGS are modified; comparison results are returned as a packed mask directly in the destination MMX register.", "pseudocode": "FOR i = 0 TO 2 STEP 16:\n IF INT16(dest[i:i+15]) > INT16(src[i:i+15]) THEN\n dest[i:i+15] ← 0xFFFF;\n ELSE\n dest[i:i+15] ← 0x0000;\n ENDIF;\nENDFOR;", "example": "PCMPGTW mm, mm/m64" }, { "mnemonic": "pcmpgtd", "architecture": "x86", "full_name": "Packed Compare Greater Than Doubleword (MMX)", "summary": "Compares doublewords for greater than (MMX).", "syntax": "PCMPGTD mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F 66 /r1", "visual_parts": [], "binary_pattern": "0F | 66", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Performs a signed greater-than comparison on four packed 32-bit doublewords in the destination MMX register and source operand, setting each corresponding doubleword in the destination to all 1s if the comparison is true, or all 0s if false. No EFLAGS are affected; this is a data-parallel operation that operates entirely within the MMX register file.", "pseudocode": "for i = 0 to 1 {\n if (signed(dest.dword[i]) > signed(src.dword[i])) {\n dest.dword[i] ← 0xFFFFFFFF\n } else {\n dest.dword[i] ← 0x00000000\n }\n}", "example": "PCMPGTD mm, mm/m64" }, { "mnemonic": "pcmpeqb", "architecture": "x86", "full_name": "Packed Compare Equal Byte (MMX)", "summary": "Compares bytes for equality (MMX).", "syntax": "PCMPEQB mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F 74 /r1", "visual_parts": [], "binary_pattern": "0F | 74", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Performs an equality comparison on eight packed 8-bit bytes in the destination MMX register and source operand, setting each corresponding byte in the destination to all 1s if equal, or all 0s if not equal. No EFLAGS are affected; the result is a byte-wise mask suitable for conditional data selection.", "pseudocode": "for i = 0 to 7 {\n if (dest.byte[i] == src.byte[i]) {\n dest.byte[i] ← 0xFF\n } else {\n dest.byte[i] ← 0x00\n }\n}", "example": "PCMPEQB mm, mm/m64" }, { "mnemonic": "pcmpeqw", "architecture": "x86", "full_name": "Packed Compare Equal Word (MMX)", "summary": "Compares words for equality (MMX).", "syntax": "PCMPEQW mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F 75 /r1", "visual_parts": [], "binary_pattern": "0F | 75", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Performs an equality comparison on four packed 16-bit words in the destination MMX register and source operand, setting each corresponding word in the destination to all 1s if equal, or all 0s if not equal. No EFLAGS are affected; this is used for creating word-level masks in SIMD operations.", "pseudocode": "for i = 0 to 3 {\n if (dest.word[i] == src.word[i]) {\n dest.word[i] ← 0xFFFF\n } else {\n dest.word[i] ← 0x0000\n }\n}", "example": "PCMPEQW mm, mm/m64" }, { "mnemonic": "pcmpeqd", "architecture": "x86", "full_name": "Packed Compare Equal Doubleword (MMX)", "summary": "Compares doublewords for equality (MMX).", "syntax": "PCMPEQD mm, mm/m64", "encoding": { "format": "MMX", "hex_opcode": "NP 0F 76 /r1", "visual_parts": [], "binary_pattern": "0F | 76", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Performs an equality comparison on two packed 32-bit doublewords in the destination MMX register and source operand, setting each corresponding doubleword in the destination to all 1s if equal, or all 0s if not equal. No EFLAGS are affected; the result is a doubleword-wise mask suitable for conditional operations.", "pseudocode": "for i = 0 to 1 {\n if (dest.dword[i] == src.dword[i]) {\n dest.dword[i] ← 0xFFFFFFFF\n } else {\n dest.dword[i] ← 0x00000000\n }\n}", "example": "PCMPEQD mm, mm/m64" }, { "mnemonic": "psllw", "architecture": "x86", "full_name": "Packed Shift Left Logical Word (MMX)", "summary": "Shifts words left (MMX).", "syntax": "PSLLW mm, imm8", "encoding": { "format": "MMX", "hex_opcode": "NP 0F 71 /6 ib", "visual_parts": [], "binary_pattern": "0F | 71 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs a logical left shift on four packed 16-bit words in the destination MMX register by the count specified in the 8-bit immediate operand, shifting bits out to the left and filling vacated positions with zeros. No EFLAGS are affected; shift counts greater than or equal to 16 result in all zeros for the affected words.", "pseudocode": "count ← src & 0xFF\nfor i = 0 to 3 {\n if (count >= 16) {\n dest.word[i] ← 0x0000\n } else {\n dest.word[i] ← dest.word[i] << count\n }\n}", "example": "PSLLW mm, 3" }, { "mnemonic": "pslld", "architecture": "x86", "full_name": "Packed Shift Left Logical Doubleword (MMX)", "summary": "Shifts doublewords left (MMX).", "syntax": "PSLLD mm, imm8", "encoding": { "format": "MMX", "hex_opcode": "66 0F 72 /6 ib", "visual_parts": [], "binary_pattern": "0F | 72 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs a logical left shift on two packed 32-bit doublewords in the destination MMX register by the count specified in the 8-bit immediate operand, shifting bits out to the left and filling vacated positions with zeros. No EFLAGS are affected; shift counts greater than or equal to 32 result in all zeros for the affected doublewords.", "pseudocode": "count ← src & 0xFF\nfor i = 0 to 1 {\n if (count >= 32) {\n dest.dword[i] ← 0x00000000\n } else {\n dest.dword[i] ← dest.dword[i] << count\n }\n}", "example": "PSLLD mm, 3" }, { "mnemonic": "psllq", "architecture": "x86", "full_name": "Packed Shift Left Logical Quadword (MMX)", "summary": "Shifts quadword left (MMX).", "syntax": "PSLLQ mm, imm8", "encoding": { "format": "MMX", "hex_opcode": "66 0F 73 /6 ib", "visual_parts": [], "binary_pattern": "0F | 73 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs a logical left shift on one packed 64-bit quadword in the destination MMX register by the count specified in the 8-bit immediate operand, shifting bits out to the left and filling vacated positions with zeros. No EFLAGS are affected; shift counts greater than or equal to 64 result in zero.", "pseudocode": "count ← src & 0xFF\nif (count >= 64) {\n dest.qword[0] ← 0x0000000000000000\n} else {\n dest.qword[0] ← dest.qword[0] << count\n}", "example": "PSLLQ mm, 3" }, { "mnemonic": "psrlw", "architecture": "x86", "full_name": "Packed Shift Right Logical Word (MMX)", "summary": "Shifts words right logical (MMX).", "syntax": "PSRLW mm, imm8", "encoding": { "format": "MMX", "hex_opcode": "66 0F 71 /2 ib", "visual_parts": [], "binary_pattern": "0F | 71 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs a logical right shift on four packed 16-bit words in the destination MMX register by the count specified in the 8-bit immediate operand, shifting bits out to the right and filling vacated positions with zeros. No EFLAGS are affected; shift counts greater than or equal to 16 result in all zeros for the affected words.", "pseudocode": "count ← src & 0xFF\nfor i = 0 to 3 {\n if (count >= 16) {\n dest.word[i] ← 0x0000\n } else {\n dest.word[i] ← dest.word[i] >> count\n }\n}", "example": "PSRLW mm, 3" }, { "mnemonic": "psrld", "architecture": "x86", "full_name": "Packed Shift Right Logical Doubleword (MMX)", "summary": "Shifts doublewords right logical (MMX).", "syntax": "PSRLD mm, imm8", "encoding": { "format": "MMX", "hex_opcode": "66 0F 72 /2 ib", "visual_parts": [], "binary_pattern": "0F | 72 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each 32-bit doubleword element in an MMX register right by an immediate count, filling vacated high-order bits with zeros. This is a logical right shift (sign-insensitive) operating on packed doubleword elements. No flags are affected; the shift amount is masked to 5 bits (0-31).", "pseudocode": "count ← src AND 31;\nfor i ← 0 to 1 do\n dest.dw[i] ← dest.dw[i] >> count;\nend;", "example": "PSRLD mm, 3" }, { "mnemonic": "psrlq", "architecture": "x86", "full_name": "Packed Shift Right Logical Quadword (MMX)", "summary": "Shifts quadword right logical (MMX).", "syntax": "PSRLQ mm, imm8", "encoding": { "format": "MMX", "hex_opcode": "66 0F 73 /2 ib", "visual_parts": [], "binary_pattern": "0F | 73 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts the 64-bit quadword in an MMX register right by an immediate count, filling vacated high-order bits with zeros. This is a logical right shift operating on a single 64-bit element. No flags are affected; the shift amount is masked to 6 bits (0-63).", "pseudocode": "count ← src AND 63;\ndest.qw ← dest.qw >> count;", "example": "PSRLQ mm, 3" }, { "mnemonic": "psraw", "architecture": "x86", "full_name": "Packed Shift Right Arithmetic Word (MMX)", "summary": "Shifts words right arithmetic (MMX).", "syntax": "PSRAW mm, imm8", "encoding": { "format": "MMX", "hex_opcode": "66 0F 71 /4 ib", "visual_parts": [], "binary_pattern": "0F | 71 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each 16-bit word element in an MMX register right by an immediate count, filling vacated high-order bits with the sign bit (arithmetic shift). This preserves the sign of signed 16-bit integers. No flags are affected; the shift amount is masked to 4 bits (0-15).", "pseudocode": "count ← src AND 15;\nfor i ← 0 to 3 do\n dest.w[i] ← ARITHMETIC_SHIFT_RIGHT(dest.w[i], count);\nend;", "example": "PSRAW mm, 3" }, { "mnemonic": "psrad", "architecture": "x86", "full_name": "Packed Shift Right Arithmetic Doubleword (MMX)", "summary": "Shifts doublewords right arithmetic (MMX).", "syntax": "PSRAD mm, imm8", "encoding": { "format": "MMX", "hex_opcode": "66 0F 72 /4 ib", "visual_parts": [], "binary_pattern": "0F | 72 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each 32-bit doubleword element in an MMX register right by an immediate count, filling vacated high-order bits with the sign bit (arithmetic shift). This preserves the sign of signed 32-bit integers. No flags are affected; the shift amount is masked to 5 bits (0-31).", "pseudocode": "count ← src AND 31;\nfor i ← 0 to 1 do\n dest.dw[i] ← ARITHMETIC_SHIFT_RIGHT(dest.dw[i], count);\nend;", "example": "PSRAD mm, 3" }, { "mnemonic": "mov", "architecture": "x86", "full_name": "Move", "summary": "Copies data from source to destination.", "syntax": "MOV r/m, r", "pseudocode": "dest ← src;", "example": "MOV EAX, 5 ; Load 5 into EAX\nMOV [EBX], EAX ; Store EAX to memory at EBX", "encoding": { "format": "Legacy", "hex_opcode": "89", "length": "2+", "visual_parts": [], "binary_pattern": "89", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Copies data from the source register to the destination register or memory location. Operates on 16-bit, 32-bit, or 64-bit operands (size determined by operand-size prefix and REX.W in 64-bit mode). No flags are affected; memory ordering is not guaranteed with respect to other threads without explicit synchronization." }, { "mnemonic": "add", "architecture": "x86", "full_name": "Add", "summary": "Adds src to dest and stores result in dest.", "syntax": "ADD r/m, r", "pseudocode": "result ← dest + src;\nOF ← overflow_occurred(dest, src, result);\nSF ← (result < 0);\nZF ← (result == 0);\nAF ← carry_from_bit(3);\nPF ← parity(result);\nCF ← carry_out;\ndest ← result;", "example": "ADD EAX, EBX ; Add EBX to EAX\nADD [EAX], 5 ; Add 5 to the 32-bit integer at address EAX", "encoding": { "format": "Legacy", "hex_opcode": "01", "length": "2+", "visual_parts": [], "binary_pattern": "01", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Adds the source operand to the destination operand and stores the result in the destination; the sum is computed modulo 2^(operand size). Sets OF, SF, ZF, AF, CF, and PF based on the result. Available in 16-bit, 32-bit, and 64-bit forms; operand size is determined by the prefix and REX.W in 64-bit mode." }, { "mnemonic": "sub", "architecture": "x86", "full_name": "Subtract", "summary": "Subtracts src from dest.", "syntax": "SUB r/m, r", "pseudocode": "result ← dest - src;\nOF ← overflow_occurred(dest, src, result);\nSF ← (result < 0);\nZF ← (result == 0);\nAF ← borrow_from_bit(3);\nPF ← parity(result);\nCF ← borrow_out;\ndest ← result;", "example": "SUB EAX, 10 ; Subtract 10 from EAX\nSUB ECX, EDX ; Subtract EDX from ECX", "encoding": { "format": "Legacy", "hex_opcode": "29", "length": "2+", "visual_parts": [], "binary_pattern": "29", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Subtracts the source operand from the destination operand and stores the result in the destination; the difference is computed modulo 2^(operand size). Sets OF, SF, ZF, AF, CF, and PF based on the result. Available in 16-bit, 32-bit, and 64-bit forms; operand size is determined by the prefix and REX.W in 64-bit mode." }, { "mnemonic": "and", "architecture": "x86", "full_name": "Logical AND", "summary": "Performs bitwise AND.", "syntax": "AND r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "21", "length": "2+", "visual_parts": [], "binary_pattern": "21", "bit_positions": "+0" }, "operands": [ { "name": "dest", "desc": "Register/Memory", "type": "r/m" }, { "name": "src", "desc": "Register", "type": "r" } ], "extension": "Base", "description": "Performs a bitwise logical AND of the destination and source operands, storing the result in the destination. Sets SF, ZF, and PF based on the result; clears OF and CF; AF is undefined. Available in 16-bit, 32-bit, and 64-bit forms; operand size is determined by the prefix and REX.W in 64-bit mode.", "pseudocode": "result ← dest AND src;\nSF ← (result < 0);\nZF ← (result == 0);\nPF ← parity(result);\nOF ← 0;\nCF ← 0;\nAF ← undefined;\ndest ← result;", "example": "AND EAX, 0xFF ; Keep lowest 8 bits\nAND ECX, EDX ; Bitwise AND of ECX and EDX" }, { "mnemonic": "or", "architecture": "x86", "full_name": "Logical OR", "summary": "Performs bitwise OR.", "syntax": "OR r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "09", "length": "2+", "visual_parts": [], "binary_pattern": "09", "bit_positions": "+0" }, "operands": [ { "name": "dest", "desc": "Register/Memory", "type": "r/m" }, { "name": "src", "desc": "Register", "type": "r" } ], "extension": "Base", "description": "Performs a bitwise logical OR between the destination and source operands, storing the result in the destination. Sets ZF, SF, and PF based on the result; clears OF and CF; AF is undefined. Available in 8, 16, 32, and 64-bit variants across all modes.", "pseudocode": "dest ← dest | src; ZF ← (result == 0); SF ← (result < 0); PF ← parity(result); CF ← 0; OF ← 0; AF ← undefined;", "example": "OR EAX, 1 ; Set lowest bit\nOR EAX, EAX ; Check if EAX is zero (sets ZF)" }, { "mnemonic": "xor", "architecture": "x86", "full_name": "Logical Exclusive OR", "summary": "Performs bitwise XOR.", "syntax": "XOR r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "31", "length": "2+", "visual_parts": [], "binary_pattern": "31", "bit_positions": "+0" }, "operands": [ { "name": "dest", "desc": "Register/Memory", "type": "r/m" }, { "name": "src", "desc": "Register", "type": "r" } ], "extension": "Base", "description": "Performs a bitwise logical exclusive OR (XOR) between the destination and source operands, storing the result in the destination. Sets ZF, SF, and PF based on the result; clears OF and CF; AF is undefined. Available in 8, 16, 32, and 64-bit variants across all modes.", "pseudocode": "dest ← dest ^ src; ZF ← (result == 0); SF ← (result < 0); PF ← parity(result); CF ← 0; OF ← 0; AF ← undefined;", "example": "XOR EAX, EAX ; Clear EAX (set to 0)\nXOR EAX, 5 ; Toggle bits 0 and 2" }, { "mnemonic": "cmp", "architecture": "x86", "full_name": "Compare Two Operands", "summary": "Subtracts src from dest and updates flags (dest not modified).", "syntax": "CMP r/m, r", "encoding": { "format": "Legacy", "hex_opcode": "39", "length": "2+", "visual_parts": [], "binary_pattern": "39", "bit_positions": "+0" }, "operands": [ { "name": "dest", "desc": "Register/Memory", "type": "r/m" }, { "name": "src", "desc": "Register", "type": "r" } ], "extension": "Base", "description": "Subtracts the source operand from the destination operand and updates the EFLAGS register without modifying the destination. Sets or clears CF, PF, AF, ZF, SF, and OF based on the subtraction result. Available in 8, 16, 32, and 64-bit variants across all modes.", "pseudocode": "temp ← dest - src; CF ← (dest < src); ZF ← (temp == 0); SF ← (temp < 0); OF ← overflow(dest, src); PF ← parity(temp); AF ← half_borrow(dest, src);", "example": "CMP EAX, 10 ; Compare EAX with 10\nJE label ; Jump if Equal" }, { "mnemonic": "test", "architecture": "x86", "full_name": "Logical Compare", "summary": "ANDs operands and updates flags (result discarded).", "syntax": "TEST r/m, r", "pseudocode": "temp ← dest & src; ZF ← (temp == 0); SF ← (temp < 0); PF ← parity(temp); CF ← 0; OF ← 0; AF ← undefined;", "example": "TEST EAX, EAX ; Check if EAX is 0\nTEST AL, 1 ; Check if lowest bit is set", "encoding": { "format": "Legacy", "hex_opcode": "85", "length": "2+", "visual_parts": [], "binary_pattern": "85", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m", "desc": "Register or memory operand" }, { "name": "src", "type": "r", "desc": "General-purpose register" } ], "description": "Performs a bitwise logical AND between the destination and source operands, updating EFLAGS without modifying either operand. Sets ZF, SF, and PF based on the AND result; clears OF and CF; AF is undefined. Available in 8, 16, 32, and 64-bit variants across all modes." }, { "mnemonic": "lfence", "architecture": "x86", "full_name": "Load Fence", "summary": "Serializes load operations (Wait for prior loads to complete).", "syntax": "LFENCE", "encoding": { "format": "SSE2", "hex_opcode": "NP 0F AE E8", "visual_parts": [], "binary_pattern": "0F | AE | E8", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [], "description": "Serializes all load instructions that precede it in program order; subsequent loads wait until prior loads complete and their data is globally visible. Provides acquire-like semantics for loads on TSO (Total Store Order) architectures. No flags are affected. SSE2 extension; acts as a no-op on non-TSO systems without explicit serialization requirements.", "pseudocode": "wait_for_all_prior_loads_to_complete();", "example": "LFENCE" }, { "mnemonic": "sfence", "architecture": "x86", "full_name": "Store Fence", "summary": "Serializes store operations (Wait for prior stores to complete).", "syntax": "SFENCE", "encoding": { "format": "SSE", "hex_opcode": "NP 0F AE F8", "visual_parts": [], "binary_pattern": "0F | AE | F8", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [], "description": "Serializes all store instructions that precede it in program order; subsequent stores wait until prior stores complete and are globally visible. Provides release-like semantics for stores. No flags are affected. SSE extension; acts as a no-op on processors where stores are already globally ordered.", "pseudocode": "wait_for_all_prior_stores_to_complete();", "example": "SFENCE" }, { "mnemonic": "mfence", "architecture": "x86", "full_name": "Memory Fence", "summary": "Serializes all load and store operations.", "syntax": "MFENCE", "encoding": { "format": "SSE2", "hex_opcode": "NP 0F AE F0", "visual_parts": [], "binary_pattern": "0F | AE | F0", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [], "description": "Serializes all load and store instructions (both prior and subsequent) with respect to one another; acts as a full memory barrier. Ensures all prior memory operations complete and are globally visible before any subsequent memory operations begin. No flags are affected. SSE2 extension; commonly used for cross-CPU synchronization.", "pseudocode": "wait_for_all_prior_loads_and_stores_to_complete(); wait_for_global_visibility();", "example": "MFENCE" }, { "mnemonic": "clflush", "architecture": "x86", "full_name": "Cache Line Flush", "summary": "Flushes the cache line containing the operand from all caches.", "syntax": "CLFLUSH m8", "encoding": { "format": "SSE2", "hex_opcode": "NP 0F AE /7", "visual_parts": [], "binary_pattern": "0F | AE | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "m8", "desc": "8-bit memory operand" } ], "description": "Flushes the cache line containing the specified memory address from all cache levels (L1, L2, L3) without writing dirty data back to memory. Serializes the instruction stream and ensures all prior memory operations complete before execution. No flags are modified. Supported in protected and 64-bit modes; requires SSE2 or equivalent.", "pseudocode": "cache_line ← address_of(memory_address)\nfor each cache_level in (L1, L2, L3):\n invalidate(cache_line in cache_level)", "example": "CLFLUSH [rbp-1]" }, { "mnemonic": "rdtscp", "architecture": "x86", "full_name": "Read Time-Stamp Counter and Processor ID", "summary": "Reads TSC into EDX:EAX and Processor ID into ECX.", "syntax": "RDTSCP", "encoding": { "format": "Legacy", "hex_opcode": "0F 01 F9", "visual_parts": [], "binary_pattern": "0F | 01 | F9", "bit_positions": "+0 | +1 | +2" }, "extension": "Base", "operands": [], "description": "Reads the 64-bit Time-Stamp Counter (TSC) into EDX:EAX and writes the low byte of the IA32_TSC_AUX MSR into ECX. Acts as a serializing instruction, ensuring all prior instructions have completed before TSC is captured. No arithmetic flags are modified. Requires RDTSCP capability; available in both 32-bit and 64-bit modes.", "pseudocode": "EDX:EAX ← TSC\nECX ← (IA32_TSC_AUX MSR)[0:31]", "example": "RDTSCP" }, { "mnemonic": "xsave", "architecture": "x86", "full_name": "Save Processor Extended States", "summary": "Saves specified state components (AVX, SSE, etc.) to memory.", "syntax": "XSAVE m", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F AE /4", "visual_parts": [], "binary_pattern": "0F | AE | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "XSAVE", "operands": [ { "name": "dest", "type": "m", "desc": "Memory operand" } ], "description": "Saves processor extended state components (selected by EDX:EAX, typically FPU, SSE, AVX, and AVX-512 state) to a memory region starting at the address specified in the operand. Serializes the instruction stream and performs a context save without modifying any flags. Requires XSAVE capability; privilege level may be restricted depending on state component being saved.", "pseudocode": "state_mask ← EDX:EAX\nfor each enabled_state in state_components:\n if state_mask & enabled_state:\n memory_region ← save(enabled_state)", "example": "XSAVE [rbp-8]" }, { "mnemonic": "xrstor", "architecture": "x86", "full_name": "Restore Processor Extended States", "summary": "Restores specified state components from memory.", "syntax": "XRSTOR m", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F AE /5", "visual_parts": [], "binary_pattern": "0F | AE | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "XSAVE", "operands": [ { "name": "dest", "type": "m", "desc": "Memory operand" } ], "description": "Restores processor extended state components (selected by EDX:EAX) from a memory region at the specified address. Loads FPU, SSE, AVX, and AVX-512 state as indicated by the state mask. Serializes the instruction stream and does not modify arithmetic flags. Requires XRSTOR capability; memory layout must match that produced by XSAVE.", "pseudocode": "state_mask ← EDX:EAX\nfor each enabled_state in state_components:\n if state_mask & enabled_state:\n enabled_state ← memory_region[offset]", "example": "XRSTOR [rbp-8]" }, { "mnemonic": "xgetbv", "architecture": "x86", "full_name": "Get Value of Extended Control Register", "summary": "Reads the state of XCR0 (feature mask) into EDX:EAX.", "syntax": "XGETBV", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 D0", "visual_parts": [], "binary_pattern": "0F | 01 | D0", "bit_positions": "+0 | +1 | +2" }, "extension": "XSAVE", "operands": [], "description": "Reads the 64-bit value of extended control register XCR0 (feature mask indicating which extended processor states are enabled) into EDX:EAX. Does not modify any arithmetic flags. Requires XSAVE capability and typically requires execution at privilege level 0, though user-mode access may be permitted with UMWAIT or in certain OS configurations.", "pseudocode": "EDX:EAX ← XCR0", "example": "XGETBV" }, { "mnemonic": "xsetbv", "architecture": "x86", "full_name": "Set Value of Extended Control Register", "summary": "Writes EDX:EAX to XCR0 (Enables/disables AVX/SSE states).", "syntax": "XSETBV", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 D1", "visual_parts": [], "binary_pattern": "0F | 01 | D1", "bit_positions": "+0 | +1 | +2" }, "extension": "XSAVE", "operands": [], "description": "Writes the 64-bit value from EDX:EAX into extended control register XCR0, enabling or disabling processor extended states (AVX, SSE, AVX-512, etc.). Serializes the instruction stream and forces all prior instructions to complete. No arithmetic flags are modified. Requires privilege level 0 and XSAVE capability.", "pseudocode": "XCR0 ← EDX:EAX", "example": "XSETBV" }, { "mnemonic": "shufps", "architecture": "x86", "full_name": "Shuffle Packed Single-Precision", "summary": "Shuffles 32-bit floats between two XMM registers.", "syntax": "SHUFPS xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE", "hex_opcode": "NP 0F C6 /r ib", "visual_parts": [], "binary_pattern": "0F | C6", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shuffles four 32-bit single-precision floating-point values from the destination XMM register and source XMM/memory operand according to a 2-bit control value in the immediate byte, placing the result in the destination. The immediate selects which of the four source elements populate each destination element. No arithmetic flags are affected. Supported in SSE and later.", "pseudocode": "dest[31:0] ← select_from_2bits(imm8[1:0], dest[31:0], dest[63:32], src[31:0], src[63:32])\ndest[63:32] ← select_from_2bits(imm8[3:2], dest[31:0], dest[63:32], src[31:0], src[63:32])\ndest[95:64] ← select_from_2bits(imm8[5:4], src[127:96], src[95:64], src[31:0], src[63:32])\ndest[127:96] ← select_from_2bits(imm8[7:6], src[127:96], src[95:64], src[31:0], src[63:32])", "example": "SHUFPS xmm1, xmm2/m128, 3" }, { "mnemonic": "shufpd", "architecture": "x86", "full_name": "Shuffle Packed Double-Precision", "summary": "Shuffles 64-bit doubles between two XMM registers.", "syntax": "SHUFPD xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE2", "hex_opcode": "66 0F C6", "visual_parts": [], "binary_pattern": "66 | 0F | C6", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shuffles two 64-bit double-precision floating-point values from the destination XMM register and source XMM/memory operand according to a 2-bit control value in the immediate byte, placing the result in the destination. The low bit selects element 0 of the result (from dest or src), the high bit selects element 1. No arithmetic flags are affected. Requires SSE2 or later.", "pseudocode": "dest[63:0] ← imm8[0] ? src[63:0] : dest[63:0]\ndest[127:64] ← imm8[1] ? src[127:64] : dest[127:64]", "example": "SHUFPD xmm1, xmm2/m128, 3" }, { "mnemonic": "unpcklps", "architecture": "x86", "full_name": "Unpack Low Packed Single-Precision", "summary": "Interleaves low floats from two registers.", "syntax": "UNPCKLPS xmm1, xmm2/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 14 /r", "visual_parts": [], "binary_pattern": "0F | 14", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Interleaves the low 64 bits (two 32-bit floats) from the destination XMM register with the low 64 bits from the source, producing [src[31:0], dest[31:0], src[63:32], dest[63:32]] in the destination. This SIMD instruction has no effect on CPU flags and operates only on the XMM register file. It is part of the SSE extension and works identically across all modern 64-bit modes.", "pseudocode": "xmm1[31:0] ← xmm1[31:0];\nxmm1[63:32] ← src[31:0];\nxmm1[95:64] ← xmm1[63:32];\nxmm1[127:96] ← src[63:32];", "example": "UNPCKLPS xmm1, xmm2/m128" }, { "mnemonic": "unpckhps", "architecture": "x86", "full_name": "Unpack High Packed Single-Precision", "summary": "Interleaves high floats from two registers.", "syntax": "UNPCKHPS xmm1, xmm2/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 15 /r", "visual_parts": [], "binary_pattern": "0F | 15", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Interleaves the high 64 bits (two 32-bit floats) from the destination XMM register with the high 64 bits from the source, producing [src[95:64], dest[95:64], src[127:96], dest[127:96]] in the destination. This SIMD instruction has no effect on CPU flags and operates only on the XMM register file. It is part of the SSE extension and works identically across all modern 64-bit modes.", "pseudocode": "xmm1[31:0] ← xmm1[95:64];\nxmm1[63:32] ← src[95:64];\nxmm1[95:64] ← xmm1[127:96];\nxmm1[127:96] ← src[127:96];", "example": "UNPCKHPS xmm1, xmm2/m128" }, { "mnemonic": "movntps", "architecture": "x86", "full_name": "Move Non-Temporal Packed Single", "summary": "Stores float vectors directly to RAM, bypassing cache.", "syntax": "MOVNTPS m128, xmm", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 2B /r", "visual_parts": [], "binary_pattern": "0F | 2B", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "m128", "desc": "128-bit memory operand" }, { "name": "src", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" } ], "description": "Writes 128 bits from an XMM register directly to memory without bringing the cache line into the L1 data cache, using a write-combining memory type. This non-temporal store is optimal for streaming data that will not be reused soon. The instruction has no effect on CPU flags and executes as a store-to-memory operation without fence semantics.", "pseudocode": "[m128] ← xmm;", "example": "MOVNTPS [rbp-16], xmm0" }, { "mnemonic": "movntpd", "architecture": "x86", "full_name": "Move Non-Temporal Packed Double", "summary": "Stores double vectors directly to RAM, bypassing cache.", "syntax": "MOVNTPD m128, xmm", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 2B", "visual_parts": [], "binary_pattern": "66 | 0F | 2B", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "m128", "desc": "128-bit memory operand" }, { "name": "src", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" } ], "description": "Writes 128 bits from an XMM register directly to memory without bringing the cache line into the L1 data cache, using a write-combining memory type, operating on two 64-bit double-precision floats. This non-temporal store is optimal for streaming data that will not be reused soon. The instruction has no effect on CPU flags and executes as a store-to-memory operation without fence semantics.", "pseudocode": "[m128] ← xmm;", "example": "MOVNTPD [rbp-16], xmm0" }, { "mnemonic": "blendpd", "architecture": "x86", "full_name": "Blend Packed Double-Precision", "summary": "Selects doubles from two sources based on immediate mask.", "syntax": "BLENDPD xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 0D", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 0D", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Selects each 64-bit double-precision element from the destination or source register based on the corresponding bit in an 8-bit immediate mask (bit 0 for element 0, bit 1 for element 1). If the bit is 0, the element from xmm1 is retained; if 1, the element from the source is used. No CPU flags are affected by this SIMD operation, which is part of the SSE4.1 extension.", "pseudocode": "imm ← imm8;\nxmm1[63:0] ← (imm[0] == 1) ? src[63:0] : xmm1[63:0];\nxmm1[127:64] ← (imm[1] == 1) ? src[127:64] : xmm1[127:64];", "example": "BLENDPD xmm1, xmm2/m128, 3" }, { "mnemonic": "insertps", "architecture": "x86", "full_name": "Insert Packed Single-Precision", "summary": "Inserts a single float into a specific index of XMM.", "syntax": "INSERTPS xmm1, xmm2/m32, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 21", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 21", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Inserts a single 32-bit float from a source (register or memory) into a specific lane of the destination XMM register as specified by bits [5:4] of the immediate operand, and optionally zeros lanes specified by bits [3:0]. No CPU flags are affected by this SIMD operation, which is part of the SSE4.1 extension.", "pseudocode": "imm ← imm8;\ncount_d ← (imm >> 4) & 0x3;\nzero_mask ← imm & 0xF;\nsrc_dword ← src[31:0];\nxmm1[count_d*32 + 31 : count_d*32] ← src_dword;\nfor i in 0 to 3:\n if (zero_mask & (1 << i)) then xmm1[i*32 + 31 : i*32] ← 0;", "example": "INSERTPS xmm1, xmm2/m32, 3" }, { "mnemonic": "extractps", "architecture": "x86", "full_name": "Extract Packed Single-Precision", "summary": "Extracts a single float from XMM to an integer register.", "syntax": "EXTRACTPS r32/m32, xmm1, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 17", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 17", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "r32/m32", "desc": "General-purpose register or Memory operand" }, { "name": "src1", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Extracts a single 32-bit float from a source XMM register at a lane specified by bits [1:0] of the immediate operand and writes it to a 32-bit destination (GP register or memory). The extracted value is zero-extended if written to a 32-bit register. No CPU flags are affected by this SIMD operation, which is part of the SSE4.1 extension.", "pseudocode": "imm ← imm8;\nindex ← imm & 0x3;\nsrc_dword ← xmm1[index*32 + 31 : index*32];\ndest[31:0] ← src_dword;", "example": "EXTRACTPS r32/m32, xmm1, 3" }, { "mnemonic": "dpps", "architecture": "x86", "full_name": "Dot Product Packed Single-Precision", "summary": "Computes the dot product of two float vectors.", "syntax": "DPPS xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 40", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 40", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Computes the dot product of the four 32-bit float elements in the destination and source registers, then selectively masks the result and zeros based on an 8-bit immediate. The result (or zero) is replicated into each 32-bit element of the destination according to the mask. No CPU flags are affected by this SIMD operation, which is part of the SSE4.1 extension.", "pseudocode": "imm ← imm8;\nproduct ← 0.0;\nfor i in 0 to 3:\n if (imm & (1 << (i+4))) then\n product ← product + (dest[i*32+31:i*32] * src[i*32+31:i*32]);\nfor i in 0 to 3:\n if (imm & (1 << i)) then\n dest[i*32+31:i*32] ← product;\n else\n dest[i*32+31:i*32] ← 0.0;", "example": "DPPS xmm1, xmm2/m128, 3" }, { "mnemonic": "dppd", "architecture": "x86", "full_name": "Dot Product Packed Double-Precision", "summary": "Computes the dot product of two double vectors.", "syntax": "DPPD xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 41", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 41", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Computes the dot product of two packed double-precision floating-point vectors (2 doubles per 128-bit operand) and stores the result in the destination. The imm8 byte controls which elements participate in the dot product and which output elements are zeroed. No flags are affected; this is a SSE4.1 instruction that operates only in 64-bit and protected modes.", "pseudocode": "select_mask ← imm8[7:4]\nproduct_mask ← imm8[3:0]\ntemp ← 0.0\nfor i in 0..1:\n if (product_mask[i] == 1):\n temp ← temp + (xmm1[i*64+63:i*64] * src1[i*64+63:i*64])\nfor i in 0..1:\n if (select_mask[i] == 1):\n dest[i*64+63:i*64] ← temp\n else:\n dest[i*64+63:i*64] ← 0.0", "example": "DPPD xmm1, xmm2/m128, 3" }, { "mnemonic": "roundps", "architecture": "x86", "full_name": "Round Packed Single-Precision", "summary": "Rounds all packed floats according to immediate mode.", "syntax": "ROUNDPS xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 08", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 08", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rounds each packed single-precision floating-point element in the source operand according to the rounding mode specified in imm8 and stores the result in the destination. The rounding mode imm8[2:0] selects between round-to-nearest, round-down, round-up, or truncate; bit 3 selects whether to suppress inexact exceptions. No CPU flags are modified; this is a SSE4.1 instruction available in 64-bit and protected modes.", "pseudocode": "rounding_mode ← imm8[2:0]\nsuppress_inexact ← imm8[3]\nfor i in 0..3:\n f32 ← src[i*32+31:i*32]\n if (rounding_mode == 0): /* round to nearest */\n result ← round_nearest(f32)\n elif (rounding_mode == 1): /* round down */\n result ← round_down(f32)\n elif (rounding_mode == 2): /* round up */\n result ← round_up(f32)\n elif (rounding_mode == 3): /* truncate */\n result ← truncate(f32)\n dest[i*32+31:i*32] ← result", "example": "ROUNDPS xmm1, xmm2/m128, 3" }, { "mnemonic": "roundpd", "architecture": "x86", "full_name": "Round Packed Double-Precision", "summary": "Rounds all packed doubles according to immediate mode.", "syntax": "ROUNDPD xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 09", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 09", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rounds each packed double-precision floating-point element in the source operand according to the rounding mode specified in imm8 and stores the result in the destination. The rounding mode imm8[2:0] selects between round-to-nearest, round-down, round-up, or truncate; bit 3 controls inexact exception suppression. No CPU flags are modified; this is a SSE4.1 instruction available in 64-bit and protected modes.", "pseudocode": "rounding_mode ← imm8[2:0]\nsuppress_inexact ← imm8[3]\nfor i in 0..1:\n f64 ← src[i*64+63:i*64]\n if (rounding_mode == 0): /* round to nearest */\n result ← round_nearest(f64)\n elif (rounding_mode == 1): /* round down */\n result ← round_down(f64)\n elif (rounding_mode == 2): /* round up */\n result ← round_up(f64)\n elif (rounding_mode == 3): /* truncate */\n result ← truncate(f64)\n dest[i*64+63:i*64] ← result", "example": "ROUNDPD xmm1, xmm2/m128, 3" }, { "mnemonic": "pcmpeqq", "architecture": "x86", "full_name": "Packed Compare Equal Quadword", "summary": "Checks if 64-bit integer elements are equal.", "syntax": "PCMPEQQ xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 29", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 29", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed 64-bit signed integer elements in the destination and source operands for equality, setting all bits to 1 in the corresponding 64-bit result element if equal, or 0 if not equal. No CPU flags are affected; this is a SSE4.1 instruction available in 64-bit and protected modes.", "pseudocode": "for i in 0..1:\n if (dest[i*64+63:i*64] == src[i*64+63:i*64]):\n dest[i*64+63:i*64] ← 0xFFFFFFFFFFFFFFFF\n else:\n dest[i*64+63:i*64] ← 0x0000000000000000", "example": "PCMPEQQ xmm1, xmm2/m128" }, { "mnemonic": "pcmpestri", "architecture": "x86", "full_name": "Packed Compare Explicit Length Strings, Return Index", "summary": "Complex string search/compare; returns index in ECX.", "syntax": "PCMPESTRI xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE4.2", "hex_opcode": "66 0F 3A 61", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 61", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs explicit-length packed string comparison between two 128-bit operands using element size and comparison operation encoded in imm8, returning the index of the first match (or mismatch, depending on control bits) in ECX and setting CF and ZF flags. The lengths of the strings are provided implicitly in EAX and EDX; this is a SSE4.2 instruction that can serialize the pipeline and is available in 64-bit and protected modes.", "pseudocode": "pcmp_control ← imm8[2:0]\nstring_type ← imm8[5:4]\npolarity ← imm8[7:6]\nlen1 ← EAX & 0xFFFF\nlen2 ← EDX & 0xFFFF\nintres ← perform_string_compare(dest, src, string_type, pcmp_control, len1, len2)\nECX ← intres\nCF ← (intres < string_length)\nZF ← (intres == string_length)\nSF ← OF ← undefined", "example": "PCMPESTRI xmm1, xmm2/m128, 3" }, { "mnemonic": "pcmpestrm", "architecture": "x86", "full_name": "Packed Compare Explicit Length Strings, Return Mask", "summary": "Complex string search/compare; returns mask in XMM0.", "syntax": "PCMPESTRM xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE4.2", "hex_opcode": "66 0F 3A 60", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 60", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs explicit-length packed string comparison between two 128-bit operands using element size and comparison operation encoded in imm8, returning a 128-bit mask of comparison results in XMM0 and setting CF and ZF flags. The string lengths are provided implicitly in EAX and EDX; this is a SSE4.2 instruction that can serialize the pipeline and is available in 64-bit and protected modes.", "pseudocode": "pcmp_control ← imm8[2:0]\nstring_type ← imm8[5:4]\npolarity ← imm8[7:6]\nlen1 ← EAX & 0xFFFF\nlen2 ← EDX & 0xFFFF\nmask ← perform_string_compare_mask(dest, src, string_type, pcmp_control, len1, len2)\nXMM0 ← mask\nCF ← (any_match_found)\nZF ← (all_matches_found)\nSF ← OF ← undefined", "example": "PCMPESTRM xmm1, xmm2/m128, 3" }, { "mnemonic": "pcmpistri", "architecture": "x86", "full_name": "Packed Compare Implicit Length Strings, Return Index", "summary": "String search (null-terminated); returns index in ECX.", "syntax": "PCMPISTRI xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE4.2", "hex_opcode": "66 0F 3A 63", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 63", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs implicit-length (null-terminated) packed string comparison between two 128-bit operands using element size and comparison operation encoded in imm8, returning the index of the first match in ECX and setting CF and ZF flags. String lengths are determined by scanning for zero terminators; this is a SSE4.2 instruction that can serialize the pipeline and is available in 64-bit and protected modes.", "pseudocode": "pcmp_control ← imm8[2:0]\nstring_type ← imm8[5:4]\npolarity ← imm8[7:6]\nlen1 ← scan_for_null(dest, string_type)\nlen2 ← scan_for_null(src, string_type)\nintres ← perform_string_compare(dest, src, string_type, pcmp_control, len1, len2)\nECX ← intres\nCF ← (intres < max_length)\nZF ← (intres == max_length)\nSF ← OF ← undefined", "example": "PCMPISTRI xmm1, xmm2/m128, 3" }, { "mnemonic": "vfmadd132ss", "architecture": "x86", "full_name": "Fused Multiply-Add Scalar Single (132)", "summary": "Scalar FMA: Dest = (Dest * Src2) + Src1.", "syntax": "VFMADD132SS xmm1, xmm2, xmm3/m32", "encoding": { "format": "FMA3", "hex_opcode": "VEX.LIG.66.0F38.W0 99 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "FMA3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs a scalar fused multiply-add of three operands using VEX encoding: computes (Dest * Src2) + Src1 and stores the result in Dest with only the lower 32-bit scalar single-precision element affected while preserving upper 96 bits. The operand order '132' indicates destination is the first operand, first source is the second register operand, and second source is the third operand. No CPU flags are modified; this is a FMA3 instruction available in 64-bit mode on processors supporting the FMA3 extension.", "pseudocode": "temp_f32 ← (dest[31:0] * src2[31:0]) + src1[31:0]\ndest[31:0] ← temp_f32\n/* dest[127:32] unchanged */", "example": "VFMADD132SS xmm1, xmm2, xmm3/m32" }, { "mnemonic": "vfmadd213ss", "architecture": "x86", "full_name": "Fused Multiply-Add Scalar Single (213)", "summary": "Scalar FMA: Dest = (Src1 * Dest) + Src2.", "syntax": "VFMADD213SS xmm1, xmm2, xmm3/m32", "encoding": { "format": "FMA3", "hex_opcode": "VEX.LIG.66.0F38.W0 A9 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "FMA3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Fused multiply-add scalar single: performs (Src1 * Dest) + Src2, storing the result in Dest with a single rounding step. Only the lowest 32-bit float element is operated on; upper 96 bits of Dest are preserved. No EFLAGS are modified; rounding is controlled by MXCSR.", "pseudocode": "Dest[0..31] ← FMA(Src1[0..31] * Dest[0..31] + Src2[0..31])\nDest[32..127] ← unchanged", "example": "VFMADD213SS xmm1, xmm2, xmm3/m32" }, { "mnemonic": "vfmadd231ss", "architecture": "x86", "full_name": "Fused Multiply-Add Scalar Single (231)", "summary": "Scalar FMA: Dest = (Src1 * Src2) + Dest.", "syntax": "VFMADD231SS xmm1, xmm2, xmm3/m32", "encoding": { "format": "FMA3", "hex_opcode": "VEX.LIG.66.0F38.W0 B9 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "FMA3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Fused multiply-add scalar single: performs (Src1 * Src2) + Dest, storing the result in Dest with a single rounding step. Only the lowest 32-bit float element is operated on; upper 96 bits of Dest are preserved. No EFLAGS are modified; rounding is controlled by MXCSR.", "pseudocode": "Dest[0..31] ← FMA(Src1[0..31] * Src2[0..31] + Dest[0..31])\nDest[32..127] ← unchanged", "example": "VFMADD231SS xmm1, xmm2, xmm3/m32" }, { "mnemonic": "vpermilps", "architecture": "x86", "full_name": "Permute In-Lane Packed Single", "summary": "Shuffles floats within 128-bit lanes (AVX).", "syntax": "VPERMILPS ymm1, ymm2/m256, imm8", "encoding": { "format": "AVX", "hex_opcode": "VEX.256.66.0F3A.W0 04 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2/m256", "desc": "256-bit YMM AVX register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Permutes 32-bit float elements within 128-bit lanes independently using an 8-bit immediate, allowing shuffles within the lower and upper halves of a 256-bit register. No EFLAGS are affected. The immediate encoding selects 2-bit indices per float element.", "pseudocode": "for each 128-bit lane L in 0..1:\n for each 32-bit element i in 0..3:\n idx ← (Src1[L*128 + i*2 + 1 : L*128 + i*2]) & 0x3\n Dest[L*128 + i*32 : L*128 + i*32 + 31] ← Src1[L*128 + idx*32 : L*128 + idx*32 + 31]", "example": "VPERMILPS ymm1, ymm2/m256, 3" }, { "mnemonic": "vpermilpd", "architecture": "x86", "full_name": "Permute In-Lane Packed Double", "summary": "Shuffles doubles within 128-bit lanes (AVX).", "syntax": "VPERMILPD ymm1, ymm2/m256, imm8", "encoding": { "format": "AVX", "hex_opcode": "VEX.256.66.0F3A.W0 05 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2/m256", "desc": "256-bit YMM AVX register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Permutes 64-bit double elements within 128-bit lanes independently using an 8-bit immediate, allowing shuffles within the lower and upper halves of a 256-bit register. No EFLAGS are affected. The immediate encoding selects 1-bit indices per double element.", "pseudocode": "for each 128-bit lane L in 0..1:\n for each 64-bit element i in 0..1:\n idx ← (Src1[L*128 + i]) & 0x1\n Dest[L*128 + i*64 : L*128 + i*64 + 63] ← Src1[L*128 + idx*64 : L*128 + idx*64 + 63]", "example": "VPERMILPD ymm1, ymm2/m256, 3" }, { "mnemonic": "vbroadcastss", "architecture": "x86", "full_name": "Broadcast Scalar Single", "summary": "Loads one float and replicates it to all YMM elements.", "syntax": "VBROADCASTSS ymm1, m32", "encoding": { "format": "AVX", "hex_opcode": "VEX.256.66.0F38.W0 18 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src", "type": "m32", "desc": "32-bit memory operand" } ], "description": "Loads a single 32-bit float from memory and replicates it to all eight 32-bit elements in a 256-bit YMM register. No EFLAGS are modified. Requires AVX support.", "pseudocode": "value ← [Src]\nfor i ← 0 to 7:\n Dest[i*32 : i*32 + 31] ← value", "example": "VBROADCASTSS ymm1, [rbp-4]" }, { "mnemonic": "vpbroadcastd", "architecture": "x86", "full_name": "Broadcast Doubleword", "summary": "Loads one integer and replicates it to all YMM elements.", "syntax": "VPBROADCASTD ymm1, xmm2/m32", "encoding": { "format": "AVX2", "hex_opcode": "VEX.256.66.0F38.W0 58 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Loads a single 32-bit integer from a register or memory and replicates it to all eight 32-bit elements in a 256-bit YMM register. No EFLAGS are modified. Requires AVX2 support.", "pseudocode": "if Src is xmm register:\n value ← Src[0..31]\nelse (Src is m32):\n value ← [Src]\nfor i ← 0 to 7:\n Dest[i*32 : i*32 + 31] ← value", "example": "VPBROADCASTD ymm1, xmm2/m32" }, { "mnemonic": "pclmulqdq", "architecture": "x86", "full_name": "Carry-Less Multiplication", "summary": "Performs carry-less multiplication (Galois Field math for AES-GCM).", "syntax": "PCLMULQDQ xmm1, xmm2/m128, imm8", "encoding": { "format": "PCLMUL", "hex_opcode": "66 0F 3A 44", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 44", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "PCLMULQDQ", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs carry-less multiplication of two 64-bit operands extracted from 128-bit XMM operands, producing a 128-bit result. Used in Galois/Counter Mode (GCM) for AES authentication. No EFLAGS are modified. The immediate selects which 64-bit halves of the operands participate.", "pseudocode": "if Imm[0] == 0:\n a ← Src1[0..63]\nelse:\n a ← Src1[64..127]\nif Imm[4] == 0:\n b ← Src2[0..63]\nelse:\n b ← Src2[64..127]\nDest ← GF_multiply(a, b) // Carry-less multiplication in GF(2^64), result fits in 128 bits", "example": "PCLMULQDQ xmm1, xmm2/m128, 3" }, { "mnemonic": "crc32", "architecture": "x86", "full_name": "Accumulate CRC32 Value", "summary": "Accumulates CRC32C value using polynomial 0x11EDC6F41.", "syntax": "CRC32 r32, r/m", "encoding": { "format": "SSE4.2", "hex_opcode": "F2 0F 38 F1", "visual_parts": [], "binary_pattern": "F2 | 0F | 38 | F1", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Accumulates a CRC32C checksum using the Castagnoli polynomial (0x11EDC6F41) into the destination register. The source operand size (8/16/32/64-bit) determines the operation width; destination is zero-extended to full register width. No EFLAGS are modified. Requires SSE4.2.", "pseudocode": "if Src is 8-bit:\n Dest[0..31] ← CRC32C(Dest[0..31], [Src])\n Dest[32..63] ← 0 (if 64-bit destination)\nelse if Src is 16-bit:\n Dest[0..31] ← CRC32C(Dest[0..31], [Src])\n Dest[32..63] ← 0 (if 64-bit destination)\nelse if Src is 32-bit:\n Dest[0..31] ← CRC32C(Dest[0..31], [Src])\n Dest[32..63] ← 0 (if 64-bit destination)\nelse if Src is 64-bit:\n Dest ← CRC32C(Dest, [Src])", "example": "CRC32 eax, rbx" }, { "mnemonic": "cvtsq2ss", "architecture": "x86", "full_name": "Convert Signed Quadword Integer to Scalar Single-Precision", "summary": "Converts 64-bit integer to float.", "syntax": "CVTSQ2SS xmm1, r/m64", "encoding": { "format": "SSE", "hex_opcode": "F3 REX.W 0F 2A /r", "visual_parts": [], "binary_pattern": "F3 | 0F | 2A", "bit_positions": "+0 | +1 | +2" }, "extension": "Base (64-bit)", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "r/m64", "desc": "64-bit register or memory" } ], "description": "Converts a signed 64-bit integer to a single-precision floating-point value and stores it in the low 32 bits of the destination XMM register; the upper 96 bits are zeroed. The conversion uses the current rounding mode from MXCSR. This instruction is only available in 64-bit mode and sets no flags.", "pseudocode": "dest[31:0] ← ConvertInt64ToSinglePrecision(src);\ndest[127:32] ← 0;", "example": "CVTSQ2SS xmm1, rbx" }, { "mnemonic": "cvtsq2sd", "architecture": "x86", "full_name": "Convert Signed Quadword Integer to Scalar Double-Precision", "summary": "Converts 64-bit integer to double.", "syntax": "CVTSQ2SD xmm1, r/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 REX.W 0F 2A /r", "visual_parts": [], "binary_pattern": "F2 | 0F | 2A", "bit_positions": "+0 | +1 | +2" }, "extension": "Base (64-bit)", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "r/m64", "desc": "64-bit register or memory" } ], "description": "Converts a signed 64-bit integer to a double-precision floating-point value and stores it in the low 64 bits of the destination XMM register; the upper 64 bits are zeroed. The conversion uses the current rounding mode from MXCSR. This instruction is only available in 64-bit mode and sets no flags.", "pseudocode": "dest[63:0] ← ConvertInt64ToDoublePrecision(src);\ndest[127:64] ← 0;", "example": "CVTSQ2SD xmm1, rbx" }, { "mnemonic": "cvtss2sq", "architecture": "x86", "full_name": "Convert Scalar Single-Precision to Signed Quadword Integer", "summary": "Converts float to 64-bit integer (Rounded).", "syntax": "CVTSS2SQ r64, xmm/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 REX.W 0F 2D /r", "visual_parts": [], "binary_pattern": "F3 | 0F | 2D", "bit_positions": "+0 | +1 | +2" }, "extension": "Base (64-bit)", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" }, { "name": "src", "type": "xmm/m32", "desc": "128-bit XMM register or 32-bit memory" } ], "description": "Converts the low 32-bit single-precision floating-point value from the source XMM register or memory to a signed 64-bit integer, using the current rounding mode from MXCSR. The result is stored in the destination 64-bit general-purpose register. This instruction is only available in 64-bit mode and sets no flags.", "pseudocode": "dest ← ConvertSinglePrecisionToInt64(src[31:0]);", "example": "CVTSS2SQ rax, xmm1" }, { "mnemonic": "cvtsd2sq", "architecture": "x86", "full_name": "Convert Scalar Double-Precision to Signed Quadword Integer", "summary": "Converts double to 64-bit integer (Rounded).", "syntax": "CVTSD2SQ r64, xmm/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 REX.W 0F 2D /r", "visual_parts": [], "binary_pattern": "F2 | 0F | 2D", "bit_positions": "+0 | +1 | +2" }, "extension": "Base (64-bit)", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" }, { "name": "src", "type": "xmm/m64", "desc": "128-bit XMM register or 64-bit memory" } ], "description": "Converts the low 64-bit double-precision floating-point value from the source XMM register or memory to a signed 64-bit integer, using the current rounding mode from MXCSR. The result is stored in the destination 64-bit general-purpose register. This instruction is only available in 64-bit mode and sets no flags.", "pseudocode": "dest ← ConvertDoublePrecisionToInt64(src[63:0]);", "example": "CVTSD2SQ rax, xmm1" }, { "mnemonic": "cvttss2sq", "architecture": "x86", "full_name": "Convert with Truncation Scalar Single-Precision to Signed Quadword Integer", "summary": "Converts float to 64-bit integer (Truncated).", "syntax": "CVTTSS2SQ r64, xmm/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 REX.W 0F 2C /r", "visual_parts": [], "binary_pattern": "F3 | 0F | 2C", "bit_positions": "+0 | +1 | +2" }, "extension": "Base (64-bit)", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" }, { "name": "src", "type": "xmm/m32", "desc": "128-bit XMM register or 32-bit memory" } ], "description": "Converts the low 32-bit single-precision floating-point value from the source XMM register or memory to a signed 64-bit integer by truncating toward zero (ignoring MXCSR rounding mode). The result is stored in the destination 64-bit general-purpose register. This instruction is only available in 64-bit mode and sets no flags.", "pseudocode": "dest ← TruncateSinglePrecisionToInt64(src[31:0]);", "example": "CVTTSS2SQ rax, xmm1" }, { "mnemonic": "cvttsd2sq", "architecture": "x86", "full_name": "Convert with Truncation Scalar Double-Precision to Signed Quadword Integer", "summary": "Converts double to 64-bit integer (Truncated).", "syntax": "CVTTSD2SQ r64, xmm/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 REX.W 0F 2C /r", "visual_parts": [], "binary_pattern": "F2 | 0F | 2C", "bit_positions": "+0 | +1 | +2" }, "extension": "Base (64-bit)", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" }, { "name": "src", "type": "xmm/m64", "desc": "128-bit XMM register or 64-bit memory" } ], "description": "Converts the low 64-bit double-precision floating-point value from the source XMM register or memory to a signed 64-bit integer by truncating toward zero (ignoring MXCSR rounding mode). The result is stored in the destination 64-bit general-purpose register. This instruction is only available in 64-bit mode and sets no flags.", "pseudocode": "dest ← TruncateDoublePrecisionToInt64(src[63:0]);", "example": "CVTTSD2SQ rax, xmm1" }, { "mnemonic": "haddpd", "architecture": "x86", "full_name": "Horizontal Add Packed Double-Precision", "summary": "Adds adjacent double-precision elements horizontally.", "syntax": "HADDPD xmm1, xmm2/m128", "encoding": { "format": "SSE3", "hex_opcode": "66 0F 7C", "visual_parts": [], "binary_pattern": "66 | 0F | 7C", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Horizontally adds adjacent pairs of double-precision floating-point elements: the first destination element is the sum of the two low double elements, and the second destination element is the sum of the two high double elements. The source operand may be an XMM register or 128-bit memory. No flags are modified.", "pseudocode": "dest[63:0] ← dest[63:0] + dest[127:64];\ndest[127:64] ← src[63:0] + src[127:64];", "example": "HADDPD xmm1, xmm2/m128" }, { "mnemonic": "hsubps", "architecture": "x86", "full_name": "Horizontal Subtract Packed Single-Precision", "summary": "Subtracts adjacent single-precision elements horizontally.", "syntax": "HSUBPS xmm1, xmm2/m128", "encoding": { "format": "SSE3", "hex_opcode": "F2 0F 7D", "visual_parts": [], "binary_pattern": "F2 | 0F | 7D", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Horizontally subtracts adjacent pairs of single-precision floating-point elements: the first destination element is the difference of the two low single elements, and the second destination element is the difference of the two high single elements. The source operand may be an XMM register or 128-bit memory. No flags are modified.", "pseudocode": "dest[31:0] ← dest[31:0] - dest[63:32];\ndest[63:32] ← dest[95:64] - dest[127:96];\ndest[95:64] ← src[31:0] - src[63:32];\ndest[127:96] ← src[95:64] - src[127:96];", "example": "HSUBPS xmm1, xmm2/m128" }, { "mnemonic": "hsubpd", "architecture": "x86", "full_name": "Horizontal Subtract Packed Double-Precision", "summary": "Subtracts adjacent double-precision elements horizontally.", "syntax": "HSUBPD xmm1, xmm2/m128", "encoding": { "format": "SSE3", "hex_opcode": "66 0F 7D", "visual_parts": [], "binary_pattern": "66 | 0F | 7D", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs horizontal subtraction of adjacent pairs of double-precision floating-point values in the source and destination XMM registers, storing results in the destination. Specifically, it subtracts the upper element from the lower element of each 128-bit lane (result[63:0] = dest[63:0] - dest[127:64]; result[127:64] = src[63:0] - src[127:64]). All floating-point exception flags may be set based on the operation; no integer flags are affected. This is an SSE3 instruction operating exclusively on 128-bit XMM registers.", "pseudocode": "dest[63:0] ← dest[63:0] - dest[127:64];\ndest[127:64] ← src[63:0] - src[127:64];", "example": "HSUBPD xmm1, xmm2/m128" }, { "mnemonic": "addsubpd", "architecture": "x86", "full_name": "Packed Double-FP Add/Subtract", "summary": "Adds odd elements, subtracts even elements (Double).", "syntax": "ADDSUBPD xmm1, xmm2/m128", "encoding": { "format": "SSE3", "hex_opcode": "66 0F D0", "visual_parts": [], "binary_pattern": "66 | 0F | D0", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE3", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs lane-wise alternating addition and subtraction on packed double-precision floating-point values: even-indexed elements (0, 2, ...) are subtracted, odd-indexed elements (1, 3, ...) are added. The operation is (dest[63:0] - src[63:0]) in the low qword and (dest[127:64] + src[127:64]) in the high qword. All floating-point exception flags may be set; no integer flags are affected. This is an SSE3 instruction operating on 128-bit XMM registers.", "pseudocode": "dest[63:0] ← dest[63:0] - src[63:0];\ndest[127:64] ← dest[127:64] + src[127:64];", "example": "ADDSUBPD xmm1, xmm2/m128" }, { "mnemonic": "vpermi2q", "architecture": "x86", "full_name": "Permute Two-Source Quadwords", "summary": "Shuffles quadwords from two ZMM registers into destination.", "syntax": "VPERMI2Q zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 76 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 76", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Performs a two-source permutation of 64-bit quadwords using indices from the destination register (zmm1), which acts as the index/control vector. Each 6-bit index in zmm1 selects a quadword from either zmm2 (index 0-7) or zmm3 (index 8-15), with the selected element placed into the corresponding position in the destination. The instruction supports AVX-512F masking via the k1 opmask register and operates on 512-bit ZMM registers. Memory operands are supported for zmm3/m512.", "pseudocode": "for i = 0 to 7 {\n idx ← zmm1[i*64+5:i*64];\n if idx[3] == 0:\n zmm1[i*64+63:i*64] ← zmm2[idx[2:0]*64+63:idx[2:0]*64];\n else:\n zmm1[i*64+63:i*64] ← zmm3[(idx[2:0])*64+63:(idx[2:0])*64];\n}", "example": "VPERMI2Q zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpermt2q", "architecture": "x86", "full_name": "Permute Two-Source Quadwords (Overwrite)", "summary": "Shuffles 2 sources, overwriting the index register (Quadword).", "syntax": "VPERMT2Q zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 7E /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 7F", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Performs a two-source permutation of 64-bit quadwords using indices from the second source register (zmm2), which acts as the control vector. Each 6-bit index in zmm2 selects a quadword from either zmm1 (index 0-7) or zmm3 (index 8-15), and the result is stored in the destination (zmm1), overwriting the original source data. The instruction supports AVX-512F masking via the k1 opmask register and operates on 512-bit ZMM registers. Memory operands are supported for zmm3/m512.", "pseudocode": "temp ← zmm1;\nfor i = 0 to 7 {\n idx ← zmm2[i*64+5:i*64];\n if idx[3] == 0:\n zmm1[i*64+63:i*64] ← temp[idx[2:0]*64+63:idx[2:0]*64];\n else:\n zmm1[i*64+63:i*64] ← zmm3[(idx[2:0])*64+63:(idx[2:0])*64];\n}", "example": "VPERMT2Q zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpsllvd", "architecture": "x86", "full_name": "Variable Bit Shift Left Logical Doubleword", "summary": "Shifts doublewords left by individual counts.", "syntax": "VPSLLVD ymm1, ymm2, ymm3/m256", "encoding": { "format": "AVX2", "hex_opcode": "VEX.256.66.0F38.W0 47 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Performs variable left logical bit shift on packed 32-bit doublewords, where each element is shifted by the corresponding count value from the third operand (bits 4:0 of each 32-bit element determine the shift amount, max 31 bits). Bits shifted out are lost; positions vacated are filled with zeros. The instruction operates on 256-bit YMM registers with AVX2 encoding and does not affect any integer flags.", "pseudocode": "for i = 0 to 7 {\n shift_amt ← ymm3[i*32+4:i*32];\n if shift_amt > 31:\n ymm1[i*32+31:i*32] ← 0;\n else:\n ymm1[i*32+31:i*32] ← ymm2[i*32+31:i*32] << shift_amt;\n}", "example": "VPSLLVD ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vpsllvq", "architecture": "x86", "full_name": "Variable Bit Shift Left Logical Quadword", "summary": "Shifts quadwords left by individual counts.", "syntax": "VPSLLVQ ymm1, ymm2, ymm3/m256", "encoding": { "format": "AVX2", "hex_opcode": "VEX.256.66.0F38.W1 47 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Performs variable left logical bit shift on packed 64-bit quadwords, where each element is shifted by the corresponding count value from the third operand (bits 5:0 of each 64-bit element determine the shift amount, max 63 bits). Bits shifted out are lost; positions vacated are filled with zeros. The instruction operates on 256-bit YMM registers with AVX2 encoding and does not affect any integer flags.", "pseudocode": "for i = 0 to 3 {\n shift_amt ← ymm3[i*64+5:i*64];\n if shift_amt > 63:\n ymm1[i*64+63:i*64] ← 0;\n else:\n ymm1[i*64+63:i*64] ← ymm2[i*64+63:i*64] << shift_amt;\n}", "example": "VPSLLVQ ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vpsravd", "architecture": "x86", "full_name": "Variable Bit Shift Right Arithmetic Doubleword", "summary": "Shifts doublewords right arithmetic by individual counts.", "syntax": "VPSRAVD ymm1, ymm2, ymm3/m256", "encoding": { "format": "AVX2", "hex_opcode": "VEX.256.66.0F38.W0 46 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Performs variable arithmetic right shift on packed 32-bit signed doublewords, where each element is shifted by the corresponding count value from the third operand (bits 4:0 of each 32-bit element determine the shift amount, max 31 bits). The sign bit is replicated into vacated positions. The instruction operates on 256-bit YMM registers with AVX2 encoding and does not affect any integer flags.", "pseudocode": "for i = 0 to 7 {\n shift_amt ← ymm3[i*32+4:i*32];\n if shift_amt > 31:\n if ymm2[i*32+31] == 1:\n ymm1[i*32+31:i*32] ← -1;\n else:\n ymm1[i*32+31:i*32] ← 0;\n else:\n ymm1[i*32+31:i*32] ← (signed) ymm2[i*32+31:i*32] >> shift_amt;\n}", "example": "VPSRAVD ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vpsravq", "architecture": "x86", "full_name": "Variable Bit Shift Right Arithmetic Quadword", "summary": "Shifts quadwords right arithmetic by individual counts.", "syntax": "VPSRAVQ zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 46 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 46", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Performs variable arithmetic right shift on packed 64-bit signed quadwords, where each element is shifted by the corresponding count value from the third operand (bits 5:0 of each 64-bit element determine the shift amount, max 63 bits). The sign bit is replicated into vacated positions. The instruction supports AVX-512F masking via the k1 opmask register and operates on 512-bit ZMM registers. Memory operands are supported for zmm3/m512; no integer flags are affected.", "pseudocode": "for i = 0 to 7 {\n shift_amt ← zmm2[i*64+5:i*64];\n if shift_amt > 63:\n if zmm2[i*64+63] == 1:\n zmm1[i*64+63:i*64] ← -1;\n else:\n zmm1[i*64+63:i*64] ← 0;\n else:\n zmm1[i*64+63:i*64] ← (signed) zmm2[i*64+63:i*64] >> shift_amt;\n}", "example": "VPSRAVQ zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpsrlvd", "architecture": "x86", "full_name": "Variable Bit Shift Right Logical Doubleword", "summary": "Shifts doublewords right logical by individual counts.", "syntax": "VPSRLVD ymm1, ymm2, ymm3/m256", "encoding": { "format": "AVX2", "hex_opcode": "VEX.256.66.0F38.W0 45 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Performs variable logical right shifts on packed 32-bit doublewords in the first source operand (ymm2) by the amounts specified in the corresponding doubleword elements of the second source operand (ymm3/m256), storing results in the destination (ymm1). Each doubleword is shifted independently; shift amounts > 31 produce zero. No flags are affected; this is an AVX2 instruction available in 256-bit form.", "pseudocode": "for i in 0 to 7:\n shift_amount = src2[i*32 : i*32+31]\n if shift_amount > 31:\n dest[i*32 : i*32+31] = 0\n else:\n dest[i*32 : i*32+31] = src1[i*32 : i*32+31] >> shift_amount", "example": "VPSRLVD ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vpsrlvq", "architecture": "x86", "full_name": "Variable Bit Shift Right Logical Quadword", "summary": "Shifts quadwords right logical by individual counts.", "syntax": "VPSRLVQ ymm1, ymm2, ymm3/m256", "encoding": { "format": "AVX2", "hex_opcode": "VEX.256.66.0F38.W1 45 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Performs variable logical right shifts on packed 64-bit quadwords in the first source operand (ymm2) by the amounts specified in the corresponding quadword elements of the second source operand (ymm3/m256), storing results in the destination (ymm1). Each quadword is shifted independently; shift amounts > 63 produce zero. No flags are affected; this is an AVX2 instruction available in 256-bit form.", "pseudocode": "for i in 0 to 3:\n shift_amount = src2[i*64 : i*64+63]\n if shift_amount > 63:\n dest[i*64 : i*64+63] = 0\n else:\n dest[i*64 : i*64+63] = src1[i*64 : i*64+63] >> shift_amount", "example": "VPSRLVQ ymm1, ymm2, ymm3/m256" }, { "mnemonic": "pminsb", "architecture": "x86", "full_name": "Minimum of Packed Signed Byte Integers", "summary": "Returns minimum of signed bytes.", "syntax": "PMINSB xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 38", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 38", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed signed byte integers in the destination operand (xmm1) with those in the source operand (xmm2/m128) and stores the minimum of each pair in the destination. Each of the 16 bytes is compared independently as a signed 8-bit value. No flags are affected; this is an SSE4.1 instruction that operates on 128-bit XMM registers.", "pseudocode": "for i in 0 to 15:\n byte_a = sign_extend(dest[i*8 : i*8+7])\n byte_b = sign_extend(src[i*8 : i*8+7])\n dest[i*8 : i*8+7] = (byte_a < byte_b) ? byte_a : byte_b", "example": "PMINSB xmm1, xmm2/m128" }, { "mnemonic": "pmaxsb", "architecture": "x86", "full_name": "Maximum of Packed Signed Byte Integers", "summary": "Returns maximum of signed bytes.", "syntax": "PMAXSB xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 3C", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 3C", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed signed byte integers in the destination operand (xmm1) with those in the source operand (xmm2/m128) and stores the maximum of each pair in the destination. Each of the 16 bytes is compared independently as a signed 8-bit value. No flags are affected; this is an SSE4.1 instruction that operates on 128-bit XMM registers.", "pseudocode": "for i in 0 to 15:\n byte_a = sign_extend(dest[i*8 : i*8+7])\n byte_b = sign_extend(src[i*8 : i*8+7])\n dest[i*8 : i*8+7] = (byte_a > byte_b) ? byte_a : byte_b", "example": "PMAXSB xmm1, xmm2/m128" }, { "mnemonic": "pminuw", "architecture": "x86", "full_name": "Minimum of Packed Unsigned Word Integers", "summary": "Returns minimum of unsigned words.", "syntax": "PMINUW xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 3A", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 3A", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed unsigned word integers in the destination operand (xmm1) with those in the source operand (xmm2/m128) and stores the minimum of each pair in the destination. Each of the 8 words is compared independently as an unsigned 16-bit value. No flags are affected; this is an SSE4.1 instruction that operates on 128-bit XMM registers.", "pseudocode": "for i in 0 to 7:\n word_a = dest[i*16 : i*16+15]\n word_b = src[i*16 : i*16+15]\n dest[i*16 : i*16+15] = (word_a < word_b) ? word_a : word_b", "example": "PMINUW xmm1, xmm2/m128" }, { "mnemonic": "pmaxuw", "architecture": "x86", "full_name": "Maximum of Packed Unsigned Word Integers", "summary": "Returns maximum of unsigned words.", "syntax": "PMAXUW xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 3E", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 3E", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed unsigned word integers in the destination operand (xmm1) with those in the source operand (xmm2/m128) and stores the maximum of each pair in the destination. Each of the 8 words is compared independently as an unsigned 16-bit value. No flags are affected; this is an SSE4.1 instruction that operates on 128-bit XMM registers.", "pseudocode": "for i in 0 to 7:\n word_a = dest[i*16 : i*16+15]\n word_b = src[i*16 : i*16+15]\n dest[i*16 : i*16+15] = (word_a > word_b) ? word_a : word_b", "example": "PMAXUW xmm1, xmm2/m128" }, { "mnemonic": "pminud", "architecture": "x86", "full_name": "Minimum of Packed Unsigned Doubleword Integers", "summary": "Returns minimum of unsigned doublewords.", "syntax": "PMINUD xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 3B", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 3B", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed unsigned doubleword integers in the destination operand (xmm1) with those in the source operand (xmm2/m128) and stores the minimum of each pair in the destination. Each of the 4 doublewords is compared independently as an unsigned 32-bit value. No flags are affected; this is an SSE4.1 instruction that operates on 128-bit XMM registers.", "pseudocode": "for i in 0 to 3:\n dword_a = dest[i*32 : i*32+31]\n dword_b = src[i*32 : i*32+31]\n dest[i*32 : i*32+31] = (dword_a < dword_b) ? dword_a : dword_b", "example": "PMINUD xmm1, xmm2/m128" }, { "mnemonic": "pmaxud", "architecture": "x86", "full_name": "Maximum of Packed Unsigned Doubleword Integers", "summary": "Returns maximum of unsigned doublewords.", "syntax": "PMAXUD xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 3F", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 3F", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed unsigned doubleword integers in the destination operand (xmm1) with those in the source operand (xmm2/m128) and stores the maximum of each pair in the destination. Each of the 4 doublewords is compared independently as an unsigned 32-bit value. No flags are affected; this is an SSE4.1 instruction that operates on 128-bit XMM registers.", "pseudocode": "for i in 0 to 3:\n dword_a = dest[i*32 : i*32+31]\n dword_b = src[i*32 : i*32+31]\n dest[i*32 : i*32+31] = (dword_a > dword_b) ? dword_a : dword_b", "example": "PMAXUD xmm1, xmm2/m128" }, { "mnemonic": "pminsd", "architecture": "x86", "full_name": "Minimum of Packed Signed Doubleword Integers", "summary": "Returns minimum of signed doublewords.", "syntax": "PMINSD xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 39", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 39", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed signed 32-bit integers in xmm1 with xmm2/m128 and writes the minimum of each pair to xmm1. This is a SIMD operation with no effect on the CPU flags. Available in SSE4.1 and later; operates on 128-bit XMM registers containing four 32-bit signed doublewords.", "pseudocode": "xmm1[127:96] ← (xmm1[127:96] < xmm2[127:96]) ? xmm1[127:96] : xmm2[127:96];\nxmm1[95:64] ← (xmm1[95:64] < xmm2[95:64]) ? xmm1[95:64] : xmm2[95:64];\nxmm1[63:32] ← (xmm1[63:32] < xmm2[63:32]) ? xmm1[63:32] : xmm2[63:32];\nxmm1[31:0] ← (xmm1[31:0] < xmm2[31:0]) ? xmm1[31:0] : xmm2[31:0];", "example": "PMINSD xmm1, xmm2/m128" }, { "mnemonic": "pmaxsd", "architecture": "x86", "full_name": "Maximum of Packed Signed Doubleword Integers", "summary": "Returns maximum of signed doublewords.", "syntax": "PMAXSD xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 3D", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 3D", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed signed 32-bit integers in xmm1 with xmm2/m128 and writes the maximum of each pair to xmm1. This is a SIMD operation with no effect on the CPU flags. Available in SSE4.1 and later; operates on 128-bit XMM registers containing four 32-bit signed doublewords.", "pseudocode": "xmm1[127:96] ← (xmm1[127:96] > xmm2[127:96]) ? xmm1[127:96] : xmm2[127:96];\nxmm1[95:64] ← (xmm1[95:64] > xmm2[95:64]) ? xmm1[95:64] : xmm2[95:64];\nxmm1[63:32] ← (xmm1[63:32] > xmm2[63:32]) ? xmm1[63:32] : xmm2[63:32];\nxmm1[31:0] ← (xmm1[31:0] > xmm2[31:0]) ? xmm1[31:0] : xmm2[31:0];", "example": "PMAXSD xmm1, xmm2/m128" }, { "mnemonic": "pinsrd", "architecture": "x86", "full_name": "Packed Insert Doubleword", "summary": "Inserts a doubleword from register to XMM.", "syntax": "PINSRD xmm1, r32/m32, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 22", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 22", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "r32/m32", "desc": "General-purpose register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Inserts a 32-bit doubleword from a general-purpose register or memory into an XMM register at the position specified by an 8-bit immediate index. The remaining XMM lanes are unchanged. Available in SSE4.1 and later; no flags are affected by this instruction.", "pseudocode": "index ← imm8[1:0];\ncase index of\n 0: xmm1[31:0] ← (r32/m32 is register) ? r32 : [r32/m32];\n 1: xmm1[63:32] ← (r32/m32 is register) ? r32 : [r32/m32];\n 2: xmm1[95:64] ← (r32/m32 is register) ? r32 : [r32/m32];\n 3: xmm1[127:96] ← (r32/m32 is register) ? r32 : [r32/m32];\nendcase;", "example": "PINSRD xmm1, r32/m32, 3" }, { "mnemonic": "pinsrq", "architecture": "x86", "full_name": "Packed Insert Quadword", "summary": "Inserts a quadword from register to XMM.", "syntax": "PINSRQ xmm1, r64/m64, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 REX.W 0F 3A 22 /r ib", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 22", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "r64/m64", "desc": "General-purpose register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Inserts a 64-bit quadword from a general-purpose register or memory into an XMM register at the position specified by an 8-bit immediate index. The other 64-bit lane remains unchanged. Available in SSE4.1 and later (64-bit mode only); no flags are affected by this instruction.", "pseudocode": "index ← imm8[0];\ncase index of\n 0: xmm1[63:0] ← (r64/m64 is register) ? r64 : [r64/m64];\n 1: xmm1[127:64] ← (r64/m64 is register) ? r64 : [r64/m64];\nendcase;", "example": "PINSRQ xmm1, r64/m64, 3" }, { "mnemonic": "pextrd", "architecture": "x86", "full_name": "Packed Extract Doubleword", "summary": "Extracts a doubleword from XMM to register.", "syntax": "PEXTRD r32/m32, xmm1, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 16", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 16", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "r32/m32", "desc": "General-purpose register or Memory operand" }, { "name": "src1", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Extracts a 32-bit doubleword from an XMM register at the position specified by an 8-bit immediate and writes it to a general-purpose register or memory. Zero-extends the extracted value when writing to a 32-bit register. Available in SSE4.1 and later; no flags are affected by this instruction.", "pseudocode": "index ← imm8[1:0];\ncase index of\n 0: value ← xmm1[31:0];\n 1: value ← xmm1[63:32];\n 2: value ← xmm1[95:64];\n 3: value ← xmm1[127:96];\nendcase;\nif (r32/m32 is register) then\n r32 ← value;\nelse\n [r32/m32] ← value;\nendif;", "example": "PEXTRD r32/m32, xmm1, 3" }, { "mnemonic": "pextrq", "architecture": "x86", "full_name": "Packed Extract Quadword", "summary": "Extracts a quadword from XMM to register.", "syntax": "PEXTRQ r64/m64, xmm1, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 REX.W 0F 3A 16 /r ib", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 16", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "r64/m64", "desc": "General-purpose register or Memory operand" }, { "name": "src1", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Extracts a 64-bit quadword from an XMM register at the position specified by an 8-bit immediate and writes it to a general-purpose register or memory. Available in SSE4.1 and later (64-bit mode only); no flags are affected by this instruction.", "pseudocode": "index ← imm8[0];\ncase index of\n 0: value ← xmm1[63:0];\n 1: value ← xmm1[127:64];\nendcase;\nif (r64/m64 is register) then\n r64 ← value;\nelse\n [r64/m64] ← value;\nendif;", "example": "PEXTRQ r64/m64, xmm1, 3" }, { "mnemonic": "movntdqa", "architecture": "x86", "full_name": "Load Double Quadword Non-Temporal Aligned", "summary": "Efficiently loads 128-bits from WC memory (Streaming Load).", "syntax": "MOVNTDQA xmm1, m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 2A", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 2A", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Loads 128 bits from write-combining (WC) memory into an XMM register using a non-temporal hint to minimize cache pollution. This instruction bypasses the normal cache coherency protocol and is optimized for streaming data loads. Available in SSE4.1 and later; no flags are affected. The memory address should be 16-byte aligned for best performance.", "pseudocode": "xmm1 ← [m128];", "example": "MOVNTDQA xmm1, [rbp-16]" }, { "mnemonic": "pcmpgtq", "architecture": "x86", "full_name": "Packed Compare Greater Than Quadword", "summary": "Compares quadwords for greater than (signed).", "syntax": "PCMPGTQ xmm1, xmm2/m128", "encoding": { "format": "SSE4.2", "hex_opcode": "66 0F 38 37", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 37", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed signed 64-bit integers in xmm1 with xmm2/m128 for greater-than, writing a mask (all-1s for true, all-0s for false) of each comparison to xmm1. This is a SIMD comparison with no effect on the CPU flags. Available in SSE4.2 and later; operates on 128-bit XMM registers containing two 64-bit signed quadwords.", "pseudocode": "xmm1[127:64] ← (xmm1[127:64] > xmm2[127:64]) ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000;\nxmm1[63:0] ← (xmm1[63:0] > xmm2[63:0]) ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000;", "example": "PCMPGTQ xmm1, xmm2/m128" }, { "mnemonic": "packusdw", "architecture": "x86", "full_name": "Pack with Unsigned Saturation Doubleword to Word", "summary": "Converts signed dwords to unsigned words with saturation.", "syntax": "PACKUSDW xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 2B", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 2B", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Packs four signed doublewords (32-bit) from each 128-bit operand into eight unsigned words (16-bit) with unsigned saturation, storing the result in the destination XMM register. Values outside the range [0, 65535] are saturated to the nearest boundary. No flags are affected.", "pseudocode": "dest[0:15] ← saturate_unsigned(src1[0:31], 0, 65535)\ndest[16:31] ← saturate_unsigned(src1[32:63], 0, 65535)\ndest[32:47] ← saturate_unsigned(src1[64:95], 0, 65535)\ndest[48:63] ← saturate_unsigned(src1[96:127], 0, 65535)\ndest[64:79] ← saturate_unsigned(src2[0:31], 0, 65535)\ndest[80:95] ← saturate_unsigned(src2[32:63], 0, 65535)\ndest[96:111] ← saturate_unsigned(src2[64:95], 0, 65535)\ndest[112:127] ← saturate_unsigned(src2[96:127], 0, 65535)", "example": "PACKUSDW xmm1, xmm2/m128" }, { "mnemonic": "sets", "architecture": "x86", "full_name": "Set Byte on Sign", "summary": "Sets byte to 1 if SF=1 (Negative).", "syntax": "SETS r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 98", "visual_parts": [], "binary_pattern": "0F | 98", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the Sign Flag (SF) is set (indicating a negative result from the previous operation), otherwise sets it to 0. No flags are affected by this instruction. Available in all x86/x64 modes.", "pseudocode": "if (SF == 1) {\n dest ← 0xFF\n} else {\n dest ← 0x00\n}", "example": "SETS bl" }, { "mnemonic": "setns", "architecture": "x86", "full_name": "Set Byte on Not Sign", "summary": "Sets byte to 1 if SF=0 (Positive).", "syntax": "SETNS r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 99", "visual_parts": [], "binary_pattern": "0F | 99", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the Sign Flag (SF) is clear (indicating a positive or zero result from the previous operation), otherwise sets it to 0. No flags are affected by this instruction. Available in all x86/x64 modes.", "pseudocode": "if (SF == 0) {\n dest ← 0xFF\n} else {\n dest ← 0x00\n}", "example": "SETNS bl" }, { "mnemonic": "setp", "architecture": "x86", "full_name": "Set Byte on Parity", "summary": "Sets byte to 1 if PF=1 (Even Parity).", "syntax": "SETP r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 9A", "visual_parts": [], "binary_pattern": "0F | 9A", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the Parity Flag (PF) is set (indicating an even number of 1-bits in the low byte of the result), otherwise sets it to 0. No flags are affected by this instruction. Available in all x86/x64 modes.", "pseudocode": "if (PF == 1) {\n dest ← 0xFF\n} else {\n dest ← 0x00\n}", "example": "SETP bl" }, { "mnemonic": "setnp", "architecture": "x86", "full_name": "Set Byte on Not Parity", "summary": "Sets byte to 1 if PF=0 (Odd Parity).", "syntax": "SETNP r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 9B", "visual_parts": [], "binary_pattern": "0F | 9B", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the Parity Flag (PF) is clear (indicating an odd number of 1-bits in the low byte of the result), otherwise sets it to 0. No flags are affected by this instruction. Available in all x86/x64 modes.", "pseudocode": "if (PF == 0) {\n dest ← 0xFF\n} else {\n dest ← 0x00\n}", "example": "SETNP bl" }, { "mnemonic": "setl", "architecture": "x86", "full_name": "Set Byte on Less", "summary": "Sets byte to 1 if SF!=OF.", "syntax": "SETL r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 9C", "visual_parts": [], "binary_pattern": "0F | 9C", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the previous signed comparison or arithmetic result indicates a less-than condition (SF ≠ OF), otherwise sets it to 0. No flags are affected by this instruction. Used after signed compare or arithmetic operations.", "pseudocode": "if (SF != OF) {\n dest ← 0xFF\n} else {\n dest ← 0x00\n}", "example": "SETL bl" }, { "mnemonic": "setle", "architecture": "x86", "full_name": "Set Byte on Less or Equal", "summary": "Sets byte to 1 if ZF=1 or SF!=OF.", "syntax": "SETLE r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 9E", "visual_parts": [], "binary_pattern": "0F | 9E", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the previous signed comparison or arithmetic result indicates a less-than-or-equal condition (ZF = 1 or SF ≠ OF), otherwise sets it to 0. No flags are affected by this instruction. Used after signed compare or arithmetic operations.", "pseudocode": "if ((ZF == 1) || (SF != OF)) {\n dest ← 0xFF\n} else {\n dest ← 0x00\n}", "example": "SETLE bl" }, { "mnemonic": "setg", "architecture": "x86", "full_name": "Set Byte on Greater", "summary": "Sets byte to 1 if ZF=0 and SF=OF.", "syntax": "SETG r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 9F", "visual_parts": [], "binary_pattern": "0F | 9F", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the previous signed comparison or arithmetic result indicates a greater-than condition (ZF = 0 and SF = OF), otherwise sets it to 0. No flags are affected by this instruction. Used after signed compare or arithmetic operations.", "pseudocode": "if ((ZF == 0) && (SF == OF)) {\n dest ← 0xFF\n} else {\n dest ← 0x00\n}", "example": "SETG bl" }, { "mnemonic": "setge", "architecture": "x86", "full_name": "Set Byte on Greater or Equal", "summary": "Sets byte to 1 if SF=OF.", "syntax": "SETGE r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 9D", "visual_parts": [], "binary_pattern": "0F | 9D", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the signed comparison condition is true (SF = OF, indicating greater-than-or-equal for signed integers), or to 0 otherwise. This instruction reads the SF and OF flags from EFLAGS and does not modify any flags. It operates only on 8-bit destinations in all modes.", "pseudocode": "dest ← (SF == OF) ? 1 : 0;", "example": "SETGE bl" }, { "mnemonic": "setb", "architecture": "x86", "full_name": "Set Byte on Below", "summary": "Sets byte to 1 if CF=1.", "syntax": "SETB r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 92", "visual_parts": [], "binary_pattern": "0F | 92", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the carry flag (CF) is set, indicating an unsigned borrow or carry condition, or to 0 otherwise. This instruction reads CF from EFLAGS and does not modify any flags. It operates only on 8-bit destinations in all modes.", "pseudocode": "dest ← CF ? 1 : 0;", "example": "SETB bl" }, { "mnemonic": "setbe", "architecture": "x86", "full_name": "Set Byte on Below or Equal", "summary": "Sets byte to 1 if CF=1 or ZF=1.", "syntax": "SETBE r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 96", "visual_parts": [], "binary_pattern": "0F | 96", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the unsigned comparison condition is true (CF = 1 or ZF = 1, indicating below-or-equal for unsigned integers), or to 0 otherwise. This instruction reads the CF and ZF flags from EFLAGS and does not modify any flags. It operates only on 8-bit destinations in all modes.", "pseudocode": "dest ← (CF || ZF) ? 1 : 0;", "example": "SETBE bl" }, { "mnemonic": "seta", "architecture": "x86", "full_name": "Set Byte on Above", "summary": "Sets byte to 1 if CF=0 and ZF=0.", "syntax": "SETA r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 97", "visual_parts": [], "binary_pattern": "0F | 97", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the unsigned comparison condition is true (CF = 0 and ZF = 0, indicating above for unsigned integers), or to 0 otherwise. This instruction reads the CF and ZF flags from EFLAGS and does not modify any flags. It operates only on 8-bit destinations in all modes.", "pseudocode": "dest ← (!CF && !ZF) ? 1 : 0;", "example": "SETA bl" }, { "mnemonic": "setae", "architecture": "x86", "full_name": "Set Byte on Above or Equal", "summary": "Sets byte to 1 if CF=0.", "syntax": "SETAE r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 93", "visual_parts": [], "binary_pattern": "0F | 93", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the carry flag (CF) is clear, indicating no unsigned borrow (above-or-equal for unsigned integers), or to 0 otherwise. This instruction reads CF from EFLAGS and does not modify any flags. It operates only on 8-bit destinations in all modes.", "pseudocode": "dest ← (!CF) ? 1 : 0;", "example": "SETAE bl" }, { "mnemonic": "kunpckwd", "architecture": "x86", "full_name": "Unpack and Interleave Masks Word to Doubleword", "summary": "Interleaves 16-bit masks into 32-bit mask.", "syntax": "KUNPCKWD k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.0F.W0 4B /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 4B", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Unpacks and interleaves two 16-bit mask registers into a 32-bit mask register, with src2 supplying the high 16 bits and src1 supplying the low 16 bits of the result. This instruction is part of AVX-512BW and operates only on opmask registers (k0-k7); it does not modify any EFLAGS flags. The opmask register k0 cannot be used as a write mask.", "pseudocode": "dest[15:0] ← src1[15:0]; dest[31:16] ← src2[15:0]; dest[63:32] ← 0;", "example": "KUNPCKWD k1, k2, k3" }, { "mnemonic": "kunpckdq", "architecture": "x86", "full_name": "Unpack and Interleave Masks Doubleword to Quadword", "summary": "Interleaves 32-bit masks into 64-bit mask.", "syntax": "KUNPCKDQ k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.0F.W1 4B /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 4B", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Unpacks and interleaves two 32-bit mask registers into a 64-bit mask register, with src2 supplying the high 32 bits and src1 supplying the low 32 bits of the result. This instruction is part of AVX-512BW and operates only on opmask registers (k0-k7); it does not modify any EFLAGS flags. The opmask register k0 cannot be used as a write mask.", "pseudocode": "dest[31:0] ← src1[31:0]; dest[63:32] ← src2[31:0];", "example": "KUNPCKDQ k1, k2, k3" }, { "mnemonic": "vpconflictq", "architecture": "x86", "full_name": "Detect Conflicts Within a Vector of Packed Quadword Values", "summary": "Detects duplicate values in a quadword vector.", "syntax": "VPCONFLICTQ zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 C4 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | C4", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512CD", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Detects conflicts (duplicate values) within a vector of 64-bit quadword values and writes a conflict mask to the destination; each element in the result contains a bitmask indicating which earlier elements in the source vector have the same value. This instruction is part of AVX-512CD, supports embedded masking via k1, and does not modify EFLAGS. Zeroing masking clears masked elements in the destination.", "pseudocode": "for i ← 0 to 7 do { dest[i*64+63:i*64] ← 0; for j ← 0 to i-1 do if src[i*64+63:i*64] == src[j*64+63:j*64] then dest[i*64+j] ← 1; } if k1_mask[i] == 0 and zeroing then dest[i*64+63:i*64] ← 0;", "example": "VPCONFLICTQ zmm1, zmm2/m512" }, { "mnemonic": "vplzcntq", "architecture": "x86", "full_name": "Count Leading Zero Bits Quadword", "summary": "Counts leading zeros for each quadword element.", "syntax": "VPLZCNTQ zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 44 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 44", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512CD", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Counts the number of leading zero bits in each 64-bit quadword element of the source operand and stores the results in the destination register. Operates element-wise on 8 quadwords (512-bit / 64-bit per element). The instruction does not modify CPU flags; it is a pure SIMD data-parallel operation with AVX-512 opmask support for conditional write-masking.", "pseudocode": "for i = 0 to 7:\n src_qw = src2[64*i : 64*i+63]\n dest[64*i : 64*i+63] ← count_leading_zeros_64(src_qw)", "example": "VPLZCNTQ zmm1, zmm2/m512" }, { "mnemonic": "vpermw", "architecture": "x86", "full_name": "Permute Word Integers", "summary": "Full permutation of 32 words using indices.", "syntax": "VPERMW zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 8D /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 8D", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Performs a full permutation of 32 word (16-bit) elements across the entire 512-bit register using indices from a second vector operand. The index operand specifies which source element to copy to each destination position. Supports AVX-512 opmask write-masking; does not affect CPU flags.", "pseudocode": "for i = 0 to 31:\n index = src2[16*i : 16*i+15] & 0x1F\n dest[16*i : 16*i+15] ← src1[16*index : 16*index+15]", "example": "VPERMW zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpermq", "architecture": "x86", "full_name": "Permute Quadword Integers", "summary": "Shuffles quadwords within 256-bit lanes using immediate.", "syntax": "VPERMQ ymm1, ymm2/m256, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F3A.W1 00 /r ib", "visual_parts": [], "binary_pattern": "VEX | 66 | 0F | 3A | 00", "bit_positions": "+0 | +3 | +4 | +5 | +6" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2/m256", "desc": "256-bit YMM AVX register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shuffles four 64-bit quadword elements within each 256-bit lane using a 2-bit immediate index for each element. The immediate controls the permutation pattern within the two halves of the 256-bit operand independently. Does not affect CPU flags; operates on 256-bit YMM registers under AVX2.", "pseudocode": "for i = 0 to 3:\n index = (imm8 >> (2*i)) & 0x3\n dest[64*i : 64*i+63] ← src[64*index : 64*index+63]", "example": "VPERMQ ymm1, ymm2/m256, 3" }, { "mnemonic": "vprolvq", "architecture": "x86", "full_name": "Rotate Left Quadword Variable", "summary": "Rotates quadwords left by amounts in second vector.", "syntax": "VPROLVQ zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 15 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 15", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Rotates each 64-bit quadword element in the first source left by the number of bits specified in the corresponding element of the second source operand. Operates on 8 quadwords in parallel; supports AVX-512 opmask write-masking. Does not modify CPU flags.", "pseudocode": "for i = 0 to 7:\n value = src1[64*i : 64*i+63]\n shift_count = src2[64*i : 64*i+63] & 0x3F\n dest[64*i : 64*i+63] ← rotate_left_64(value, shift_count)", "example": "VPROLVQ zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vprorvd", "architecture": "x86", "full_name": "Rotate Right Doubleword Variable", "summary": "Rotates doublewords right by amounts in second vector.", "syntax": "VPRORVD zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 14 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 14", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Rotates each 32-bit doubleword element in the first source right by the number of bits specified in the corresponding element of the second source operand. Operates on 16 doublewords in parallel; supports AVX-512 opmask write-masking. Does not modify CPU flags.", "pseudocode": "for i = 0 to 15:\n value = src1[32*i : 32*i+31]\n shift_count = src2[32*i : 32*i+31] & 0x1F\n dest[32*i : 32*i+31] ← rotate_right_32(value, shift_count)", "example": "VPRORVD zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vprorvq", "architecture": "x86", "full_name": "Rotate Right Quadword Variable", "summary": "Rotates quadwords right by amounts in second vector.", "syntax": "VPRORVQ zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 14 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 14", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Rotates each 64-bit quadword element in the first source right by the number of bits specified in the corresponding element of the second source operand. Operates on 8 quadwords in parallel; supports AVX-512 opmask write-masking. Does not modify CPU flags.", "pseudocode": "for i = 0 to 7:\n value = src1[64*i : 64*i+63]\n shift_count = src2[64*i : 64*i+63] & 0x3F\n dest[64*i : 64*i+63] ← rotate_right_64(value, shift_count)", "example": "VPRORVQ zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpmovb2m", "architecture": "x86", "full_name": "Move Byte Mask to Mask Register", "summary": "Moves byte integer mask from ZMM to k-register.", "syntax": "VPMOVB2M k1, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W0 29 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Extracts the most significant bit (MSB) from each byte element in a 512-bit ZMM register and compacts them into a 64-bit opmask register. The resulting mask register has one bit per original byte, forming a 64-bit result. Does not modify CPU flags; operates in 64-bit mode only with AVX-512BW.", "pseudocode": "mask_result = 0\nfor i = 0 to 63:\n if (src[8*i+7] != 0):\n mask_result |= (1 << i)\ndest ← mask_result", "example": "VPMOVB2M k1, zmm1" }, { "mnemonic": "vpmovw2m", "architecture": "x86", "full_name": "Move Word Mask to Mask Register", "summary": "Moves word integer mask from ZMM to k-register.", "syntax": "VPMOVW2M k1, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W1 29 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Extracts the most significant bit (MSB) from each word (16-bit) element in a 512-bit ZMM register and compacts them into a 32-bit opmask register. The resulting mask register has one bit per original word, forming a 32-bit result. Does not modify CPU flags; operates in 64-bit mode only with AVX-512BW.", "pseudocode": "mask_result = 0\nfor i = 0 to 31:\n if (src[16*i+15] != 0):\n mask_result |= (1 << i)\ndest ← mask_result", "example": "VPMOVW2M k1, zmm1" }, { "mnemonic": "vpmovd2m", "architecture": "x86", "full_name": "Move Doubleword Mask to Mask Register", "summary": "Moves doubleword integer mask from ZMM to k-register.", "syntax": "VPMOVD2M k1, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W0 39 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Extracts the sign bit (MSB) from each 32-bit doubleword element in a 512-bit ZMM register and compacts these bits into an 8-bit mask register (k1). This instruction performs a vectorized comparison-to-mask operation, setting each bit in the destination k-register based on the corresponding doubleword's sign bit. No flags are affected by this instruction.", "pseudocode": "for i in 0 to 15:\n k1[i] ← zmm1[i*32 + 31]\nk1[16:63] ← 0", "example": "VPMOVD2M k1, zmm1" }, { "mnemonic": "vpmovq2m", "architecture": "x86", "full_name": "Move Quadword Mask to Mask Register", "summary": "Moves quadword integer mask from ZMM to k-register.", "syntax": "VPMOVQ2M k1, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W1 39 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Extracts the sign bit (MSB) from each 64-bit quadword element in a 512-bit ZMM register and compacts these bits into an 8-bit mask register (k1). This instruction performs a vectorized comparison-to-mask operation on 64-bit elements, setting each bit in the destination k-register based on the corresponding quadword's sign bit. No flags are affected by this instruction.", "pseudocode": "for i in 0 to 7:\n k1[i] ← zmm1[i*64 + 63]\nk1[8:63] ← 0", "example": "VPMOVQ2M k1, zmm1" }, { "mnemonic": "vpmovm2b", "architecture": "x86", "full_name": "Move Mask Register to Byte Mask", "summary": "Expands k-register bits to byte elements in ZMM.", "syntax": "VPMOVM2B zmm1, k1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W0 28 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Expands each bit from an 8-bit mask register into a full byte (0x00 or 0xFF) in a 512-bit ZMM register, producing 64 byte elements. Each set bit in the source k-register generates a byte of all 1s (0xFF) in the destination; each clear bit generates a byte of all 0s (0x00). No flags are affected; this is a mask-expansion operation with no conditional behavior.", "pseudocode": "for i in 0 to 63:\n zmm1[i*8:i*8+7] ← (k1[i] ? 0xFF : 0x00)", "example": "VPMOVM2B zmm1, k1" }, { "mnemonic": "vpmovm2w", "architecture": "x86", "full_name": "Move Mask Register to Word Mask", "summary": "Expands k-register bits to word elements in ZMM.", "syntax": "VPMOVM2W zmm1, k1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W1 28 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Expands each bit from an 8-bit mask register into a full word (0x0000 or 0xFFFF) in a 512-bit ZMM register, producing 32 word elements. Each set bit in the source k-register generates a word of all 1s (0xFFFF) in the destination; each clear bit generates a word of all 0s (0x0000). No flags are affected; this is a mask-expansion operation with no conditional behavior.", "pseudocode": "for i in 0 to 31:\n zmm1[i*16:i*16+15] ← (k1[i] ? 0xFFFF : 0x0000)", "example": "VPMOVM2W zmm1, k1" }, { "mnemonic": "vpmovm2d", "architecture": "x86", "full_name": "Move Mask Register to Doubleword Mask", "summary": "Expands k-register bits to doubleword elements in ZMM.", "syntax": "VPMOVM2D zmm1, k1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W0 38 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Expands each bit from an 8-bit mask register into a full doubleword (0x00000000 or 0xFFFFFFFF) in a 512-bit ZMM register, producing 16 doubleword elements. Each set bit in the source k-register generates a doubleword of all 1s (0xFFFFFFFF) in the destination; each clear bit generates a doubleword of all 0s (0x00000000). No flags are affected; this is a mask-expansion operation with no conditional behavior.", "pseudocode": "for i in 0 to 15:\n zmm1[i*32:i*32+31] ← (k1[i] ? 0xFFFFFFFF : 0x00000000)", "example": "VPMOVM2D zmm1, k1" }, { "mnemonic": "vpmovm2q", "architecture": "x86", "full_name": "Move Mask Register to Quadword Mask", "summary": "Expands k-register bits to quadword elements in ZMM.", "syntax": "VPMOVM2Q zmm1, k1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W1 38 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Expands each bit from an 8-bit mask register into a full quadword (0x0000000000000000 or 0xFFFFFFFFFFFFFFFF) in a 512-bit ZMM register, producing 8 quadword elements. Each set bit in the source k-register generates a quadword of all 1s (0xFFFFFFFFFFFFFFFF) in the destination; each clear bit generates a quadword of all 0s (0x0000000000000000). No flags are affected; this is a mask-expansion operation with no conditional behavior.", "pseudocode": "for i in 0 to 7:\n zmm1[i*64:i*64+63] ← (k1[i] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000)", "example": "VPMOVM2Q zmm1, k1" }, { "mnemonic": "kshiftrb", "architecture": "x86", "full_name": "Shift Right Mask Byte", "summary": "Logically shifts 8-bit mask right.", "syntax": "KSHIFTRB k1, k2, imm8", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F3A.W0 30 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 30", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Logically shifts the 8-bit contents of the source k-register right by the count specified in an 8-bit immediate, storing the result in the destination k-register. Vacated bit positions are filled with zeros; bits shifted out are discarded. No flags are affected by this mask shift operation.", "pseudocode": "shift_count ← imm8 & 0x07\nk1 ← k2 >> shift_count\nk1[8:63] ← 0", "example": "KSHIFTRB k1, k2, 3" }, { "mnemonic": "kshiftrw", "architecture": "x86", "full_name": "Shift Right Mask Word", "summary": "Logically shifts 16-bit mask right.", "syntax": "KSHIFTRW k1, k2, imm8", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F3A.W1 30 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 32", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Logically shifts the 16-bit contents of the source k-register right by the count specified in an 8-bit immediate, storing the result in the destination k-register. Vacated bit positions are filled with zeros; bits shifted out are discarded. No flags are affected by this mask shift operation.", "pseudocode": "shift_count ← imm8 & 0x0F\nk1 ← k2 >> shift_count\nk1[16:63] ← 0", "example": "KSHIFTRW k1, k2, 3" }, { "mnemonic": "kshiftrd", "architecture": "x86", "full_name": "Shift Right Mask Doubleword", "summary": "Logically shifts 32-bit mask right.", "syntax": "KSHIFTRD k1, k2, imm8", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F3A.W0 31 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 34", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Logically shifts the 32-bit content of the source mask register right by the amount specified in the immediate operand, storing the result in the destination mask register. Bits shifted out are discarded; vacant bit positions are filled with zeros. No flags are affected; this is an AVX-512BW instruction that operates only on opmask registers (k0-k7).", "pseudocode": "dest ← (src1 >> imm8) & 0xFFFFFFFF;", "example": "KSHIFTRD k1, k2, 3" }, { "mnemonic": "kshiftrq", "architecture": "x86", "full_name": "Shift Right Mask Quadword", "summary": "Logically shifts 64-bit mask right.", "syntax": "KSHIFTRQ k1, k2, imm8", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F3A.W1 31 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 36", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Logically shifts the 64-bit content of the source mask register right by the amount specified in the immediate operand, storing the result in the destination mask register. Bits shifted out are discarded; vacant bit positions are filled with zeros. No flags are affected; this is an AVX-512BW instruction that operates only on opmask registers (k0-k7).", "pseudocode": "dest ← (src1 >> imm8) & 0xFFFFFFFFFFFFFFFF;", "example": "KSHIFTRQ k1, k2, 3" }, { "mnemonic": "kshiftlb", "architecture": "x86", "full_name": "Shift Left Mask Byte", "summary": "Logically shifts 8-bit mask left.", "syntax": "KSHIFTLB k1, k2, imm8", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F3A.W0 32 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 31", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Logically shifts the 8-bit content of the source mask register left by the amount specified in the immediate operand, storing the result in the destination mask register. Bits shifted out are discarded; vacant bit positions are filled with zeros. No flags are affected; this is an AVX-512DQ instruction that operates only on opmask registers (k0-k7).", "pseudocode": "dest ← (src1 << imm8) & 0xFF;", "example": "KSHIFTLB k1, k2, 3" }, { "mnemonic": "kshiftlw", "architecture": "x86", "full_name": "Shift Left Mask Word", "summary": "Logically shifts 16-bit mask left.", "syntax": "KSHIFTLW k1, k2, imm8", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F3A.W1 32 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 33", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Logically shifts the 16-bit content of the source mask register left by the amount specified in the immediate operand, storing the result in the destination mask register. Bits shifted out are discarded; vacant bit positions are filled with zeros. No flags are affected; this is an AVX-512F instruction that operates only on opmask registers (k0-k7).", "pseudocode": "dest ← (src1 << imm8) & 0xFFFF;", "example": "KSHIFTLW k1, k2, 3" }, { "mnemonic": "kshiftld", "architecture": "x86", "full_name": "Shift Left Mask Doubleword", "summary": "Logically shifts 32-bit mask left.", "syntax": "KSHIFTLD k1, k2, imm8", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F3A.W0 33 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 35", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Logically shifts the 32-bit content of the source mask register left by the amount specified in the immediate operand, storing the result in the destination mask register. Bits shifted out are discarded; vacant bit positions are filled with zeros. No flags are affected; this is an AVX-512BW instruction that operates only on opmask registers (k0-k7).", "pseudocode": "dest ← (src1 << imm8) & 0xFFFFFFFF;", "example": "KSHIFTLD k1, k2, 3" }, { "mnemonic": "kshiftlq", "architecture": "x86", "full_name": "Shift Left Mask Quadword", "summary": "Logically shifts 64-bit mask left.", "syntax": "KSHIFTLQ k1, k2, imm8", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F3A.W1 33 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 37", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Logically shifts the 64-bit content of the source mask register left by the amount specified in the immediate operand, storing the result in the destination mask register. Bits shifted out are discarded; vacant bit positions are filled with zeros. No flags are affected; this is an AVX-512BW instruction that operates only on opmask registers (k0-k7).", "pseudocode": "dest ← (src1 << imm8) & 0xFFFFFFFFFFFFFFFF;", "example": "KSHIFTLQ k1, k2, 3" }, { "mnemonic": "knotb", "architecture": "x86", "full_name": "NOT Mask Byte", "summary": "Bitwise NOT of 8-bit mask.", "syntax": "KNOTB k1, k2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F.W0 44 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 44", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise NOT of the 8-bit content of the source mask register, storing the result in the destination mask register. Only the lower 8 bits are affected; other bits are zeroed. No flags are affected; this is an AVX-512DQ instruction that operates only on opmask registers (k0-k7).", "pseudocode": "dest ← (~src) & 0xFF;", "example": "KNOTB k1, k2" }, { "mnemonic": "knotd", "architecture": "x86", "full_name": "NOT Mask Doubleword", "summary": "Bitwise NOT of 32-bit mask.", "syntax": "KNOTD k1, k2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F.W1 44 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 44", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise NOT of the 32-bit content of the source mask register, storing the result in the destination mask register. Only the lower 32 bits are affected; other bits are zeroed. No flags are affected; this is an AVX-512BW instruction that operates only on opmask registers (k0-k7).", "pseudocode": "dest ← (~src) & 0xFFFFFFFF;", "example": "KNOTD k1, k2" }, { "mnemonic": "korb", "architecture": "x86", "full_name": "OR Mask Byte", "summary": "Bitwise OR of 8-bit masks.", "syntax": "KORB k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.66.0F.W0 45 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 45", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise OR of two 8-bit AVX-512 opmask registers and stores the result in the destination opmask. This instruction operates on the mask registers (k0-k7) and does not affect EFLAGS. It is part of the AVX-512DQ extension and executes with minimal latency on modern AVX-512 capable processors.", "pseudocode": "k1 ← k2 | k3;", "example": "KORB k1, k2, k3" }, { "mnemonic": "kord", "architecture": "x86", "full_name": "OR Mask Doubleword", "summary": "Bitwise OR of 32-bit masks.", "syntax": "KORD k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.66.0F.W1 45 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 45", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise OR of two 32-bit AVX-512 opmask registers and stores the result in the destination opmask. This instruction operates on mask registers (k0-k7) treating them as 32-bit values and does not affect EFLAGS. It is part of the AVX-512BW extension and executes with minimal latency.", "pseudocode": "k1 ← k2 | k3;", "example": "KORD k1, k2, k3" }, { "mnemonic": "kxorq", "architecture": "x86", "full_name": "XOR Mask Quadword", "summary": "Bitwise XOR of 64-bit masks.", "syntax": "KXORQ k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.0F.W1 47 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 47", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise XOR of two 64-bit AVX-512 opmask registers and stores the result in the destination opmask. This instruction operates on mask registers (k0-k7) treating them as 64-bit values and does not affect EFLAGS. It is part of the AVX-512BW extension and executes with minimal latency.", "pseudocode": "k1 ← k2 ^ k3;", "example": "KXORQ k1, k2, k3" }, { "mnemonic": "kxord", "architecture": "x86", "full_name": "XOR Mask Doubleword", "summary": "Bitwise XOR of 32-bit masks.", "syntax": "KXORD k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.66.0F.W1 47 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 47", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise XOR of two 32-bit AVX-512 opmask registers and stores the result in the destination opmask. This instruction operates on mask registers (k0-k7) treating them as 32-bit values and does not affect EFLAGS. It is part of the AVX-512BW extension and executes with minimal latency.", "pseudocode": "k1 ← k2 ^ k3;", "example": "KXORD k1, k2, k3" }, { "mnemonic": "kxorb", "architecture": "x86", "full_name": "XOR Mask Byte", "summary": "Bitwise XOR of 8-bit masks.", "syntax": "KXORB k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.66.0F.W0 47 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 47", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise XOR of two 8-bit AVX-512 opmask registers and stores the result in the destination opmask. This instruction operates on mask registers (k0-k7) and does not affect EFLAGS. It is part of the AVX-512DQ extension and executes with minimal latency.", "pseudocode": "k1 ← k2 ^ k3;", "example": "KXORB k1, k2, k3" }, { "mnemonic": "kortestb", "architecture": "x86", "full_name": "OR Masks and Set Flags Byte", "summary": "ORs 8-bit masks and sets EFLAGS (ZF/CF).", "syntax": "KORTESTB k1, k2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F.W0 98 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 98", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "ORs two 8-bit AVX-512 opmask registers and sets EFLAGS based on the result without storing the OR result. Sets ZF if the OR result is all zeros, and CF if the first source opmask is all zeros. Part of the AVX-512DQ extension, this instruction is useful for testing mask conditions.", "pseudocode": "temp ← k1 | k2; ZF ← (temp == 0); CF ← (k1 == 0);", "example": "KORTESTB k1, k2" }, { "mnemonic": "kortestq", "architecture": "x86", "full_name": "OR Masks and Set Flags Quadword", "summary": "ORs 64-bit masks and sets EFLAGS (ZF/CF).", "syntax": "KORTESTQ k1, k2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.0F.W1 98 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 98", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "ORs two 64-bit AVX-512 opmask registers and sets EFLAGS based on the result without storing the OR result. Sets ZF if the OR result is all zeros, and CF if the first source opmask is all zeros. Part of the AVX-512BW extension, this instruction is useful for testing mask conditions.", "pseudocode": "temp ← k1 | k2; ZF ← (temp == 0); CF ← (k1 == 0);", "example": "KORTESTQ k1, k2" }, { "mnemonic": "ktestb", "architecture": "x86", "full_name": "Test Masks Byte", "summary": "ANDs 8-bit masks and sets EFLAGS (ZF/CF).", "syntax": "KTESTB k1, k2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F.W0 99 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 99", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "ANDs two 8-bit AVX-512 opmask registers and sets EFLAGS based on the result without storing the AND result. Sets ZF if the AND result is all zeros, and CF if the first source opmask is all zeros. Part of the AVX-512DQ extension, this instruction is useful for testing mask bit intersections.", "pseudocode": "temp ← k1 & k2; ZF ← (temp == 0); CF ← (k1 == 0);", "example": "KTESTB k1, k2" }, { "mnemonic": "ktestw", "architecture": "x86", "full_name": "Test Masks Word", "summary": "ANDs 16-bit masks and sets EFLAGS (ZF/CF).", "syntax": "KTESTW k1, k2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.0F.W0 99 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 99", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise AND of two 16-bit AVX-512 opmask registers and updates EFLAGS based on the result without storing the AND product. Sets ZF if the result is zero, clears ZF otherwise; sets CF if all bits of the first operand are zero, clears CF otherwise. This instruction executes in 64-bit mode only and is part of AVX-512F.", "pseudocode": "temp ← k1 AND k2\nZF ← (temp == 0)\nCF ← (k1 == 0)\nOF ← 0\nSF ← 0\nAF ← undefined\nPF ← undefined", "example": "KTESTW k1, k2" }, { "mnemonic": "ktestd", "architecture": "x86", "full_name": "Test Masks Doubleword", "summary": "ANDs 32-bit masks and sets EFLAGS (ZF/CF).", "syntax": "KTESTD k1, k2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.66.0F.W1 99 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 99", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise AND of two 32-bit AVX-512 opmask registers and updates EFLAGS based on the result without storing the AND product. Sets ZF if the result is zero, clears ZF otherwise; sets CF if all bits of the first operand are zero, clears CF otherwise. This instruction executes in 64-bit mode only and requires AVX-512BW.", "pseudocode": "temp ← k1 AND k2\nZF ← (temp == 0)\nCF ← (k1 == 0)\nOF ← 0\nSF ← 0\nAF ← undefined\nPF ← undefined", "example": "KTESTD k1, k2" }, { "mnemonic": "ktestq", "architecture": "x86", "full_name": "Test Masks Quadword", "summary": "ANDs 64-bit masks and sets EFLAGS (ZF/CF).", "syntax": "KTESTQ k1, k2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.0F.W1 99 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 99", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise AND of two 64-bit AVX-512 opmask registers and updates EFLAGS based on the result without storing the AND product. Sets ZF if the result is zero, clears ZF otherwise; sets CF if all bits of the first operand are zero, clears CF otherwise. This instruction executes in 64-bit mode only and requires AVX-512BW.", "pseudocode": "temp ← k1 AND k2\nZF ← (temp == 0)\nCF ← (k1 == 0)\nOF ← 0\nSF ← 0\nAF ← undefined\nPF ← undefined", "example": "KTESTQ k1, k2" }, { "mnemonic": "vcvtudq2pd", "architecture": "x86", "full_name": "Convert Packed Unsigned Doubleword to Double", "summary": "Converts unsigned 32-bit integers to 64-bit doubles.", "syntax": "VCVTUDQ2PD zmm1 {k1}, ymm2/m256", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F.W0 7A /r", "visual_parts": [], "binary_pattern": "EVEX | F3 | 0F | 7A", "bit_positions": "+0 | +4 | +5 | +6" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "ymm2/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Converts four unsigned 32-bit doublewords (from a 256-bit YMM or memory operand) to four 64-bit double-precision floating-point values, storing the result in a 512-bit ZMM register with optional opmask write control. The conversion uses the current rounding mode from MXCSR. Executes in 64-bit mode only and requires AVX-512F; precision may be lost for large unsigned integers that exceed 2^53.", "pseudocode": "for i ← 0 to 3\n if k1[i] or no mask:\n zmm1[64*i:64*i+63] ← convert_udq_to_pd(ymm2_or_mem[32*i:32*i+31])\n else if zeroing:\n zmm1[64*i:64*i+63] ← 0", "example": "VCVTUDQ2PD zmm1, ymm2/m256" }, { "mnemonic": "vcvtpd2udq", "architecture": "x86", "full_name": "Convert Packed Double to Unsigned Doubleword", "summary": "Converts 64-bit doubles to unsigned 32-bit integers.", "syntax": "VCVTPD2UDQ ymm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.0F.W1 79 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 79", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Converts eight 64-bit double-precision floating-point values (from a 512-bit ZMM or memory operand) to eight unsigned 32-bit doublewords, storing the result in a 256-bit YMM register with optional opmask write control. The conversion uses the current rounding mode from MXCSR; out-of-range values saturate to the maximum unsigned 32-bit integer (2^32-1). Executes in 64-bit mode only and requires AVX-512F.", "pseudocode": "for i ← 0 to 7\n if k1[i] or no mask:\n ymm1[32*i:32*i+31] ← convert_pd_to_udq_saturate(zmm2_or_mem[64*i:64*i+63])\n else if zeroing:\n ymm1[32*i:32*i+31] ← 0", "example": "VCVTPD2UDQ ymm1, zmm2/m512" }, { "mnemonic": "vcvtps2udq", "architecture": "x86", "full_name": "Convert Packed Single to Unsigned Doubleword", "summary": "Converts 32-bit floats to unsigned 32-bit integers.", "syntax": "VCVTPS2UDQ zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.0F.W0 79 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 79", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Converts sixteen 32-bit single-precision floating-point values (from a 512-bit ZMM or memory operand) to sixteen unsigned 32-bit doublewords, storing the result in a 512-bit ZMM register with optional opmask write control. The conversion uses the current rounding mode from MXCSR; out-of-range values saturate to the maximum unsigned 32-bit integer (2^32-1). Executes in 64-bit mode only and requires AVX-512F.", "pseudocode": "for i ← 0 to 15\n if k1[i] or no mask:\n zmm1[32*i:32*i+31] ← convert_ps_to_udq_saturate(zmm2_or_mem[32*i:32*i+31])\n else if zeroing:\n zmm1[32*i:32*i+31] ← 0", "example": "VCVTPS2UDQ zmm1, zmm2/m512" }, { "mnemonic": "vcvtuqq2ps", "architecture": "x86", "full_name": "Convert Packed Unsigned Quadword to Single", "summary": "Converts unsigned 64-bit integers to 32-bit floats.", "syntax": "VCVTUQQ2PS ymm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F2.0F.W1 7A /r", "visual_parts": [], "binary_pattern": "EVEX | F2 | 0F | 7A", "bit_positions": "+0 | +4 | +5 | +6" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Converts eight unsigned 64-bit quadwords (from a 512-bit ZMM or memory operand) to eight 32-bit single-precision floating-point values, storing the result in a 256-bit YMM register with optional opmask write control. The conversion uses the current rounding mode from MXCSR. Executes in 64-bit mode only and requires AVX-512F; precision may be lost for large unsigned integers that exceed 2^24.", "pseudocode": "for i ← 0 to 7\n if k1[i] or no mask:\n ymm1[32*i:32*i+31] ← convert_uq_to_ps(zmm2_or_mem[64*i:64*i+63])\n else if zeroing:\n ymm1[32*i:32*i+31] ← 0", "example": "VCVTUQQ2PS ymm1, zmm2/m512" }, { "mnemonic": "vcvtuqq2pd", "architecture": "x86", "full_name": "Convert Packed Unsigned Quadword to Double", "summary": "Converts unsigned 64-bit integers to 64-bit doubles.", "syntax": "VCVTUQQ2PD zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F.W1 7A /r", "visual_parts": [], "binary_pattern": "EVEX | F3 | 0F | 7A", "bit_positions": "+0 | +4 | +5 | +6" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Converts eight unsigned 64-bit quadwords (from a 512-bit ZMM or memory operand) to eight 64-bit double-precision floating-point values, storing the result in a 512-bit ZMM register with optional opmask write control. The conversion uses the current rounding mode from MXCSR. Executes in 64-bit mode only and requires AVX-512F; full precision is maintained since IEEE 754 double can exactly represent all 64-bit unsigned integers.", "pseudocode": "for i ← 0 to 7\n if k1[i] or no mask:\n zmm1[64*i:64*i+63] ← convert_uq_to_pd(zmm2_or_mem[64*i:64*i+63])\n else if zeroing:\n zmm1[64*i:64*i+63] ← 0", "example": "VCVTUQQ2PD zmm1, zmm2/m512" }, { "mnemonic": "vcvtps2uqq", "architecture": "x86", "full_name": "Convert Packed Single to Unsigned Quadword", "summary": "Converts 32-bit floats to unsigned 64-bit integers.", "syntax": "VCVTPS2UQ zmm1 {k1}, ymm2/m256", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F.W0 79 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 79", "bit_positions": "+0 | +4 | +5 | +6" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "ymm2/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Converts packed 32-bit single-precision floating-point values to unsigned 64-bit integers. The instruction reads 256 bits (4 × 32-bit floats from ymm2/m256) and produces 512 bits (4 × 64-bit unsigned integers in zmm1). EVEX encoding enables masking via k1 and rounding mode control; results are undefined if any value overflows the unsigned 64-bit range, and invalid floating-point exceptions are raised on NaN inputs. The instruction operates in 64-bit, protected, and real modes with AVX-512F support.", "pseudocode": "zmm1[63:0] ← (src[31:0] is valid && src[31:0] ≤ 2^64-1) ? convert_float_to_uint64(src[31:0]) : undefined; zmm1[127:64] ← convert_float_to_uint64(src[63:32]); zmm1[191:128] ← convert_float_to_uint64(src[95:64]); zmm1[255:192] ← convert_float_to_uint64(src[127:96]);", "example": "VCVTPS2UQ zmm1, ymm2/m256" }, { "mnemonic": "vcvtpd2uqq", "architecture": "x86", "full_name": "Convert Packed Double to Unsigned Quadword", "summary": "Converts 64-bit doubles to unsigned 64-bit integers.", "syntax": "VCVTPD2UQ zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F.W1 79 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 79", "bit_positions": "+0 | +4 | +5 | +6" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Converts packed 64-bit double-precision floating-point values to unsigned 64-bit integers. The instruction reads 512 bits (4 × 64-bit doubles from zmm2/m512) and produces 512 bits (4 × 64-bit unsigned integers in zmm1). EVEX masking via k1 and rounding control are supported; overflow conditions and NaN inputs trigger invalid floating-point exceptions. Operates in 64-bit, protected, and real modes with AVX-512F support.", "pseudocode": "zmm1[63:0] ← convert_double_to_uint64(src[63:0]); zmm1[127:64] ← convert_double_to_uint64(src[127:64]); zmm1[191:128] ← convert_double_to_uint64(src[191:128]); zmm1[255:192] ← convert_double_to_uint64(src[255:192]);", "example": "VCVTPD2UQ zmm1, zmm2/m512" }, { "mnemonic": "vfmaddcph", "architecture": "x86", "full_name": "Complex Multiply-Add FP16", "summary": "Complex multiply-add for half-precision.", "syntax": "VFMADDCPH zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.MAP6.W0 56 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Performs complex multiply-add on packed half-precision (FP16) complex numbers. Each ZMM register holds 16 FP16 values (8 complex pairs); the instruction computes (src1 × src2) + dest for each complex pair and stores the result in dest. EVEX masking (k1) and embedded rounding are supported. Intermediate calculations use extended precision to minimize rounding errors. Requires AVX-512-FP16 support.", "pseudocode": "for i = 0 to 7 do: real_i ← src1[32*i+15:32*i] * src2[32*i+15:32*i] - src1[32*i+31:32*i+16] * src2[32*i+31:32*i+16]; imag_i ← src1[32*i+15:32*i] * src2[32*i+31:32*i+16] + src1[32*i+31:32*i+16] * src2[32*i+15:32*i]; dest[32*i+15:32*i] ← real_i + dest[32*i+15:32*i]; dest[32*i+31:32*i+16] ← imag_i + dest[32*i+31:32*i+16];", "example": "VFMADDCPH zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vfcmaddcph", "architecture": "x86", "full_name": "Complex Conjugate Multiply-Add FP16", "summary": "Complex conjugate multiply-add for half-precision.", "syntax": "VFCMADDCPH zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F2.MAP6.W0 56 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Performs complex conjugate multiply-add on packed half-precision (FP16) complex numbers. Each ZMM holds 16 FP16 values (8 complex pairs); the instruction computes (src1 × conj(src2)) + dest for each pair, where conj() negates the imaginary component. EVEX masking (k1) and embedded rounding control are supported. Intermediate precision extension minimizes rounding artifacts. Requires AVX-512-FP16 support.", "pseudocode": "for i = 0 to 7 do: real_i ← src1[32*i+15:32*i] * src2[32*i+15:32*i] + src1[32*i+31:32*i+16] * src2[32*i+31:32*i+16]; imag_i ← src1[32*i+31:32*i+16] * src2[32*i+15:32*i] - src1[32*i+15:32*i] * src2[32*i+31:32*i+16]; dest[32*i+15:32*i] ← real_i + dest[32*i+15:32*i]; dest[32*i+31:32*i+16] ← imag_i + dest[32*i+31:32*i+16];", "example": "VFCMADDCPH zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vfmaddcsh", "architecture": "x86", "full_name": "Complex Multiply-Add Scalar FP16", "summary": "Complex multiply-add for scalar half-precision.", "syntax": "VFMADDCSH xmm1 {k1}, xmm2, xmm3/m32", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.F3.MAP6.W0 57 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs scalar complex multiply-add on half-precision (FP16) complex numbers. The lower 32 bits of xmm1 and xmm2 represent a single complex number (two FP16 values: real and imaginary); the instruction computes (src1 × src2) + dest for that pair and updates only the lower 32 bits of xmm1. EVEX masking (k1) and embedded rounding are supported. Requires AVX-512-FP16 support.", "pseudocode": "real ← src1[15:0] * src2[15:0] - src1[31:16] * src2[31:16]; imag ← src1[15:0] * src2[31:16] + src1[31:16] * src2[15:0]; xmm1[15:0] ← real + dest[15:0]; xmm1[31:16] ← imag + dest[31:16]; xmm1[127:32] ← dest[127:32];", "example": "VFMADDCSH xmm1, xmm2, xmm3/m32" }, { "mnemonic": "vcmpps", "architecture": "x86", "full_name": "Compare Packed Single-Precision (AVX)", "summary": "Compares packed floats (AVX version with immediate).", "syntax": "VCMPPS ymm1, ymm2, ymm3/m256, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.0F.WIG C2 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Compares packed 32-bit single-precision floats and stores the boolean result (all-ones or all-zeros per element) in the destination YMM register. The comparison operator is encoded in the imm8 field (0=EQ, 1=LT, 2=LE, 4=NEQ, 5=NLT, 6=NLE, etc.). Quiet NaNs produce false results; signaling NaNs trigger invalid floating-point exceptions (unless masked). VEX encoding supports 256-bit operations; three-operand form allows non-destructive destination. Operates in 64-bit, protected, and real modes with AVX support.", "pseudocode": "for i = 0 to 7 do: cmp_result ← compare_float(src1[32*i+31:32*i], src2[32*i+31:32*i], imm8); dest[32*i+31:32*i] ← cmp_result ? 0xFFFFFFFF : 0x00000000;", "example": "VCMPPS ymm1, ymm2, ymm3/m256, 3" }, { "mnemonic": "vcmppd", "architecture": "x86", "full_name": "Compare Packed Double-Precision (AVX)", "summary": "Compares packed doubles (AVX version with immediate).", "syntax": "VCMPPD ymm1, ymm2, ymm3/m256, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F.WIG C2 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Compares packed 64-bit double-precision floats and stores the boolean result (all-ones or all-zeros per element) in the destination YMM register. The comparison predicate is encoded in imm8 (0=EQ, 1=LT, 2=LE, 4=NEQ, 5=NLT, 6=NLE, etc.). Quiet NaNs return false; signaling NaNs trigger invalid floating-point exceptions (unless masked). VEX encoding supports 256-bit operations; three-operand form enables non-destructive destination. Operates in 64-bit, protected, and real modes with AVX support.", "pseudocode": "for i = 0 to 3 do: cmp_result ← compare_double(src1[64*i+63:64*i], src2[64*i+63:64*i], imm8); dest[64*i+63:64*i] ← cmp_result ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000;", "example": "VCMPPD ymm1, ymm2, ymm3/m256, 3" }, { "mnemonic": "vpcmpb", "architecture": "x86", "full_name": "Compare Packed Byte Integers", "summary": "Compares bytes and stores result in k-register mask.", "syntax": "VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 3F /r ib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Compares packed 8-bit signed integers and stores the boolean result in an AVX-512 opmask register (k1). The comparison operator is encoded in imm8 (0=EQ, 1=LT, 2=LE, 4=NEQ, 5=NLT, 6=NLE, etc.). EVEX encoding enables masking via k2 (merge-with-zero or keep-unchanged per bit). The destination k1 register holds 64 single-bit results corresponding to 64 bytes. Operates in 64-bit mode with AVX-512BW support.", "pseudocode": "for i = 0 to 63 do: if k2[i] == 1 or k2 is unused then: cmp_result ← compare_signed_byte(src1[8*i+7:8*i], src2[8*i+7:8*i], imm8); k1[i] ← cmp_result ? 1 : 0; else: k1[i] ← 0;", "example": "VPCMPB k1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpcmpw", "architecture": "x86", "full_name": "Compare Packed Word Integers", "summary": "Compares words and stores result in k-register mask.", "syntax": "VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 3F /r ib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Compares packed signed 16-bit integers in zmm2 against zmm3/m512 using the comparison predicate specified in imm8, storing the boolean results in the opmask k1 (optionally merged with k2). The instruction operates on 32 word elements in 512-bit vectors and does not modify EFLAGS; the predicate selector in imm8 determines the comparison type (equal, less, less-equal, unordered, etc.). Available only in 64-bit mode with AVX-512BW extension.", "pseudocode": "for i in 0..31:\n elem1 ← zmm2[16*i : 16*i+15] as signed 16-bit\n elem2 ← zmm3/m512[16*i : 16*i+15] as signed 16-bit\n k1[i] ← (mask_merge) ? k2[i] : 0\n if pred(elem1, elem2, imm8) then k1[i] ← 1", "example": "VPCMPW k1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpcmpd", "architecture": "x86", "full_name": "Compare Packed Doubleword Integers", "summary": "Compares doublewords and stores result in k-register mask.", "syntax": "VPCMPD k1 {k2}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 1F /r ib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Compares packed signed 32-bit integers in zmm2 against zmm3/m512 using the comparison predicate in imm8, storing boolean results in opmask k1 (optionally merged with k2). Operates on 16 doubleword elements in 512-bit vectors without affecting EFLAGS; the imm8 predicate determines comparison semantics (EQ, LT, LE, NEQ, NLT, NLE, etc.). Available in 64-bit mode with AVX-512F extension.", "pseudocode": "for i in 0..15:\n elem1 ← zmm2[32*i : 32*i+31] as signed 32-bit\n elem2 ← zmm3/m512[32*i : 32*i+31] as signed 32-bit\n k1[i] ← (mask_merge) ? k2[i] : 0\n if pred(elem1, elem2, imm8) then k1[i] ← 1", "example": "VPCMPD k1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpcmpq", "architecture": "x86", "full_name": "Compare Packed Quadword Integers", "summary": "Compares quadwords and stores result in k-register mask.", "syntax": "VPCMPQ k1 {k2}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 1F /r ib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Compares packed signed 64-bit integers in zmm2 against zmm3/m512 using the comparison predicate in imm8, storing boolean results in opmask k1 (optionally merged with k2). Operates on 8 quadword elements in 512-bit vectors without modifying EFLAGS; the imm8 predicate encodes the comparison condition (equal, less-than, less-than-or-equal, etc.). Available in 64-bit mode with AVX-512F extension.", "pseudocode": "for i in 0..7:\n elem1 ← zmm2[64*i : 64*i+63] as signed 64-bit\n elem2 ← zmm3/m512[64*i : 64*i+63] as signed 64-bit\n k1[i] ← (mask_merge) ? k2[i] : 0\n if pred(elem1, elem2, imm8) then k1[i] ← 1", "example": "VPCMPQ k1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpcmpub", "architecture": "x86", "full_name": "Compare Packed Unsigned Byte Integers", "summary": "Compares unsigned bytes and stores result in k-register.", "syntax": "VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 3E /r ib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Compares packed unsigned 8-bit integers in zmm2 against zmm3/m512 using the comparison predicate in imm8, storing boolean results in opmask k1 (optionally merged with k2). Operates on 64 byte elements in 512-bit vectors; comparison is performed as unsigned and imm8 specifies the predicate (equal, less, less-equal, etc.). Available in 64-bit mode with AVX-512BW extension; EFLAGS are not modified.", "pseudocode": "for i in 0..63:\n elem1 ← zmm2[8*i : 8*i+7] as unsigned 8-bit\n elem2 ← zmm3/m512[8*i : 8*i+7] as unsigned 8-bit\n k1[i] ← (mask_merge) ? k2[i] : 0\n if pred(elem1, elem2, imm8) then k1[i] ← 1", "example": "VPCMPUB k1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpcmpuw", "architecture": "x86", "full_name": "Compare Packed Unsigned Word Integers", "summary": "Compares unsigned words and stores result in k-register.", "syntax": "VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 3E /r ib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Compares packed unsigned 16-bit integers in zmm2 against zmm3/m512 using the comparison predicate in imm8, storing boolean results in opmask k1 (optionally merged with k2). Operates on 32 word elements in 512-bit vectors; comparison is performed as unsigned and imm8 encodes the predicate type (equal, less, less-equal, not-equal, etc.). Available in 64-bit mode with AVX-512BW extension; EFLAGS remain unaffected.", "pseudocode": "for i in 0..31:\n elem1 ← zmm2[16*i : 16*i+15] as unsigned 16-bit\n elem2 ← zmm3/m512[16*i : 16*i+15] as unsigned 16-bit\n k1[i] ← (mask_merge) ? k2[i] : 0\n if pred(elem1, elem2, imm8) then k1[i] ← 1", "example": "VPCMPUW k1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpcmpud", "architecture": "x86", "full_name": "Compare Packed Unsigned Doubleword Integers", "summary": "Compares unsigned doublewords and stores result in k-register.", "syntax": "VPCMPUD k1 {k2}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 1E /r ib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Compares packed unsigned 32-bit integers in zmm2 against zmm3/m512 using the comparison predicate in imm8, storing boolean results in opmask k1 (optionally merged with k2). Operates on 16 doubleword elements in 512-bit vectors; all comparisons are unsigned and imm8 specifies the predicate (equal, less, less-equal, not-equal, etc.). Available in 64-bit mode with AVX-512F extension; EFLAGS are not modified.", "pseudocode": "for i in 0..15:\n elem1 ← zmm2[32*i : 32*i+31] as unsigned 32-bit\n elem2 ← zmm3/m512[32*i : 32*i+31] as unsigned 32-bit\n k1[i] ← (mask_merge) ? k2[i] : 0\n if pred(elem1, elem2, imm8) then k1[i] ← 1", "example": "VPCMPUD k1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpcmpuq", "architecture": "x86", "full_name": "Compare Packed Unsigned Quadword Integers", "summary": "Compares unsigned quadwords and stores result in k-register.", "syntax": "VPCMPUQ k1 {k2}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 1E /r ib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Compares packed unsigned 64-bit integers in zmm2 against zmm3/m512 using the comparison predicate in imm8, storing boolean results in opmask k1 (optionally merged with k2). Operates on 8 quadword elements in 512-bit vectors; all comparisons are unsigned and imm8 encodes the predicate (equal, less-than, less-equal, not-equal, etc.). Available in 64-bit mode with AVX-512F extension; EFLAGS remain unchanged.", "pseudocode": "for i in 0..7:\n elem1 ← zmm2[64*i : 64*i+63] as unsigned 64-bit\n elem2 ← zmm3/m512[64*i : 64*i+63] as unsigned 64-bit\n k1[i] ← (mask_merge) ? k2[i] : 0\n if pred(elem1, elem2, imm8) then k1[i] ← 1", "example": "VPCMPUQ k1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vptestmb", "architecture": "x86", "full_name": "Packed Test Mask Byte", "summary": "Tests byte integers and sets k-register mask.", "syntax": "VPTESTMB k1 {k2}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 26 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Tests packed 8-bit integers by performing a bitwise AND of zmm2 and zmm3/m512, setting each bit in opmask k1 if the result is nonzero (optionally merged with k2). Operates on 64 byte elements in 512-bit vectors and does not modify EFLAGS; this is a destructive AND-test operation that sets mask bits based on non-zero results. Available in 64-bit mode with AVX-512BW extension.", "pseudocode": "for i in 0..63:\n elem1 ← zmm2[8*i : 8*i+7]\n elem2 ← zmm3/m512[8*i : 8*i+7]\n k1[i] ← (mask_merge) ? k2[i] : 0\n if (elem1 & elem2) != 0 then k1[i] ← 1", "example": "VPTESTMB k1, zmm2, zmm3/m512" }, { "mnemonic": "vptestmw", "architecture": "x86", "full_name": "Packed Test Mask Word", "summary": "Tests word integers and sets k-register mask.", "syntax": "VPTESTMW k1 {k2}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 26 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Tests packed word integers by performing a bitwise AND between two 512-bit ZMM sources and sets the result bits in the destination k-register mask. Each bit in the k-register corresponds to whether the AND result for that word element is nonzero. No arithmetic flags (OF, SF, ZF, AF, CF, PF) are modified; only the k-register mask is updated. This is an AVX-512BW instruction that operates on 16-bit elements.", "pseudocode": "for i = 0 to 31:\n element_result = zmm2[i*16+15:i*16] & zmm3[i*16+15:i*16]\n k1[i] = (element_result != 0) ? 1 : 0", "example": "VPTESTMW k1, zmm2, zmm3/m512" }, { "mnemonic": "vptestmd", "architecture": "x86", "full_name": "Packed Test Mask Doubleword", "summary": "Tests doubleword integers and sets k-register mask.", "syntax": "VPTESTMD k1 {k2}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 27 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Tests packed doubleword integers by performing a bitwise AND between two 512-bit ZMM sources and sets the result bits in the destination k-register mask. Each bit in the k-register corresponds to whether the AND result for that doubleword element is nonzero. No arithmetic flags (OF, SF, ZF, AF, CF, PF) are modified; only the k-register mask is updated. This is an AVX-512F instruction that operates on 32-bit elements.", "pseudocode": "for i = 0 to 15:\n element_result = zmm2[i*32+31:i*32] & zmm3[i*32+31:i*32]\n k1[i] = (element_result != 0) ? 1 : 0", "example": "VPTESTMD k1, zmm2, zmm3/m512" }, { "mnemonic": "vptestmq", "architecture": "x86", "full_name": "Packed Test Mask Quadword", "summary": "Tests quadword integers and sets k-register mask.", "syntax": "VPTESTMQ k1 {k2}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 27 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Tests packed quadword integers by performing a bitwise AND between two 512-bit ZMM sources and sets the result bits in the destination k-register mask. Each bit in the k-register corresponds to whether the AND result for that quadword element is nonzero. No arithmetic flags (OF, SF, ZF, AF, CF, PF) are modified; only the k-register mask is updated. This is an AVX-512F instruction that operates on 64-bit elements.", "pseudocode": "for i = 0 to 7:\n element_result = zmm2[i*64+63:i*64] & zmm3[i*64+63:i*64]\n k1[i] = (element_result != 0) ? 1 : 0", "example": "VPTESTMQ k1, zmm2, zmm3/m512" }, { "mnemonic": "monitorx", "architecture": "x86", "full_name": "Monitor Extended", "summary": "Sets up a monitor address (AMD extension).", "syntax": "MONITORX", "encoding": { "format": "AMD", "hex_opcode": "0F 01 FA", "visual_parts": [], "binary_pattern": "0F | 01 | FA", "bit_positions": "+0 | +1 | +2" }, "extension": "AMD", "operands": [], "description": "Sets up a monitor address and optional extensions for memory monitoring (AMD-specific extension). The instruction uses the address in EAX (or RAX in 64-bit mode) as the monitor target, with optional parameters in ECX (monitor extensions/timeout) and EDX (optional threshold). This instruction primes the CPU's monitoring hardware for use with MWAITX and does not modify any arithmetic flags. MONITORX is a privileged instruction available on AMD Zen and later processors.", "pseudocode": "monitor_address ← EAX\nmonitor_extensions ← ECX\nmonitor_threshold ← EDX", "example": "MONITORX" }, { "mnemonic": "mwaitx", "architecture": "x86", "full_name": "Monitor Wait Extended", "summary": "Waits for a write to monitored address (AMD extension).", "syntax": "MWAITX", "encoding": { "format": "AMD", "hex_opcode": "0F 01 FB", "visual_parts": [], "binary_pattern": "0F | 01 | FB", "bit_positions": "+0 | +1 | +2" }, "extension": "AMD", "operands": [], "description": "Waits for a write to the address set by MONITORX, with optional timeout support (AMD-specific extension). The instruction operates with implicit operands: EAX contains the monitor address, ECX contains extensions/flags, and EDX contains a timeout value in clock cycles (if ECX[1] is set for timeout mode). The instruction is interruptible and will exit on an interrupt, cache line write to the monitored address, or timeout expiration. No arithmetic flags are modified; this is a privileged instruction available on AMD Zen and later processors.", "pseudocode": "while (memory[monitor_address] has not been written) {\n if (ECX[1] == 1 && timeout_expired(EDX)) break\n if (interrupt_pending()) break\n wait()\n}", "example": "MWAITX" }, { "mnemonic": "subss", "architecture": "x86", "full_name": "Subtract Scalar Single-Precision", "summary": "Subtracts the low single-precision floating-point value.", "syntax": "SUBSS xmm1, xmm2/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 5C", "visual_parts": [], "binary_pattern": "F3 | 0F | 5C", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Subtracts the low 32-bit single-precision floating-point value in the source from the destination XMM register, following IEEE 754 semantics. The high 96 bits of the destination XMM register are left unchanged. The result may raise floating-point exceptions (invalid operation, overflow, underflow, inexact) but does not modify the general-purpose arithmetic flags (OF, SF, ZF, AF, CF, PF). This is an SSE instruction available in 32-bit and 64-bit modes.", "pseudocode": "xmm1[31:0] ← xmm1[31:0] - src[31:0] (IEEE 754 single-precision)\nxmm1[127:32] ← unchanged\nFP_exceptions may be raised", "example": "SUBSS xmm1, xmm2/m32" }, { "mnemonic": "subsd", "architecture": "x86", "full_name": "Subtract Scalar Double-Precision", "summary": "Subtracts the low double-precision floating-point value.", "syntax": "SUBSD xmm1, xmm2/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 5C", "visual_parts": [], "binary_pattern": "F2 | 0F | 5C", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Subtracts the low 64-bit double-precision floating-point value in the source from the destination XMM register, following IEEE 754 semantics. The high 64 bits of the destination XMM register are left unchanged. The result may raise floating-point exceptions (invalid operation, overflow, underflow, inexact) but does not modify the general-purpose arithmetic flags (OF, SF, ZF, AF, CF, PF). This is an SSE2 instruction available in 32-bit and 64-bit modes.", "pseudocode": "xmm1[63:0] ← xmm1[63:0] - src[63:0] (IEEE 754 double-precision)\nxmm1[127:64] ← unchanged\nFP_exceptions may be raised", "example": "SUBSD xmm1, xmm2/m64" }, { "mnemonic": "mulss", "architecture": "x86", "full_name": "Multiply Scalar Single-Precision", "summary": "Multiplies the low single-precision floating-point value.", "syntax": "MULSS xmm1, xmm2/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 59", "visual_parts": [], "binary_pattern": "F3 | 0F | 59", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Multiplies the low 32-bit single-precision floating-point value in the source by the destination XMM register, following IEEE 754 semantics. The high 96 bits of the destination XMM register are left unchanged. The result may raise floating-point exceptions (invalid operation, overflow, underflow, inexact) but does not modify the general-purpose arithmetic flags (OF, SF, ZF, AF, CF, PF). This is an SSE instruction available in 32-bit and 64-bit modes.", "pseudocode": "xmm1[31:0] ← xmm1[31:0] * src[31:0] (IEEE 754 single-precision)\nxmm1[127:32] ← unchanged\nFP_exceptions may be raised", "example": "MULSS xmm1, xmm2/m32" }, { "mnemonic": "mulsd", "architecture": "x86", "full_name": "Multiply Scalar Double-Precision", "summary": "Multiplies the low double-precision floating-point value.", "syntax": "MULSD xmm1, xmm2/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 59", "visual_parts": [], "binary_pattern": "F2 | 0F | 59", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Multiplies the low 64-bit double-precision floating-point value in xmm1 by the low 64-bit value from xmm2/m64, storing the result in xmm1; the high 64-bit value in xmm1 is preserved. This operation follows IEEE 754 semantics for floating-point multiplication and does not modify EFLAGS.", "pseudocode": "xmm1[0:63] ← FP64_multiply(xmm1[0:63], xmm2/m64[0:63])\nxmm1[64:127] ← unchanged", "example": "MULSD xmm1, xmm2/m64" }, { "mnemonic": "divss", "architecture": "x86", "full_name": "Divide Scalar Single-Precision", "summary": "Divides the low single-precision floating-point value.", "syntax": "DIVSS xmm1, xmm2/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 5E", "visual_parts": [], "binary_pattern": "F3 | 0F | 5E", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Divides the low 32-bit single-precision floating-point value in xmm1 by the low 32-bit value from xmm2/m32, storing the result in xmm1; the upper 96 bits of xmm1 are preserved. This operation follows IEEE 754 semantics and does not modify EFLAGS; division by zero produces infinity or NaN per IEEE rules.", "pseudocode": "xmm1[0:31] ← FP32_divide(xmm1[0:31], xmm2/m32[0:31])\nxmm1[32:127] ← unchanged", "example": "DIVSS xmm1, xmm2/m32" }, { "mnemonic": "divsd", "architecture": "x86", "full_name": "Divide Scalar Double-Precision", "summary": "Divides the low double-precision floating-point value.", "syntax": "DIVSD xmm1, xmm2/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 5E", "visual_parts": [], "binary_pattern": "F2 | 0F | 5E", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Divides the low 64-bit double-precision floating-point value in xmm1 by the low 64-bit value from xmm2/m64, storing the result in xmm1; the high 64-bit value in xmm1 is preserved. This operation follows IEEE 754 semantics and does not modify EFLAGS; division by zero produces infinity or NaN per IEEE rules.", "pseudocode": "xmm1[0:63] ← FP64_divide(xmm1[0:63], xmm2/m64[0:63])\nxmm1[64:127] ← unchanged", "example": "DIVSD xmm1, xmm2/m64" }, { "mnemonic": "sqrtss", "architecture": "x86", "full_name": "Square Root Scalar Single-Precision", "summary": "Computes square root of the low float.", "syntax": "SQRTSS xmm1, xmm2/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 51", "visual_parts": [], "binary_pattern": "F3 | 0F | 51", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Computes the square root of the low 32-bit single-precision floating-point value in xmm2/m32 and stores the result in the low 32 bits of xmm1; the upper 96 bits of xmm1 are set to zero. This operation follows IEEE 754 semantics and does not modify EFLAGS; negative operands produce NaN.", "pseudocode": "xmm1[0:31] ← FP32_sqrt(xmm2/m32[0:31])\nxmm1[32:127] ← 0", "example": "SQRTSS xmm1, xmm2/m32" }, { "mnemonic": "sqrtsd", "architecture": "x86", "full_name": "Square Root Scalar Double-Precision", "summary": "Computes square root of the low double.", "syntax": "SQRTSD xmm1, xmm2/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 51", "visual_parts": [], "binary_pattern": "F2 | 0F | 51", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Computes the square root of the low 64-bit double-precision floating-point value in xmm2/m64 and stores the result in the low 64 bits of xmm1; the high 64 bits of xmm1 are set to zero. This operation follows IEEE 754 semantics and does not modify EFLAGS; negative operands produce NaN.", "pseudocode": "xmm1[0:63] ← FP64_sqrt(xmm2/m64[0:63])\nxmm1[64:127] ← 0", "example": "SQRTSD xmm1, xmm2/m64" }, { "mnemonic": "minss", "architecture": "x86", "full_name": "Minimum Scalar Single-Precision", "summary": "Returns the minimum of two low single-precision values.", "syntax": "MINSS xmm1, xmm2/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 5D", "visual_parts": [], "binary_pattern": "F3 | 0F | 5D", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Returns the minimum of the low 32-bit single-precision floating-point values from xmm1 and xmm2/m32, storing the result in xmm1; the upper 96 bits of xmm1 are preserved. Comparison follows IEEE 754 rules where NaN comparisons return NaN and negative zero is less than positive zero; EFLAGS are not modified.", "pseudocode": "xmm1[0:31] ← FP32_min(xmm1[0:31], xmm2/m32[0:31])\nxmm1[32:127] ← unchanged", "example": "MINSS xmm1, xmm2/m32" }, { "mnemonic": "minsd", "architecture": "x86", "full_name": "Minimum Scalar Double-Precision", "summary": "Returns the minimum of two low double-precision values.", "syntax": "MINSD xmm1, xmm2/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 5D", "visual_parts": [], "binary_pattern": "F2 | 0F | 5D", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Returns the minimum of the low 64-bit double-precision floating-point values from xmm1 and xmm2/m64, storing the result in xmm1; the high 64 bits of xmm1 are preserved. Comparison follows IEEE 754 rules where NaN comparisons return NaN and negative zero is less than positive zero; EFLAGS are not modified.", "pseudocode": "xmm1[0:63] ← FP64_min(xmm1[0:63], xmm2/m64[0:63])\nxmm1[64:127] ← unchanged", "example": "MINSD xmm1, xmm2/m64" }, { "mnemonic": "maxss", "architecture": "x86", "full_name": "Maximum Scalar Single-Precision", "summary": "Returns the maximum of two low single-precision values.", "syntax": "MAXSS xmm1, xmm2/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 5F", "visual_parts": [], "binary_pattern": "F3 | 0F | 5F", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Returns the maximum of the low 32-bit single-precision floating-point values from xmm1 and xmm2/m32, storing the result in xmm1; the upper 96 bits of xmm1 are preserved. Comparison follows IEEE 754 rules where NaN comparisons return NaN and positive zero is greater than negative zero; EFLAGS are not modified.", "pseudocode": "xmm1[0:31] ← FP32_max(xmm1[0:31], xmm2/m32[0:31])\nxmm1[32:127] ← unchanged", "example": "MAXSS xmm1, xmm2/m32" }, { "mnemonic": "maxsd", "architecture": "x86", "full_name": "Maximum Scalar Double-Precision", "summary": "Returns the maximum of two low double-precision values.", "syntax": "MAXSD xmm1, xmm2/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 5F", "visual_parts": [], "binary_pattern": "F2 | 0F | 5F", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares the low 64-bit double-precision floating-point values in the destination and source operands, returns the maximum value, and stores it in the low 64 bits of the destination XMM register while leaving the high 64 bits unchanged. No CPU flags are affected. This instruction operates only on the scalar (low) element; the upper 64 bits of xmm1 are preserved.", "pseudocode": "xmm1[0:63] ← max(xmm1[0:63], src[0:63]); xmm1[64:127] ← xmm1[64:127];", "example": "MAXSD xmm1, xmm2/m64" }, { "mnemonic": "cmpss", "architecture": "x86", "full_name": "Compare Scalar Single-Precision", "summary": "Compares low single-precision values and returns mask.", "syntax": "CMPSS xmm1, xmm2/m32, imm8", "encoding": { "format": "SSE", "hex_opcode": "F3 0F C2", "visual_parts": [], "binary_pattern": "F3 | 0F | C2", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs a scalar single-precision floating-point comparison between the low 32-bit elements of xmm1 and xmm2/m32 according to the condition specified by the immediate byte, storing a mask (all 1s or all 0s) in the low 32 bits of xmm1 while the upper 96 bits are preserved. No CPU flags are modified. The comparison predicate is encoded in imm8[2:0].", "pseudocode": "condition ← imm8[2:0]; result ← compare(xmm1[0:31], src[0:31], condition); xmm1[0:31] ← result ? 0xFFFFFFFF : 0; xmm1[32:127] ← xmm1[32:127];", "example": "CMPSS xmm1, xmm2/m32, 3" }, { "mnemonic": "cmpsd", "architecture": "x86", "full_name": "Compare Scalar Double-Precision", "summary": "Compares low double-precision values and returns mask.", "syntax": "CMPSD xmm1, xmm2/m64, imm8", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F C2", "visual_parts": [], "binary_pattern": "F2 | 0F | C2", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs a scalar double-precision floating-point comparison between the low 64-bit elements of xmm1 and xmm2/m64 according to the condition specified by the immediate byte, storing a mask (all 1s or all 0s) in the low 64 bits of xmm1 while the upper 64 bits are preserved. No CPU flags are modified. The comparison predicate is encoded in imm8[2:0].", "pseudocode": "condition ← imm8[2:0]; result ← compare(xmm1[0:63], src[0:63], condition); xmm1[0:63] ← result ? 0xFFFFFFFFFFFFFFFF : 0; xmm1[64:127] ← xmm1[64:127];", "example": "CMPSD xmm1, xmm2/m64, 3" }, { "mnemonic": "rcpss", "architecture": "x86", "full_name": "Reciprocal Scalar Single-Precision", "summary": "Computes approximate reciprocal (1/x) of low float.", "syntax": "RCPSS xmm1, xmm2/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 53", "visual_parts": [], "binary_pattern": "F3 | 0F | 53", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Computes an approximate reciprocal (1/x) of the low 32-bit single-precision floating-point value in the source operand and stores the result in the low 32 bits of the destination XMM register, while preserving the upper 96 bits of xmm1. No CPU flags are affected. The result has a maximum relative error of approximately 1.5×2^-12.", "pseudocode": "xmm1[0:31] ← 1.0 / src[0:31]; xmm1[32:127] ← xmm1[32:127];", "example": "RCPSS xmm1, xmm2/m32" }, { "mnemonic": "rsqrtss", "architecture": "x86", "full_name": "Reciprocal Square Root Scalar Single-Precision", "summary": "Computes approximate reciprocal sqrt (1/sqrt(x)) of low float.", "syntax": "RSQRTSS xmm1, xmm2/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 52", "visual_parts": [], "binary_pattern": "F3 | 0F | 52", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Computes an approximate reciprocal square root (1/√x) of the low 32-bit single-precision floating-point value in the source operand and stores the result in the low 32 bits of the destination XMM register, while preserving the upper 96 bits of xmm1. No CPU flags are affected. The result has a maximum relative error of approximately 1.5×2^-12.", "pseudocode": "xmm1[0:31] ← 1.0 / sqrt(src[0:31]); xmm1[32:127] ← xmm1[32:127];", "example": "RSQRTSS xmm1, xmm2/m32" }, { "mnemonic": "roundss", "architecture": "x86", "full_name": "Round Scalar Single-Precision", "summary": "Rounds low float according to immediate mode.", "syntax": "ROUNDSS xmm1, xmm2/m32, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 0A", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 0A", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rounds the low 32-bit single-precision floating-point value in xmm2/m32 according to the rounding mode specified in imm8 and stores the rounded result in the low 32 bits of xmm1, while preserving the upper 96 bits of xmm1. No CPU flags are affected. Rounding mode is selected via imm8[1:0]; bit 2 can suppress inexact exceptions.", "pseudocode": "mode ← imm8[1:0]; precision_exception_suppress ← imm8[2]; xmm1[0:31] ← round(src[0:31], mode, precision_exception_suppress); xmm1[32:127] ← xmm1[32:127];", "example": "ROUNDSS xmm1, xmm2/m32, 3" }, { "mnemonic": "roundsd", "architecture": "x86", "full_name": "Round Scalar Double-Precision", "summary": "Rounds low double according to immediate mode.", "syntax": "ROUNDSD xmm1, xmm2/m64, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 0B", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 0B", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rounds the low 64-bit double-precision floating-point value in xmm2/m64 according to the rounding mode specified in imm8 and stores the rounded result in the low 64 bits of xmm1, while preserving the upper 64 bits of xmm1. No CPU flags are affected. Rounding mode is selected via imm8[1:0]; bit 2 can suppress inexact exceptions.", "pseudocode": "mode ← imm8[1:0]; precision_exception_suppress ← imm8[2]; xmm1[0:63] ← round(src[0:63], mode, precision_exception_suppress); xmm1[64:127] ← xmm1[64:127];", "example": "ROUNDSD xmm1, xmm2/m64, 3" }, { "mnemonic": "cvttps2pi", "architecture": "x86", "full_name": "Convert with Truncation Packed Single to Packed Integer (MMX)", "summary": "Converts packed floats to packed MMX integers (Truncate).", "syntax": "CVTTPS2PI mm, xmm/m64", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 2C /r", "visual_parts": [], "binary_pattern": "0F | 2C", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "xmm/m64", "desc": "128-bit XMM register or 64-bit memory" } ], "description": "Converts the two low single-precision floating-point values (32 bits each) from an XMM register or 64-bit memory location to two packed 32-bit signed integers via truncation, storing the result in an MMX register. The upper two single-precision values in the XMM operand are ignored. No CPU flags are affected; the instruction operates on the MMX register state.", "pseudocode": "mm[0:31] ← truncate_to_int32(src[0:31]); mm[32:63] ← truncate_to_int32(src[32:63]);", "example": "CVTTPS2PI mm, xmm1" }, { "mnemonic": "cvtps2pd", "architecture": "x86", "full_name": "Convert Packed Single to Packed Double", "summary": "Converts lower two floats to doubles.", "syntax": "CVTPS2PD xmm1, xmm2/m64", "encoding": { "format": "SSE2", "hex_opcode": "NP 0F 5A /r", "visual_parts": [], "binary_pattern": "0F | 5A", "bit_positions": "+0 | +1" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Converts the lower two packed single-precision floats (32-bit) to two packed double-precision floats (64-bit), storing the result in the destination XMM register. The conversion rounds according to the MXCSR rounding mode; #IA (invalid operation) and #D (denormal) exceptions may be signaled. No flags are affected.", "pseudocode": "dest[0:63] ← convert_sp_to_dp(src[0:31]);\ndest[64:127] ← convert_sp_to_dp(src[32:63]);", "example": "CVTPS2PD xmm1, xmm2/m64" }, { "mnemonic": "cvtpd2ps", "architecture": "x86", "full_name": "Convert Packed Double to Packed Single", "summary": "Converts two doubles to two floats.", "syntax": "CVTPD2PS xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 5A", "visual_parts": [], "binary_pattern": "66 | 0F | 5A", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Converts two packed double-precision floats (64-bit each) to two packed single-precision floats (32-bit each), storing the result in the lower 64 bits of the destination XMM register and zeroing the upper 64 bits. The conversion rounds according to the MXCSR rounding mode; #IA and #O (overflow) exceptions may be signaled. No flags are affected.", "pseudocode": "dest[0:31] ← convert_dp_to_sp(src[0:63]);\ndest[32:63] ← convert_dp_to_sp(src[64:127]);\ndest[64:127] ← 0;", "example": "CVTPD2PS xmm1, xmm2/m128" }, { "mnemonic": "jo", "architecture": "x86", "full_name": "Jump if Overflow", "summary": "Jump near if overflow flag is 1.", "syntax": "JO rel", "encoding": { "format": "Legacy", "hex_opcode": "70", "visual_parts": [], "binary_pattern": "70", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Performs a near jump to the target address if the overflow flag (OF) is set (1). The jump is relative to the instruction pointer; this is a conditional branch with no effect on CPU flags. Available in all modes (real, protected, 64-bit).", "pseudocode": "if (OF == 1) {\n RIP ← RIP + sign_extend(rel8_or_rel32);\n}", "example": "JO rel" }, { "mnemonic": "jno", "architecture": "x86", "full_name": "Jump if Not Overflow", "summary": "Jump near if overflow flag is 0.", "syntax": "JNO rel", "encoding": { "format": "Legacy", "hex_opcode": "71", "visual_parts": [], "binary_pattern": "71", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Performs a near jump to the target address if the overflow flag (OF) is clear (0). The jump is relative to the instruction pointer; this is a conditional branch with no effect on CPU flags. Available in all modes (real, protected, 64-bit).", "pseudocode": "if (OF == 0) {\n RIP ← RIP + sign_extend(rel8_or_rel32);\n}", "example": "JNO rel" }, { "mnemonic": "js", "architecture": "x86", "full_name": "Jump if Sign", "summary": "Jump near if sign flag is 1 (Negative).", "syntax": "JS rel", "encoding": { "format": "Legacy", "hex_opcode": "78", "visual_parts": [], "binary_pattern": "78", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Performs a near jump to the target address if the sign flag (SF) is set (1), indicating a negative result from a prior arithmetic operation. The jump is relative to the instruction pointer; this is a conditional branch with no effect on CPU flags. Available in all modes (real, protected, 64-bit).", "pseudocode": "if (SF == 1) {\n RIP ← RIP + sign_extend(rel8_or_rel32);\n}", "example": "JS rel" }, { "mnemonic": "jns", "architecture": "x86", "full_name": "Jump if Not Sign", "summary": "Jump near if sign flag is 0 (Positive).", "syntax": "JNS rel", "encoding": { "format": "Legacy", "hex_opcode": "79", "visual_parts": [], "binary_pattern": "79", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Performs a near jump to the target address if the sign flag (SF) is clear (0), indicating a non-negative result from a prior arithmetic operation. The jump is relative to the instruction pointer; this is a conditional branch with no effect on CPU flags. Available in all modes (real, protected, 64-bit).", "pseudocode": "if (SF == 0) {\n RIP ← RIP + sign_extend(rel8_or_rel32);\n}", "example": "JNS rel" }, { "mnemonic": "jp", "architecture": "x86", "full_name": "Jump if Parity", "summary": "Jump near if parity flag is 1 (Even parity).", "syntax": "JP rel", "encoding": { "format": "Legacy", "hex_opcode": "7A", "visual_parts": [], "binary_pattern": "7A", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Performs a near jump to the target address if the parity flag (PF) is set (1), indicating even parity in the low-order byte of a prior operation result. The jump is relative to the instruction pointer; this is a conditional branch with no effect on CPU flags. Available in all modes (real, protected, 64-bit).", "pseudocode": "if (PF == 1) {\n RIP ← RIP + sign_extend(rel8_or_rel32);\n}", "example": "JP rel" }, { "mnemonic": "jnp", "architecture": "x86", "full_name": "Jump if Not Parity", "summary": "Jump near if parity flag is 0 (Odd parity).", "syntax": "JNP rel", "encoding": { "format": "Legacy", "hex_opcode": "7B", "visual_parts": [], "binary_pattern": "7B", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "rel", "desc": "Relative branch offset" } ], "description": "Performs a near jump to the target address if the parity flag (PF) is clear (0), indicating odd parity in the low-order byte of a prior operation result. The jump is relative to the instruction pointer; this is a conditional branch with no effect on CPU flags. Available in all modes (real, protected, 64-bit).", "pseudocode": "if (PF == 0) {\n RIP ← RIP + sign_extend(rel8_or_rel32);\n}", "example": "JNP rel" }, { "mnemonic": "seto", "architecture": "x86", "full_name": "Set Byte on Overflow", "summary": "Sets byte to 1 if OF=1.", "syntax": "SETO r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 90", "visual_parts": [], "binary_pattern": "0F | 90", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the Overflow Flag (OF) is set, otherwise sets it to 0. This instruction does not modify any flags. Available in 32-bit and 64-bit modes; commonly used after arithmetic operations to test for signed overflow.", "pseudocode": "dest ← (OF == 1) ? 1 : 0;", "example": "SETO bl" }, { "mnemonic": "setno", "architecture": "x86", "full_name": "Set Byte on Not Overflow", "summary": "Sets byte to 1 if OF=0.", "syntax": "SETNO r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 91", "visual_parts": [], "binary_pattern": "0F | 91", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the Overflow Flag (OF) is clear, otherwise sets it to 0. This instruction does not modify any flags. Available in 32-bit and 64-bit modes; used to test when no signed overflow has occurred.", "pseudocode": "dest ← (OF == 0) ? 1 : 0;", "example": "SETNO bl" }, { "mnemonic": "setz", "architecture": "x86", "full_name": "Set Byte on Zero", "summary": "Sets byte to 1 if ZF=1.", "syntax": "SETZ r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 94", "visual_parts": [], "binary_pattern": "0F | 94", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the Zero Flag (ZF) is set, otherwise sets it to 0. This instruction does not modify any flags. Available in 32-bit and 64-bit modes; commonly used after comparisons or arithmetic to test if the result was zero.", "pseudocode": "dest ← (ZF == 1) ? 1 : 0;", "example": "SETZ bl" }, { "mnemonic": "setnz", "architecture": "x86", "full_name": "Set Byte on Not Zero", "summary": "Sets byte to 1 if ZF=0.", "syntax": "SETNZ r/m8", "encoding": { "format": "Legacy", "hex_opcode": "0F 95", "visual_parts": [], "binary_pattern": "0F | 95", "bit_positions": "+0 | +1" }, "extension": "Base", "operands": [ { "name": "dest", "type": "r/m8", "desc": "8-bit register or memory" } ], "description": "Sets the destination byte to 1 if the Zero Flag (ZF) is clear, otherwise sets it to 0. This instruction does not modify any flags. Available in 32-bit and 64-bit modes; commonly used after comparisons or arithmetic to test if the result was non-zero.", "pseudocode": "dest ← (ZF == 0) ? 1 : 0;", "example": "SETNZ bl" }, { "mnemonic": "cmovg", "architecture": "x86", "full_name": "Conditional Move Greater", "summary": "Move if ZF=0 and SF=OF.", "syntax": "CMOVG r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F 4F", "visual_parts": [], "binary_pattern": "0F | 4F", "bit_positions": "+0 | +1" }, "extension": "CMOV", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Conditionally moves the source operand to the destination register if the signed greater-than condition is true (ZF=0 and SF=OF). No flags are modified by this instruction. The operand size can be 16, 32, or 64 bits (determined by REX.W and operand-size prefix). Requires the CMOV extension; available in 32-bit and 64-bit modes.", "pseudocode": "if (ZF == 0 && SF == OF) dest ← src;", "example": "CMOVG rax, rbx" }, { "mnemonic": "cmovge", "architecture": "x86", "full_name": "Conditional Move Greater or Equal", "summary": "Move if SF=OF.", "syntax": "CMOVGE r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F 4D", "visual_parts": [], "binary_pattern": "0F | 4D", "bit_positions": "+0 | +1" }, "extension": "CMOV", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Conditionally moves the source operand to the destination register if the signed greater-than-or-equal condition is true (SF=OF). No flags are modified by this instruction. The operand size can be 16, 32, or 64 bits (determined by REX.W and operand-size prefix). Requires the CMOV extension; available in 32-bit and 64-bit modes.", "pseudocode": "if (SF == OF) dest ← src;", "example": "CMOVGE rax, rbx" }, { "mnemonic": "cmovl", "architecture": "x86", "full_name": "Conditional Move Less", "summary": "Move if SF!=OF.", "syntax": "CMOVL r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F 4C", "visual_parts": [], "binary_pattern": "0F | 4C", "bit_positions": "+0 | +1" }, "extension": "CMOV", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Conditionally moves the source operand to the destination register if the signed less-than condition is true (SF≠OF). No flags are modified by this instruction. The operand size can be 16, 32, or 64 bits (determined by REX.W and operand-size prefix). Requires the CMOV extension; available in 32-bit and 64-bit modes.", "pseudocode": "if (SF != OF) dest ← src;", "example": "CMOVL rax, rbx" }, { "mnemonic": "cmovle", "architecture": "x86", "full_name": "Conditional Move Less or Equal", "summary": "Move if ZF=1 or SF!=OF.", "syntax": "CMOVLE r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F 4E", "visual_parts": [], "binary_pattern": "0F | 4E", "bit_positions": "+0 | +1" }, "extension": "CMOV", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Conditionally moves the source operand to the destination register if the signed less-than-or-equal condition is true (ZF=1 or SF≠OF). No flags are modified by this instruction. The operand size can be 16, 32, or 64 bits (determined by REX.W and operand-size prefix). Requires the CMOV extension; available in 32-bit and 64-bit modes.", "pseudocode": "if (ZF == 1 || SF != OF) dest ← src;", "example": "CMOVLE rax, rbx" }, { "mnemonic": "cmovz", "architecture": "x86", "full_name": "Conditional Move Zero", "summary": "Move if ZF=1.", "syntax": "CMOVZ r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F 44", "visual_parts": [], "binary_pattern": "0F | 44", "bit_positions": "+0 | +1" }, "extension": "CMOV", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Conditionally moves the source operand to the destination register if the Zero Flag (ZF) is set to 1, otherwise the destination register remains unchanged. This instruction operates on 16/32/64-bit operands and does not modify any CPU flags. It is available in protected mode and 64-bit mode on processors supporting the CMOV extension.", "pseudocode": "if (ZF == 1) { dest ← src; }", "example": "CMOVZ rax, rbx" }, { "mnemonic": "cmovnz", "architecture": "x86", "full_name": "Conditional Move Not Zero", "summary": "Move if ZF=0.", "syntax": "CMOVNZ r, r/m", "encoding": { "format": "Legacy", "hex_opcode": "0F 45", "visual_parts": [], "binary_pattern": "0F | 45", "bit_positions": "+0 | +1" }, "extension": "CMOV", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "r/m", "desc": "Register or memory operand" } ], "description": "Conditionally moves the source operand to the destination register if the Zero Flag (ZF) is cleared to 0 (i.e., result was non-zero), otherwise the destination register remains unchanged. This instruction operates on 16/32/64-bit operands and does not modify any CPU flags. It is available in protected mode and 64-bit mode on processors supporting the CMOV extension.", "pseudocode": "if (ZF == 0) { dest ← src; }", "example": "CMOVNZ rax, rbx" }, { "mnemonic": "paddusw", "architecture": "x86", "full_name": "Packed Add Unsigned Saturation Word", "summary": "Adds 16-bit words with unsigned saturation.", "syntax": "PADDUSW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F DD", "visual_parts": [], "binary_pattern": "66 | 0F | DD", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Adds eight pairs of 16-bit unsigned integers in parallel from the destination and source operands, with unsigned saturation applied to each pair independently. The result is stored in the destination XMM register; overflow is clamped to 0xFFFF and does not set CPU flags. Available in SSE2 and later extensions.", "pseudocode": "for (i = 0; i < 8; i++) { result[i] = UNSIGNED_SAT_16(dest[i] + src[i]); } dest ← result;", "example": "PADDUSW xmm1, xmm2/m128" }, { "mnemonic": "paddsw", "architecture": "x86", "full_name": "Packed Add Signed Saturation Word", "summary": "Adds 16-bit words with signed saturation.", "syntax": "PADDSW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F ED", "visual_parts": [], "binary_pattern": "66 | 0F | ED", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Adds eight pairs of 16-bit signed integers in parallel from the destination and source operands, with signed saturation applied to each pair independently. The result is stored in the destination XMM register; overflow is clamped to 0x7FFF and underflow to 0x8000, and no CPU flags are modified. Available in SSE2 and later extensions.", "pseudocode": "for (i = 0; i < 8; i++) { result[i] = SIGNED_SAT_16(dest[i] + src[i]); } dest ← result;", "example": "PADDSW xmm1, xmm2/m128" }, { "mnemonic": "psubusw", "architecture": "x86", "full_name": "Packed Subtract Unsigned Saturation Word", "summary": "Subtracts 16-bit words with unsigned saturation.", "syntax": "PSUBUSW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F D9", "visual_parts": [], "binary_pattern": "66 | 0F | D9", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Subtracts eight pairs of 16-bit unsigned integers in parallel; the source is subtracted from the destination with unsigned saturation applied to each pair independently. The result is stored in the destination XMM register; underflow is clamped to 0x0000 and does not set CPU flags. Available in SSE2 and later extensions.", "pseudocode": "for (i = 0; i < 8; i++) { result[i] = UNSIGNED_SAT_16(dest[i] - src[i]); } dest ← result;", "example": "PSUBUSW xmm1, xmm2/m128" }, { "mnemonic": "psubsw", "architecture": "x86", "full_name": "Packed Subtract Signed Saturation Word", "summary": "Subtracts 16-bit words with signed saturation.", "syntax": "PSUBSW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F E9", "visual_parts": [], "binary_pattern": "66 | 0F | E9", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Subtracts eight pairs of 16-bit signed integers in parallel; the source is subtracted from the destination with signed saturation applied to each pair independently. The result is stored in the destination XMM register; overflow is clamped to 0x7FFF and underflow to 0x8000, and no CPU flags are modified. Available in SSE2 and later extensions.", "pseudocode": "for (i = 0; i < 8; i++) { result[i] = SIGNED_SAT_16(dest[i] - src[i]); } dest ← result;", "example": "PSUBSW xmm1, xmm2/m128" }, { "mnemonic": "pmullw", "architecture": "x86", "full_name": "Packed Multiply Low Word", "summary": "Multiplies 16-bit words and stores low 16-bit result.", "syntax": "PMULLW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F D5", "visual_parts": [], "binary_pattern": "66 | 0F | D5", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Multiplies eight pairs of 16-bit signed integers from the destination and source operands in parallel; the low 16 bits of each 32-bit product are stored in the destination XMM register while the high 16 bits are discarded. No CPU flags are modified, and this instruction does not generate saturation. Available in SSE2 and later extensions.", "pseudocode": "for (i = 0; i < 8; i++) { product = (int32_t)dest[i] * (int32_t)src[i]; result[i] = (int16_t)(product & 0xFFFF); } dest ← result;", "example": "PMULLW xmm1, xmm2/m128" }, { "mnemonic": "pmaddwd", "architecture": "x86", "full_name": "Packed Multiply and Add Word to Doubleword", "summary": "Multiplies words, adds adjacent pairs to doublewords.", "syntax": "PMADDWD xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F F5", "visual_parts": [], "binary_pattern": "66 | 0F | F5", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Multiplies four pairs of 16-bit signed integers from the destination and source operands in parallel; adjacent pairs of 32-bit products are then summed with signed saturation, and the four 32-bit saturated results are stored in the destination XMM register. No CPU flags are modified. Available in SSE2 and later extensions.", "pseudocode": "for (i = 0; i < 4; i++) { prod0 = (int32_t)dest[2*i] * (int32_t)src[2*i]; prod1 = (int32_t)dest[2*i+1] * (int32_t)src[2*i+1]; result[i] = SIGNED_SAT_32(prod0 + prod1); } dest ← result;", "example": "PMADDWD xmm1, xmm2/m128" }, { "mnemonic": "pcmpgtb", "architecture": "x86", "full_name": "Packed Compare Greater Than Byte", "summary": "Compares bytes for greater than (signed).", "syntax": "PCMPGTB xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 64", "visual_parts": [], "binary_pattern": "66 | 0F | 64", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed signed bytes in xmm1 against xmm2/m128, setting each byte in xmm1 to 0xFF if the comparison is true or 0x00 if false. This is a SIMD integer comparison with no CPU flags affected; the result mask is stored directly in the destination XMM register.", "pseudocode": "for i = 0 to 15:\n if xmm1[byte_i] > xmm2/m128[byte_i] (signed):\n xmm1[byte_i] ← 0xFF\n else:\n xmm1[byte_i] ← 0x00", "example": "PCMPGTB xmm1, xmm2/m128" }, { "mnemonic": "pcmpgtw", "architecture": "x86", "full_name": "Packed Compare Greater Than Word", "summary": "Compares words for greater than (signed).", "syntax": "PCMPGTW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 65", "visual_parts": [], "binary_pattern": "66 | 0F | 65", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed signed words in xmm1 against xmm2/m128, setting each word in xmm1 to 0xFFFF if the comparison is true or 0x0000 if false. This is a SIMD integer comparison with no CPU flags affected; the result mask is stored directly in the destination XMM register.", "pseudocode": "for i = 0 to 7:\n if xmm1[word_i] > xmm2/m128[word_i] (signed):\n xmm1[word_i] ← 0xFFFF\n else:\n xmm1[word_i] ← 0x0000", "example": "PCMPGTW xmm1, xmm2/m128" }, { "mnemonic": "pcmpgtd", "architecture": "x86", "full_name": "Packed Compare Greater Than Doubleword", "summary": "Compares doublewords for greater than (signed).", "syntax": "PCMPGTD xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 66", "visual_parts": [], "binary_pattern": "66 | 0F | 66", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Compares packed signed doublewords in xmm1 against xmm2/m128, setting each doubleword in xmm1 to 0xFFFFFFFF if the comparison is true or 0x00000000 if false. This is a SIMD integer comparison with no CPU flags affected; the result mask is stored directly in the destination XMM register.", "pseudocode": "for i = 0 to 3:\n if xmm1[dword_i] > xmm2/m128[dword_i] (signed):\n xmm1[dword_i] ← 0xFFFFFFFF\n else:\n xmm1[dword_i] ← 0x00000000", "example": "PCMPGTD xmm1, xmm2/m128" }, { "mnemonic": "pinsrw", "architecture": "x86", "full_name": "Packed Insert Word", "summary": "Inserts a word from integer register into XMM.", "syntax": "PINSRW xmm1, r32/m16, imm8", "encoding": { "format": "SSE", "hex_opcode": "66 0F C4", "visual_parts": [], "binary_pattern": "66 | 0F | C4", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "r32/m16", "desc": "General-purpose register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Inserts a 16-bit word from a general-purpose register or memory into an XMM register at the position specified by an 8-bit index. The low 16 bits of the source are extracted; other bits in the destination XMM register remain unchanged. No CPU flags are affected.", "pseudocode": "index ← imm8 & 0x7\nword_value ← (r32/m16) & 0xFFFF\nxmm1[word_index * 16 : word_index * 16 + 15] ← word_value", "example": "PINSRW xmm1, r32/m16, 3" }, { "mnemonic": "pextrw", "architecture": "x86", "full_name": "Packed Extract Word", "summary": "Extracts a word from XMM to integer register.", "syntax": "PEXTRW r32, xmm1, imm8", "encoding": { "format": "SSE", "hex_opcode": "66 0F C5", "visual_parts": [], "binary_pattern": "66 | 0F | C5", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src1", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Extracts a 16-bit word from an XMM register at the position specified by an 8-bit index and zero-extends it into a 32-bit general-purpose register. The upper 16 bits of the destination register are zeroed. No CPU flags are affected.", "pseudocode": "index ← imm8 & 0x7\nword_value ← xmm1[word_index * 16 : word_index * 16 + 15]\nr32 ← zero_extend(word_value, 32)", "example": "PEXTRW eax, xmm1, 3" }, { "mnemonic": "pshuflw", "architecture": "x86", "full_name": "Packed Shuffle Low Words", "summary": "Shuffles the low 4 words of XMM.", "syntax": "PSHUFLW xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 70", "visual_parts": [], "binary_pattern": "F2 | 0F | 70", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shuffles the low 4 words of an XMM register using an 8-bit immediate that specifies the source indices for each destination word; the high 4 words are unchanged. This is a data permutation with no CPU flags affected.", "pseudocode": "order ← imm8\nfor i = 0 to 3:\n src_index ← (order >> (i * 2)) & 0x3\n xmm1[word_i] ← (xmm2/m128)[word_src_index]\nfor i = 4 to 7:\n xmm1[word_i] ← (xmm2/m128)[word_i]", "example": "PSHUFLW xmm1, xmm2/m128, 3" }, { "mnemonic": "pshufhw", "architecture": "x86", "full_name": "Packed Shuffle High Words", "summary": "Shuffles the high 4 words of XMM.", "syntax": "PSHUFHW xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE2", "hex_opcode": "F3 0F 70", "visual_parts": [], "binary_pattern": "F3 | 0F | 70", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shuffles the high 4 words of an XMM register using an 8-bit immediate that specifies the source indices for each destination word; the low 4 words are unchanged. This is a data permutation with no CPU flags affected.", "pseudocode": "order ← imm8\nfor i = 0 to 3:\n xmm1[word_i] ← (xmm2/m128)[word_i]\nfor i = 4 to 7:\n src_index ← (order >> ((i - 4) * 2)) & 0x3\n xmm1[word_i] ← (xmm2/m128)[word_(4 + src_index)]", "example": "PSHUFHW xmm1, xmm2/m128, 3" }, { "mnemonic": "movntq", "architecture": "x86", "full_name": "Move Non-Temporal Quadword", "summary": "Stores 64-bit MMX data bypassing cache.", "syntax": "MOVNTQ m64, mm", "encoding": { "format": "SSE", "hex_opcode": "NP 0F E7 /r", "visual_parts": [], "binary_pattern": "0F | E7", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "m64", "desc": "64-bit memory operand (quadword)" }, { "name": "src", "type": "mm", "desc": "64-bit MMX register" } ], "description": "Stores a 64-bit quadword from an MMX register directly to memory, bypassing the L1 and L2 caches (non-temporal hint). This instruction provides a memory-ordering serialization point and can improve performance for streaming writes that do not benefit from caching. No CPU flags are affected.", "pseudocode": "[m64] ← mm (non-temporal write)", "example": "MOVNTQ [rbp-8], mm" }, { "mnemonic": "movnti", "architecture": "x86", "full_name": "Move Non-Temporal Integer", "summary": "Stores integer register to memory bypassing cache.", "syntax": "MOVNTI m32, r32", "encoding": { "format": "SSE2", "hex_opcode": "NP 0F C3 /r", "visual_parts": [], "binary_pattern": "0F | C3", "bit_positions": "+0 | +1" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "m32", "desc": "32-bit memory operand" }, { "name": "src", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Stores a 32-bit or 64-bit general-purpose register to memory while bypassing the L1 and L2 caches, using a non-temporal hint to the memory subsystem. This instruction is useful for streaming writes that are unlikely to be reused soon. No flags are affected; the instruction may serialize the store buffer but does not guarantee memory ordering with respect to other instructions.", "pseudocode": "[dest] ← src", "example": "MOVNTI [rbp-4], eax" }, { "mnemonic": "cmpxchg16b", "architecture": "x86", "full_name": "Compare and Exchange 16 Bytes", "summary": "Atomically compares 128-bit memory with RDX:RAX.", "syntax": "CMPXCHG16B m128", "encoding": { "format": "Base (64-bit)", "hex_opcode": "REX.W + 0F C7 /1", "visual_parts": [], "binary_pattern": "0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "Base (64-bit)", "operands": [ { "name": "dest", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Atomically compares a 128-bit memory operand with the implicit 128-bit value in RDX:RAX; if they match, writes RCX:RBX to memory and sets ZF to 1; otherwise, loads the memory value into RDX:RAX and clears ZF. This instruction requires 16-byte alignment and is only available in 64-bit mode; it serializes the memory bus and guarantees atomic execution.", "pseudocode": "if ([dest] == (RDX:RAX)) {\n [dest] ← (RCX:RBX);\n ZF ← 1;\n} else {\n (RDX:RAX) ← [dest];\n ZF ← 0;\n}", "example": "CMPXCHG16B [rbp-16]" }, { "mnemonic": "movbe", "architecture": "x86", "full_name": "Move Big-Endian", "summary": "Moves data swapping bytes (Big Endian load/store).", "syntax": "MOVBE r, m", "encoding": { "format": "Legacy", "hex_opcode": "0F 38 F0", "visual_parts": [], "binary_pattern": "0F | 38 | F0", "bit_positions": "+0 | +1 | +2" }, "extension": "MOVBE", "operands": [ { "name": "dest", "type": "r", "desc": "General-purpose register" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Loads data from memory or register and reverses the byte order (big-endian conversion) while storing to the destination register or memory. Supports 16-bit, 32-bit, and 64-bit operands; no flags are affected. Available on processors with the MOVBE extension; useful for endianness conversion in multi-byte data transfers.", "pseudocode": "if (dest is register) {\n dest ← byte_reverse(src);\n} else {\n [dest] ← byte_reverse(src);\n}", "example": "MOVBE rax, [rbp-8]" }, { "mnemonic": "blendvpd", "architecture": "x86", "full_name": "Variable Blend Packed Double", "summary": "Blends doubles based on variable mask in XMM0.", "syntax": "BLENDVPD xmm1, xmm2/m128, ", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 15", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 15", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "", "desc": "Implicit XMM0 register (blend control mask)" } ], "description": "Blends two packed double-precision floating-point values in XMM registers or memory based on per-lane sign bits of an implicit mask in XMM0; for each 64-bit lane, if the sign bit is 1, the value from the second source is selected, otherwise from the first source. Part of SSE4.1; no flags are affected. The result is stored in the first source operand (xmm1).", "pseudocode": "for i = 0 to 1 {\n if (XMM0.qword[i] < 0) {\n xmm1.double[i] ← src1.double[i];\n } else {\n xmm1.double[i] ← xmm1.double[i];\n }\n}", "example": "BLENDVPD xmm1, xmm2/m128, " }, { "mnemonic": "blendvps", "architecture": "x86", "full_name": "Variable Blend Packed Single", "summary": "Blends floats based on variable mask in XMM0.", "syntax": "BLENDVPS xmm1, xmm2/m128, ", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 14", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 14", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "", "desc": "Implicit XMM0 register (blend control mask)" } ], "description": "Blends two packed single-precision floating-point values in XMM registers or memory based on per-lane sign bits of an implicit mask in XMM0; for each 32-bit lane, if the sign bit is 1, the value from the second source is selected, otherwise from the first source. Part of SSE4.1; no flags are affected. The result is stored in the first source operand (xmm1).", "pseudocode": "for i = 0 to 3 {\n if (XMM0.dword[i] < 0) {\n xmm1.float[i] ← src1.float[i];\n } else {\n xmm1.float[i] ← xmm1.float[i];\n }\n}", "example": "BLENDVPS xmm1, xmm2/m128, " }, { "mnemonic": "pblendvb", "architecture": "x86", "full_name": "Variable Blend Packed Bytes", "summary": "Blends bytes based on variable mask in XMM0.", "syntax": "PBLENDVB xmm1, xmm2/m128, ", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 10", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 10", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "", "desc": "Implicit XMM0 register (blend control mask)" } ], "description": "Blends two packed byte values in XMM registers or memory based on per-byte sign bits of an implicit mask in XMM0; for each byte, if the sign bit is 1, the value from the second source is selected, otherwise from the first source. Part of SSE4.1; no flags are affected. The result is stored in the first source operand (xmm1).", "pseudocode": "for i = 0 to 15 {\n if (XMM0.byte[i] < 0) {\n xmm1.byte[i] ← src1.byte[i];\n } else {\n xmm1.byte[i] ← xmm1.byte[i];\n }\n}", "example": "PBLENDVB xmm1, xmm2/m128, " }, { "mnemonic": "vmrun", "architecture": "x86", "full_name": "Run Virtual Machine", "summary": "Switch to guest VM (AMD SVM).", "syntax": "VMRUN", "encoding": { "format": "SVM", "hex_opcode": "0F 01 D8", "visual_parts": [], "binary_pattern": "0F | 01 | D8", "bit_positions": "+0 | +1 | +2" }, "extension": "SVM", "operands": [], "description": "Switches execution from host to guest virtual machine context by loading guest state from the VMCB (Virtual Machine Control Block) addressed by RAX; serializes the processor and triggers a full context switch including segment registers, control registers, and TLB state. Available only in 64-bit mode with AMD SVM (Secure Virtual Machine) enabled and appropriate privilege level; no flags are affected from the host perspective as execution transfers to guest.", "pseudocode": "VMCB_addr ← RAX;\nload_guest_state(VMCB_addr);\nexecute_guest();", "example": "VMRUN" }, { "mnemonic": "vmload", "architecture": "x86", "full_name": "Load State from VMCB", "summary": "Loads processor state from VMCB (AMD SVM).", "syntax": "VMLOAD", "encoding": { "format": "SVM", "hex_opcode": "0F 01 DA", "visual_parts": [], "binary_pattern": "0F | 01 | DA", "bit_positions": "+0 | +1 | +2" }, "extension": "SVM", "operands": [], "description": "Loads processor state (segments, control registers, debug registers, and other hidden state) from the VMCB (Virtual Machine Control Block) referenced by RAX without switching to guest mode execution. Part of AMD SVM; requires 64-bit mode and appropriate privilege level; no flags are affected. This instruction is typically used in host or nested virtualization contexts to synchronize host state.", "pseudocode": "VMCB_addr ← RAX;\nload_state_from_VMCB(VMCB_addr);", "example": "VMLOAD" }, { "mnemonic": "vmsave", "architecture": "x86", "full_name": "Save State to VMCB", "summary": "Saves processor state to VMCB (AMD SVM).", "syntax": "VMSAVE", "encoding": { "format": "SVM", "hex_opcode": "0F 01 DB", "visual_parts": [], "binary_pattern": "0F | 01 | DB", "bit_positions": "+0 | +1 | +2" }, "extension": "SVM", "operands": [], "description": "Saves the current processor state to the VMCB (Virtual Machine Control Block) at the address specified in RAX. This is a privileged SVM instruction that serializes the processor and must execute at privilege level 0. The instruction writes guest state registers and internal processor state to memory; it does not modify flags.", "pseudocode": "[RAX + offset] ← processor_state; // VMCB state save", "example": "VMSAVE" }, { "mnemonic": "clgi", "architecture": "x86", "full_name": "Clear Global Interrupt Flag", "summary": "Disables global interrupts (AMD SVM).", "syntax": "CLGI", "encoding": { "format": "SVM", "hex_opcode": "0F 01 DD", "visual_parts": [], "binary_pattern": "0F | 01 | DD", "bit_positions": "+0 | +1 | +2" }, "extension": "SVM", "operands": [], "description": "Clears the Global Interrupt Flag (GIF) in the VMCB, which disables interrupts and exceptions at the SVM guest level. This is a privileged instruction that requires CPL=0 and SVM capability. It does not modify EFLAGS but affects the processor's ability to accept external interrupts.", "pseudocode": "GIF ← 0; // Global interrupt flag disabled", "example": "CLGI" }, { "mnemonic": "stgi", "architecture": "x86", "full_name": "Set Global Interrupt Flag", "summary": "Enables global interrupts (AMD SVM).", "syntax": "STGI", "encoding": { "format": "SVM", "hex_opcode": "0F 01 DC", "visual_parts": [], "binary_pattern": "0F | 01 | DC", "bit_positions": "+0 | +1 | +2" }, "extension": "SVM", "operands": [], "description": "Sets the Global Interrupt Flag (GIF) in the VMCB, enabling interrupts and exceptions at the SVM guest level. This is a privileged instruction requiring CPL=0 and SVM capability. After execution, the processor will accept maskable interrupts; no EFLAGS are modified.", "pseudocode": "GIF ← 1; // Global interrupt flag enabled", "example": "STGI" }, { "mnemonic": "invlpga", "architecture": "x86", "full_name": "Invalidate TLB Entry in ASID", "summary": "Invalidates TLB entry for specific ASID (AMD SVM).", "syntax": "INVLPGA", "encoding": { "format": "SVM", "hex_opcode": "0F 01 DF", "visual_parts": [], "binary_pattern": "0F | 01 | DF", "bit_positions": "+0 | +1 | +2" }, "extension": "SVM", "operands": [], "description": "Invalidates TLB entries for a linear address using the ASID (Address Space Identifier) specified in ECX, applicable only within the current VMCB context. This is a privileged SVM instruction that selectively flushes TLB entries without serializing the entire pipeline. The linear address is implicitly taken from RAX.", "pseudocode": "TLB_entry ← invalidate(RAX, ECX); // Invalidate TLB with ASID", "example": "INVLPGA" }, { "mnemonic": "pfadd", "architecture": "x86", "full_name": "Packed Floating-Point Add", "summary": "Adds two packed floats (3DNow!).", "syntax": "PFADD mm, mm/m64", "encoding": { "format": "3DNow!", "hex_opcode": "0F 0F /r 9E", "visual_parts": [], "binary_pattern": "0F | 0F | ModRM | 9E", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "3DNow!", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Adds two packed single-precision floating-point values (two 32-bit floats per 64-bit operand) using 3DNow! arithmetic. The result is written to the destination MMX register with round-to-nearest mode. This instruction does not modify EFLAGS; floating-point exceptions may be masked or pending.", "pseudocode": "dest[31:0] ← float_add(dest[31:0], src[31:0]); dest[63:32] ← float_add(dest[63:32], src[63:32]);", "example": "PFADD mm, mm/m64" }, { "mnemonic": "pfsub", "architecture": "x86", "full_name": "Packed Floating-Point Subtract", "summary": "Subtracts packed floats (3DNow!).", "syntax": "PFSUB mm, mm/m64", "encoding": { "format": "3DNow!", "hex_opcode": "0F 0F /r 9A", "visual_parts": [], "binary_pattern": "0F | 0F | ModRM | 9A", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "3DNow!", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Subtracts two packed single-precision floating-point values (two 32-bit floats per 64-bit operand) using 3DNow! arithmetic. The result is written to the destination MMX register. This instruction does not modify EFLAGS; floating-point exceptions may be masked or pending.", "pseudocode": "dest[31:0] ← float_sub(dest[31:0], src[31:0]); dest[63:32] ← float_sub(dest[63:32], src[63:32]);", "example": "PFSUB mm, mm/m64" }, { "mnemonic": "pfmul", "architecture": "x86", "full_name": "Packed Floating-Point Multiply", "summary": "Multiplies packed floats (3DNow!).", "syntax": "PFMUL mm, mm/m64", "encoding": { "format": "3DNow!", "hex_opcode": "0F 0F /r B4", "visual_parts": [], "binary_pattern": "0F | 0F | ModRM | B4", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "3DNow!", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Multiplies two packed single-precision floating-point values (two 32-bit floats per 64-bit operand) using 3DNow! arithmetic. The result is written to the destination MMX register. This instruction does not modify EFLAGS; floating-point exceptions may be masked or pending.", "pseudocode": "dest[31:0] ← float_mul(dest[31:0], src[31:0]); dest[63:32] ← float_mul(dest[63:32], src[63:32]);", "example": "PFMUL mm, mm/m64" }, { "mnemonic": "pfrcp", "architecture": "x86", "full_name": "Packed Floating-Point Reciprocal", "summary": "Approximates reciprocal (3DNow!).", "syntax": "PFRCP mm, mm/m64", "encoding": { "format": "3DNow!", "hex_opcode": "0F 0F /r 96", "visual_parts": [], "binary_pattern": "0F | 0F | ModRM | 96", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "3DNow!", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Computes a fast approximation of the reciprocal (1/x) for each packed single-precision floating-point value using 3DNow!. The result is written to the destination MMX register with reduced precision (typically 14-15 bits of accuracy). This instruction does not modify EFLAGS; it may generate floating-point exceptions.", "pseudocode": "dest[31:0] ← float_reciprocal_approx(src[31:0]); dest[63:32] ← float_reciprocal_approx(src[63:32]);", "example": "PFRCP mm, mm/m64" }, { "mnemonic": "pfrsqrt", "architecture": "x86", "full_name": "Packed Floating-Point Reciprocal Square Root", "summary": "Approximates reciprocal sqrt (3DNow!).", "syntax": "PFRSQRT mm, mm/m64", "encoding": { "format": "3DNow!", "hex_opcode": "0F 0F /r 97", "visual_parts": [], "binary_pattern": "0F | 0F | ModRM | 97", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "3DNow!", "operands": [ { "name": "dest", "type": "mm", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm/m64", "desc": "64-bit MMX register or Memory operand" } ], "description": "Computes a fast approximation of the reciprocal square root (1/√x) for two packed single-precision floating-point values in parallel. This is a 3DNow! extension instruction that performs low-precision approximation suitable for iterative refinement; the approximation has limited accuracy (typically ~11-12 bits). No EFLAGS are modified.", "pseudocode": "dest[0:31] ← approx_rsqrt(src[0:31]);\ndest[32:63] ← approx_rsqrt(src[32:63]);", "example": "PFRSQRT mm, mm/m64" }, { "mnemonic": "vaddsh", "architecture": "x86", "full_name": "Add Scalar Half-Precision", "summary": "Adds low FP16 value.", "syntax": "VADDSH xmm1 {k1}, xmm2, xmm3/m16", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.F3.MAP5.W0 58 /r", "visual_parts": [], "binary_pattern": "EVEX | 58", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m16", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Adds the low-order half-precision (FP16) element from two XMM registers and stores the scalar result in the low 16 bits of the destination, with upper 112 bits cleared or preserved based on write-mask. Uses EVEX encoding with optional masking and suppression of exceptions. Rounding mode is determined by MXCSR[15:13].", "pseudocode": "if (k1[0] || !masking_enabled) {\n dest[0:15] ← src1[0:15] +FP16 src2[0:15];\n} else {\n dest[0:15] ← preserve_or_zero(dest[0:15]);\n}\ndest[16:127] ← 0;", "example": "VADDSH xmm1, xmm2, xmm3/m16" }, { "mnemonic": "vsubsh", "architecture": "x86", "full_name": "Subtract Scalar Half-Precision", "summary": "Subtracts low FP16 value.", "syntax": "VSUBSH xmm1 {k1}, xmm2, xmm3/m16", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.F3.MAP5.W0 5C /r", "visual_parts": [], "binary_pattern": "EVEX | 5C", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m16", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Subtracts the low-order half-precision (FP16) element of the second operand from the first and stores the scalar result in the low 16 bits of the destination, with upper 112 bits cleared or preserved based on write-mask. Uses EVEX encoding with optional masking and exception suppression. Rounding controlled by MXCSR[15:13].", "pseudocode": "if (k1[0] || !masking_enabled) {\n dest[0:15] ← src1[0:15] -FP16 src2[0:15];\n} else {\n dest[0:15] ← preserve_or_zero(dest[0:15]);\n}\ndest[16:127] ← 0;", "example": "VSUBSH xmm1, xmm2, xmm3/m16" }, { "mnemonic": "vmulsh", "architecture": "x86", "full_name": "Multiply Scalar Half-Precision", "summary": "Multiplies low FP16 value.", "syntax": "VMULSH xmm1 {k1}, xmm2, xmm3/m16", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.F3.MAP5.W0 59 /r", "visual_parts": [], "binary_pattern": "EVEX | 59", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m16", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Multiplies the low-order half-precision (FP16) element from two operands and stores the scalar result in the low 16 bits of the destination, with upper 112 bits cleared or preserved based on write-mask. Uses EVEX encoding with optional masking and exception control. Rounding mode determined by MXCSR[15:13].", "pseudocode": "if (k1[0] || !masking_enabled) {\n dest[0:15] ← src1[0:15] ×FP16 src2[0:15];\n} else {\n dest[0:15] ← preserve_or_zero(dest[0:15]);\n}\ndest[16:127] ← 0;", "example": "VMULSH xmm1, xmm2, xmm3/m16" }, { "mnemonic": "vdivsh", "architecture": "x86", "full_name": "Divide Scalar Half-Precision", "summary": "Divides low FP16 value.", "syntax": "VDIVSH xmm1 {k1}, xmm2, xmm3/m16", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.F3.MAP5.W0 5E /r", "visual_parts": [], "binary_pattern": "EVEX | 5E", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m16", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Divides the low-order half-precision (FP16) element of the first operand by the second and stores the scalar result in the low 16 bits of the destination, with upper 112 bits cleared or preserved based on write-mask. Uses EVEX encoding with optional masking and exception suppression. Rounding controlled by MXCSR[15:13]; may generate precision/underflow/overflow exceptions.", "pseudocode": "if (k1[0] || !masking_enabled) {\n dest[0:15] ← src1[0:15] ÷FP16 src2[0:15];\n} else {\n dest[0:15] ← preserve_or_zero(dest[0:15]);\n}\ndest[16:127] ← 0;", "example": "VDIVSH xmm1, xmm2, xmm3/m16" }, { "mnemonic": "vsqrtsh", "architecture": "x86", "full_name": "Square Root Scalar Half-Precision", "summary": "Square root of low FP16 value.", "syntax": "VSQRTSH xmm1 {k1}, xmm2/m16", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.F3.MAP5.W0 51 /r", "visual_parts": [], "binary_pattern": "EVEX | 51", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m16", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Computes the square root of the low-order half-precision (FP16) element and stores the scalar result in the low 16 bits of the destination, with upper 112 bits cleared or preserved based on write-mask. Uses EVEX encoding with optional masking and exception suppression. Rounding mode determined by MXCSR[15:13].", "pseudocode": "if (k1[0] || !masking_enabled) {\n dest[0:15] ← sqrt_FP16(src[0:15]);\n} else {\n dest[0:15] ← preserve_or_zero(dest[0:15]);\n}\ndest[16:127] ← 0;", "example": "VSQRTSH xmm1, xmm2/m16" }, { "mnemonic": "vfmadd132sh", "architecture": "x86", "full_name": "Fused Multiply-Add Scalar Half-Precision (132)", "summary": "Scalar FMA (Dest * Src2 + Src1) for FP16.", "syntax": "VFMADD132SH xmm1 {k1}, xmm2, xmm3/m16", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.66.MAP6.W0 99 /r", "visual_parts": [], "binary_pattern": "EVEX | 99", "bit_positions": "+0 | +4" }, "extension": "AVX-512-FP16", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m16", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs fused multiply-add on scalar half-precision (FP16) values: multiplies the destination by src2, adds src1, and stores result in destination. The '132' form computes (dest × src2) + src1. Uses EVEX encoding with optional masking and exception suppression. Single rounding applied to the final result per MXCSR[15:13].", "pseudocode": "if (k1[0] || !masking_enabled) {\n dest[0:15] ← (dest[0:15] ×FP16 src2[0:15]) +FP16 src1[0:15];\n} else {\n dest[0:15] ← preserve_or_zero(dest[0:15]);\n}\ndest[16:127] ← 0;", "example": "VFMADD132SH xmm1, xmm2, xmm3/m16" }, { "mnemonic": "vpmullq", "architecture": "x86", "full_name": "Packed Multiply Low Quadword", "summary": "Multiplies 64-bit integers and keeps low 64-bit result.", "syntax": "VPMULLQ zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 40 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 40", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Multiplies eight packed 64-bit signed integers and stores the low 64-bit results of each multiplication in eight 64-bit elements of the destination ZMM register. Uses EVEX encoding with optional per-element masking via write-mask register. No overflow flags are set; overflow is silently truncated to 64 bits.", "pseudocode": "for (i = 0; i < 8; i++) {\n if (k1[i] || !masking_enabled) {\n dest[64*i:64*i+63] ← (src1[64*i:64*i+63] ×64-bit src2[64*i:64*i+63]) & 0xFFFFFFFFFFFFFFFF;\n } else {\n dest[64*i:64*i+63] ← preserve_or_zero(dest[64*i:64*i+63]);\n }\n}", "example": "VPMULLQ zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpabsd", "architecture": "x86", "full_name": "Packed Absolute Value Doubleword", "summary": "Computes absolute value of 32-bit integers.", "syntax": "VPABSD zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 1E /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 1E", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Computes the absolute value of packed 32-bit signed integers in the source operand and stores the results in the destination register. Each 32-bit element is independently processed; if the input is 0x80000000 (minimum signed 32-bit), the result remains 0x80000000 due to two's complement representation. Operates on 512-bit data with EVEX prefix, supporting write-masking via k1.", "pseudocode": "for i = 0 to 15 {\n src_val = src[32*i+31:32*i]\n if (src_val == 0x80000000) {\n dest[32*i+31:32*i] = 0x80000000\n } else if (src_val & 0x80000000 == 1) {\n dest[32*i+31:32*i] = -src_val\n } else {\n dest[32*i+31:32*i] = src_val\n }\n}", "example": "VPABSD zmm1, zmm2/m512" }, { "mnemonic": "valignq", "architecture": "x86", "full_name": "Align Quadword Vectors", "summary": "Extracts 512-bits from two concatenated ZMMs shifted by count.", "syntax": "VALIGNQ zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 03 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 03", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Extracts 512 bits from two concatenated 512-bit quadword vectors, with the extraction window shifted by an immediate count (in quadword units). The operation concatenates src1 and src2, then shifts right by count*64 bits. The lowest 512 bits of the result are stored in dest. Operates under EVEX with write-masking support.", "pseudocode": "shift_bits = (imm8 & 0x7) * 64\nconcatenated = (src2 << 512) | src1\nshifted = concatenated >> shift_bits\ndest = shifted[511:0]", "example": "VALIGNQ zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vdbpsadbw", "architecture": "x86", "full_name": "Double Block Packed Sum-Absolute-Differences", "summary": "Computes SAD on 16-bit blocks.", "syntax": "VDBPSADBW zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 42 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 42", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Computes double-block packed sum-of-absolute-differences on 16-bit blocks between src1 and src2, producing 16-bit results. The operation partitions each 128-bit lane into blocks of 16 bits, computes SAD across specified block boundaries controlled by imm8, and accumulates results into 16-bit fields. Requires AVX-512BW; operates on 512-bit vectors with EVEX masking.", "pseudocode": "for lane = 0 to 3 {\n for block = 0 to 3 {\n result = 0\n block_offset = (imm8 >> (block*2)) & 0x3\n for j = 0 to 1 {\n idx1 = lane*128 + block*32 + j*16\n idx2 = lane*128 + block_offset*32 + j*16\n result += abs(src1[idx1+15:idx1] - src2[idx2+15:idx2])\n }\n dest[lane*128 + block*16 + 15 : lane*128 + block*16] = result[15:0]\n }\n}", "example": "VDBPSADBW zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vrangess", "architecture": "x86", "full_name": "Range Restriction Calculation Scalar Single", "summary": "Calculates range (min/max/abs) of low float.", "syntax": "VRANGESS xmm1 {k1}, xmm2, xmm3/m32, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.66.0F3A.W0 51 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 51", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m32", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Restricts the range of the low single-precision float in xmm2 and the corresponding float from xmm3/m32 according to the range specification in imm8, storing the result in xmm1. The imm8 encodes operations such as minimum, maximum, and absolute value selection. Upper three floats of xmm1 are copied from xmm2 unchanged. Operates in 32-bit scalar mode with EVEX write-masking via k1; requires AVX-512DQ.", "pseudocode": "range_op = imm8[3:0]\nop1_float = xmm2[31:0]\nop2_float = xmm3/m32[31:0]\nxmm1[31:0] = perform_range_restriction(op1_float, op2_float, range_op)\nxmm1[127:32] = xmm2[127:32]", "example": "VRANGESS xmm1, xmm2, xmm3/m32, 3" }, { "mnemonic": "vfixupimmss", "architecture": "x86", "full_name": "Fix Up Special Scalar Float32 Value", "summary": "Fixes special cases (NaN, Inf) in low float using table.", "syntax": "VFIXUPIMMSS xmm1 {k1}, xmm2, xmm3/m32, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.66.0F3A.W0 55 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 55", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m32", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Fixes up special floating-point values (NaN, infinity, denormal, sign) in the low single-precision float using a table lookup controlled by imm8. The lookup uses xmm2[31:0] as one input and xmm3/m32[31:0] as reference, producing a corrected value in xmm1[31:0]. Upper three floats in xmm1 are copied from xmm2. Operates under EVEX with write-masking; AVX-512F compliant.", "pseudocode": "op1 = xmm2[31:0]\nop2 = xmm3/m32[31:0]\nlookup_index = (sign_of(op1)<<4) | (class_of(op1)<<1) | (class_of(op2))\nfixed_value = fixup_table[lookup_index][imm8[7:0]]\nxmm1[31:0] = fixed_value\nxmm1[127:32] = xmm2[127:32]", "example": "VFIXUPIMMSS xmm1, xmm2, xmm3/m32, 3" }, { "mnemonic": "vreducess", "architecture": "x86", "full_name": "Perform Reduction Transformation Scalar Single", "summary": "Performs reduction on low float.", "syntax": "VREDUCESS xmm1 {k1}, xmm2, xmm3/m32, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.66.0F3A.W0 57 /r /ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 57", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512DQ", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3/m32", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs a reduction transformation (rounding, exponent manipulation) on the low single-precision float from xmm2 and xmm3/m32 according to the control specified in imm8, storing the scalar result in xmm1[31:0]. Upper three floats in xmm1 are copied from xmm2. Reduction includes operations like round-to-integral, exponent bias removal, or truncation. Requires AVX-512DQ with EVEX masking.", "pseudocode": "reduction_op = (imm8[3:0])\nsignaling_bit = imm8[4]\nop1_float = xmm2[31:0]\nop2_float = xmm3/m32[31:0]\nxmm1[31:0] = perform_reduction(op1_float, op2_float, reduction_op, signaling_bit)\nxmm1[127:32] = xmm2[127:32]", "example": "VREDUCESS xmm1, xmm2, xmm3/m32, 3" }, { "mnemonic": "kandq", "architecture": "x86", "full_name": "Bitwise Logical AND Masks Quadword", "summary": "Bitwise AND of 64-bit mask registers.", "syntax": "KANDQ k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.0F.W1 41 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 41", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise logical AND on two 64-bit mask registers (k2 and k3) and stores the result in the destination mask register (k1). All 64 bits of the mask registers are operated on. This is a low-latency operation with no flag modifications. Requires AVX-512BW for 64-bit mask register support.", "pseudocode": "k1 = k2 & k3", "example": "KANDQ k1, k2, k3" }, { "mnemonic": "korq", "architecture": "x86", "full_name": "Bitwise Logical OR Masks Quadword", "summary": "Bitwise OR of 64-bit mask registers.", "syntax": "KORQ k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.0F.W1 45 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 45", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise logical OR on two 64-bit mask registers (k2 and k3) and stores the result in the destination mask register (k1). All 64 bits of the mask registers participate in the operation. This is a low-latency mask manipulation instruction with no EFLAGS modification. Requires AVX-512BW for 64-bit mask operations.", "pseudocode": "k1 = k2 | k3", "example": "KORQ k1, k2, k3" }, { "mnemonic": "knotq", "architecture": "x86", "full_name": "Bitwise Logical NOT Masks Quadword", "summary": "Bitwise NOT of 64-bit mask register.", "syntax": "KNOTQ k1, k2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.0F.W1 44 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 44", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise logical NOT operation on a 64-bit AVX-512 opmask register, inverting all bits. The instruction operates only on opmask registers (k0-k7) and does not affect general EFLAGS. This is an AVX-512BW extension instruction with no flag side effects.", "pseudocode": "dest ← ~src", "example": "KNOTQ k1, k2" }, { "mnemonic": "aesimc", "architecture": "x86", "full_name": "AES Inverse Mix Columns", "summary": "Performs AES InvMixColumns transformation (decryption helper).", "syntax": "AESIMC xmm1, xmm2/m128", "encoding": { "format": "AES-NI", "hex_opcode": "66 0F 38 DB", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | DB", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "AES-NI", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs the AES InvMixColumns transformation on a 128-bit XMM register, applying the inverse MixColumns step used in AES block cipher decryption. This is a cryptographic acceleration instruction from the AES-NI extension that operates on 128-bit values and produces no flag modifications.", "pseudocode": "dest ← InvMixColumns(src)", "example": "AESIMC xmm1, xmm2/m128" }, { "mnemonic": "maskmovq", "architecture": "x86", "full_name": "Store Selected Bytes of Quadword", "summary": "Non-temporal store of selected MMX bytes.", "syntax": "MASKMOVQ mm1, mm2", "encoding": { "format": "MMX", "hex_opcode": "NP 0F F7 /r", "visual_parts": [], "binary_pattern": "0F | F7", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [ { "name": "dest", "type": "mm1", "desc": "64-bit MMX register" }, { "name": "src", "type": "mm2", "desc": "64-bit MMX register" } ], "description": "Conditionally stores selected bytes from a 64-bit MMX register to memory based on byte-granularity mask bits from another MMX register, using the implicit address in EDI (32-bit) or RDI (64-bit). The instruction writes non-temporally where supported and does not affect EFLAGS; it requires real or protected mode for address generation.", "pseudocode": "for (i = 0; i < 8; i++) {\n if (src[i*8 + 7] == 1) {\n [EDI/RDI + i] ← dest[i*8 : i*8+7]\n }\n}", "example": "MASKMOVQ mm1, mm2" }, { "mnemonic": "pmulld", "architecture": "x86", "full_name": "Packed Multiply Low Doubleword", "summary": "Multiplies 32-bit integers, stores low 32-bit result.", "syntax": "PMULLD xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 40", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 40", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Multiplies four pairs of 32-bit signed integers in parallel, storing the low 32 bits of each product in the destination XMM register. This SSE4.1 instruction operates on 128-bit vectors and does not modify EFLAGS; overflow is silently discarded.", "pseudocode": "for (i = 0; i < 4; i++) {\n dest[i*32 : i*32+31] ← (src1[i*32 : i*32+31] * src2[i*32 : i*32+31]) & 0xFFFFFFFF\n}", "example": "PMULLD xmm1, xmm2/m128" }, { "mnemonic": "pmovsxbw", "architecture": "x86", "full_name": "Packed Move with Sign Extend Byte to Word", "summary": "Sign extends 8-bit integers to 16-bit.", "syntax": "PMOVSXBW xmm1, xmm2/m64", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 20", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 20", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Sign-extends four 8-bit signed integers from the lower 32 bits of the source to four 16-bit signed integers in the destination XMM register. This SSE4.1 instruction performs element-wise sign extension with no flag side effects; the upper 64 bits of the source are ignored.", "pseudocode": "for (i = 0; i < 4; i++) {\n dest[i*16 : i*16+15] ← sign_extend_8to16(src[i*8 : i*8+7])\n}\ndest[64:127] ← 0", "example": "PMOVSXBW xmm1, xmm2/m64" }, { "mnemonic": "pmovzxbw", "architecture": "x86", "full_name": "Packed Move with Zero Extend Byte to Word", "summary": "Zero extends 8-bit integers to 16-bit.", "syntax": "PMOVZXBW xmm1, xmm2/m64", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 30", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 30", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Zero-extends four 8-bit unsigned integers from the lower 32 bits of the source to four 16-bit unsigned integers in the destination XMM register. This SSE4.1 instruction performs element-wise zero extension with no flag modifications; the upper 64 bits of the source are ignored.", "pseudocode": "for (i = 0; i < 4; i++) {\n dest[i*16 : i*16+15] ← zero_extend_8to16(src[i*8 : i*8+7])\n}\ndest[64:127] ← 0", "example": "PMOVZXBW xmm1, xmm2/m64" }, { "mnemonic": "pinsrb", "architecture": "x86", "full_name": "Packed Insert Byte", "summary": "Inserts a byte from integer register into XMM.", "syntax": "PINSRB xmm1, r32/m8, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 20", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 20", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "r32/m8", "desc": "General-purpose register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Inserts an 8-bit integer value from a general-purpose register or memory into a byte position within the destination XMM register, as specified by an immediate index. This SSE4.1 instruction does not affect EFLAGS; the immediate selects one of 16 byte lanes (0-15) in the 128-bit register.", "pseudocode": "index ← src2 & 0xF\ndest[index*8 : index*8+7] ← src1[0:7]", "example": "PINSRB xmm1, r32/m8, 3" }, { "mnemonic": "pextrb", "architecture": "x86", "full_name": "Packed Extract Byte", "summary": "Extracts a byte from XMM to integer register.", "syntax": "PEXTRB r32/m8, xmm1, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 14", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 14", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "r32/m8", "desc": "General-purpose register or Memory operand" }, { "name": "src1", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Extracts an 8-bit byte from a specified position within the source XMM register and stores it into a general-purpose register or memory location. This SSE4.1 instruction does not modify EFLAGS; the immediate selects one of 16 byte lanes (0-15), and destination registers are zero-extended to 32 bits when writing to r32.", "pseudocode": "index ← src2 & 0xF\ndest ← src1[index*8 : index*8+7]", "example": "PEXTRB r32/m8, xmm1, 3" }, { "mnemonic": "ptest", "architecture": "x86", "full_name": "Packed Logical Comparison", "summary": "Bitwise compare of 128-bit value (AND) setting flags.", "syntax": "PTEST xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 17", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 17", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4.1", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs a bitwise AND of the 128-bit source operand with the 128-bit destination operand and sets EFLAGS based on the result, without modifying the destination. Sets ZF if the AND result is all zeros, sets CF if the AND of the source with the bitwise NOT of the destination is all zeros. Does not update OF, SF, AF, or PF. Available only in SSE4.1 and later; operates on 128-bit XMM registers.", "pseudocode": "temp ← dest[127:0] AND src[127:0];\nZF ← (temp == 0);\nCF ← ((src[127:0] AND (NOT dest[127:0])) == 0);\nOF ← 0; SF ← 0; AF ← 0; PF ← 0;", "example": "PTEST xmm1, xmm2/m128" }, { "mnemonic": "aesenc", "architecture": "x86", "full_name": "AES Encrypt", "summary": "Performs one round of AES encryption flow.", "syntax": "AESENC xmm1, xmm2/m128", "encoding": { "format": "AES-NI", "hex_opcode": "66 0F 38 DC", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | DC", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "AES-NI", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs a single round of AES encryption on the 128-bit state in the destination XMM register using the round key in the source operand. The operation includes SubBytes, ShiftRows, MixColumns, and AddRoundKey transformations. Does not modify EFLAGS. Requires the AES-NI instruction set extension; operates on 128-bit XMM registers or memory.", "pseudocode": "dest[127:0] ← AES_EncryptionRound(dest[127:0], src[127:0]);\nOF ← 0; CF ← 0; ZF ← 0; SF ← 0; AF ← 0; PF ← 0;", "example": "AESENC xmm1, xmm2/m128" }, { "mnemonic": "aesenclast", "architecture": "x86", "full_name": "AES Encrypt Last Round", "summary": "Performs the last round of AES encryption.", "syntax": "AESENCLAST xmm1, xmm2/m128", "encoding": { "format": "AES-NI", "hex_opcode": "66 0F 38 DD", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | DD", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "AES-NI", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs the final round of AES encryption on the 128-bit state in the destination XMM register using the round key in the source operand. The final round excludes the MixColumns transformation compared to aesenc. Does not modify EFLAGS. Requires the AES-NI instruction set extension; operates on 128-bit XMM registers or memory.", "pseudocode": "dest[127:0] ← AES_EncryptionLastRound(dest[127:0], src[127:0]);\nOF ← 0; CF ← 0; ZF ← 0; SF ← 0; AF ← 0; PF ← 0;", "example": "AESENCLAST xmm1, xmm2/m128" }, { "mnemonic": "aesdec", "architecture": "x86", "full_name": "AES Decrypt", "summary": "Performs one round of AES decryption flow.", "syntax": "AESDEC xmm1, xmm2/m128", "encoding": { "format": "AES-NI", "hex_opcode": "66 0F 38 DE", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | DE", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "AES-NI", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs a single round of AES decryption on the 128-bit state in the destination XMM register using the round key in the source operand. The operation includes InvSubBytes, InvShiftRows, InvMixColumns, and AddRoundKey transformations. Does not modify EFLAGS. Requires the AES-NI instruction set extension; operates on 128-bit XMM registers or memory.", "pseudocode": "dest[127:0] ← AES_DecryptionRound(dest[127:0], src[127:0]);\nOF ← 0; CF ← 0; ZF ← 0; SF ← 0; AF ← 0; PF ← 0;", "example": "AESDEC xmm1, xmm2/m128" }, { "mnemonic": "aeskeygenassist", "architecture": "x86", "full_name": "AES Key Generation Assist", "summary": "Generates round key for AES encryption.", "syntax": "AESKEYGENASSIST xmm1, xmm2/m128, imm8", "encoding": { "format": "AES-NI", "hex_opcode": "66 0F 3A DF", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | DF", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "AES-NI", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Generates a round key for AES encryption by performing key schedule computation on the 128-bit source operand and an immediate byte, storing the result in the destination XMM register. Used to facilitate AES key expansion during encryption key setup. Does not modify EFLAGS. Requires the AES-NI instruction set extension; operates on 128-bit XMM registers or memory with an 8-bit immediate.", "pseudocode": "dest[127:0] ← AES_KeyGenAssist(src[127:0], imm8);\nOF ← 0; CF ← 0; ZF ← 0; SF ← 0; AF ← 0; PF ← 0;", "example": "AESKEYGENASSIST xmm1, xmm2/m128, 3" }, { "mnemonic": "vaddps", "architecture": "x86", "full_name": "Add Packed Single-Precision (AVX)", "summary": "Adds packed floats (256-bit YMM support).", "syntax": "VADDPS ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.0F.WIG 58 /r", "visual_parts": [], "binary_pattern": "VEX | C5 | ModRM | 58", "bit_positions": "+0 | +3 | +4 | +5" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Adds four packed single-precision floating-point values from the source operand to the corresponding values in the first source operand and stores the result in the destination YMM register. Floating-point exceptions and rounding mode are controlled by MXCSR. Does not modify EFLAGS. Requires AVX and is available in 64-bit mode; operates on 256-bit YMM registers or memory with three-operand form.", "pseudocode": "dest[255:0] ← src1[255:0] + src2[255:0];\nfor i ← 0 to 7 do\n dest[32*i+31:32*i] ← FP32_Add(src1[32*i+31:32*i], src2[32*i+31:32*i]);\nendfor;", "example": "VADDPS ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vmulps", "architecture": "x86", "full_name": "Multiply Packed Single-Precision (AVX)", "summary": "Multiplies packed floats (256-bit).", "syntax": "VMULPS ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.0F.WIG 59 /r", "visual_parts": [], "binary_pattern": "VEX | C5 | ModRM | 59", "bit_positions": "+0 | +3 | +4 | +5" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Multiplies four packed single-precision floating-point values from the source operand by the corresponding values in the first source operand and stores the result in the destination YMM register. Floating-point exceptions and rounding mode are controlled by MXCSR. Does not modify EFLAGS. Requires AVX and is available in 64-bit mode; operates on 256-bit YMM registers or memory with three-operand form.", "pseudocode": "dest[255:0] ← src1[255:0] * src2[255:0];\nfor i ← 0 to 7 do\n dest[32*i+31:32*i] ← FP32_Multiply(src1[32*i+31:32*i], src2[32*i+31:32*i]);\nendfor;", "example": "VMULPS ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vfmadd231ps", "architecture": "x86", "full_name": "Fused Multiply-Add (132)", "summary": "Computes (Dest * Src2) + Src1.", "syntax": "VFMADD231PS ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.0 B8 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "FMA3", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Performs a fused multiply-add operation: multiplies the destination operand by the third operand and adds the result to the second operand, storing the result in the destination YMM register. The 231 variant computes (dest * src2) + src1 in a single operation with one rounding step, improving precision over separate multiply and add. Does not modify EFLAGS. Requires FMA3 and is available in 64-bit mode; operates on 256-bit YMM registers or memory.", "pseudocode": "dest[255:0] ← FMA(dest[255:0], src2[255:0], src1[255:0]);\nfor i ← 0 to 7 do\n dest[32*i+31:32*i] ← FP32_FMA(dest[32*i+31:32*i], src2[32*i+31:32*i], src1[32*i+31:32*i]);\nendfor;", "example": "VFMADD231PS ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vinsertf128", "architecture": "x86", "full_name": "Insert Float 128-bit", "summary": "Inserts 128-bits into a YMM register.", "syntax": "VINSERTF128 ymm1, ymm2, xmm3/m128, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F3A.W0 18 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "xmm3/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Inserts a 128-bit float vector into a 256-bit YMM register at either the lower or upper 128-bit lane, with the remaining lane copied from the first source operand. This is a non-destructive three-operand instruction where the immediate byte (bits 0-7) selects the destination lane (0=lower, 1=upper). No flags are affected; this is purely a data movement and lane selection operation.", "pseudocode": "imm_index ← imm8[0];\nif (imm_index == 0) {\n ymm1[0:127] ← xmm3/m128[0:127];\n ymm1[128:255] ← ymm2[128:255];\n} else {\n ymm1[0:127] ← ymm2[0:127];\n ymm1[128:255] ← xmm3/m128[0:127];\n}", "example": "VINSERTF128 ymm1, ymm2, xmm3/m128, 3" }, { "mnemonic": "vextractf128", "architecture": "x86", "full_name": "Extract Float 128-bit", "summary": "Extracts 128-bits from YMM register.", "syntax": "VEXTRACTF128 xmm1/m128, ymm2, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F3A.W0 19 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "xmm1/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Extracts a 128-bit float vector from a 256-bit YMM register based on an immediate selector and stores it to an XMM register or 128-bit memory location. The immediate byte (bit 0) selects which 128-bit lane to extract (0=lower, 1=upper). No flags are affected; this is a data extraction and movement operation only.", "pseudocode": "imm_index ← imm8[0];\nif (imm_index == 0) {\n xmm1/m128[0:127] ← ymm2[0:127];\n} else {\n xmm1/m128[0:127] ← ymm2[128:255];\n}", "example": "VEXTRACTF128 xmm1/m128, ymm2, 3" }, { "mnemonic": "vzeroupper", "architecture": "x86", "full_name": "Zero Upper Bits of YMM Registers", "summary": "Clears bits 128-255 of all YMM registers (Avoids AVX-SSE transition penalty).", "syntax": "VZEROUPPER", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.0F.WIG 77", "visual_parts": [], "binary_pattern": "VEX | C5 | F8 | 77", "bit_positions": "+0 | +3 | +4 | +5" }, "extension": "AVX", "operands": [], "description": "Clears bits 128-255 of all 16 YMM registers (YMM0-YMM15 in 64-bit mode, YMM0-YMM7 in 32-bit mode), leaving bits 0-127 unchanged. This eliminates the AVX-to-SSE transition penalty by ensuring the upper 128-bit portions are zero before executing SSE instructions. No flags are affected. This instruction must be executed in protected or 64-bit mode.", "pseudocode": "for i from 0 to (is_64bit_mode ? 15 : 7) {\n YMM[i][128:255] ← 0;\n}", "example": "VZEROUPPER" }, { "mnemonic": "vzeroall", "architecture": "x86", "full_name": "Zero All YMM Registers", "summary": "Clears all YMM registers.", "syntax": "VZEROALL", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.0F.WIG 77", "visual_parts": [], "binary_pattern": "VEX | C5 | FC | 77", "bit_positions": "+0 | +3 | +4 | +5" }, "extension": "AVX", "operands": [], "description": "Clears all bits of all 16 YMM registers (YMM0-YMM15 in 64-bit mode, YMM0-YMM7 in 32-bit mode) to zero. This is a faster alternative to clearing individual YMM registers via multiple VXORPS or similar instructions. No flags are affected. Execution is restricted to protected or 64-bit mode.", "pseudocode": "for i from 0 to (is_64bit_mode ? 15 : 7) {\n YMM[i][0:255] ← 0;\n}", "example": "VZEROALL" }, { "mnemonic": "emms", "architecture": "x86", "full_name": "Empty MMX Technology State", "summary": "Clears the FPU tag word to allow FP instructions after MMX.", "syntax": "EMMS", "encoding": { "format": "MMX", "hex_opcode": "NP 0F 77", "visual_parts": [], "binary_pattern": "0F | 77", "bit_positions": "+0 | +1" }, "extension": "MMX", "operands": [], "description": "Sets all tag bits in the x87 FPU tag word to 1 (all entries marked empty), allowing the x87 FPU to be used immediately after MMX instructions without a transition penalty. This instruction clears the MMX state and must be executed before mixing MMX and x87 floating-point operations. No general-purpose flags are affected, but internal x87 state is modified.", "pseudocode": "FPU_TAG_WORD[0:15] ← 0xFFFF;", "example": "EMMS" }, { "mnemonic": "movd", "architecture": "x86", "full_name": "Move Doubleword", "summary": "Moves 32 bits between GPR and XMM/MMX register.", "syntax": "MOVD mm/xmm, r32/m32", "encoding": { "format": "SSE", "hex_opcode": "66 0F 6E /r", "visual_parts": [], "binary_pattern": "0F | 6E", "bit_positions": "+0 | +1" }, "extension": "MMX/SSE2", "operands": [ { "name": "dest", "type": "mm/xmm", "desc": "64-bit MMX register or 128-bit XMM SIMD register" }, { "name": "src", "type": "r32/m32", "desc": "General-purpose register or Memory operand" } ], "description": "Moves a 32-bit value from a general-purpose register or memory location into the lower 32 bits of an MMX or XMM register, zero-extending or copying the upper bits depending on context. When destination is MMX, the upper 32 bits become undefined; when destination is XMM, the upper 96 bits are zeroed (for SSE2 and later). No flags are affected. Supported in MMX and SSE2 extensions.", "pseudocode": "if (dest_is_xmm) {\n xmm[0:31] ← r32/m32[0:31];\n xmm[32:127] ← 0;\n} else {\n mm[0:31] ← r32/m32[0:31];\n}", "example": "MOVD mm/xmm, r32/m32" }, { "mnemonic": "movq", "architecture": "x86", "full_name": "Move Quadword", "summary": "Moves 64 bits between XMM registers or memory.", "syntax": "MOVQ xmm, xmm/m64", "encoding": { "format": "SSE2", "hex_opcode": "F3 0F 7E", "visual_parts": [], "binary_pattern": "F3 | 0F | 7E", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m64", "desc": "128-bit XMM register or 64-bit memory" } ], "description": "Moves a 64-bit quadword between XMM registers or from/to 64-bit memory. When the source is memory, only the lower 64 bits of the destination XMM register are updated and the upper 64 bits are zeroed. When both operands are XMM registers, all 128 bits of the destination are affected (lower 64 from source, upper 64 zeroed). No flags are affected. This instruction is part of SSE2 and later.", "pseudocode": "xmm_dest[0:63] ← xmm/m64[0:63];\nxmm_dest[64:127] ← 0;", "example": "MOVQ xmm0, xmm1" }, { "mnemonic": "movaps", "architecture": "x86", "full_name": "Move Aligned Packed Single-Precision", "summary": "Moves 128-bit packed float data (Must be 16-byte aligned).", "syntax": "MOVAPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 28 /r", "visual_parts": [], "binary_pattern": "0F | 28", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Moves 128 bits of packed single-precision floating-point data between XMM registers or between an XMM register and 16-byte aligned memory. The memory operand must be 16-byte aligned; unaligned memory access results in a general-protection exception (#GP). This is a cache-efficient operation for aligned data. No flags are affected. Supported in SSE and later extensions.", "pseudocode": "xmm_dest[0:127] ← xmm/m128[0:127];", "example": "MOVAPS xmm0, xmm1" }, { "mnemonic": "movups", "architecture": "x86", "full_name": "Move Unaligned Packed Single-Precision", "summary": "Moves 128-bit packed float data (Unaligned).", "syntax": "MOVUPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 10 /r", "visual_parts": [], "binary_pattern": "0F | 10", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Moves 128 bits of unaligned packed single-precision floating-point data from source to destination XMM register. No alignment requirement on memory operand. Does not affect any flags; operates only on XMM state.", "pseudocode": "dest[127:0] ← src[127:0]", "example": "MOVUPS xmm0, xmm1" }, { "mnemonic": "movapd", "architecture": "x86", "full_name": "Move Aligned Packed Double-Precision", "summary": "Moves 128-bit packed double data (Must be 16-byte aligned).", "syntax": "MOVAPD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 28", "visual_parts": [], "binary_pattern": "66 | 0F | 28", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Moves 128 bits of aligned packed double-precision floating-point data from source to destination XMM register. Memory operand must be 16-byte aligned; unaligned access generates #GP(0). Does not affect any flags; operates only on XMM state.", "pseudocode": "dest[127:0] ← src[127:0]", "example": "MOVAPD xmm0, xmm1" }, { "mnemonic": "movupd", "architecture": "x86", "full_name": "Move Unaligned Packed Double-Precision", "summary": "Moves 128-bit packed double data (Unaligned).", "syntax": "MOVUPD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 10", "visual_parts": [], "binary_pattern": "66 | 0F | 10", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Moves 128 bits of unaligned packed double-precision floating-point data from source to destination XMM register. No alignment requirement on memory operand. Does not affect any flags; operates only on XMM state.", "pseudocode": "dest[127:0] ← src[127:0]", "example": "MOVUPD xmm0, xmm1" }, { "mnemonic": "movdqa", "architecture": "x86", "full_name": "Move Aligned Packed Integer", "summary": "Moves 128-bit integer data (Aligned).", "syntax": "MOVDQA xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 6F", "visual_parts": [], "binary_pattern": "66 | 0F | 6F", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Moves 128 bits of aligned packed integer data from source to destination XMM register. Memory operand must be 16-byte aligned; unaligned access generates #GP(0). Does not affect any flags; operates only on XMM state.", "pseudocode": "dest[127:0] ← src[127:0]", "example": "MOVDQA xmm0, xmm1" }, { "mnemonic": "movdqu", "architecture": "x86", "full_name": "Move Unaligned Packed Integer", "summary": "Moves 128-bit integer data (Unaligned).", "syntax": "MOVDQU xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "F3 0F 6F", "visual_parts": [], "binary_pattern": "F3 | 0F | 6F", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Moves 128 bits of unaligned packed integer data from source to destination XMM register. No alignment requirement on memory operand. Does not affect any flags; operates only on XMM state.", "pseudocode": "dest[127:0] ← src[127:0]", "example": "MOVDQU xmm0, xmm1" }, { "mnemonic": "addps", "architecture": "x86", "full_name": "Add Packed Single-Precision", "summary": "Adds four 32-bit floats.", "syntax": "ADDPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 58 /r", "visual_parts": [], "binary_pattern": "0F | 58", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Adds four 32-bit single-precision floating-point values element-wise from source to destination XMM register, storing results in destination. Each element addition produces IEEE 754 floating-point result; does not affect integer flags. Available in 128-bit (XMM) form.", "pseudocode": "dest[31:0] ← dest[31:0] + src[31:0]\ndest[63:32] ← dest[63:32] + src[63:32]\ndest[95:64] ← dest[95:64] + src[95:64]\ndest[127:96] ← dest[127:96] + src[127:96]", "example": "ADDPS xmm0, xmm1" }, { "mnemonic": "addpd", "architecture": "x86", "full_name": "Add Packed Double-Precision", "summary": "Adds two 64-bit doubles.", "syntax": "ADDPD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 58", "visual_parts": [], "binary_pattern": "66 | 0F | 58", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Adds two 64-bit double-precision floating-point values element-wise from source to destination XMM register, storing results in destination. Each element addition produces IEEE 754 floating-point result; does not affect integer flags. Available in 128-bit (XMM) form.", "pseudocode": "dest[63:0] ← dest[63:0] + src[63:0]\ndest[127:64] ← dest[127:64] + src[127:64]", "example": "ADDPD xmm0, xmm1" }, { "mnemonic": "addss", "architecture": "x86", "full_name": "Add Scalar Single-Precision", "summary": "Adds the low 32-bit float.", "syntax": "ADDSS xmm, xmm/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 58", "visual_parts": [], "binary_pattern": "F3 | 0F | 58", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m32", "desc": "128-bit XMM register or 32-bit memory" } ], "description": "Adds the low 32-bit single-precision floating-point values from source to destination XMM register; upper three 32-bit elements of destination are unchanged. Scalar operation on lowest element; does not affect integer flags. Result follows IEEE 754 floating-point semantics.", "pseudocode": "dest[31:0] ← dest[31:0] + src[31:0]\ndest[127:32] ← dest[127:32]", "example": "ADDSS xmm0, xmm1" }, { "mnemonic": "addsd", "architecture": "x86", "full_name": "Add Scalar Double-Precision", "summary": "Adds the low 64-bit double.", "syntax": "ADDSD xmm, xmm/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 58", "visual_parts": [], "binary_pattern": "F2 | 0F | 58", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m64", "desc": "128-bit XMM register or 64-bit memory" } ], "description": "Adds the low 64-bit double-precision floating-point value in the source operand to the low 64-bit double-precision value in the destination XMM register, storing the result in the destination. The high 64 bits of the destination remain unchanged. This instruction operates on scalar (single) values and respects IEEE 754 rounding modes controlled by MXCSR.", "pseudocode": "dest[63:0] ← dest[63:0] + src[63:0];\ndest[127:64] ← unchanged;", "example": "ADDSD xmm0, xmm1" }, { "mnemonic": "subps", "architecture": "x86", "full_name": "Subtract Packed Single-Precision", "summary": "Subtracts four 32-bit floats.", "syntax": "SUBPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 5C /r", "visual_parts": [], "binary_pattern": "0F | 5C", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Subtracts four 32-bit single-precision floating-point values in the source operand from the four 32-bit single-precision values in the destination XMM register, storing all four results in the destination. Operates on packed values in parallel and respects IEEE 754 rounding modes controlled by MXCSR.", "pseudocode": "dest[31:0] ← dest[31:0] - src[31:0];\ndest[63:32] ← dest[63:32] - src[63:32];\ndest[95:64] ← dest[95:64] - src[95:64];\ndest[127:96] ← dest[127:96] - src[127:96];", "example": "SUBPS xmm0, xmm1" }, { "mnemonic": "subpd", "architecture": "x86", "full_name": "Subtract Packed Double-Precision", "summary": "Subtracts two 64-bit doubles.", "syntax": "SUBPD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 5C", "visual_parts": [], "binary_pattern": "66 | 0F | 5C", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Subtracts two 64-bit double-precision floating-point values in the source operand from the two 64-bit double-precision values in the destination XMM register, storing both results in the destination. Operates on packed values in parallel and respects IEEE 754 rounding modes controlled by MXCSR.", "pseudocode": "dest[63:0] ← dest[63:0] - src[63:0];\ndest[127:64] ← dest[127:64] - src[127:64];", "example": "SUBPD xmm0, xmm1" }, { "mnemonic": "mulps", "architecture": "x86", "full_name": "Multiply Packed Single-Precision", "summary": "Multiplies four 32-bit floats.", "syntax": "MULPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 59 /r", "visual_parts": [], "binary_pattern": "0F | 59", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Multiplies four 32-bit single-precision floating-point values in the source operand by the four 32-bit single-precision values in the destination XMM register, storing all four products in the destination. Operates on packed values in parallel and respects IEEE 754 rounding modes controlled by MXCSR.", "pseudocode": "dest[31:0] ← dest[31:0] * src[31:0];\ndest[63:32] ← dest[63:32] * src[63:32];\ndest[95:64] ← dest[95:64] * src[95:64];\ndest[127:96] ← dest[127:96] * src[127:96];", "example": "MULPS xmm0, xmm1" }, { "mnemonic": "mulpd", "architecture": "x86", "full_name": "Multiply Packed Double-Precision", "summary": "Multiplies two 64-bit doubles.", "syntax": "MULPD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 59", "visual_parts": [], "binary_pattern": "66 | 0F | 59", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Multiplies two 64-bit double-precision floating-point values in the source operand by the two 64-bit double-precision values in the destination XMM register, storing both products in the destination. Operates on packed values in parallel and respects IEEE 754 rounding modes controlled by MXCSR.", "pseudocode": "dest[63:0] ← dest[63:0] * src[63:0];\ndest[127:64] ← dest[127:64] * src[127:64];", "example": "MULPD xmm0, xmm1" }, { "mnemonic": "divps", "architecture": "x86", "full_name": "Divide Packed Single-Precision", "summary": "Divides four 32-bit floats.", "syntax": "DIVPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 5E /r", "visual_parts": [], "binary_pattern": "0F | 5E", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Divides four 32-bit single-precision floating-point values in the destination XMM register by the four 32-bit single-precision values in the source operand, storing all four quotients in the destination. Operates on packed values in parallel and respects IEEE 754 rounding modes controlled by MXCSR; division by zero produces infinity or NaN according to IEEE 754 rules.", "pseudocode": "dest[31:0] ← dest[31:0] / src[31:0];\ndest[63:32] ← dest[63:32] / src[63:32];\ndest[95:64] ← dest[95:64] / src[95:64];\ndest[127:96] ← dest[127:96] / src[127:96];", "example": "DIVPS xmm0, xmm1" }, { "mnemonic": "divpd", "architecture": "x86", "full_name": "Divide Packed Double-Precision", "summary": "Divides two 64-bit doubles.", "syntax": "DIVPD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 5E", "visual_parts": [], "binary_pattern": "66 | 0F | 5E", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Divides two 64-bit double-precision floating-point values in the destination XMM register by the two 64-bit double-precision values in the source operand, storing both quotients in the destination. Operates on packed values in parallel and respects IEEE 754 rounding modes controlled by MXCSR; division by zero produces infinity or NaN according to IEEE 754 rules.", "pseudocode": "dest[63:0] ← dest[63:0] / src[63:0];\ndest[127:64] ← dest[127:64] / src[127:64];", "example": "DIVPD xmm0, xmm1" }, { "mnemonic": "sqrtps", "architecture": "x86", "full_name": "Square Root Packed Single-Precision", "summary": "Computes square root of four 32-bit floats.", "syntax": "SQRTPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 51 /r", "visual_parts": [], "binary_pattern": "0F | 51", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Computes the square root of four 32-bit single-precision floating-point values in the source operand and stores all four results in the destination XMM register. Operates on packed values in parallel and respects IEEE 754 rounding modes controlled by MXCSR; negative values produce NaN according to IEEE 754 rules.", "pseudocode": "dest[31:0] ← sqrt(src[31:0]);\ndest[63:32] ← sqrt(src[63:32]);\ndest[95:64] ← sqrt(src[95:64]);\ndest[127:96] ← sqrt(src[127:96]);", "example": "SQRTPS xmm0, xmm1" }, { "mnemonic": "sqrtpd", "architecture": "x86", "full_name": "Square Root Packed Double-Precision", "summary": "Computes square root of two 64-bit doubles.", "syntax": "SQRTPD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 51", "visual_parts": [], "binary_pattern": "66 | 0F | 51", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Computes the square root of two packed 64-bit double-precision floating-point values and stores the results in the destination XMM register. This instruction operates at the FPU execution unit and sets MXCSR exception flags according to IEEE 754 rounding mode and precision; no general-purpose flags are affected. Requires SSE2 support.", "pseudocode": "dest[0:63] ← sqrt(src[0:63])\ndest[64:127] ← sqrt(src[64:127])\nMXCSR exception flags ← updated based on IEEE 754 result", "example": "SQRTPD xmm0, xmm1" }, { "mnemonic": "rcpps", "architecture": "x86", "full_name": "Reciprocal Packed Single-Precision", "summary": "Approximate reciprocal (1/x) of four 32-bit floats.", "syntax": "RCPPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 53 /r", "visual_parts": [], "binary_pattern": "0F | 53", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Computes the approximate reciprocal (1/x) of four packed 32-bit single-precision floating-point values with a relative error of at most 1.5×2⁻¹² and stores results in the destination XMM register. This is a fast approximation instruction suitable for iterative refinement; no general-purpose flags are affected. Requires SSE support.", "pseudocode": "dest[0:31] ← approx_reciprocal(src[0:31])\ndest[32:63] ← approx_reciprocal(src[32:63])\ndest[64:95] ← approx_reciprocal(src[64:95])\ndest[96:127] ← approx_reciprocal(src[96:127])", "example": "RCPPS xmm0, xmm1" }, { "mnemonic": "rsqrtps", "architecture": "x86", "full_name": "Reciprocal Square Root Packed Single-Precision", "summary": "Approximate reciprocal sqrt (1/sqrt(x)) of four 32-bit floats.", "syntax": "RSQRTPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 52 /r", "visual_parts": [], "binary_pattern": "0F | 52", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Computes the approximate reciprocal square root (1/√x) of four packed 32-bit single-precision floating-point values with a relative error of at most 1.5×2⁻¹² and stores results in the destination XMM register. This is a fast approximation instruction useful for physics simulations and graphics; no general-purpose flags are affected. Requires SSE support.", "pseudocode": "dest[0:31] ← approx_reciprocal_sqrt(src[0:31])\ndest[32:63] ← approx_reciprocal_sqrt(src[32:63])\ndest[64:95] ← approx_reciprocal_sqrt(src[64:95])\ndest[96:127] ← approx_reciprocal_sqrt(src[96:127])", "example": "RSQRTPS xmm0, xmm1" }, { "mnemonic": "maxps", "architecture": "x86", "full_name": "Maximum Packed Single-Precision", "summary": "Returns maximum of packed floats.", "syntax": "MAXPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 5F /r", "visual_parts": [], "binary_pattern": "0F | 5F", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Compares four packed 32-bit single-precision floating-point values element-wise and stores the maximum of each pair in the destination XMM register. Special values (NaN, signed zeros) follow IEEE 754 comparison semantics; no general-purpose flags are affected. Requires SSE support.", "pseudocode": "dest[0:31] ← max(dest[0:31], src[0:31])\ndest[32:63] ← max(dest[32:63], src[32:63])\ndest[64:95] ← max(dest[64:95], src[64:95])\ndest[96:127] ← max(dest[96:127], src[96:127])", "example": "MAXPS xmm0, xmm1" }, { "mnemonic": "minps", "architecture": "x86", "full_name": "Minimum Packed Single-Precision", "summary": "Returns minimum of packed floats.", "syntax": "MINPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 5D /r", "visual_parts": [], "binary_pattern": "0F | 5D", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Compares four packed 32-bit single-precision floating-point values element-wise and stores the minimum of each pair in the destination XMM register. Special values (NaN, signed zeros) follow IEEE 754 comparison semantics; no general-purpose flags are affected. Requires SSE support.", "pseudocode": "dest[0:31] ← min(dest[0:31], src[0:31])\ndest[32:63] ← min(dest[32:63], src[32:63])\ndest[64:95] ← min(dest[64:95], src[64:95])\ndest[96:127] ← min(dest[96:127], src[96:127])", "example": "MINPS xmm0, xmm1" }, { "mnemonic": "andps", "architecture": "x86", "full_name": "Bitwise Logical AND Packed Single-Precision", "summary": "Bitwise AND of 128 bits.", "syntax": "ANDPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 54 /r", "visual_parts": [], "binary_pattern": "0F | 54", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs a bitwise logical AND of all 128 bits in the destination and source XMM registers and stores the result in the destination. This is a pure logical operation treating the packed single-precision floats as integer bit patterns; no general-purpose flags are affected. Requires SSE support.", "pseudocode": "dest[0:127] ← dest[0:127] AND src[0:127]", "example": "ANDPS xmm0, xmm1" }, { "mnemonic": "andpd", "architecture": "x86", "full_name": "Bitwise Logical AND Packed Double-Precision", "summary": "Bitwise AND of 128 bits.", "syntax": "ANDPD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 54", "visual_parts": [], "binary_pattern": "66 | 0F | 54", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs a bitwise logical AND of all 128 bits in the destination and source XMM registers and stores the result in the destination. This is a pure logical operation treating the packed double-precision floats as integer bit patterns; no general-purpose flags are affected. Requires SSE2 support.", "pseudocode": "dest[0:127] ← dest[0:127] AND src[0:127]", "example": "ANDPD xmm0, xmm1" }, { "mnemonic": "orps", "architecture": "x86", "full_name": "Bitwise Logical OR Packed Single-Precision", "summary": "Bitwise OR of 128 bits.", "syntax": "ORPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 56 /r", "visual_parts": [], "binary_pattern": "0F | 56", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs a bitwise logical OR of all 128 bits in the destination and source XMM registers and stores the result in the destination. This is a pure logical operation treating the packed single-precision floats as integer bit patterns; no general-purpose flags are affected. Requires SSE support.", "pseudocode": "dest[0:127] ← dest[0:127] OR src[0:127]", "example": "ORPS xmm0, xmm1" }, { "mnemonic": "xorps", "architecture": "x86", "full_name": "Bitwise Logical XOR Packed Single-Precision", "summary": "Bitwise XOR of 128 bits (Used to clear registers).", "syntax": "XORPS xmm, xmm/m128", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 57 /r", "visual_parts": [], "binary_pattern": "0F | 57", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs a bitwise XOR of two 128-bit packed single-precision floating-point values, storing the result in the destination XMM register. No flags are affected by this operation. This instruction is commonly used to zero XMM registers efficiently (xorps xmm0, xmm0) as a dependency-breaking micro-optimization.", "pseudocode": "dest ← dest XOR src", "example": "XORPS xmm0, xmm1" }, { "mnemonic": "paddb", "architecture": "x86", "full_name": "Packed Add Bytes", "summary": "Adds 16 bytes (Wraparound).", "syntax": "PADDB xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F FC", "visual_parts": [], "binary_pattern": "66 | 0F | FC", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs 16 independent 8-bit unsigned or signed integer additions in parallel on packed byte data, wrapping on overflow without affecting flags. Results are stored in the destination XMM register with no saturation; overflow is silent and wraps modulo 256.", "pseudocode": "for i = 0 to 15:\n dest[i*8 + 7 : i*8] ← (dest[i*8 + 7 : i*8] + src[i*8 + 7 : i*8]) AND 0xFF", "example": "PADDB xmm0, xmm1" }, { "mnemonic": "paddw", "architecture": "x86", "full_name": "Packed Add Words", "summary": "Adds 8 words (Wraparound).", "syntax": "PADDW xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F FD", "visual_parts": [], "binary_pattern": "66 | 0F | FD", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs 8 independent 16-bit unsigned or signed integer additions in parallel on packed word data, wrapping on overflow without affecting flags. Results are stored in the destination XMM register with no saturation; overflow wraps modulo 65536.", "pseudocode": "for i = 0 to 7:\n dest[i*16 + 15 : i*16] ← (dest[i*16 + 15 : i*16] + src[i*16 + 15 : i*16]) AND 0xFFFF", "example": "PADDW xmm0, xmm1" }, { "mnemonic": "paddd", "architecture": "x86", "full_name": "Packed Add Doublewords", "summary": "Adds 4 doublewords (Wraparound).", "syntax": "PADDD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F FE", "visual_parts": [], "binary_pattern": "66 | 0F | FE", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs 4 independent 32-bit unsigned or signed integer additions in parallel on packed doubleword data, wrapping on overflow without affecting flags. Results are stored in the destination XMM register with no saturation; overflow wraps modulo 2^32.", "pseudocode": "for i = 0 to 3:\n dest[i*32 + 31 : i*32] ← (dest[i*32 + 31 : i*32] + src[i*32 + 31 : i*32]) AND 0xFFFFFFFF", "example": "PADDD xmm0, xmm1" }, { "mnemonic": "paddq", "architecture": "x86", "full_name": "Packed Add Quadwords", "summary": "Adds 2 quadwords (Wraparound).", "syntax": "PADDQ xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F D4", "visual_parts": [], "binary_pattern": "66 | 0F | D4", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs 2 independent 64-bit unsigned or signed integer additions in parallel on packed quadword data, wrapping on overflow without affecting flags. Results are stored in the destination XMM register with no saturation; overflow wraps modulo 2^64.", "pseudocode": "for i = 0 to 1:\n dest[i*64 + 63 : i*64] ← (dest[i*64 + 63 : i*64] + src[i*64 + 63 : i*64]) AND 0xFFFFFFFFFFFFFFFF", "example": "PADDQ xmm0, xmm1" }, { "mnemonic": "paddsb", "architecture": "x86", "full_name": "Packed Add Bytes Signed Saturate", "summary": "Adds 16 signed bytes with saturation.", "syntax": "PADDSB xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F EC", "visual_parts": [], "binary_pattern": "66 | 0F | EC", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs 16 independent 8-bit signed integer additions in parallel with signed saturation on packed byte data. If the result overflows or underflows the signed 8-bit range [-128, 127], the value is clamped to the nearest boundary; no flags are affected.", "pseudocode": "for i = 0 to 15:\n temp ← (int32)(int8)dest[i*8 + 7 : i*8] + (int32)(int8)src[i*8 + 7 : i*8]\n if temp > 127: dest[i*8 + 7 : i*8] ← 127\n else if temp < -128: dest[i*8 + 7 : i*8] ← -128\n else: dest[i*8 + 7 : i*8] ← temp AND 0xFF", "example": "PADDSB xmm0, xmm1" }, { "mnemonic": "paddusb", "architecture": "x86", "full_name": "Packed Add Bytes Unsigned Saturate", "summary": "Adds 16 unsigned bytes with saturation.", "syntax": "PADDUSB xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F DC", "visual_parts": [], "binary_pattern": "66 | 0F | DC", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs 16 independent 8-bit unsigned integer additions in parallel with unsigned saturation on packed byte data. If the result exceeds 255, the value is clamped to 255; no flags are affected.", "pseudocode": "for i = 0 to 15:\n temp ← (uint16)dest[i*8 + 7 : i*8] + (uint16)src[i*8 + 7 : i*8]\n if temp > 255: dest[i*8 + 7 : i*8] ← 255\n else: dest[i*8 + 7 : i*8] ← temp AND 0xFF", "example": "PADDUSB xmm0, xmm1" }, { "mnemonic": "psubb", "architecture": "x86", "full_name": "Packed Subtract Bytes", "summary": "Subtracts 16 bytes.", "syntax": "PSUBB xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F F8", "visual_parts": [], "binary_pattern": "66 | 0F | F8", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs 16 independent 8-bit unsigned or signed integer subtractions in parallel on packed byte data, wrapping on underflow without affecting flags. Results are stored in the destination XMM register with no saturation; underflow wraps modulo 256.", "pseudocode": "for i = 0 to 15:\n dest[i*8 + 7 : i*8] ← (dest[i*8 + 7 : i*8] - src[i*8 + 7 : i*8]) AND 0xFF", "example": "PSUBB xmm0, xmm1" }, { "mnemonic": "psubw", "architecture": "x86", "full_name": "Packed Subtract Words", "summary": "Subtracts 8 words.", "syntax": "PSUBW xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F F9", "visual_parts": [], "binary_pattern": "66 | 0F | F9", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Subtracts packed 16-bit words element-wise: each of the 8 words in the destination XMM register is decremented by the corresponding word in the source XMM register or 128-bit memory operand, with wrapping on underflow. No flags are affected; the operation is performed modulo 2^16 for each element.", "pseudocode": "for i = 0 to 7 do\n dest.word[i] ← (dest.word[i] - src.word[i]) mod 2^16\nend for", "example": "PSUBW xmm0, xmm1" }, { "mnemonic": "psubd", "architecture": "x86", "full_name": "Packed Subtract Doublewords", "summary": "Subtracts 4 doublewords.", "syntax": "PSUBD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F FA", "visual_parts": [], "binary_pattern": "66 | 0F | FA", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Subtracts packed 32-bit doublewords element-wise: each of the 4 doublewords in the destination XMM register is decremented by the corresponding doubleword in the source XMM register or 128-bit memory operand, with wrapping on underflow. No flags are affected; the operation is performed modulo 2^32 for each element.", "pseudocode": "for i = 0 to 3 do\n dest.dword[i] ← (dest.dword[i] - src.dword[i]) mod 2^32\nend for", "example": "PSUBD xmm0, xmm1" }, { "mnemonic": "pand", "architecture": "x86", "full_name": "Packed Logical AND", "summary": "Bitwise AND of 128-bit integers.", "syntax": "PAND xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F DB", "visual_parts": [], "binary_pattern": "66 | 0F | DB", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs a bitwise logical AND operation on the entire 128-bit content of the destination XMM register with the source XMM register or 128-bit memory operand, storing the result back in the destination. No flags are affected; the operation is a pure bitwise AND with no carry or borrow semantics.", "pseudocode": "dest ← dest AND src", "example": "PAND xmm0, xmm1" }, { "mnemonic": "por", "architecture": "x86", "full_name": "Packed Logical OR", "summary": "Bitwise OR of 128-bit integers.", "syntax": "POR xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F EB", "visual_parts": [], "binary_pattern": "66 | 0F | EB", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs a bitwise logical OR operation on the entire 128-bit content of the destination XMM register with the source XMM register or 128-bit memory operand, storing the result back in the destination. No flags are affected; the operation is a pure bitwise OR with no carry or borrow semantics.", "pseudocode": "dest ← dest OR src", "example": "POR xmm0, xmm1" }, { "mnemonic": "pxor", "architecture": "x86", "full_name": "Packed Logical Exclusive OR", "summary": "Bitwise XOR of 128-bit integers.", "syntax": "PXOR xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F EF", "visual_parts": [], "binary_pattern": "66 | 0F | EF", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs a bitwise logical exclusive OR operation on the entire 128-bit content of the destination XMM register with the source XMM register or 128-bit memory operand, storing the result back in the destination. No flags are affected; the operation is a pure bitwise XOR with no carry or borrow semantics.", "pseudocode": "dest ← dest XOR src", "example": "PXOR xmm0, xmm1" }, { "mnemonic": "psllw", "architecture": "x86", "full_name": "Packed Shift Left Logical Word", "summary": "Shifts words left.", "syntax": "PSLLW xmm, imm8", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 71 /6", "visual_parts": [], "binary_pattern": "66 | 0F | 71 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each of the 8 packed 16-bit words in the destination XMM register left logically by the number of bits specified in the 8-bit immediate operand, with zero fill on the right. Shift amounts greater than or equal to 16 zero out the corresponding word. No flags are affected.", "pseudocode": "count ← imm8 AND 0xFF\nfor i = 0 to 7 do\n if count >= 16 then\n dest.word[i] ← 0\n else\n dest.word[i] ← (dest.word[i] << count) AND 0xFFFF\n end if\nend for", "example": "PSLLW xmm0, 3" }, { "mnemonic": "pslld", "architecture": "x86", "full_name": "Packed Shift Left Logical Doubleword", "summary": "Shifts doublewords left.", "syntax": "PSLLD xmm, imm8", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 72 /6", "visual_parts": [], "binary_pattern": "66 | 0F | 72 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each of the 4 packed 32-bit doublewords in the destination XMM register left logically by the number of bits specified in the 8-bit immediate operand, with zero fill on the right. Shift amounts greater than or equal to 32 zero out the corresponding doubleword. No flags are affected.", "pseudocode": "count ← imm8 AND 0xFF\nfor i = 0 to 3 do\n if count >= 32 then\n dest.dword[i] ← 0\n else\n dest.dword[i] ← (dest.dword[i] << count) AND 0xFFFFFFFF\n end if\nend for", "example": "PSLLD xmm0, 3" }, { "mnemonic": "psrlw", "architecture": "x86", "full_name": "Packed Shift Right Logical Word", "summary": "Shifts words right logical.", "syntax": "PSRLW xmm, imm8", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 71 /2", "visual_parts": [], "binary_pattern": "66 | 0F | 71 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each of the 8 packed 16-bit words in the destination XMM register right logically (unsigned) by the number of bits specified in the 8-bit immediate operand, with zero fill on the left. Shift amounts greater than or equal to 16 zero out the corresponding word. No flags are affected.", "pseudocode": "count ← imm8 AND 0xFF\nfor i = 0 to 7 do\n if count >= 16 then\n dest.word[i] ← 0\n else\n dest.word[i] ← (dest.word[i] >> count) AND 0xFFFF\n end if\nend for", "example": "PSRLW xmm0, 3" }, { "mnemonic": "psrld", "architecture": "x86", "full_name": "Packed Shift Right Logical Doubleword", "summary": "Shifts doublewords right logical.", "syntax": "PSRLD xmm, imm8", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 72 /2", "visual_parts": [], "binary_pattern": "66 | 0F | 72 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each 32-bit doubleword element in the XMM register right logically by the count specified in the immediate value. Bits shifted out are discarded, and vacated positions are filled with zeros. No flags are affected. Available in SSE2 and later; operates on 128-bit packed data (four 32-bit elements).", "pseudocode": "for i ← 0 to 3 do\n xmm.dword[i] ← xmm.dword[i] >> imm8\nend for", "example": "PSRLD xmm0, 3" }, { "mnemonic": "psraw", "architecture": "x86", "full_name": "Packed Shift Right Arithmetic Word", "summary": "Shifts words right arithmetic (sign bit).", "syntax": "PSRAW xmm, imm8", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 71 /4", "visual_parts": [], "binary_pattern": "66 | 0F | 71 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each 16-bit word element in the XMM register right arithmetically by the count specified in the immediate value. The sign bit is replicated into vacated positions. No flags are affected. Available in SSE2 and later; operates on 128-bit packed data (eight 16-bit elements).", "pseudocode": "for i ← 0 to 7 do\n sign_bit ← xmm.word[i][15]\n xmm.word[i] ← arithmetic_shift_right(xmm.word[i], imm8)\n if imm8 >= 16 then xmm.word[i] ← sign_bit ? 0xFFFF : 0x0000 end if\nend for", "example": "PSRAW xmm0, 3" }, { "mnemonic": "psrad", "architecture": "x86", "full_name": "Packed Shift Right Arithmetic Doubleword", "summary": "Shifts doublewords right arithmetic.", "syntax": "PSRAD xmm, imm8", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 72 /4", "visual_parts": [], "binary_pattern": "66 | 0F | 72 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each 32-bit doubleword element in the XMM register right arithmetically by the count specified in the immediate value. The sign bit is replicated into vacated positions. No flags are affected. Available in SSE2 and later; operates on 128-bit packed data (four 32-bit elements).", "pseudocode": "for i ← 0 to 3 do\n sign_bit ← xmm.dword[i][31]\n xmm.dword[i] ← arithmetic_shift_right(xmm.dword[i], imm8)\n if imm8 >= 32 then xmm.dword[i] ← sign_bit ? 0xFFFFFFFF : 0x00000000 end if\nend for", "example": "PSRAD xmm0, 3" }, { "mnemonic": "pcmpeqb", "architecture": "x86", "full_name": "Packed Compare Equal Byte", "summary": "Compares bytes for equality (Result mask 0xFF or 0x00).", "syntax": "PCMPEQB xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 74", "visual_parts": [], "binary_pattern": "66 | 0F | 74", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs a packed comparison for equality on 8-bit byte elements. For each byte position, the result is 0xFF if the elements are equal, or 0x00 if they are not equal. No traditional flags (OF, SF, ZF, etc.) are affected; results are stored in the destination register. Available in SSE2 and later; operates on 128-bit vectors (sixteen 8-bit elements).", "pseudocode": "for i ← 0 to 15 do\n if dest.byte[i] == src.byte[i] then\n dest.byte[i] ← 0xFF\n else\n dest.byte[i] ← 0x00\n end if\nend for", "example": "PCMPEQB xmm0, xmm1" }, { "mnemonic": "pcmpeqw", "architecture": "x86", "full_name": "Packed Compare Equal Word", "summary": "Compares words for equality.", "syntax": "PCMPEQW xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 75", "visual_parts": [], "binary_pattern": "66 | 0F | 75", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs a packed comparison for equality on 16-bit word elements. For each word position, the result is 0xFFFF if the elements are equal, or 0x0000 if they are not equal. No traditional flags are affected; results are stored in the destination register. Available in SSE2 and later; operates on 128-bit vectors (eight 16-bit elements).", "pseudocode": "for i ← 0 to 7 do\n if dest.word[i] == src.word[i] then\n dest.word[i] ← 0xFFFF\n else\n dest.word[i] ← 0x0000\n end if\nend for", "example": "PCMPEQW xmm0, xmm1" }, { "mnemonic": "pcmpeqd", "architecture": "x86", "full_name": "Packed Compare Equal Doubleword", "summary": "Compares doublewords for equality.", "syntax": "PCMPEQD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 76", "visual_parts": [], "binary_pattern": "66 | 0F | 76", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Performs a packed comparison for equality on 32-bit doubleword elements. For each doubleword position, the result is 0xFFFFFFFF if the elements are equal, or 0x00000000 if they are not equal. No traditional flags are affected; results are stored in the destination register. Available in SSE2 and later; operates on 128-bit vectors (four 32-bit elements).", "pseudocode": "for i ← 0 to 3 do\n if dest.dword[i] == src.dword[i] then\n dest.dword[i] ← 0xFFFFFFFF\n else\n dest.dword[i] ← 0x00000000\n end if\nend for", "example": "PCMPEQD xmm0, xmm1" }, { "mnemonic": "pshufd", "architecture": "x86", "full_name": "Packed Shuffle Doubleword", "summary": "Shuffles 32-bit integers.", "syntax": "PSHUFD xmm, xmm/m128, imm8", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 70", "visual_parts": [], "binary_pattern": "66 | 0F | 70", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src1", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rearranges the four 32-bit doubleword elements in an XMM register according to the shuffle pattern encoded in the 8-bit immediate operand. Each pair of bits in the immediate selects which source doubleword populates each destination position. No flags are affected. Available in SSE2 and later; operates on 128-bit vectors.", "pseudocode": "temp ← src\nfor i ← 0 to 3 do\n selector ← (imm8 >> (i * 2)) & 0x3\n dest.dword[i] ← temp.dword[selector]\nend for", "example": "PSHUFD xmm0, xmm1, 3" }, { "mnemonic": "cvtsi2ss", "architecture": "x86", "full_name": "Convert Doubleword Integer to Scalar Single-Precision", "summary": "Converts 32-bit int to float.", "syntax": "CVTSI2SS xmm, r/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 2A", "visual_parts": [], "binary_pattern": "F3 | 0F | 2A", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Converts a 32-bit signed integer operand to a scalar single-precision floating-point value and stores the result in the low 32-bit lane of the destination XMM register, leaving the upper 96 bits unchanged. No traditional flags are affected. Available in SSE and later; the conversion follows IEEE 754 rounding rules.", "pseudocode": "src_int ← [src] (sign-extended if r/m32)\nfp_value ← convert_int32_to_float(src_int)\ndest.float32[0] ← fp_value\n// dest.float32[1..3] unchanged", "example": "CVTSI2SS xmm0, ebx" }, { "mnemonic": "cvtsi2sd", "architecture": "x86", "full_name": "Convert Doubleword Integer to Scalar Double-Precision", "summary": "Converts 32-bit int to double.", "syntax": "CVTSI2SD xmm, r/m32", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 2A", "visual_parts": [], "binary_pattern": "F2 | 0F | 2A", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Converts a 32-bit signed integer to a 64-bit double-precision floating-point value and stores the result in the low 64 bits of the destination XMM register, leaving the upper 64 bits unchanged. The conversion uses the current rounding mode from MXCSR. No EFLAGS are affected by this instruction.", "pseudocode": "dest.low64 ← (double)src32;", "example": "CVTSI2SD xmm0, ebx" }, { "mnemonic": "cvttss2si", "architecture": "x86", "full_name": "Convert with Truncation Scalar Single to Integer", "summary": "Converts float to 32-bit int (Truncate).", "syntax": "CVTTSS2SI r32, xmm/m32", "encoding": { "format": "SSE", "hex_opcode": "F3 0F 2C", "visual_parts": [], "binary_pattern": "F3 | 0F | 2C", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "xmm/m32", "desc": "128-bit XMM register or 32-bit memory" } ], "description": "Converts a 32-bit single-precision floating-point value to a 32-bit signed integer using truncation towards zero, regardless of the rounding mode in MXCSR. If a NaN or overflow occurs, the result is INT32_MIN (0x80000000) and no exception is raised by default.", "pseudocode": "dest32 ← (int32)truncate(src32_float); CF ← 0; OF ← 0; SF ← 0; ZF ← 0; AF ← 0; PF ← 0;", "example": "CVTTSS2SI eax, xmm1" }, { "mnemonic": "cvttsd2si", "architecture": "x86", "full_name": "Convert with Truncation Scalar Double to Integer", "summary": "Converts double to 32-bit int (Truncate).", "syntax": "CVTTSD2SI r32, xmm/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 2C", "visual_parts": [], "binary_pattern": "F2 | 0F | 2C", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "xmm/m64", "desc": "128-bit XMM register or 64-bit memory" } ], "description": "Converts a 64-bit double-precision floating-point value to a 32-bit signed integer using truncation towards zero, independent of the MXCSR rounding mode. If a NaN or overflow occurs, the result is INT32_MIN (0x80000000) with no exception raised by default.", "pseudocode": "dest32 ← (int32)truncate(src64_double); CF ← 0; OF ← 0; SF ← 0; ZF ← 0; AF ← 0; PF ← 0;", "example": "CVTTSD2SI eax, xmm1" }, { "mnemonic": "cvtss2sd", "architecture": "x86", "full_name": "Convert Scalar Single to Scalar Double", "summary": "Converts float to double.", "syntax": "CVTSS2SD xmm, xmm/m32", "encoding": { "format": "SSE2", "hex_opcode": "F3 0F 5A", "visual_parts": [], "binary_pattern": "F3 | 0F | 5A", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m32", "desc": "128-bit XMM register or 32-bit memory" } ], "description": "Converts a 32-bit single-precision floating-point value to a 64-bit double-precision floating-point value and stores the result in the low 64 bits of the destination XMM register, preserving the upper 64 bits. The conversion uses the current rounding mode from MXCSR, though single-to-double conversion is typically lossless.", "pseudocode": "dest.low64 ← (double)src32_float;", "example": "CVTSS2SD xmm0, xmm1" }, { "mnemonic": "cvtsd2ss", "architecture": "x86", "full_name": "Convert Scalar Double to Scalar Single", "summary": "Converts double to float.", "syntax": "CVTSD2SS xmm, xmm/m64", "encoding": { "format": "SSE2", "hex_opcode": "F2 0F 5A", "visual_parts": [], "binary_pattern": "F2 | 0F | 5A", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m64", "desc": "128-bit XMM register or 64-bit memory" } ], "description": "Converts a 64-bit double-precision floating-point value to a 32-bit single-precision floating-point value and stores the result in the low 32 bits of the destination XMM register, leaving bits 32-127 unchanged. The conversion uses the current rounding mode from MXCSR and may result in precision loss or denormalized results.", "pseudocode": "dest.low32 ← (float)src64_double;", "example": "CVTSD2SS xmm0, xmm1" }, { "mnemonic": "ucomiss", "architecture": "x86", "full_name": "Unordered Compare Scalar Single-Precision", "summary": "Compares low float and sets EFLAGS.", "syntax": "UCOMISS xmm1, xmm2/m32", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 2E /r", "visual_parts": [], "binary_pattern": "0F | 2E", "bit_positions": "+0 | +1" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m32", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs an unordered comparison of two single-precision floating-point values and sets EFLAGS (ZF, PF, CF) based on the result. If either operand is a signaling NaN, the comparison is treated as unordered; quiet NaNs also produce an unordered result. EFLAGS are set such that ZF=1, PF=1, CF=1 for unordered, ZF=0 for less, ZF=0 CF=1 for greater, and ZF=1 for equal.", "pseudocode": "cmp_result ← unordered_compare(dest.low32_float, src.low32_float); ZF ← (cmp_result == equal); PF ← (cmp_result == unordered); CF ← (cmp_result == less || cmp_result == unordered); AF ← 0; OF ← 0; SF ← 0;", "example": "UCOMISS xmm1, xmm2/m32" }, { "mnemonic": "ucomisd", "architecture": "x86", "full_name": "Unordered Compare Scalar Double-Precision", "summary": "Compares low double and sets EFLAGS.", "syntax": "UCOMISD xmm1, xmm2/m64", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 2E", "visual_parts": [], "binary_pattern": "66 | 0F | 2E", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m64", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs an unordered comparison of two double-precision floating-point values and sets EFLAGS (ZF, PF, CF) based on the result. If either operand is a signaling NaN, the comparison is unordered; quiet NaNs also produce an unordered result. EFLAGS reflect unordered (ZF=PF=CF=1), less, greater, or equal conditions.", "pseudocode": "cmp_result ← unordered_compare(dest.low64_double, src.low64_double); ZF ← (cmp_result == equal); PF ← (cmp_result == unordered); CF ← (cmp_result == less || cmp_result == unordered); AF ← 0; OF ← 0; SF ← 0;", "example": "UCOMISD xmm1, xmm2/m64" }, { "mnemonic": "punpcklbw", "architecture": "x86", "full_name": "Unpack Low Data Bytes", "summary": "Interleaves low bytes from two sources.", "syntax": "PUNPCKLBW xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 60", "visual_parts": [], "binary_pattern": "66 | 0F | 60", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Interleaves the low 64 bits (8 bytes) of the destination and source XMM registers, expanding them to 128 bits with alternating bytes from each source: byte 0 from dest, byte 0 from src, byte 1 from dest, byte 1 from src, and so on. No EFLAGS are affected.", "pseudocode": "for i ← 0 to 7 do dest.byte[2*i] ← dest.byte[i]; dest.byte[2*i+1] ← src.byte[i];", "example": "PUNPCKLBW xmm0, xmm1" }, { "mnemonic": "punpcklwd", "architecture": "x86", "full_name": "Unpack Low Data Words", "summary": "Interleaves low words.", "syntax": "PUNPCKLWD xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 61", "visual_parts": [], "binary_pattern": "66 | 0F | 61", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Interleaves the low 64 bits (4 words) of the destination XMM register with the low 64 bits (4 words) of the source XMM/memory operand, placing results back in the destination. No flags are affected. This SSE2 instruction operates on 128-bit packed word data and is available in 64-bit and protected modes.", "pseudocode": "dest[127:0] = [dest[47:32], src[47:32], dest[31:16], src[31:16], dest[15:0], src[15:0], dest[63:48], src[63:48]]", "example": "PUNPCKLWD xmm0, xmm1" }, { "mnemonic": "punpckldq", "architecture": "x86", "full_name": "Unpack Low Data Doublewords", "summary": "Interleaves low doublewords.", "syntax": "PUNPCKLDQ xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 62", "visual_parts": [], "binary_pattern": "66 | 0F | 62", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Interleaves the low 64 bits (2 doublewords) of the destination XMM register with the low 64 bits (2 doublewords) of the source XMM/memory operand, placing results back in the destination. No flags are affected. This SSE2 instruction operates on 128-bit packed doubleword data and is available in 64-bit and protected modes.", "pseudocode": "dest[127:0] = [dest[31:0], src[31:0], dest[63:32], src[63:32]]", "example": "PUNPCKLDQ xmm0, xmm1" }, { "mnemonic": "punpcklqdq", "architecture": "x86", "full_name": "Unpack Low Data Quadwords", "summary": "Interleaves low quadwords.", "syntax": "PUNPCKLQDQ xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 6C", "visual_parts": [], "binary_pattern": "66 | 0F | 6C", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Interleaves the low 64 bits (1 quadword) of the destination XMM register with the low 64 bits (1 quadword) of the source XMM/memory operand, placing results back in the destination. No flags are affected. This SSE2 instruction operates on 128-bit packed quadword data and is available in 64-bit and protected modes.", "pseudocode": "dest[127:0] = [dest[63:0], src[63:0]]", "example": "PUNPCKLQDQ xmm0, xmm1" }, { "mnemonic": "packsswb", "architecture": "x86", "full_name": "Pack with Signed Saturation Word to Byte", "summary": "Converts words to bytes with saturation.", "syntax": "PACKSSWB xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 63", "visual_parts": [], "binary_pattern": "66 | 0F | 63", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Packs 8 signed word values from the destination and source XMM registers into 16 signed byte values using signed saturation, storing the result in the destination. Values outside the range [-128, 127] are clamped to the boundaries. No flags are affected. This SSE2 instruction is available in 64-bit and protected modes.", "pseudocode": "for i in 0..7:\n dest[8*i+7:8*i] = SaturateSignedWordToByte(dest[16*i+15:16*i])\nfor i in 0..7:\n dest[8*(i+8)+7:8*(i+8)] = SaturateSignedWordToByte(src[16*i+15:16*i])", "example": "PACKSSWB xmm0, xmm1" }, { "mnemonic": "packssdw", "architecture": "x86", "full_name": "Pack with Signed Saturation Doubleword to Word", "summary": "Converts doublewords to words with saturation.", "syntax": "PACKSSDW xmm, xmm/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 6B", "visual_parts": [], "binary_pattern": "66 | 0F | 6B", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm/m128", "desc": "128-bit XMM register or 128-bit memory" } ], "description": "Packs 4 signed doubleword values from the destination and source XMM registers into 8 signed word values using signed saturation, storing the result in the destination. Values outside the range [-32768, 32767] are clamped to the boundaries. No flags are affected. This SSE2 instruction is available in 64-bit and protected modes.", "pseudocode": "for i in 0..3:\n dest[16*i+15:16*i] = SaturateSignedDwordToWord(dest[32*i+31:32*i])\nfor i in 0..3:\n dest[16*(i+4)+15:16*(i+4)] = SaturateSignedDwordToWord(src[32*i+31:32*i])", "example": "PACKSSDW xmm0, xmm1" }, { "mnemonic": "pmovmskb", "architecture": "x86", "full_name": "Move Byte Mask", "summary": "Creates a mask from the MSB of each byte in XMM.", "syntax": "PMOVMSKB r32, xmm", "encoding": { "format": "SSE2", "hex_opcode": "66 0F D7", "visual_parts": [], "binary_pattern": "66 | 0F | D7", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" } ], "description": "Extracts the most significant bit from each of the 16 bytes in the source XMM register and packs them into the low 16 bits of the destination 32-bit register; the upper 16 bits of the destination are zeroed. No flags are affected. This SSE2 instruction is useful for creating byte masks and is available in 64-bit and protected modes.", "pseudocode": "mask = 0\nfor i in 0..15:\n if src[8*i+7] == 1:\n mask |= (1 << i)\ndest[31:0] = mask", "example": "PMOVMSKB eax, xmm0" }, { "mnemonic": "maskmovdqu", "architecture": "x86", "full_name": "Store Selected Bytes of Double Quadword", "summary": "Non-temporal store of selected bytes (masked).", "syntax": "MASKMOVDQU xmm, xmm", "encoding": { "format": "SSE2", "hex_opcode": "66 0F F7", "visual_parts": [], "binary_pattern": "66 | 0F | F7", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE2", "operands": [ { "name": "dest", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" }, { "name": "src", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" } ], "description": "Conditionally stores bytes from the first XMM register to memory at the address in EDI/RDI, using the second XMM register as a write mask (only bytes with MSB set are written). This is a weakly-ordered operation; memory ordering is not guaranteed without explicit serialization. The first operand is the source of data, the second is the mask. No flags are affected. This SSE2 instruction is available in 64-bit and protected modes.", "pseudocode": "address = EDI (32-bit mode) or RDI (64-bit mode)\nfor i in 0..15:\n if src[8*i+7] == 1:\n [address + i] = dest[8*i+7:8*i]", "example": "MASKMOVDQU xmm0, xmm0" }, { "mnemonic": "ldmxcsr", "architecture": "x86", "full_name": "Load MXCSR Register", "summary": "Loads the MXCSR control/status register from memory.", "syntax": "LDMXCSR m32", "encoding": { "format": "SSE", "hex_opcode": "NP 0F AE /2", "visual_parts": [], "binary_pattern": "0F | AE | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "m32", "desc": "32-bit memory operand" } ], "description": "Loads the MXCSR control and status register from a 32-bit memory operand, updating all SSE floating-point rounding modes, exception masks, exception flags, and DAZ/FTZ controls. This instruction serializes the CPU pipeline on many implementations. The instruction is available in 64-bit and protected modes with SSE support.", "pseudocode": "MXCSR ← [m32]", "example": "LDMXCSR [rbp-4]" }, { "mnemonic": "stmxcsr", "architecture": "x86", "full_name": "Store MXCSR Register", "summary": "Stores the MXCSR register to memory.", "syntax": "STMXCSR m32", "encoding": { "format": "SSE", "hex_opcode": "NP 0F AE /3", "visual_parts": [], "binary_pattern": "0F | AE | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "m32", "desc": "32-bit memory operand" } ], "description": "Stores the 32-bit MXCSR control and status register to a 32-bit memory location. This instruction serializes execution and is typically used to save the SSE/SSE2/SSE3 floating-point state. No flags are modified by this instruction.", "pseudocode": "[dest] ← MXCSR;", "example": "STMXCSR [rbp-4]" }, { "mnemonic": "prefetcht0", "architecture": "x86", "full_name": "Prefetch Data into all Cache Levels", "summary": "Prefetches data to L1 cache.", "syntax": "PREFETCHT0 m8", "encoding": { "format": "SSE", "hex_opcode": "0F 18 /1", "visual_parts": [], "binary_pattern": "0F | 18 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "m8", "desc": "8-bit memory operand" } ], "description": "Issues a prefetch hint to load data from the specified memory address into all levels of the cache hierarchy (L1, L2, L3). This is a non-binding hint; the CPU may optimize or ignore it. No flags are modified and no exception is raised for invalid addresses.", "pseudocode": "prefetch_hint(dest, TEMPORAL_ALL_LEVELS);", "example": "PREFETCHT0 [rbp-1]" }, { "mnemonic": "prefetchnta", "architecture": "x86", "full_name": "Prefetch Data using Non-Temporal Access", "summary": "Prefetches data to non-temporal cache structure (minimize pollution).", "syntax": "PREFETCHNTA m8", "encoding": { "format": "SSE", "hex_opcode": "0F 18 /0", "visual_parts": [], "binary_pattern": "0F | 18 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE", "operands": [ { "name": "dest", "type": "m8", "desc": "8-bit memory operand" } ], "description": "Issues a prefetch hint to load data from the specified memory address into the L1 cache using non-temporal access semantics, minimizing cache pollution for data that will not be reused. This is a non-binding hint; execution continues without waiting. No flags are modified.", "pseudocode": "prefetch_hint(dest, NON_TEMPORAL);", "example": "PREFETCHNTA [rbp-1]" }, { "mnemonic": "vfmadd132ps", "architecture": "x86", "full_name": "Fused Multiply-Add (132) Packed Single", "summary": "Computes (Dest * Src2) + Src1.", "syntax": "VFMADD132PS ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 98 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "FMA3", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Fused multiply-add on four packed single-precision floats: computes (dest × src2) + src1 with a single rounding operation, reducing latency and improving accuracy compared to separate multiply and add. Requires FMA3 extension (Intel Haswell+, AMD Piledriver+). Floating-point exceptions may be raised per IEEE 754; no integer flags are modified.", "pseudocode": "dest ← (dest * src2) + src1; // single rounding, 256-bit YMM", "example": "VFMADD132PS ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vfmadd213ps", "architecture": "x86", "full_name": "Fused Multiply-Add (213) Packed Single", "summary": "Computes (Src1 * Dest) + Src2.", "syntax": "VFMADD213PS ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 A8 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "FMA3", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Fused multiply-add on four packed single-precision floats: computes (src1 × dest) + src2 with a single rounding operation. The operand order differs from vfmadd132ps. Requires FMA3 extension. Floating-point exceptions may be raised per IEEE 754; no integer flags are modified.", "pseudocode": "dest ← (src1 * dest) + src2; // single rounding, 256-bit YMM", "example": "VFMADD213PS ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vfmsub132ps", "architecture": "x86", "full_name": "Fused Multiply-Subtract (132) Packed Single", "summary": "Computes (Dest * Src2) - Src1.", "syntax": "VFMSUB132PS ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 9A /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "FMA3", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Fused multiply-subtract on four packed single-precision floats: computes (dest × src2) - src1 with a single rounding operation. Requires FMA3 extension. Floating-point exceptions may be raised per IEEE 754; no integer flags are modified.", "pseudocode": "dest ← (dest * src2) - src1; // single rounding, 256-bit YMM", "example": "VFMSUB132PS ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vfnmadd132ps", "architecture": "x86", "full_name": "Fused Negative Multiply-Add (132) Packed Single", "summary": "Computes -(Dest * Src2) + Src1.", "syntax": "VFNMADD132PS ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 9C /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "FMA3", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Fused negative multiply-add on four packed single-precision floats: computes -(dest × src2) + src1 with a single rounding operation, negating the product before the addition. Requires FMA3 extension. Floating-point exceptions may be raised per IEEE 754; no integer flags are modified.", "pseudocode": "dest ← -(dest * src2) + src1; // single rounding, 256-bit YMM", "example": "VFNMADD132PS ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vpaddd", "architecture": "x86", "full_name": "Packed Add Doubleword (AVX2)", "summary": "Adds 8 integers (256-bit).", "syntax": "VPADDD ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F.WIG FE /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Adds eight packed 32-bit signed/unsigned integers from two 256-bit YMM registers or memory, storing the result in the destination. Integer overflow wraps around; no overflow flag is set. Requires AVX2 extension (Intel Haswell+, AMD Excavator+). No flags are modified.", "pseudocode": "for i = 0 to 7:\n dest[32*i+31:32*i] ← dest[32*i+31:32*i] + src2[32*i+31:32*i];", "example": "VPADDD ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vpaddb", "architecture": "x86", "full_name": "Packed Add Byte (AVX2)", "summary": "Adds 32 bytes (256-bit).", "syntax": "VPADDB ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F.WIG FC /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Adds packed byte integers element-wise across two 256-bit YMM registers (or one YMM and one memory operand), producing 32 sums in the destination. No arithmetic flags are affected; wrapping occurs on overflow. This is a non-destructive three-operand instruction (VEX encoding allows the first source to remain unchanged).", "pseudocode": "for i = 0 to 31:\n dest[i*8 + 7 : i*8] ← src1[i*8 + 7 : i*8] + src2[i*8 + 7 : i*8]", "example": "VPADDB ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vpsubd", "architecture": "x86", "full_name": "Packed Subtract Doubleword (AVX2)", "summary": "Subtracts 8 integers (256-bit).", "syntax": "VPSUBD ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F.WIG FA /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Subtracts packed doubleword (32-bit) integers element-wise from two 256-bit YMM registers (or one YMM and one memory operand), producing 8 differences in the destination. No arithmetic flags are affected; wrapping occurs on underflow. This is a non-destructive three-operand instruction (VEX encoding).", "pseudocode": "for i = 0 to 7:\n dest[i*32 + 31 : i*32] ← src1[i*32 + 31 : i*32] - src2[i*32 + 31 : i*32]", "example": "VPSUBD ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vpmulld", "architecture": "x86", "full_name": "Packed Multiply Low Doubleword (AVX2)", "summary": "Multiplies 8 integers (256-bit).", "syntax": "VPMULLD ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.WIG 40 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Multiplies packed doubleword (32-bit) integers element-wise across two 256-bit YMM registers (or one YMM and one memory operand), producing 8 low 32-bit products in the destination. No arithmetic flags are affected; the high 32 bits of each product are discarded. This is a non-destructive three-operand instruction (VEX encoding requires AVX2).", "pseudocode": "for i = 0 to 7:\n temp_product ← src1[i*32 + 31 : i*32] * src2[i*32 + 31 : i*32]\n dest[i*32 + 31 : i*32] ← temp_product[31 : 0]", "example": "VPMULLD ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vpshufb", "architecture": "x86", "full_name": "Packed Shuffle Bytes (AVX2)", "summary": "Shuffles 32 bytes based on indices.", "syntax": "VPSHUFB ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.WIG 00 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Shuffles 32 bytes within 256-bit YMM register using per-byte indices from another YMM register or memory; the operation works within 128-bit lanes (bytes 0-15 and 16-31 are shuffled independently). If the index's high bit (bit 7) is set, the result byte is zeroed; otherwise the low 4 bits select which source byte to copy within the lane. No arithmetic flags are affected.", "pseudocode": "for i = 0 to 1:\n for j = 0 to 15:\n idx_byte = src2[(i*16 + j)*8 + 7 : (i*16 + j)*8]\n if idx_byte[7] == 1:\n dest[(i*16 + j)*8 + 7 : (i*16 + j)*8] ← 0\n else:\n byte_offset = (i*16) + (idx_byte[3:0])\n dest[(i*16 + j)*8 + 7 : (i*16 + j)*8] ← src1[byte_offset*8 + 7 : byte_offset*8]", "example": "VPSHUFB ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vperm2i128", "architecture": "x86", "full_name": "Permute 128-bit Integer Blocks", "summary": "Shuffles two 128-bit lanes between registers.", "syntax": "VPERM2I128 ymm1, ymm2, ymm3/m256, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F3A.W0 46 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Permutes two 128-bit lanes from two 256-bit YMM registers based on an 8-bit immediate control value. The low nibble selects which 128-bit lane to take from src1, and the high nibble selects from src2; a lane can be zeroed by setting its selector to 0x8. The result fills the destination's two 128-bit halves independently. No arithmetic flags are affected.", "pseudocode": "ctrl_low = src3[3:0]\nctrl_high = src3[7:4]\nif ctrl_low == 0x8:\n dest[127:0] ← 0\nelse:\n dest[127:0] ← src1[127:0] if (ctrl_low & 0x4) == 0 else src1[255:128]\nif ctrl_high == 0x8:\n dest[255:128] ← 0\nelse:\n dest[255:128] ← src2[127:0] if (ctrl_high & 0x4) == 0 else src2[255:128]", "example": "VPERM2I128 ymm1, ymm2, ymm3/m256, 3" }, { "mnemonic": "vpermd", "architecture": "x86", "full_name": "Permute Doublewords", "summary": "Full permutation of 8 integers using indices from a register.", "syntax": "VPERMD ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 36 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Performs a full permutation of 8 doublewords (32-bit integers) within a 256-bit YMM register using per-element indices from another YMM register or memory. The low 3 bits of each index select which of the 8 source doublewords to place at that position; if bit 31 is set in the index, the result element is zeroed. No arithmetic flags are affected.", "pseudocode": "for i = 0 to 7:\n idx = src1[i*32 + 31 : i*32]\n if idx[31] == 1:\n dest[i*32 + 31 : i*32] ← 0\n else:\n src_idx = idx[2:0]\n dest[i*32 + 31 : i*32] ← src2[src_idx*32 + 31 : src_idx*32]", "example": "VPERMD ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vpermps", "architecture": "x86", "full_name": "Permute Single-Precision Floating-Point", "summary": "Full permutation of 8 floats using indices.", "syntax": "VPERMPS ymm1, ymm2, ymm3/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 16 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "ymm3/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Performs a full permutation of 8 single-precision floating-point values within a 256-bit YMM register using per-element indices from another YMM register or memory. The low 3 bits of each index select which of the 8 source floats to place at that position; if bit 31 is set in the index, the result element is zeroed. No arithmetic flags are affected.", "pseudocode": "for i = 0 to 7:\n idx = src1[i*32 + 31 : i*32]\n if idx[31] == 1:\n dest[i*32 + 31 : i*32] ← 0\n else:\n src_idx = idx[2:0]\n dest[i*32 + 31 : i*32] ← src2[src_idx*32 + 31 : src_idx*32]", "example": "VPERMPS ymm1, ymm2, ymm3/m256" }, { "mnemonic": "vpbroadcastb", "architecture": "x86", "full_name": "Broadcast Byte", "summary": "Broadcasts a byte from memory/register to all elements of YMM.", "syntax": "VPBROADCASTB ymm1, xmm2/m8", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 78 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src", "type": "xmm2/m8", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Broadcasts a single byte from an XMM register or memory location to all 32 byte positions in a 256-bit YMM destination register. The source byte is replicated 32 times, filling the entire YMM with the same byte value. No arithmetic flags are affected.", "pseudocode": "src_byte = src[7:0]\nfor i = 0 to 31:\n dest[i*8 + 7 : i*8] ← src_byte", "example": "VPBROADCASTB ymm1, xmm2/m8" }, { "mnemonic": "vgatherdps", "architecture": "x86", "full_name": "Gather Packed Single Precision", "summary": "Loads floats from non-contiguous memory using indices.", "syntax": "VGATHERDPS ymm1, [base+ymm_idx*scale], ymm_mask", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 92 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "[base+ymm_idx*scale]", "desc": "AVX scatter: base register + scaled YMM vector index" }, { "name": "src2", "type": "ymm_mask", "desc": "YMM register acting as gather/scatter mask and result destination" } ], "description": "Gathers four single-precision floating-point values from non-contiguous memory locations using a base address and a YMM vector of 32-bit indices with optional scaling, storing results in the destination YMM register. The mask register controls which elements are loaded (set bits indicate active gather); masked-out elements are zeroed. Sets ZF if all mask bits are zero, clears CF and OF; other flags undefined.", "pseudocode": "for i = 0 to 3:\n if mask[i*32 : i*32+31] != 0:\n addr = base + (index_ymm[i*32 : i*32+31] * scale)\n dest_ymm[i*32 : i*32+31] = [addr]\n mask[i*32 : i*32+31] = 0\n else:\n dest_ymm[i*32 : i*32+31] = 0\nZF = (mask == 0)\nCF = 0\nOF = 0", "example": "VGATHERDPS ymm1, [base+ymm_idx*scale], ymm_mask" }, { "mnemonic": "vgatherdpd", "architecture": "x86", "full_name": "Gather Packed Double Precision", "summary": "Loads doubles from non-contiguous memory using indices.", "syntax": "VGATHERDPD ymm1, [base+xmm_idx*scale], ymm_mask", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W1 92 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "[base+xmm_idx*scale]", "desc": "AVX gather: base register + scaled XMM vector index" }, { "name": "src2", "type": "ymm_mask", "desc": "YMM register acting as gather/scatter mask and result destination" } ], "description": "Gathers two double-precision floating-point values from non-contiguous memory locations using a base address and an XMM vector of 32-bit indices with optional scaling, storing results in the destination YMM register. The mask register (YMM) controls which of the two elements are loaded; masked-out elements are zeroed. Sets ZF if all mask bits are zero, clears CF and OF; other flags undefined.", "pseudocode": "for i = 0 to 1:\n if mask[i*64 : i*64+63] != 0:\n addr = base + (index_xmm[i*32 : i*32+31] * scale)\n dest_ymm[i*64 : i*64+63] = [addr]\n mask[i*64 : i*64+63] = 0\n else:\n dest_ymm[i*64 : i*64+63] = 0\nZF = (mask == 0)\nCF = 0\nOF = 0", "example": "VGATHERDPD ymm1, [base+xmm_idx*scale], ymm_mask" }, { "mnemonic": "andn", "architecture": "x86", "full_name": "Logical AND NOT", "summary": "Calculates (NOT src1) AND src2. Non-destructive.", "syntax": "ANDN r32, r32, r/m32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.0F38.W0 F2 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI1", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src1", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src2", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Performs bitwise AND of the logical NOT of src1 with src2, storing the result in dest without modifying src1. ZF is set if result is zero; CF and OF are cleared; AF and PF are undefined. Available in 32-bit and 64-bit operand sizes; requires BMI1 extension.", "pseudocode": "dest ← (~src1) & src2\nZF ← (dest == 0)\nCF ← 0\nOF ← 0\nAF ← undefined\nPF ← undefined", "example": "ANDN eax, eax, ebx" }, { "mnemonic": "bextr", "architecture": "x86", "full_name": "Bit Field Extract", "summary": "Extracts sequence of bits from source using index/length.", "syntax": "BEXTR r32, r/m32, r32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.0F38.W0 F7 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI1", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src1", "type": "r/m32", "desc": "32-bit register or memory" }, { "name": "src2", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Extracts a contiguous sequence of bits from src1 specified by the start position and length encoded in src2 (bits 7:0 = start, bits 15:8 = length), storing the extracted bits in dest. ZF is set if the result is zero; CF and OF are cleared; AF and PF are undefined. Available in 32-bit and 64-bit sizes; requires BMI1 extension.", "pseudocode": "start ← src2[0:7]\nlength ← src2[8:15]\nif length == 0:\n dest ← 0\nelse if (start + length) > 32:\n dest ← 0\nelse:\n dest ← (src1 >> start) & ((1 << length) - 1)\nZF ← (dest == 0)\nCF ← 0\nOF ← 0\nAF ← undefined\nPF ← undefined", "example": "BEXTR eax, ebx, eax" }, { "mnemonic": "blsi", "architecture": "x86", "full_name": "Extract Lowest Set Isolated Bit", "summary": "Extracts the lowest set bit (x & -x).", "syntax": "BLSI r32, r/m32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.0F38.W0 F3 /3", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI1", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Extracts the lowest set bit from src by computing (src & -src), storing the result in dest. ZF is set if src is zero; CF is set if src is zero; OF is cleared; AF and PF are undefined. Available in 32-bit and 64-bit sizes; requires BMI1 extension.", "pseudocode": "dest ← src & (-src)\nZF ← (src == 0)\nCF ← (src == 0)\nOF ← 0\nAF ← undefined\nPF ← undefined", "example": "BLSI eax, ebx" }, { "mnemonic": "blsmsk", "architecture": "x86", "full_name": "Get Mask Up to Lowest Set Bit", "summary": "Creates mask up to lowest set bit (x ^ (x-1)).", "syntax": "BLSMSK r32, r/m32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.0F38.W0 F3 /2", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI1", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Creates a mask of all bits set from bit 0 up to and including the lowest set bit in src by computing (src ^ (src - 1)), storing the result in dest. ZF is set if src is zero; CF is set if src is zero; OF is cleared; AF and PF are undefined. Available in 32-bit and 64-bit sizes; requires BMI1 extension.", "pseudocode": "dest ← src ^ (src - 1)\nZF ← (src == 0)\nCF ← (src == 0)\nOF ← 0\nAF ← undefined\nPF ← undefined", "example": "BLSMSK eax, ebx" }, { "mnemonic": "blsr", "architecture": "x86", "full_name": "Reset Lowest Set Bit", "summary": "Clears the lowest set bit (x & (x-1)).", "syntax": "BLSR r32, r/m32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.0F38.W0 F3 /1", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI1", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Clears the lowest set bit in src by computing (src & (src - 1)), storing the result in dest. ZF is set if the result is zero; CF is set if src is zero; OF is cleared; AF and PF are undefined. Available in 32-bit and 64-bit sizes; requires BMI1 extension.", "pseudocode": "dest ← src & (src - 1)\nZF ← (dest == 0)\nCF ← (src == 0)\nOF ← 0\nAF ← undefined\nPF ← undefined", "example": "BLSR eax, ebx" }, { "mnemonic": "tzcnt", "architecture": "x86", "full_name": "Count Trailing Zeros", "summary": "Counts the number of trailing zeros.", "syntax": "TZCNT r32, r/m32", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F BC", "visual_parts": [], "binary_pattern": "F3 | 0F | BC", "bit_positions": "+0 | +1 | +2" }, "extension": "BMI1", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Counts the number of trailing zero bits in src, storing the count in dest. If src is zero, dest is set to the operand size (32 for r/m32); ZF is set if src is zero; CF is cleared; other flags undefined. Available in 32-bit and 64-bit operand sizes; BMI1 extension provides faster behavior than BSF.", "pseudocode": "if src == 0:\n dest ← 32\n ZF ← 1\nelse:\n count ← 0\n while (src & 1) == 0:\n count ← count + 1\n src ← src >> 1\n dest ← count\n ZF ← 0\nCF ← 0", "example": "TZCNT eax, ebx" }, { "mnemonic": "bzhi", "architecture": "x86", "full_name": "Zero High Bits Starting with Specified Bit Position", "summary": "Clears high bits starting at index.", "syntax": "BZHI r32, r/m32, r32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.0F38.W0 F5 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src1", "type": "r/m32", "desc": "32-bit register or memory" }, { "name": "src2", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Zero High Bits Starting with Specified Bit Position clears all bits in the source operand at positions greater than or equal to the bit index specified in the third operand, storing the result in the destination. No flags are modified. Supported in 32-bit and 64-bit modes with BMI2 extension; the operand size can be 32 or 64 bits.", "pseudocode": "count ← src2[7:0] & 0x3F; mask ← (1 << count) - 1; dest ← src1 & mask;", "example": "BZHI eax, ebx, eax" }, { "mnemonic": "pext", "architecture": "x86", "full_name": "Parallel Bits Extract", "summary": "Extracts bits from source using mask and packs them to LSB.", "syntax": "PEXT r32, r32, r/m32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.F3.0F38.W0 F5 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src1", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src2", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Parallel Bits Extract copies bits from the first source operand to the destination at positions where the mask operand has set bits, compacting them toward the LSB. No flags are modified. Supported in 32-bit and 64-bit modes with BMI2 extension; operand size can be 32 or 64 bits.", "pseudocode": "result ← 0; dest_bit ← 0; for (i = 0; i < operand_size; i++) { if (src2[i]) { result[dest_bit] ← src1[i]; dest_bit += 1; } } dest ← result;", "example": "PEXT eax, eax, ebx" }, { "mnemonic": "pdep", "architecture": "x86", "full_name": "Parallel Bits Deposit", "summary": "Scatters bits from LSB of source to positions marked in mask.", "syntax": "PDEP r32, r32, r/m32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.F2.0F38.W0 F5 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src1", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src2", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Parallel Bits Deposit scatters bits from the LSB of the first source operand to positions marked by set bits in the mask operand, storing the result in the destination. No flags are modified. Supported in 32-bit and 64-bit modes with BMI2 extension; operand size can be 32 or 64 bits.", "pseudocode": "result ← 0; src_bit ← 0; for (i = 0; i < operand_size; i++) { if (src2[i]) { result[i] ← src1[src_bit]; src_bit += 1; } } dest ← result;", "example": "PDEP eax, eax, ebx" }, { "mnemonic": "mulx", "architecture": "x86", "full_name": "Unsigned Multiply Without Affecting Flags", "summary": "Unsigned multiply of RDX * Src. Result in Hi:Lo. No flags.", "syntax": "MULX r32, r32, r/m32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.F2.0F38.W0 F6 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src1", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src2", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Unsigned Multiply Without Affecting Flags multiplies the implicit RDX register by the source operand and stores the 128-bit product in two destination registers (high part in the first operand, low part in the second), without modifying any arithmetic flags. Supported in 32-bit and 64-bit modes with BMI2 extension; the operand size can be 32 or 64 bits.", "pseudocode": "product ← RDX * src; dest_hi ← product[127:64]; dest_lo ← product[63:0];", "example": "MULX eax, eax, ebx" }, { "mnemonic": "shlx", "architecture": "x86", "full_name": "Shift Logical Left Without Affecting Flags", "summary": "Logical left shift, count in register. No flags update.", "syntax": "SHLX r32, r/m32, r32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.66.0F38.W0 F7 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src1", "type": "r/m32", "desc": "32-bit register or memory" }, { "name": "src2", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Shift Logical Left Without Affecting Flags performs a left shift of the source operand by a count held in a register, storing the result in the destination, without modifying any arithmetic flags. Supported in 32-bit and 64-bit modes with BMI2 extension; operand size can be 32 or 64 bits.", "pseudocode": "count ← src2 & ((operand_size == 64) ? 0x3F : 0x1F); dest ← src1 << count;", "example": "SHLX eax, ebx, eax" }, { "mnemonic": "shrx", "architecture": "x86", "full_name": "Shift Logical Right Without Affecting Flags", "summary": "Logical right shift, count in register. No flags update.", "syntax": "SHRX r32, r/m32, r32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.F2.0F38.W0 F7 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src1", "type": "r/m32", "desc": "32-bit register or memory" }, { "name": "src2", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Shift Logical Right Without Affecting Flags performs a logical right shift of the source operand by a count held in a register, storing the result in the destination, without modifying any arithmetic flags. Supported in 32-bit and 64-bit modes with BMI2 extension; operand size can be 32 or 64 bits.", "pseudocode": "count ← src2 & ((operand_size == 64) ? 0x3F : 0x1F); dest ← src1 >> count;", "example": "SHRX eax, ebx, eax" }, { "mnemonic": "sarx", "architecture": "x86", "full_name": "Shift Arithmetic Right Without Affecting Flags", "summary": "Arithmetic right shift, count in register. No flags update.", "syntax": "SARX r32, r/m32, r32", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.F3.0F38.W0 F7 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src1", "type": "r/m32", "desc": "32-bit register or memory" }, { "name": "src2", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Shift Arithmetic Right Without Affecting Flags performs an arithmetic right shift of the source operand by a count held in a register, storing the result in the destination, without modifying any arithmetic flags. Supported in 32-bit and 64-bit modes with BMI2 extension; operand size can be 32 or 64 bits; the sign bit is extended into vacated positions.", "pseudocode": "count ← src2 & ((operand_size == 64) ? 0x3F : 0x1F); dest ← (signed)src1 >> count;", "example": "SARX eax, ebx, eax" }, { "mnemonic": "rorx", "architecture": "x86", "full_name": "Rotate Right Logical Without Affecting Flags", "summary": "Rotate right with immediate. No flags update.", "syntax": "RORX r32, r/m32, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.LZ.F2.0F3A.W0 F0 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "BMI2", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src1", "type": "r/m32", "desc": "32-bit register or memory" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rotate Right Logical Without Affecting Flags rotates the source operand right by an immediate count, storing the result in the destination, without modifying any arithmetic flags. Supported in 32-bit and 64-bit modes with BMI2 extension; operand size can be 32 or 64 bits.", "pseudocode": "count ← src2 & ((operand_size == 64) ? 0x3F : 0x1F); dest ← (src1 >> count) | (src1 << (operand_size - count));", "example": "RORX eax, ebx, 3" }, { "mnemonic": "rdrand", "architecture": "x86", "full_name": "Read Random Number", "summary": "Retrieves a hardware-generated random number.", "syntax": "RDRAND r32", "encoding": { "format": "Legacy", "hex_opcode": "NFx 0F C7 /6", "visual_parts": [], "binary_pattern": "0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "RDRAND", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Retrieves a cryptographically secure random number from the CPU's hardware random number generator and stores it in the destination register. The CF flag is set to 1 if a random number was successfully generated within the timeout period, or cleared to 0 if the generator failed to produce a value. No other flags are affected. This instruction is available only on processors with the RDRAND extension and cannot be used in real mode.", "pseudocode": "temp ← hardware_RNG();\nif (RNG_success) {\n dest ← temp;\n CF ← 1;\n} else {\n CF ← 0;\n}", "example": "RDRAND eax" }, { "mnemonic": "rdseed", "architecture": "x86", "full_name": "Read Random Seed", "summary": "Retrieves a random seed from hardware entropy source.", "syntax": "RDSEED r32", "encoding": { "format": "Legacy", "hex_opcode": "NFx 0F C7 /7", "visual_parts": [], "binary_pattern": "0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "RDSEED", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Retrieves an entropy seed value from the CPU's hardware entropy source and stores it in the destination register. The CF flag is set to 1 if the seed was successfully obtained within the timeout period, or cleared to 0 on failure. No other flags are affected. This instruction requires the RDSEED extension and operates in protected and 64-bit modes only.", "pseudocode": "temp ← hardware_entropy_source();\nif (entropy_success) {\n dest ← temp;\n CF ← 1;\n} else {\n CF ← 0;\n}", "example": "RDSEED eax" }, { "mnemonic": "invpcid", "architecture": "x86", "full_name": "Invalidate Process-Context Identifier", "summary": "Invalidates TLB entries based on PCID.", "syntax": "INVPCID r32, m128", "encoding": { "format": "Legacy", "hex_opcode": "66 0F 38 82", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 82", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "INVPCID", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Invalidates TLB entries based on the PCID (Process-Context Identifier) specified in the 128-bit memory operand, with the invalidation type determined by the descriptor type field. The source register provides an address (typically a general register holding PCID context information), and the memory operand contains the full 128-bit invalidation descriptor. This is a privileged instruction (CPL 0 only) that serializes the pipeline and requires the INVPCID extension. No flags are affected.", "pseudocode": "descriptor ← [src + 0:127];\ninvalidation_type ← descriptor.type;\npcid ← descriptor.pcid;\nswitch(invalidation_type) {\n case 0: invalidate_tlb_entry_by_pcid(pcid); break;\n case 1: invalidate_all_tlb_entries_by_pcid(pcid); break;\n case 2: invalidate_all_tlb_entries(); break;\n case 3: invalidate_all_tlb_entries_except_global(); break;\n}\npipeline_serialization();", "example": "INVPCID eax, [rbp-16]" }, { "mnemonic": "adcx", "architecture": "x86", "full_name": "Unsigned Integer Addition of Two Operands with Carry Flag", "summary": "Adds with Carry Flag (distinct from ADC, affects CF only).", "syntax": "ADCX r32, r/m32", "encoding": { "format": "Legacy", "hex_opcode": "66 0F 38 F6", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | F6", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "ADX", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Adds the source operand and the Carry Flag (CF) to the destination operand, storing the result in the destination. Only the CF flag is modified (set to 1 if unsigned overflow occurs, cleared to 0 otherwise); OF, SF, ZF, AF, and PF are left unchanged. This instruction is distinct from ADC in that it does not affect other flags, making it useful for parallel carry-chain operations with ADOX. Available in 32-bit and 64-bit operand sizes with the ADX extension.", "pseudocode": "temp ← dest + src + CF;\nCF ← (temp > 0xFFFFFFFF) ? 1 : 0;\ndest ← temp & 0xFFFFFFFF;", "example": "ADCX eax, ebx" }, { "mnemonic": "adox", "architecture": "x86", "full_name": "Unsigned Integer Addition of Two Operands with Overflow Flag", "summary": "Adds with Overflow Flag (Parallel addition with ADCX).", "syntax": "ADOX r32, r/m32", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 F6", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | F6", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "ADX", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Adds the source operand and the Overflow Flag (OF) to the destination operand, storing the result in the destination. Only the OF flag is modified (set to 1 if signed overflow occurs, cleared to 0 otherwise); CF, SF, ZF, AF, and PF are left unchanged. This instruction is designed to execute in parallel with ADCX for independent carry and overflow chains in multi-precision arithmetic. Available in 32-bit and 64-bit operand sizes with the ADX extension.", "pseudocode": "temp ← dest + src + OF;\nOF ← (signed_overflow(dest, src, temp)) ? 1 : 0;\ndest ← temp & 0xFFFFFFFF;", "example": "ADOX eax, ebx" }, { "mnemonic": "vinserti128", "architecture": "x86", "full_name": "Insert Integer 128-bit", "summary": "Inserts 128-bits of integer data into a YMM register.", "syntax": "VINSERTI128 ymm1, ymm2, xmm3/m128, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F3A.W0 38 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "xmm3/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Inserts a 128-bit integer value from the source operand into the destination YMM register at the position specified by the immediate operand. The lower 128 bits of the source YMM register (src1) are preserved or replaced depending on the immediate; typically imm8[0]=0 replaces the lower 128 bits, and imm8[0]=1 replaces the upper 128 bits. No flags are affected. This is a VEX-encoded AVX2 instruction that supports 32-bit or 64-bit vector elements.", "pseudocode": "if (imm8[0] == 0) {\n dest[127:0] ← src2[127:0];\n dest[255:128] ← src1[255:128];\n} else {\n dest[127:0] ← src1[127:0];\n dest[255:128] ← src2[127:0];\n}", "example": "VINSERTI128 ymm1, ymm2, xmm3/m128, 3" }, { "mnemonic": "vextracti128", "architecture": "x86", "full_name": "Extract Integer 128-bit", "summary": "Extracts 128-bits of integer data from YMM.", "syntax": "VEXTRACTI128 xmm1/m128, ymm2, imm8", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F3A.W0 39 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX2", "operands": [ { "name": "dest", "type": "xmm1/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src1", "type": "ymm2", "desc": "256-bit YMM AVX register" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Extracts a 128-bit integer value from the source YMM register and stores it in the destination XMM register or memory location. The specific 128-bit lane extracted is determined by the immediate operand (imm8[0]=0 for lower 128 bits, imm8[0]=1 for upper 128 bits). No flags are affected. This is a VEX-encoded AVX2 instruction that complements VINSERTI128 for manipulating 256-bit vectors.", "pseudocode": "if (imm8[0] == 0) {\n dest ← src1[127:0];\n} else {\n dest ← src1[255:128];\n}", "example": "VEXTRACTI128 xmm1/m128, ymm2, 3" }, { "mnemonic": "clac", "architecture": "x86", "full_name": "Clear AC Flag in EFLAGS", "summary": "Clears Alignment Check flag (SMAP prevention).", "syntax": "CLAC", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 CA", "visual_parts": [], "binary_pattern": "0F | 01 | CA", "bit_positions": "+0 | +1 | +2" }, "extension": "SMAP", "operands": [], "description": "Clears the Alignment Check (AC) flag in EFLAGS, disabling alignment checking for user-mode code. When combined with SMAP (Supervisor Mode Access Prevention), this instruction allows the kernel to temporarily disable SMAP protections. This is a privileged instruction (CPL 0 only) available with the SMAP extension. No other flags are affected.", "pseudocode": "EFLAGS.AC ← 0;", "example": "CLAC" }, { "mnemonic": "stac", "architecture": "x86", "full_name": "Set AC Flag in EFLAGS", "summary": "Sets Alignment Check flag (Allow user memory access).", "syntax": "STAC", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 CB", "visual_parts": [], "binary_pattern": "0F | 01 | CB", "bit_positions": "+0 | +1 | +2" }, "extension": "SMAP", "operands": [], "description": "Sets the Alignment Check (AC) flag in EFLAGS, enabling alignment checking and allowing user-mode access to supervisor-mode data structures when SMAP protection is present. This instruction requires SMAP support and ring 0 privilege. Only the AC flag is modified; all other flags remain unchanged.", "pseudocode": "EFLAGS.AC ← 1;", "example": "STAC" }, { "mnemonic": "gf2p8affineqb", "architecture": "x86", "full_name": "Galois Field Affine Transformation", "summary": "Computes affine transformation in GF(2^8).", "syntax": "GF2P8AFFINEQB xmm1, xmm2/m128, imm8", "encoding": { "format": "VEX", "hex_opcode": "66 0F 3A CE /r ib", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | CE", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "GFNI", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs byte-wise affine transformation in Galois Field GF(2^8) on 128-bit XMM operands using a constant 8-bit immediate as the affine constant. Each byte in the destination is transformed using the corresponding byte from the source operand. No flags are affected; this is a pure data-parallel cryptographic operation.", "pseudocode": "for i in 0..15:\n dest[i] ← GF2P8_AFFINE_TRANSFORM(dest[i], src[i], imm8);", "example": "GF2P8AFFINEQB xmm1, xmm2/m128, 3" }, { "mnemonic": "gf2p8mulb", "architecture": "x86", "full_name": "Galois Field Multiply Bytes", "summary": "Multiplies bytes in GF(2^8).", "syntax": "GF2P8MULB xmm1, xmm2/m128", "encoding": { "format": "VEX", "hex_opcode": "66 0F 38 CF /r", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | CF", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "GFNI", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Multiplies each byte in the destination XMM register by the corresponding byte in the source operand within Galois Field GF(2^8). The result replaces the destination operand byte-wise. No flags are affected; this is a pure cryptographic SIMD operation with full latency parallelism.", "pseudocode": "for i in 0..15:\n dest[i] ← GF2P8_MULTIPLY(dest[i], src[i]);", "example": "GF2P8MULB xmm1, xmm2/m128" }, { "mnemonic": "sha1msg1", "architecture": "x86", "full_name": "SHA1 Message Schedule 1", "summary": "Performs intermediate calculation for SHA1 message schedule.", "syntax": "SHA1MSG1 xmm1, xmm2/m128", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 38 C9 /r", "visual_parts": [], "binary_pattern": "0F | 38 | C9", "bit_positions": "+0 | +1 | +2" }, "extension": "SHA", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs the first intermediate step of SHA-1 message schedule expansion on 128-bit XMM operands, computing partial W values (message words) for rounds 16-19. The destination is updated with results of the schedule computation; no flags are affected.", "pseudocode": "W[0..3] ← dest[0..3];\nW[4..7] ← src[0..3];\nfor i in 0..3:\n dest[i] ← W[i] ⊕ W[i+2] ⊕ W[i+8] ⊕ W[i+13];", "example": "SHA1MSG1 xmm1, xmm2/m128" }, { "mnemonic": "sha1msg2", "architecture": "x86", "full_name": "SHA1 Message Schedule 2", "summary": "Performs final calculation for SHA1 message schedule.", "syntax": "SHA1MSG2 xmm1, xmm2/m128", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 38 CA /r", "visual_parts": [], "binary_pattern": "0F | 38 | CA", "bit_positions": "+0 | +1 | +2" }, "extension": "SHA", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs the second final step of SHA-1 message schedule expansion on 128-bit XMM operands, completing W value computation and applying left rotation. The destination is updated with final message schedule results; no flags are affected.", "pseudocode": "W[0..3] ← dest[0..3];\nW[4..7] ← src[0..3];\nfor i in 0..3:\n W[i] ← W[i] ⊕ W[i+4] ⊕ W[i+5] ⊕ W[i+6];\n dest[i] ← ROTL32(W[i], 1);", "example": "SHA1MSG2 xmm1, xmm2/m128" }, { "mnemonic": "sha1nexte", "architecture": "x86", "full_name": "SHA1 State Variable E", "summary": "Calculates SHA1 state variable E.", "syntax": "SHA1NEXTE xmm1, xmm2/m128", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 38 C8 /r", "visual_parts": [], "binary_pattern": "0F | 38 | C8", "bit_positions": "+0 | +1 | +2" }, "extension": "SHA", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Calculates intermediate SHA-1 state variable E for one round, adding the source operand (containing message schedule and round constants) to the destination operand and applying left rotation. The result updates the destination with the next E value; no flags are affected.", "pseudocode": "E ← dest[0];\nW ← src[0];\ndest[0] ← ROTL32(E, 5) + W;\ndest[1..3] ← dest[1..3] rotated left by 30 bits from the previous round state;", "example": "SHA1NEXTE xmm1, xmm2/m128" }, { "mnemonic": "sha1rnds4", "architecture": "x86", "full_name": "SHA1 Rounds 4", "summary": "Performs 4 rounds of SHA1 operation.", "syntax": "SHA1RNDS4 xmm1, xmm2/m128, imm8", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 3A CC /r ib", "visual_parts": [], "binary_pattern": "0F | 3A | CC", "bit_positions": "+0 | +1 | +2" }, "extension": "SHA", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Executes 4 rounds of the SHA-1 compression function, performing circular left shift, addition, and XOR operations on the five 32-bit state variables (A, B, C, D, E). The immediate byte selects the round function constant (K value 0-3); no flags are affected.", "pseudocode": "for round in 0..3:\n f ← SHA1_FUNCTION(round + imm8*4, B, C, D);\n K ← SHA1_CONSTANT(round + imm8*4);\n T ← ROTL32(A, 5) + f + E + K + W[round + imm8*4];\n E ← D; D ← C; C ← ROTL32(B, 30); B ← A; A ← T;", "example": "SHA1RNDS4 xmm1, xmm2/m128, 3" }, { "mnemonic": "sha256msg1", "architecture": "x86", "full_name": "SHA256 Message Schedule 1", "summary": "Performs intermediate calculation for SHA256 message schedule.", "syntax": "SHA256MSG1 xmm1, xmm2/m128", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 38 CC /r", "visual_parts": [], "binary_pattern": "0F | 38 | CC", "bit_positions": "+0 | +1 | +2" }, "extension": "SHA", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs the first intermediate step of SHA-256 message schedule expansion on 128-bit XMM operands, computing partial W values for the message schedule. The destination is updated with results of the partial expansion; no flags are affected.", "pseudocode": "W[0..3] ← dest[0..3];\nW[4..7] ← src[0..3];\nfor i in 0..3:\n dest[i] ← W[i] + SHA256_GAMMA0(W[i+1]);", "example": "SHA256MSG1 xmm1, xmm2/m128" }, { "mnemonic": "sha256msg2", "architecture": "x86", "full_name": "SHA256 Message Schedule 2", "summary": "Performs final calculation for SHA256 message schedule.", "syntax": "SHA256MSG2 xmm1, xmm2/m128", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 38 CD /r", "visual_parts": [], "binary_pattern": "0F | 38 | CD", "bit_positions": "+0 | +1 | +2" }, "extension": "SHA", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Performs the final calculation of the SHA256 message schedule for the next 4 message words. The instruction operates on 128-bit XMM registers containing 32-bit message schedule values and combines them with the previous message schedule state. All flags (CF, PF, AF, ZF, SF, OF) remain unchanged; this is a pure data-transformation instruction with no flag effects.", "pseudocode": "xmm1[127:0] ← SHA256_MSG_SCHEDULE_ROUND(xmm1[127:0], xmm2/m128[127:0])", "example": "SHA256MSG2 xmm1, xmm2/m128" }, { "mnemonic": "sha256rnds2", "architecture": "x86", "full_name": "SHA256 Rounds 2", "summary": "Performs 2 rounds of SHA256 operation.", "syntax": "SHA256RNDS2 xmm1, xmm2/m128, xmm0", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 38 CB /r", "visual_parts": [], "binary_pattern": "0F | 38 | CB", "bit_positions": "+0 | +1 | +2" }, "extension": "SHA", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "xmm0", "desc": "128-bit XMM SIMD register" } ], "description": "Executes two rounds of the SHA256 compression function on the working variables. The instruction reads round constants from XMM0 and processes the destination register in-place using the source operand as input to the SHA256 rounds. All flags remain unchanged; this instruction has no flag side effects and requires the SHA CPU extension.", "pseudocode": "xmm1[127:0] ← SHA256_ROUNDS(xmm1[127:0], xmm2/m128[127:0], xmm0[127:0], round_constants)", "example": "SHA256RNDS2 xmm1, xmm2/m128, xmm0" }, { "mnemonic": "vmxon", "architecture": "x86", "full_name": "Enter VMX Operation", "summary": "Enters VMX root operation (Host Mode).", "syntax": "VMXON m64", "encoding": { "format": "VMX", "hex_opcode": "F3 0F C7 !(11):110:bbb", "visual_parts": [], "binary_pattern": "F3 | 0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "VMX", "operands": [ { "name": "dest", "type": "m64", "desc": "64-bit memory operand (quadword)" } ], "description": "Enters VMX root operation (host/hypervisor mode) using a 64-bit VMXON region pointer loaded from memory. The instruction validates the VMXON region, sets the VMXON flag in CR4, and transitions the processor to VMX root mode; failure causes #UD or sets RFLAGS.CF/ZF. This is a privileged instruction (requires CPL=0) and available only on processors with VMX support.", "pseudocode": "if (CPL != 0 || VMX_ENABLED == 0) raise #UD\nVMXON_PTR ← [m64]\nif (!validate_vmxon_region(VMXON_PTR)) { RFLAGS.CF ← 1; RFLAGS.ZF ← 0; } else { VMX_ROOT ← 1; RFLAGS.CF ← 0; RFLAGS.ZF ← 0; }", "example": "VMXON [rbp-8]" }, { "mnemonic": "vmcall", "architecture": "x86", "full_name": "Call to VM Monitor", "summary": "Guest VM calls the Hypervisor (VM Exit).", "syntax": "VMCALL", "encoding": { "format": "VMX", "hex_opcode": "0F 01 C1", "visual_parts": [], "binary_pattern": "0F | 01 | C1", "bit_positions": "+0 | +1 | +2" }, "extension": "VMX", "operands": [], "description": "Initiates a VM exit from guest mode to invoke the VM monitor (hypervisor). The instruction immediately transitions control to the hypervisor and is available only when running in VMX non-root mode; execution in root mode raises #UD. RFLAGS.CF and ZF may be set on VM exit depending on the exit reason; other flags are preserved across the transition.", "pseudocode": "if (CPL != 0 || VMX_ROOT == 1) raise #UD\nVMEXIT(VMCALL_EXIT_REASON)\nif (exit_error) { RFLAGS.CF ← 1; RFLAGS.ZF ← 1; }", "example": "VMCALL" }, { "mnemonic": "vmclear", "architecture": "x86", "full_name": "Clear Virtual-Machine Control Structure", "summary": "Initializes a VMCS region in memory.", "syntax": "VMCLEAR m64", "encoding": { "format": "VMX", "hex_opcode": "66 0F C7 /6", "visual_parts": [], "binary_pattern": "66 | 0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "VMX", "operands": [ { "name": "dest", "type": "m64", "desc": "64-bit memory operand (quadword)" } ], "description": "Initializes a Virtual Machine Control Structure (VMCS) region in memory by clearing its launch state and marking it as inactive. The instruction loads a 64-bit VMCS pointer from memory, validates the region, and sets CF/ZF on validation failure. This is a privileged instruction (CPL=0) requiring VMX support and must be executed in VMX root mode.", "pseudocode": "if (CPL != 0 || VMX_ROOT == 0) raise #UD\nVMCS_PTR ← [m64]\nif (!validate_vmcs_region(VMCS_PTR)) { RFLAGS.CF ← 1; RFLAGS.ZF ← 0; } else { clear_vmcs(VMCS_PTR); RFLAGS.CF ← 0; RFLAGS.ZF ← 0; }", "example": "VMCLEAR [rbp-8]" }, { "mnemonic": "vmlaunch", "architecture": "x86", "full_name": "Launch Virtual Machine", "summary": "Launches a VM managed by the current VMCS.", "syntax": "VMLAUNCH", "encoding": { "format": "VMX", "hex_opcode": "0F 01 C2", "visual_parts": [], "binary_pattern": "0F | 01 | C2", "bit_positions": "+0 | +1 | +2" }, "extension": "VMX", "operands": [], "description": "Launches a virtual machine using the current VMCS. The instruction reads guest state from the current VMCS, validates it, and transitions to VMX non-root mode; on success, control transfers to the guest; on failure, returns to the instruction with CF/ZF set. This is a privileged instruction (CPL=0) available only in VMX root mode on processors with VMX support.", "pseudocode": "if (CPL != 0 || VMX_ROOT == 0) raise #UD\nif (!validate_vmcs_state()) { RFLAGS.CF ← 1; RFLAGS.ZF ← 0; } else { load_guest_state_from_vmcs(); VMX_ROOT ← 0; transfer_control_to_guest(); }", "example": "VMLAUNCH" }, { "mnemonic": "vmresume", "architecture": "x86", "full_name": "Resume Virtual Machine", "summary": "Resumes a VM from the current VMCS.", "syntax": "VMRESUME", "encoding": { "format": "VMX", "hex_opcode": "0F 01 C3", "visual_parts": [], "binary_pattern": "0F | 01 | C3", "bit_positions": "+0 | +1 | +2" }, "extension": "VMX", "operands": [], "description": "Resumes a suspended virtual machine from the current VMCS. The instruction restores guest CPU state from the VMCS and returns control to the guest; on validation failure, CF/ZF are set and control returns to the hypervisor. This is a privileged instruction (CPL=0) available only in VMX root mode and following a prior VMLAUNCH or VM exit.", "pseudocode": "if (CPL != 0 || VMX_ROOT == 0) raise #UD\nif (!validate_vmcs_state()) { RFLAGS.CF ← 1; RFLAGS.ZF ← 0; } else { restore_guest_state_from_vmcs(); VMX_ROOT ← 0; transfer_control_to_guest(); }", "example": "VMRESUME" }, { "mnemonic": "vmptrld", "architecture": "x86", "full_name": "Load Pointer to VMCS", "summary": "Loads the current VMCS pointer from memory.", "syntax": "VMPTRLD m64", "encoding": { "format": "VMX", "hex_opcode": "NP 0F C7 /6", "visual_parts": [], "binary_pattern": "0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "VMX", "operands": [ { "name": "dest", "type": "m64", "desc": "64-bit memory operand (quadword)" } ], "description": "Loads a pointer to the Virtual Machine Control Structure (VMCS) from memory and sets it as the current VMCS. The instruction reads a 64-bit VMCS physical address from memory, validates the region, and sets CF/ZF on failure. This is a privileged instruction (CPL=0) requiring VMX support and execution in VMX root mode; the VMCS region must be 4KB-aligned.", "pseudocode": "if (CPL != 0 || VMX_ROOT == 0) raise #UD\nVMCS_PTR ← [m64]\nif (!validate_vmcs_region(VMCS_PTR)) { RFLAGS.CF ← 1; RFLAGS.ZF ← 0; } else { CURRENT_VMCS ← VMCS_PTR; RFLAGS.CF ← 0; RFLAGS.ZF ← 0; }", "example": "VMPTRLD [rbp-8]" }, { "mnemonic": "vmptrst", "architecture": "x86", "full_name": "Store Pointer to VMCS", "summary": "Stores the current VMCS pointer to memory.", "syntax": "VMPTRST m64", "encoding": { "format": "VMX", "hex_opcode": "NP 0F C7 /7", "visual_parts": [], "binary_pattern": "0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2" }, "extension": "VMX", "operands": [ { "name": "dest", "type": "m64", "desc": "64-bit memory operand (quadword)" } ], "description": "Stores the current VMCS pointer (from the VMCS pointer register) to a 64-bit memory location. This instruction is privileged and requires VMX root operation; it clears the memory destination with the active VMCS pointer value. The CF flag is set if an error occurs (invalid VMCS pointer state); ZF is set to indicate success or failure.", "pseudocode": "if (VMX_mode == ROOT && VMCS_pointer != INVALID) {\n [dest] ← VMCS_pointer_register;\n CF ← 0;\n ZF ← 0;\n} else {\n CF ← 1;\n ZF ← 1;\n}", "example": "VMPTRST [rbp-8]" }, { "mnemonic": "vmread", "architecture": "x86", "full_name": "Read Field from VMCS", "summary": "Reads a field from the Virtual Machine Control Structure.", "syntax": "VMREAD r/m64, r64", "encoding": { "format": "VMX", "hex_opcode": "NP 0F 78", "visual_parts": [], "binary_pattern": "0F | 78", "bit_positions": "+0 | +1" }, "extension": "VMX", "operands": [ { "name": "dest", "type": "r/m64", "desc": "64-bit register or memory" }, { "name": "src", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" } ], "description": "Reads a 64-bit field from the current VMCS (specified by the index in the source operand) and writes the value to the destination register or memory. Requires active VMCS and VMX root or non-root operation; CF is set on error, ZF indicates field validity.", "pseudocode": "if (VMCS_pointer_valid && VMX_mode_active) {\n field_index ← src;\n value ← VMCS[field_index];\n dest ← value;\n CF ← 0;\n ZF ← 0;\n} else {\n CF ← 1;\n ZF ← 1;\n}", "example": "VMREAD rbx, rax" }, { "mnemonic": "vmwrite", "architecture": "x86", "full_name": "Write Field to VMCS", "summary": "Writes a field to the Virtual Machine Control Structure.", "syntax": "VMWRITE r64, r/m64", "encoding": { "format": "VMX", "hex_opcode": "NP 0F 79", "visual_parts": [], "binary_pattern": "0F | 79", "bit_positions": "+0 | +1" }, "extension": "VMX", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" }, { "name": "src", "type": "r/m64", "desc": "64-bit register or memory" } ], "description": "Writes a 64-bit value to a field in the current VMCS (specified by the index in the destination operand). Requires active VMCS and VMX root or non-root operation; CF is set on error, ZF indicates write success.", "pseudocode": "if (VMCS_pointer_valid && VMX_mode_active) {\n field_index ← dest;\n value ← src;\n VMCS[field_index] ← value;\n CF ← 0;\n ZF ← 0;\n} else {\n CF ← 1;\n ZF ← 1;\n}", "example": "VMWRITE rax, rbx" }, { "mnemonic": "vmxoff", "architecture": "x86", "full_name": "Leave VMX Operation", "summary": "Leaves VMX root operation.", "syntax": "VMXOFF", "encoding": { "format": "VMX", "hex_opcode": "0F 01 C4", "visual_parts": [], "binary_pattern": "0F | 01 | C4", "bit_positions": "+0 | +1 | +2" }, "extension": "VMX", "operands": [], "description": "Exits VMX root operation and returns the processor to non-VMX mode. This instruction requires VMX root operation and clears the VMXE bit in CR4. CF and ZF flags are set to indicate error conditions if the operation fails; execution may be serialized.", "pseudocode": "if (VMX_root_operation) {\n VMX_mode ← OFF;\n CR4.VMXE ← 0;\n CF ← 0;\n ZF ← 0;\n} else {\n CF ← 1;\n ZF ← 1;\n}", "example": "VMXOFF" }, { "mnemonic": "invept", "architecture": "x86", "full_name": "Invalidate Translations Derived from EPT", "summary": "Invalidates Extended Page Table entries.", "syntax": "INVEPT r64, m128", "encoding": { "format": "VMX", "hex_opcode": "66 0F 38 80", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 80", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "VMX (EPT)", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" }, { "name": "src", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Invalidates Extended Page Table (EPT) translation cache entries based on the invalidation type and operand descriptor. The destination register specifies the invalidation type (1=single context, 2=all contexts), and the source memory operand contains EPTP and VPID information. CF/ZF flags indicate success or error; this instruction may serialize execution.", "pseudocode": "if (EPT_enabled && VMX_mode_active) {\n invalidation_type ← dest;\n descriptor ← [src];\n if (invalidation_type == 1) {\n invalidate_EPT_context(descriptor);\n } else if (invalidation_type == 2) {\n invalidate_all_EPT();\n }\n CF ← 0;\n ZF ← 0;\n} else {\n CF ← 1;\n ZF ← 1;\n}", "example": "INVEPT rax, [rbp-16]" }, { "mnemonic": "invvpid", "architecture": "x86", "full_name": "Invalidate Translations Based on VPID", "summary": "Invalidates TLB entries based on Virtual Processor ID.", "syntax": "INVVPID r64, m128", "encoding": { "format": "VMX", "hex_opcode": "66 0F 38 81", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 81", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "VMX (VPID)", "operands": [ { "name": "dest", "type": "r64", "desc": "64-bit general-purpose register (e.g. RAX)" }, { "name": "src", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Invalidates TLB entries based on Virtual Processor ID (VPID). The destination register specifies the invalidation type (1=individual address, 2=single VPID context, 3=all VPID contexts, 4=individual address keeping globals), and the source memory operand contains VPID and address information. CF/ZF flags indicate success or error; this instruction serializes execution.", "pseudocode": "if (VPID_enabled && VMX_mode_active) {\n invalidation_type ← dest;\n descriptor ← [src];\n if (invalidation_type == 1) {\n invalidate_TLB_address(descriptor);\n } else if (invalidation_type == 2) {\n invalidate_TLB_VPID(descriptor);\n } else if (invalidation_type == 3) {\n invalidate_all_TLB();\n } else if (invalidation_type == 4) {\n invalidate_TLB_address_keep_global(descriptor);\n }\n CF ← 0;\n ZF ← 0;\n} else {\n CF ← 1;\n ZF ← 1;\n}", "example": "INVVPID rax, [rbp-16]" }, { "mnemonic": "kmovw", "architecture": "x86", "full_name": "Move Word Mask Register", "summary": "Moves 16-bit mask to/from k-register.", "syntax": "KMOVW k1, k2/m16", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.0F.W0 90 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 90", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2/m16", "desc": "AVX-512 opmask register (k0-k7) or Memory operand" } ], "description": "Moves a 16-bit value between AVX-512 opmask registers (k0-k7) or from/to a 16-bit memory location. When moving from register/memory to k-register, the upper bits beyond 16 are zeroed. ZF is set based on source value; CF is typically cleared unless an error occurs.", "pseudocode": "if (source_is_register) {\n dest_k ← src_k & 0xFFFF;\n} else {\n dest_k ← [src] & 0xFFFF;\n}\nZF ← (dest_k == 0);\nCF ← 0;", "example": "KMOVW k1, k2/m16" }, { "mnemonic": "kmovq", "architecture": "x86", "full_name": "Move Quadword Mask Register", "summary": "Moves 64-bit mask to/from k-register.", "syntax": "KMOVQ k1, k2/m64", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.0F.W1 90 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 90", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512BW", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2/m64", "desc": "AVX-512 opmask register (k0-k7) or Memory operand" } ], "description": "Moves a 64-bit value between AVX-512 opmask registers (k0-k7) or from/to a 64-bit memory location. Requires AVX-512BW support; destination k-register receives the full 64-bit mask. ZF is set based on source value; CF is typically cleared unless an error occurs.", "pseudocode": "if (source_is_register) {\n dest_k ← src_k;\n} else {\n dest_k ← [src];\n}\nZF ← (dest_k == 0);\nCF ← 0;", "example": "KMOVQ k1, k2/m64" }, { "mnemonic": "kandw", "architecture": "x86", "full_name": "Bitwise Logical AND Masks Word", "summary": "Bitwise AND of 16-bit masks.", "syntax": "KANDW k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.0F.W0 41 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 41", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise AND operation on two 16-bit AVX-512 opmask registers and stores the result in a third opmask register. This is a mask-only operation that does not affect EFLAGS. The instruction operates on the lower 16 bits of the k registers; bits above 16 are zeroed in the destination.", "pseudocode": "k1[15:0] ← k2[15:0] & k3[15:0]; k1[63:16] ← 0;", "example": "KANDW k1, k2, k3" }, { "mnemonic": "kandnw", "architecture": "x86", "full_name": "Bitwise Logical AND NOT Masks Word", "summary": "Bitwise AND NOT of 16-bit masks.", "syntax": "KANDNW k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.0F.W0 42 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 42", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise AND NOT operation (NOT src1 AND src2) on two 16-bit AVX-512 opmask registers and stores the result in a third opmask register. This is a mask-only operation that does not affect EFLAGS. Bits above 16 in the destination are zeroed.", "pseudocode": "k1[15:0] ← (~k2[15:0]) & k3[15:0]; k1[63:16] ← 0;", "example": "KANDNW k1, k2, k3" }, { "mnemonic": "korw", "architecture": "x86", "full_name": "Bitwise Logical OR Masks Word", "summary": "Bitwise OR of 16-bit masks.", "syntax": "KORW k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.0F.W0 45 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 45", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise OR operation on two 16-bit AVX-512 opmask registers and stores the result in a third opmask register. This is a mask-only operation that does not affect EFLAGS. Bits above 16 in the destination are zeroed.", "pseudocode": "k1[15:0] ← k2[15:0] | k3[15:0]; k1[63:16] ← 0;", "example": "KORW k1, k2, k3" }, { "mnemonic": "kxorw", "architecture": "x86", "full_name": "Bitwise Logical XOR Masks Word", "summary": "Bitwise XOR of 16-bit masks.", "syntax": "KXORW k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.0F.W0 47 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 47", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src1", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src2", "type": "k3", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise XOR operation on two 16-bit AVX-512 opmask registers and stores the result in a third opmask register. This is a mask-only operation that does not affect EFLAGS. Bits above 16 in the destination are zeroed.", "pseudocode": "k1[15:0] ← k2[15:0] ^ k3[15:0]; k1[63:16] ← 0;", "example": "KXORW k1, k2, k3" }, { "mnemonic": "knotw", "architecture": "x86", "full_name": "Bitwise Logical NOT Masks Word", "summary": "Bitwise NOT of 16-bit mask.", "syntax": "KNOTW k1, k2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.0F.W0 44 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 44", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise NOT operation on a 16-bit AVX-512 opmask register and stores the result in another opmask register. This is a mask-only operation that does not affect EFLAGS. Bits above 16 in the destination are zeroed.", "pseudocode": "k1[15:0] ← ~k2[15:0]; k1[63:16] ← 0;", "example": "KNOTW k1, k2" }, { "mnemonic": "kortestw", "architecture": "x86", "full_name": "OR Masks And Set Flags Word", "summary": "ORs two masks and sets EFLAGS (ZF, CF) based on result.", "syntax": "KORTESTW k1, k2", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L0.0F.W0 98 /r", "visual_parts": [], "binary_pattern": "EVEX | 0F | 98", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512", "operands": [ { "name": "dest", "type": "k1", "desc": "AVX-512 opmask register (k0-k7)" }, { "name": "src", "type": "k2", "desc": "AVX-512 opmask register (k0-k7)" } ], "description": "Performs a bitwise OR of two 16-bit AVX-512 opmask registers and sets EFLAGS based on the result. Sets ZF if the result is zero, CF if the result is 0xFFFF (all ones in the 16-bit field), and clears OF and SF. This instruction is typically used for predication and loop control in AVX-512 code.", "pseudocode": "temp ← k1[15:0] | k2[15:0]; ZF ← (temp == 0); CF ← (temp == 0xFFFF); OF ← 0; SF ← 0;", "example": "KORTESTW k1, k2" }, { "mnemonic": "vpternlogd", "architecture": "x86", "full_name": "Packed Doubleword Ternary Logic", "summary": "Performs one of 256 logical operations on 3 inputs.", "syntax": "VPTERNLOGD zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 25 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 25", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs one of 256 possible three-input Boolean logical operations on 512-bit packed doublewords. The immediate operand selects which Boolean function to apply; supports opmask-controlled execution and writes to ZMM registers. No EFLAGS are affected; the instruction is fully predicated by {k1} if specified.", "pseudocode": "for i ← 0 to 15 do if k1[i] or k1 is not specified then zmm1[32*i+31:32*i] ← LUT256[imm8][zmm2[32*i+31:32*i], zmm3[32*i+31:32*i], zmm1[32*i+31:32*i]];", "example": "VPTERNLOGD zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpternlogq", "architecture": "x86", "full_name": "Packed Quadword Ternary Logic", "summary": "Performs one of 256 logical operations on 3 quadwords.", "syntax": "VPTERNLOGQ zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 25 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 25", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs one of 256 possible three-input Boolean logical operations on 512-bit packed quadwords. The immediate operand selects which Boolean function to apply; supports opmask-controlled execution and writes to ZMM registers. No EFLAGS are affected; the instruction is fully predicated by {k1} if specified.", "pseudocode": "for i ← 0 to 7 do if k1[i] or k1 is not specified then zmm1[64*i+63:64*i] ← LUT256[imm8][zmm2[64*i+63:64*i], zmm3[64*i+63:64*i], zmm1[64*i+63:64*i]];", "example": "VPTERNLOGQ zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vcompresspd", "architecture": "x86", "full_name": "Store Sparse Packed Double-Precision Floating-Point Values", "summary": "Compresses active elements from ZMM to memory.", "syntax": "VCOMPRESSPD m512 {k1}, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 8A /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 8A", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "m512", "desc": "512-bit memory operand" }, { "name": "src", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Stores active (mask-enabled) 64-bit double-precision floating-point elements from a ZMM register to memory in compressed form, where only the elements selected by the opmask k1 are written consecutively to the destination address. No flags are modified. Requires AVX-512F; operates on 512-bit ZMM registers and writes up to 512 bits of memory depending on mask population.", "pseudocode": "count ← 0\nfor i in 0 to 7:\n if k1[i] == 1:\n [dest + count * 8] ← ZMM2[i*64 : (i+1)*64]\n count ← count + 1", "example": "VCOMPRESSPD [rbp-64], zmm1" }, { "mnemonic": "vcompressps", "architecture": "x86", "full_name": "Store Sparse Packed Single-Precision Floating-Point Values", "summary": "Compresses active elements from ZMM to memory.", "syntax": "VCOMPRESSPS m512 {k1}, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 8A /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 8A", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "m512", "desc": "512-bit memory operand" }, { "name": "src", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Stores active (mask-enabled) 32-bit single-precision floating-point elements from a ZMM register to memory in compressed form, where only the elements selected by the opmask k1 are written consecutively to the destination address. No flags are modified. Requires AVX-512F; operates on 512-bit ZMM registers and writes up to 512 bits of memory depending on mask population.", "pseudocode": "count ← 0\nfor i in 0 to 15:\n if k1[i] == 1:\n [dest + count * 4] ← ZMM2[i*32 : (i+1)*32]\n count ← count + 1", "example": "VCOMPRESSPS [rbp-64], zmm1" }, { "mnemonic": "vexpandpd", "architecture": "x86", "full_name": "Load Sparse Packed Double-Precision Floating-Point Values", "summary": "Expands data from memory into sparse locations in ZMM.", "syntax": "VEXPANDPD zmm1 {k1}, m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 88 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 88", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "m512", "desc": "512-bit memory operand" } ], "description": "Loads 64-bit double-precision floating-point elements from memory into a ZMM register at positions selected by the opmask k1, leaving masked-out positions unchanged if zeroing is not enabled. No flags are modified. Requires AVX-512F; reads from memory and expands sparse data into the 512-bit destination register.", "pseudocode": "count ← 0\nfor i in 0 to 7:\n if k1[i] == 1:\n ZMM1[i*64 : (i+1)*64] ← [src + count * 8]\n count ← count + 1\n else if k1[i] == 0 and zeroing == false:\n ZMM1[i*64 : (i+1)*64] ← ZMM1[i*64 : (i+1)*64]", "example": "VEXPANDPD zmm1, [rbp-64]" }, { "mnemonic": "vexpandps", "architecture": "x86", "full_name": "Load Sparse Packed Single-Precision Floating-Point Values", "summary": "Expands data from memory into sparse locations in ZMM.", "syntax": "VEXPANDPS zmm1 {k1}, m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 88 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 88", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "m512", "desc": "512-bit memory operand" } ], "description": "Loads 32-bit single-precision floating-point elements from memory into a ZMM register at positions selected by the opmask k1, leaving masked-out positions unchanged if zeroing is not enabled. No flags are modified. Requires AVX-512F; reads from memory and expands sparse data into the 512-bit destination register.", "pseudocode": "count ← 0\nfor i in 0 to 15:\n if k1[i] == 1:\n ZMM1[i*32 : (i+1)*32] ← [src + count * 4]\n count ← count + 1\n else if k1[i] == 0 and zeroing == false:\n ZMM1[i*32 : (i+1)*32] ← ZMM1[i*32 : (i+1)*32]", "example": "VEXPANDPS zmm1, [rbp-64]" }, { "mnemonic": "vpermi2d", "architecture": "x86", "full_name": "Permute Two-Source Doublewords", "summary": "Shuffles doublewords from two ZMM registers into destination.", "syntax": "VPERMI2D zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 76 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 76", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Permutes 32-bit doublewords from two source operands (zmm2 and zmm3/m512) using indices in zmm1 to produce a shuffled result in zmm1, where each 5-bit index selects one of 16 elements from each source. No flags are modified. Requires AVX-512F; results follow opmask k1 zeroing behavior. The index operand zmm1 is overwritten with the permuted result.", "pseudocode": "temp ← 0\nfor i in 0 to 15:\n if k1[i] == 1:\n idx ← ZMM1[i*32+4:i*32] & 0x1F\n if idx < 16:\n temp[i*32 : (i+1)*32] ← ZMM2[idx*32 : (idx+1)*32]\n else:\n temp[i*32 : (i+1)*32] ← ZMM3/M512[(idx-16)*32 : (idx-15)*32]\n else if zeroing == true:\n temp[i*32 : (i+1)*32] ← 0\n else:\n temp[i*32 : (i+1)*32] ← ZMM1[i*32 : (i+1)*32]\nZMM1 ← temp", "example": "VPERMI2D zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpermt2d", "architecture": "x86", "full_name": "Permute Two-Source Doublewords (Overwrite)", "summary": "Shuffles 2 sources, overwriting the index register.", "syntax": "VPERMT2D zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 7E /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 7F", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Permutes 32-bit doublewords from two source operands (zmm2 and zmm3/m512) using indices in zmm1 to produce a shuffled result in zmm1, where each 5-bit index selects one of 16 elements from each source. No flags are modified. Requires AVX-512F; the index register zmm1 is overwritten with the permutation result and follows opmask k1 zeroing behavior.", "pseudocode": "temp ← 0\nfor i in 0 to 15:\n if k1[i] == 1:\n idx ← ZMM1[i*32+4:i*32] & 0x1F\n if idx < 16:\n temp[i*32 : (i+1)*32] ← ZMM2[idx*32 : (idx+1)*32]\n else:\n temp[i*32 : (i+1)*32] ← ZMM3/M512[(idx-16)*32 : (idx-15)*32]\n else if zeroing == true:\n temp[i*32 : (i+1)*32] ← 0\n else:\n temp[i*32 : (i+1)*32] ← ZMM1[i*32 : (i+1)*32]\nZMM1 ← temp", "example": "VPERMT2D zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vshuff32x4", "architecture": "x86", "full_name": "Shuffle Packed Float32x4", "summary": "Shuffles 128-bit blocks of single-precision floats.", "syntax": "VSHUFF32X4 zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.256.66.0F3A.W0 23 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 23", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shuffles 128-bit blocks (each containing four 32-bit floats) from two ZMM sources according to an 8-bit immediate control, writing the result to the destination ZMM register. No flags are modified. Requires AVX-512F; the immediate selects which 128-bit quadwords are interleaved from the two sources. Opmask k1 controls which result elements are written.", "pseudocode": "temp ← 0\nfor i in 0 to 3:\n sel1 ← (imm8 >> (i*2)) & 0x3\n sel2 ← (imm8 >> (4 + i*2)) & 0x3\n temp[i*128 : (i+1)*128] ← ZMM2[sel1*128 : (sel1+1)*128]\n temp[(i+4)*128 : (i+5)*128] ← ZMM3/M512[sel2*128 : (sel2+1)*128]\nfor i in 0 to 15:\n if k1[i] == 1:\n ZMM1[i*32 : (i+1)*32] ← temp[i*32 : (i+1)*32]\n else if zeroing == true:\n ZMM1[i*32 : (i+1)*32] ← 0", "example": "VSHUFF32X4 zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpmovdb", "architecture": "x86", "full_name": "Truncate Doubleword to Byte", "summary": "Down-converts 32-bit integers to 8-bit.", "syntax": "VPMOVDB xmm1/m128 {k1}, zmm2", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W0 31 /r", "visual_parts": [], "binary_pattern": "EVEX | F3 | 0F | 38 | 31", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "xmm1/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Truncates 16 32-bit doubleword integers from a ZMM register down to 8-bit bytes, writing the 16 resulting bytes to an XMM register or 128-bit memory location. No flags are modified. Requires AVX-512F; the conversion is a simple truncation (low 8 bits extracted). Opmask k1 controls which byte results are written.", "pseudocode": "temp ← 0\nfor i in 0 to 15:\n if k1[i] == 1:\n temp[i*8 : (i+1)*8] ← ZMM2[i*32 : i*32+8]\n else if zeroing == true:\n temp[i*8 : (i+1)*8] ← 0\n else:\n temp[i*8 : (i+1)*8] ← temp[i*8 : (i+1)*8]\ndest[0 : 128] ← temp[0 : 128]", "example": "VPMOVDB xmm1/m128, zmm2" }, { "mnemonic": "vpmovusdb", "architecture": "x86", "full_name": "Saturate Unsigned Doubleword to Byte", "summary": "Down-converts 32-bit to 8-bit with unsigned saturation.", "syntax": "VPMOVUSDB xmm1/m128 {k1}, zmm2", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W0 11 /r", "visual_parts": [], "binary_pattern": "EVEX | F3 | 0F | 38 | 11", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "xmm1/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Converts 16 packed 32-bit unsigned integers from a ZMM register to 16 packed 8-bit unsigned integers in an XMM register or memory, saturating values that exceed 255 to 255. The operation is element-wise; each 32-bit source value is independently clamped to the range [0, 255] and stored as an 8-bit result. Operates in 64-bit mode only and respects EVEX writemask {k1} for conditional element updates.", "pseudocode": "for i = 0 to 15:\n src_val = zmm2[i*32 + 31 : i*32]\n if src_val > 255:\n result[i*8 + 7 : i*8] = 255\n else:\n result[i*8 + 7 : i*8] = src_val[7:0]\nif k1_mask[i] == 1:\n dest[i*8 + 7 : i*8] = result[i*8 + 7 : i*8]\nelse if {z} == 1:\n dest[i*8 + 7 : i*8] = 0", "example": "VPMOVUSDB xmm1/m128, zmm2" }, { "mnemonic": "vrndscalepd", "architecture": "x86", "full_name": "Round Packed Double-Precision Floating-Point with Scale", "summary": "Rounds doubles to integer values using imm8 control.", "syntax": "VRNDSCALEPD zmm1 {k1}, zmm2/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 09 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 09", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rounds 8 packed 64-bit floating-point values to integer values using rounding control specified in imm8 (bits 3:0 select round-to-nearest-even, round-down, round-up, or round-toward-zero; bits 5:4 control sign, bits 7:6 control exception behavior). Destination is written with the scaled and rounded results. The instruction may set or clear floating-point exception flags (ZF, CF, OF, SF, PF) depending on the rounding results and imm8 exception control.", "pseudocode": "for i = 0 to 7:\n src_val = zmm2/m512[i*64 + 63 : i*64]\n round_mode = imm8[3:0]\n scaled_val = 2^(-(imm8[5:4])) * src_val\n rounded = RoundToIntegerFP(scaled_val, round_mode)\n result[i*64 + 63 : i*64] = rounded\n if (imm8[6] == 0 and FP_exception_raised):\n set_FP_exception_flags()\nif k1_mask[i] == 1:\n zmm1[i*64 + 63 : i*64] = result[i*64 + 63 : i*64]\nelse if {z} == 1:\n zmm1[i*64 + 63 : i*64] = 0", "example": "VRNDSCALEPD zmm1, zmm2/m512, 3" }, { "mnemonic": "vfixupimmpd", "architecture": "x86", "full_name": "Fix Up Special Packed Float64 Values", "summary": "Fixes special cases (NaN, Inf) using a table.", "syntax": "VFIXUPIMMPD zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 54 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 54", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Fixes up special floating-point cases (NaN, Infinity, denormalized) in 8 packed 64-bit values using a lookup table indexed by imm8 and the class/sign of each element. For each source element, the instruction examines the exceptional condition bits and uses imm8 to select a fixup value or pass-through behavior. The result is placed in the destination; may set floating-point exception flags (ZF, CF, OF, SF, PF) if exceptions are not suppressed.", "pseudocode": "for i = 0 to 7:\n src1_val = zmm2[i*64 + 63 : i*64]\n src2_val = zmm3/m512[i*64 + 63 : i*64]\n class_bits = ClassifyFP64(src1_val)\n index = (imm8[1:0] << 2) | class_bits[1:0]\n lookup_result = FIXUP_TABLE[index]\n if lookup_result == PASS_THROUGH:\n result[i*64 + 63 : i*64] = src1_val\n else if lookup_result == USE_SRC2:\n result[i*64 + 63 : i*64] = src2_val\n else:\n result[i*64 + 63 : i*64] = lookup_result\n if (imm8[3:2] != 11 and exception_condition):\n set_FP_exception_flags()\nif k1_mask[i] == 1:\n zmm1[i*64 + 63 : i*64] = result[i*64 + 63 : i*64]\nelse if {z} == 1:\n zmm1[i*64 + 63 : i*64] = 0", "example": "VFIXUPIMMPD zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vgetmantpd", "architecture": "x86", "full_name": "Get Mantissa Packed Double-Precision", "summary": "Extracts mantissas from doubles.", "syntax": "VGETMANTPD zmm1 {k1}, zmm2/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 26 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 26", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Extracts the mantissa (significand) from 8 packed 64-bit floating-point values and returns them as normalized floating-point results. The imm8 parameter controls which portion of the mantissa is returned (e.g., ±[1.0, 2.0), ±[0.5, 1.0), etc.) and the rounding mode for the mantissa extraction. Denormalized inputs and exceptional cases may be handled according to imm8 bits; floating-point exception flags may be set depending on exception handling mode.", "pseudocode": "for i = 0 to 7:\n src_val = zmm2/m512[i*64 + 63 : i*64]\n mantissa_mode = imm8[1:0]\n round_mode = imm8[3:2]\n suppress_exceptions = imm8[4]\n mantissa = ExtractMantissa(src_val, mantissa_mode)\n rounded_mantissa = RoundMantissa(mantissa, round_mode)\n result[i*64 + 63 : i*64] = rounded_mantissa\n if (suppress_exceptions == 0 and exception_condition):\n set_FP_exception_flags()\nif k1_mask[i] == 1:\n zmm1[i*64 + 63 : i*64] = result[i*64 + 63 : i*64]\nelse if {z} == 1:\n zmm1[i*64 + 63 : i*64] = 0", "example": "VGETMANTPD zmm1, zmm2/m512, 3" }, { "mnemonic": "vgetexppd", "architecture": "x86", "full_name": "Get Exponent Packed Double-Precision", "summary": "Extracts exponents from doubles as float values.", "syntax": "VGETEXPPD zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 42 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 42", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Extracts the exponent from 8 packed 64-bit floating-point values and returns each exponent as a 64-bit floating-point value (i.e., the unbiased exponent is converted to a double-precision floating-point number). Special cases such as zero, denormalized, infinite, and NaN inputs follow IEEE 754 semantics; floating-point exception flags (ZF, CF, OF, SF, PF) may be set depending on the nature of the inputs and masking.", "pseudocode": "for i = 0 to 7:\n src_val = zmm2/m512[i*64 + 63 : i*64]\n if is_zero(src_val):\n result[i*64 + 63 : i*64] = -INF\n else if is_denormal(src_val):\n exp_val = MIN_EXPONENT\n result[i*64 + 63 : i*64] = ConvertToFP64(exp_val)\n else if is_infinity(src_val):\n result[i*64 + 63 : i*64] = +INF\n else if is_nan(src_val):\n result[i*64 + 63 : i*64] = NaN\n else:\n unbiased_exp = ExtractExponent(src_val) - BIAS\n result[i*64 + 63 : i*64] = ConvertToFP64(unbiased_exp)\nif k1_mask[i] == 1:\n zmm1[i*64 + 63 : i*64] = result[i*64 + 63 : i*64]\nelse if {z} == 1:\n zmm1[i*64 + 63 : i*64] = 0", "example": "VGETEXPPD zmm1, zmm2/m512" }, { "mnemonic": "vscalefpd", "architecture": "x86", "full_name": "Scale Packed Float64 Values with Float64 Exponents", "summary": "Scales doubles by exponents (x * 2^n).", "syntax": "VSCALEFPD zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 2C /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 2C", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Scales 8 packed 64-bit floating-point values by raising 2 to the power of the corresponding exponent value (dst = src1 * 2^src2) using floating-point exponentiation. Each element of src2 is treated as an integer exponent; the result is computed with full floating-point precision. The instruction may set or clear floating-point exception flags (ZF, CF, OF, SF, PF) based on overflow, underflow, or other exceptional conditions.", "pseudocode": "for i = 0 to 7:\n mantissa = zmm2[i*64 + 63 : i*64]\n exponent = zmm3/m512[i*64 + 63 : i*64]\n exp_int = ConvertToInt(exponent)\n if exp_int > MAX_EXP:\n result[i*64 + 63 : i*64] = INF (sign from mantissa)\n set_FP_exception_flag(OVERFLOW)\n else if exp_int < MIN_EXP:\n result[i*64 + 63 : i*64] = 0.0 (sign from mantissa)\n set_FP_exception_flag(UNDERFLOW)\n else:\n scaled = mantissa * (2.0 ^ exp_int)\n result[i*64 + 63 : i*64] = scaled\nif k1_mask[i] == 1:\n zmm1[i*64 + 63 : i*64] = result[i*64 + 63 : i*64]\nelse if {z} == 1:\n zmm1[i*64 + 63 : i*64] = 0", "example": "VSCALEFPD zmm1, zmm2, zmm3/m512" }, { "mnemonic": "valignd", "architecture": "x86", "full_name": "Align Doubleword Vectors", "summary": "Extracts 512-bits from two concatenated ZMMs shifted by count.", "syntax": "VALIGND zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W0 03 /r ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 03", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Extracts 512 bits from the concatenation of two ZMM registers (src2 || src1), where src2 is the high part, shifted right by imm8 * 32 bits, and writes the result to dest. This acts as a multi-element rotate-right or barrel-shift operation on the combined 1024-bit value. All 16 packed 32-bit doubleword elements shift by the same amount; elements that shift out are discarded, and zero-fill enters from the left. Operates only in 64-bit mode.", "pseudocode": "shift_amount = imm8 * 32\ntemp_concat = (zmm2[511:0] << 512) | zmm1[511:0]\nresult = temp_concat >> shift_amount\nfor i = 0 to 15:\n result_dword[i] = result[(i+1)*32 - 1 : i*32]\nif k1_mask[i] == 1:\n zmm1[i*32 + 31 : i*32] = result_dword[i]\nelse if {z} == 1:\n zmm1[i*32 + 31 : i*32] = 0", "example": "VALIGND zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpconflictd", "architecture": "x86", "full_name": "Detect Conflicts Within a Vector of Packed Dword Values", "summary": "Detects duplicate values in a vector (Conflict Detection).", "syntax": "VPCONFLICTD zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 C4 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | C4", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512CD", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Detects conflicting (duplicate) values within a vector of 16 packed 32-bit unsigned integers and writes a conflict mask to the destination. For each element, the instruction generates a 32-bit mask where bit j is set to 1 if the element at position i equals the element at position j (where j > i). This enables efficient identification of duplicate elements within a single vector. Operates only in 64-bit mode; no arithmetic flags are modified.", "pseudocode": "for i = 0 to 15:\n conflict_mask = 0\n for j = i + 1 to 15:\n if zmm2/m512[i*32 + 31 : i*32] == zmm2/m512[j*32 + 31 : j*32]:\n conflict_mask |= (1 << j)\n result[i*32 + 31 : i*32] = conflict_mask\nif k1_mask[i] == 1:\n zmm1[i*32 + 31 : i*32] = result[i*32 + 31 : i*32]\nelse if {z} == 1:\n zmm1[i*32 + 31 : i*32] = 0", "example": "VPCONFLICTD zmm1, zmm2/m512" }, { "mnemonic": "vplzcntd", "architecture": "x86", "full_name": "Count Leading Zero Bits", "summary": "Counts leading zeros for each doubleword element.", "syntax": "VPLZCNTD zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 44 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 44", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512CD", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Counts the number of leading zero bits in each 32-bit doubleword element of the source operand and writes the count to the corresponding doubleword in the destination. Operates on 512-bit vectors under EVEX encoding with optional write-mask (k1) and zeroing. No EFLAGS are affected by this instruction.", "pseudocode": "for i = 0 to 15 do\n src_val = zmm2[i*32 : (i+1)*32-1]\n count = 0\n for j = 31 downto 0 do\n if src_val[j] == 1 then break\n count++\n zmm1[i*32 : (i+1)*32-1] = count\nend for", "example": "VPLZCNTD zmm1, zmm2/m512" }, { "mnemonic": "vcvtudq2ps", "architecture": "x86", "full_name": "Convert Packed Unsigned Doubleword Integers to Packed Single-Precision Floating-Point", "summary": "Converts unsigned int32 to float.", "syntax": "VCVTUDQ2PS zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F2.0F.W0 7A /r", "visual_parts": [], "binary_pattern": "EVEX | F2 | 0F | 5B", "bit_positions": "+0 | +4 | +5 | +6" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Converts each 32-bit unsigned integer in the source to a single-precision floating-point value and stores the result in the destination. Operates on 512-bit vectors under EVEX encoding with optional write-mask (k1) and rounding control. No EFLAGS are affected; rounding follows MXCSR or embedded rounding mode.", "pseudocode": "for i = 0 to 15 do\n src_val = zmm2[i*32 : (i+1)*32-1]\n zmm1[i*32 : (i+1)*32-1] = convert_uint32_to_float32(src_val, rounding_mode)\nend for", "example": "VCVTUDQ2PS zmm1, zmm2/m512" }, { "mnemonic": "vprolvd", "architecture": "x86", "full_name": "Rotate Left Doubleword Variable", "summary": "Rotates doublewords left by amounts in second vector.", "syntax": "VPROLVD zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 15 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 15", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512F", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Rotates each 32-bit element in the first source left by the amount specified in the corresponding 32-bit element of the second source, storing results in the destination. Operates on 512-bit vectors under EVEX encoding with optional write-mask (k1). The rotation amount is taken modulo 32. No EFLAGS are affected.", "pseudocode": "for i = 0 to 15 do\n value = zmm2[i*32 : (i+1)*32-1]\n shift = zmm3[i*32 : (i+1)*32-1] & 0x1F\n zmm1[i*32 : (i+1)*32-1] = (value << shift) | (value >> (32 - shift))\nend for", "example": "VPROLVD zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpopcntd", "architecture": "x86", "full_name": "Packed Population Count Doubleword", "summary": "Counts set bits in each doubleword element.", "syntax": "VPOPCNTD zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 55 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 55", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VPOPCNTDQ", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Counts the number of set bits (1s) in each 32-bit doubleword element of the source operand and writes the population count to the corresponding doubleword in the destination. Operates on 512-bit vectors under EVEX encoding with optional write-mask (k1) and zeroing. No EFLAGS are affected.", "pseudocode": "for i = 0 to 15 do\n src_val = zmm2[i*32 : (i+1)*32-1]\n count = 0\n for j = 0 to 31 do\n if src_val[j] == 1 then count++\n zmm1[i*32 : (i+1)*32-1] = count\nend for", "example": "VPOPCNTD zmm1, zmm2/m512" }, { "mnemonic": "encls", "architecture": "x86", "full_name": "Execute Enclave Supervisor Leaf", "summary": "Executes an SGX supervisor function specified by EAX.", "syntax": "ENCLS", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 CF", "visual_parts": [], "binary_pattern": "0F | 01 | CF", "bit_positions": "+0 | +1 | +2" }, "extension": "SGX", "operands": [], "description": "Executes an SGX supervisor enclave leaf function specified by a leaf number in EAX. The instruction serializes the CPU pipeline and transitions from non-root mode to root mode for executing privileged enclave operations. The actual operation depends on the leaf function code; CF flag may be set on error conditions, and various other registers may be modified based on the leaf function.", "pseudocode": "leaf_function = EAX\nif (leaf_function == EBLOCK) then\n // Block enclave\nelseif (leaf_function == ETRACK) then\n // Flush TLB\nelseif (leaf_function == EWBLOCK) then\n // Write block enclave\nelse\n // Execute other supervisor leaf functions\nend if", "example": "ENCLS" }, { "mnemonic": "enclu", "architecture": "x86", "full_name": "Execute Enclave User Leaf", "summary": "Executes an SGX user function specified by EAX.", "syntax": "ENCLU", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F 01 D7", "visual_parts": [], "binary_pattern": "0F | 01 | D7", "bit_positions": "+0 | +1 | +2" }, "extension": "SGX", "operands": [], "description": "Executes an SGX user enclave leaf function specified by a leaf number in EAX. The instruction serializes the CPU pipeline and may transition between user and enclave execution modes depending on the leaf function. The actual operation depends on the leaf function code; various registers and flags may be modified based on the requested operation.", "pseudocode": "leaf_function = EAX\nif (leaf_function == EREPORT) then\n // Generate enclave report\nelseif (leaf_function == EGETKEY) then\n // Get sealing/reporting key\nelseif (leaf_function == EEXIT) then\n // Exit enclave\nelseif (leaf_function == EENTER) then\n // Enter enclave\nelse\n // Execute other user leaf functions\nend if", "example": "ENCLU" }, { "mnemonic": "extrq", "architecture": "x86", "full_name": "Extract Field from Register", "summary": "Extracts bit field from register (AMD SSE4a).", "syntax": "EXTRQ xmm1, xmm2", "encoding": { "format": "SSE4a", "hex_opcode": "66 0F 79 /r", "visual_parts": [], "binary_pattern": "66 | 0F | 79 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4a", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2", "desc": "128-bit XMM SIMD register" } ], "description": "Extracts a bit field from the 128-bit xmm1 register using the field length and field position specified in xmm2 bits [13:8] and [5:0] respectively. The extracted field is zero-extended and placed in xmm1; bits not part of the extracted field are zeroed. No EFLAGS are affected; this is an AMD SSE4a extension instruction.", "pseudocode": "field_length = xmm2[13:8]\nfield_pos = xmm2[5:0]\nif (field_length == 0) then\n field_length = 64\nend if\nmask = ((1 << field_length) - 1)\nextracted = (xmm1 >> field_pos) & mask\nxmm1 = extracted", "example": "EXTRQ xmm1, xmm2" }, { "mnemonic": "insertq", "architecture": "x86", "full_name": "Insert Field to Register", "summary": "Inserts bit field into register (AMD SSE4a).", "syntax": "INSERTQ xmm1, xmm2", "encoding": { "format": "SSE4a", "hex_opcode": "F2 0F 79 /r", "visual_parts": [], "binary_pattern": "66 | 0F | 79 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "SSE4a", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2", "desc": "128-bit XMM SIMD register" } ], "description": "Inserts a bit field from xmm2 into xmm1 at the position and length specified in xmm2 bits [13:8] and [5:0] respectively. The field from xmm2 is placed into xmm1 starting at the specified bit position; the rest of xmm1 remains unchanged. No EFLAGS are affected; this is an AMD SSE4a extension instruction.", "pseudocode": "field_length = xmm2[13:8]\nfield_pos = xmm2[5:0]\nif (field_length == 0) then\n field_length = 64\nend if\nmask = ((1 << field_length) - 1)\ninsert_value = xmm2 & mask\nxmm1 = (xmm1 & ~(mask << field_pos)) | (insert_value << field_pos)", "example": "INSERTQ xmm1, xmm2" }, { "mnemonic": "movntss", "architecture": "x86", "full_name": "Move Non-Temporal Scalar Single", "summary": "Stores scalar float bypassing cache (AMD SSE4a).", "syntax": "MOVNTSS m32, xmm1", "encoding": { "format": "SSE4a", "hex_opcode": "F3 0F 2B /r", "visual_parts": [], "binary_pattern": "F3 | 0F | 2B", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE4a", "operands": [ { "name": "dest", "type": "m32", "desc": "32-bit memory operand" }, { "name": "src", "type": "xmm1", "desc": "128-bit XMM SIMD register" } ], "description": "Stores the low 32-bit scalar single-precision floating-point value from an XMM register to a 32-bit memory location, bypassing the cache hierarchy using non-temporal semantics. The instruction issues a weakly-ordered write that avoids polluting the L1/L2 caches, useful for streaming writes. No arithmetic flags are affected; this is a memory store only.", "pseudocode": "[dest] ← src[31:0];", "example": "MOVNTSS [rbp-4], xmm1" }, { "mnemonic": "movntsd", "architecture": "x86", "full_name": "Move Non-Temporal Scalar Double", "summary": "Stores scalar double bypassing cache (AMD SSE4a).", "syntax": "MOVNTSD m64, xmm1", "encoding": { "format": "SSE4a", "hex_opcode": "F2 0F 2B /r", "visual_parts": [], "binary_pattern": "F2 | 0F | 2B", "bit_positions": "+0 | +1 | +2" }, "extension": "SSE4a", "operands": [ { "name": "dest", "type": "m64", "desc": "64-bit memory operand (quadword)" }, { "name": "src", "type": "xmm1", "desc": "128-bit XMM SIMD register" } ], "description": "Stores the low 64-bit scalar double-precision floating-point value from an XMM register to a 64-bit memory location, bypassing the cache hierarchy using non-temporal semantics. Similar to MOVNTSS but for 64-bit double-precision values; useful for streaming writes of double-precision data. No arithmetic flags are affected; this is a memory store only.", "pseudocode": "[dest] ← src[63:0];", "example": "MOVNTSD [rbp-8], xmm1" }, { "mnemonic": "clzero", "architecture": "x86", "full_name": "Zero Cache Line", "summary": "Clears the cache line at address RAX/EAX (AMD).", "syntax": "CLZERO", "encoding": { "format": "AMD", "hex_opcode": "0F 01 FC", "visual_parts": [], "binary_pattern": "0F | 01 | FC", "bit_positions": "+0 | +1 | +2" }, "extension": "CLZERO", "operands": [], "description": "Zeros (clears) a 64-byte cache line at the address held in RAX (in 64-bit mode) or EAX (in 32-bit mode), writing zeros to memory while bypassing caches. This instruction is a non-temporal operation useful for initializing large memory regions without cache pollution. No flags are affected; the memory is written directly and cache coherency is maintained.", "pseudocode": "lineaddr ← RAX & ~0x3F; memset([lineaddr], 0, 64);", "example": "CLZERO" }, { "mnemonic": "blci", "architecture": "x86", "full_name": "Bit Line Create Isolated", "summary": "Sets all bits to 0 except the lowest set bit inverted (x | ~(x+1)).", "syntax": "BLCI r32, r/m32", "encoding": { "format": "TBM", "hex_opcode": "XOP.L0.09.W0 02 /6", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "TBM", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Computes (src | ~(src+1)) and stores the result in dest, isolating all bits except the lowest set bit (which is inverted). Part of the TBM (Trailing Bit Manipulation) extension; sets flags based on the result: ZF if result is zero, SF based on sign bit, and CF/OF/PF are undefined. Available in 32-bit and 64-bit variants.", "pseudocode": "result ← src | ~(src + 1); dest ← result; ZF ← (result == 0); SF ← result[31]; CF ← undefined; OF ← undefined; PF ← undefined;", "example": "BLCI eax, ebx" }, { "mnemonic": "blcic", "architecture": "x86", "full_name": "Bit Line Create Isolated and Complement", "summary": "Isolates lowest clear bit (~x & (x+1)).", "syntax": "BLCIC r32, r/m32", "encoding": { "format": "TBM", "hex_opcode": "XOP.L0.09.W0 01 /5", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "TBM", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Computes (~src & (src+1)) and stores the result in dest, isolating the lowest clear (zero) bit. Part of the TBM extension; sets ZF if result is zero and SF based on the sign bit of the result; CF, OF, and PF are undefined. Available in 32-bit and 64-bit variants.", "pseudocode": "result ← ~src & (src + 1); dest ← result; ZF ← (result == 0); SF ← result[31]; CF ← undefined; OF ← undefined; PF ← undefined;", "example": "BLCIC eax, ebx" }, { "mnemonic": "blcmsk", "architecture": "x86", "full_name": "Bit Line Create Mask", "summary": "Creates mask from lowest clear bit (x ^ (x+1)).", "syntax": "BLCMSK r32, r/m32", "encoding": { "format": "TBM", "hex_opcode": "XOP.L0.09.W0 02 /1", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "TBM", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Computes (src ^ (src+1)) and stores the result in dest, creating a mask from the lowest clear bit to bit 0. Part of the TBM extension; sets ZF if result is zero and SF based on the sign bit of the result; CF, OF, and PF are undefined. Available in 32-bit and 64-bit variants.", "pseudocode": "result ← src ^ (src + 1); dest ← result; ZF ← (result == 0); SF ← result[31]; CF ← undefined; OF ← undefined; PF ← undefined;", "example": "BLCMSK eax, ebx" }, { "mnemonic": "blcs", "architecture": "x86", "full_name": "Bit Line Create Set", "summary": "Sets lowest clear bit (x | (x+1)).", "syntax": "BLCS r32, r/m32", "encoding": { "format": "TBM", "hex_opcode": "XOP.L0.09.W0 01 /3", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "TBM", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Computes (src | (src+1)) and stores the result in dest, setting the lowest clear bit. Part of the TBM extension; sets ZF if result is zero and SF based on the sign bit of the result; CF, OF, and PF are undefined. Available in 32-bit and 64-bit variants.", "pseudocode": "result ← src | (src + 1); dest ← result; ZF ← (result == 0); SF ← result[31]; CF ← undefined; OF ← undefined; PF ← undefined;", "example": "BLCS eax, ebx" }, { "mnemonic": "blsfill", "architecture": "x86", "full_name": "Bit Line Set Fill", "summary": "Sets all bits below lowest set bit ((x-1) | x).", "syntax": "BLSFILL r32, r/m32", "encoding": { "format": "TBM", "hex_opcode": "XOP.L0.09.W0 01 /2", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "TBM", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Computes ((src-1) | src) and stores the result in dest, filling all bits below and including the lowest set bit. Part of the TBM extension; sets ZF if result is zero and SF based on the sign bit of the result; CF, OF, and PF are undefined. Available in 32-bit and 64-bit variants.", "pseudocode": "result ← (src - 1) | src; dest ← result; ZF ← (result == 0); SF ← result[31]; CF ← undefined; OF ← undefined; PF ← undefined;", "example": "BLSFILL eax, ebx" }, { "mnemonic": "blsic", "architecture": "x86", "full_name": "Bit Line Set Isolated and Complement", "summary": "Isolates lowest set bit and complements (~x | (x-1)).", "syntax": "BLSIC r32, r/m32", "encoding": { "format": "TBM", "hex_opcode": "XOP.L0.09.W0 01 /6", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "TBM", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Isolates the lowest set bit and complements the result, computing ~src | (src - 1). This TBM instruction is useful for extracting bit masks and operates on 32-bit operands in protected/64-bit modes. No flags are modified by this instruction.", "pseudocode": "dest ← ~src | (src - 1)", "example": "BLSIC eax, ebx" }, { "mnemonic": "t1mskc", "architecture": "x86", "full_name": "Inverse Mask From Trailing Ones", "summary": "Creates mask from trailing ones (~x | (x+1)).", "syntax": "T1MSKC r32, r/m32", "encoding": { "format": "TBM", "hex_opcode": "XOP.L0.09.W0 01 /7", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "TBM", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Creates a mask from trailing ones by computing ~src | (src + 1), isolating all bits from the least significant one through trailing ones. This TBM instruction operates on 32-bit operands and does not modify CPU flags.", "pseudocode": "dest ← ~src | (src + 1)", "example": "T1MSKC eax, ebx" }, { "mnemonic": "tzmsk", "architecture": "x86", "full_name": "Mask From Trailing Zeros", "summary": "Creates mask from trailing zeros (~x & (x-1)).", "syntax": "TZMSK r32, r/m32", "encoding": { "format": "TBM", "hex_opcode": "XOP.L0.09.W0 01 /4", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "TBM", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r/m32", "desc": "32-bit register or memory" } ], "description": "Creates a mask from trailing zeros by computing ~src & (src - 1), isolating only the trailing zero bits. This TBM instruction operates on 32-bit operands in protected/64-bit modes and does not modify any CPU flags.", "pseudocode": "dest ← ~src & (src - 1)", "example": "TZMSK eax, ebx" }, { "mnemonic": "vprotb", "architecture": "x86", "full_name": "Vector Packed Rotate Byte", "summary": "Rotates bytes in XMM register.", "syntax": "VPROTB xmm1, xmm2/m128, imm8", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.08.W0 C0 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rotates each byte within a 128-bit XMM register by the amount specified in the 8-bit signed immediate, with rotation direction determined by the sign of the immediate (positive = left rotate, negative = right rotate). This XOP instruction is part of the AMD Bulldozer-era vector extensions and does not modify CPU flags.", "pseudocode": "for i in 0..15:\n if (imm8 >= 0):\n xmm1[i*8+7:i*8] ← ROL(src1[i*8+7:i*8], imm8 & 7)\n else:\n xmm1[i*8+7:i*8] ← ROR(src1[i*8+7:i*8], (-imm8) & 7)", "example": "VPROTB xmm1, xmm2/m128, 3" }, { "mnemonic": "vprotw", "architecture": "x86", "full_name": "Vector Packed Rotate Word", "summary": "Rotates words in XMM register.", "syntax": "VPROTW xmm1, xmm2/m128, imm8", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.08.W0 C1 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rotates each 16-bit word within a 128-bit XMM register by the amount specified in the 8-bit signed immediate, with rotation direction determined by sign (positive = left rotate, negative = right rotate). This XOP vector instruction does not modify CPU flags.", "pseudocode": "for i in 0..7:\n if (imm8 >= 0):\n xmm1[i*16+15:i*16] ← ROL(src1[i*16+15:i*16], imm8 & 15)\n else:\n xmm1[i*16+15:i*16] ← ROR(src1[i*16+15:i*16], (-imm8) & 15)", "example": "VPROTW xmm1, xmm2/m128, 3" }, { "mnemonic": "vprotd", "architecture": "x86", "full_name": "Vector Packed Rotate Doubleword", "summary": "Rotates doublewords in XMM register.", "syntax": "VPROTD xmm1, xmm2/m128, imm8", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.08.W0 C2 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rotates each 32-bit doubleword within a 128-bit XMM register by the amount specified in the 8-bit signed immediate, with rotation direction determined by sign (positive = left rotate, negative = right rotate). This XOP instruction does not affect CPU flags.", "pseudocode": "for i in 0..3:\n if (imm8 >= 0):\n xmm1[i*32+31:i*32] ← ROL(src1[i*32+31:i*32], imm8 & 31)\n else:\n xmm1[i*32+31:i*32] ← ROR(src1[i*32+31:i*32], (-imm8) & 31)", "example": "VPROTD xmm1, xmm2/m128, 3" }, { "mnemonic": "vprotq", "architecture": "x86", "full_name": "Vector Packed Rotate Quadword", "summary": "Rotates quadwords in XMM register.", "syntax": "VPROTQ xmm1, xmm2/m128, imm8", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.08.W0 C3 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Rotates each 64-bit quadword within a 128-bit XMM register by the amount specified in the 8-bit signed immediate, with rotation direction determined by sign (positive = left rotate, negative = right rotate). This XOP vector instruction does not modify CPU flags.", "pseudocode": "for i in 0..1:\n if (imm8 >= 0):\n xmm1[i*64+63:i*64] ← ROL(src1[i*64+63:i*64], imm8 & 63)\n else:\n xmm1[i*64+63:i*64] ← ROR(src1[i*64+63:i*64], (-imm8) & 63)", "example": "VPROTQ xmm1, xmm2/m128, 3" }, { "mnemonic": "vpshab", "architecture": "x86", "full_name": "Vector Packed Shift Arithmetic Byte", "summary": "Shifts bytes arithmetically.", "syntax": "VPSHAB xmm1, xmm2/m128, xmm3", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.09.W0 98 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs arithmetic left or right shift on each byte element within a 128-bit XMM register based on the 8-bit signed immediate, with positive values for left shift and negative for right shift (sign-extending). This XOP instruction does not modify CPU flags.", "pseudocode": "for i in 0..15:\n if (imm8 >= 0):\n xmm1[i*8+7:i*8] ← src1[i*8+7:i*8] << (imm8 & 7)\n else:\n xmm1[i*8+7:i*8] ← arithmetic_shift_right(src1[i*8+7:i*8], (-imm8) & 7)", "example": "VPSHAB xmm1, xmm2/m128, 3" }, { "mnemonic": "vpshaw", "architecture": "x86", "full_name": "Vector Packed Shift Arithmetic Word", "summary": "Shifts words arithmetically.", "syntax": "VPSHAW xmm1, xmm2/m128, xmm3", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.09.W0 99 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each 16-bit word in xmm2/m128 arithmetically by the signed immediate count, storing results in xmm1. Arithmetic right shifts replicate the sign bit; left shifts fill with zeros. This XOP extension instruction operates on 128-bit packed word data and does not affect EFLAGS.", "pseudocode": "for i = 0 to 7 {\n if (imm8 >= 0) {\n xmm1[16*i:16*i+15] ← (xmm2/m128[16*i:16*i+15]) << imm8\n } else {\n xmm1[16*i:16*i+15] ← (xmm2/m128[16*i:16*i+15]) >> (-imm8) // arithmetic shift\n }\n}", "example": "VPSHAW xmm1, xmm2/m128, 3" }, { "mnemonic": "vpshad", "architecture": "x86", "full_name": "Vector Packed Shift Arithmetic Doubleword", "summary": "Shifts doublewords arithmetically.", "syntax": "VPSHAD xmm1, xmm2/m128, xmm3", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.09.W0 9A /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each 32-bit doubleword in xmm2/m128 arithmetically by the signed immediate count, storing results in xmm1. Arithmetic right shifts preserve the sign bit; left shifts fill with zeros. This XOP extension instruction operates on 128-bit packed doubleword data and does not affect EFLAGS.", "pseudocode": "for i = 0 to 3 {\n if (imm8 >= 0) {\n xmm1[32*i:32*i+31] ← (xmm2/m128[32*i:32*i+31]) << imm8\n } else {\n xmm1[32*i:32*i+31] ← (xmm2/m128[32*i:32*i+31]) >> (-imm8) // arithmetic shift\n }\n}", "example": "VPSHAD xmm1, xmm2/m128, 3" }, { "mnemonic": "vpshaq", "architecture": "x86", "full_name": "Vector Packed Shift Arithmetic Quadword", "summary": "Shifts quadwords arithmetically.", "syntax": "VPSHAQ xmm1, xmm2/m128, xmm3", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.09.W0 9B /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" }, { "name": "src2", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Shifts each 64-bit quadword in xmm2/m128 arithmetically by the signed immediate count, storing results in xmm1. Arithmetic right shifts maintain the sign bit; left shifts fill with zeros. This XOP extension instruction operates on 128-bit packed quadword data and does not affect EFLAGS.", "pseudocode": "for i = 0 to 1 {\n if (imm8 >= 0) {\n xmm1[64*i:64*i+63] ← (xmm2/m128[64*i:64*i+63]) << imm8\n } else {\n xmm1[64*i:64*i+63] ← (xmm2/m128[64*i:64*i+63]) >> (-imm8) // arithmetic shift\n }\n}", "example": "VPSHAQ xmm1, xmm2/m128, 3" }, { "mnemonic": "vphaddbw", "architecture": "x86", "full_name": "Vector Packed Horizontal Add Byte to Word", "summary": "Adds adjacent bytes to words.", "syntax": "VPHADDBW xmm1, xmm2/m128", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.09.W0 C1 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Horizontally adds adjacent pairs of signed 8-bit bytes from xmm2/m128, accumulating results as 16-bit words in xmm1. Each pair of bytes produces one 16-bit word result; the operation doubles the data width. This XOP extension instruction does not affect EFLAGS and handles signed arithmetic with saturation or wrapping semantics dependent on implementation.", "pseudocode": "for i = 0 to 7 {\n xmm1[16*i:16*i+15] ← sign_extend(xmm2/m128[8*(2*i):8*(2*i)+7]) + sign_extend(xmm2/m128[8*(2*i+1):8*(2*i+1)+7])\n}", "example": "VPHADDBW xmm1, xmm2/m128" }, { "mnemonic": "vphaddbd", "architecture": "x86", "full_name": "Vector Packed Horizontal Add Byte to Doubleword", "summary": "Adds adjacent bytes to doublewords.", "syntax": "VPHADDBD xmm1, xmm2/m128", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.09.W0 C2 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Horizontally adds adjacent groups of four signed 8-bit bytes from xmm2/m128, accumulating results as 32-bit doublewords in xmm1. Four consecutive bytes are summed to produce one 32-bit result. This XOP extension instruction does not affect EFLAGS and performs signed arithmetic.", "pseudocode": "for i = 0 to 3 {\n xmm1[32*i:32*i+31] ← sign_extend(xmm2/m128[8*(4*i):8*(4*i)+7]) + sign_extend(xmm2/m128[8*(4*i+1):8*(4*i+1)+7]) + sign_extend(xmm2/m128[8*(4*i+2):8*(4*i+2)+7]) + sign_extend(xmm2/m128[8*(4*i+3):8*(4*i+3)+7])\n}", "example": "VPHADDBD xmm1, xmm2/m128" }, { "mnemonic": "vphaddbq", "architecture": "x86", "full_name": "Vector Packed Horizontal Add Byte to Quadword", "summary": "Adds adjacent bytes to quadwords.", "syntax": "VPHADDBQ xmm1, xmm2/m128", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.09.W0 C3 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Horizontally adds all eight signed 8-bit bytes from xmm2/m128 (lower half) and (upper half separately), accumulating results as 64-bit quadwords in xmm1. All bytes from each half are summed to produce two 64-bit results. This XOP extension instruction does not affect EFLAGS and performs signed arithmetic.", "pseudocode": "xmm1[63:0] ← sign_extend(xmm2/m128[7:0]) + sign_extend(xmm2/m128[15:8]) + sign_extend(xmm2/m128[23:16]) + sign_extend(xmm2/m128[31:24]) + sign_extend(xmm2/m128[39:32]) + sign_extend(xmm2/m128[47:40]) + sign_extend(xmm2/m128[55:48]) + sign_extend(xmm2/m128[63:56])\nxmm1[127:64] ← sign_extend(xmm2/m128[71:64]) + sign_extend(xmm2/m128[79:72]) + sign_extend(xmm2/m128[87:80]) + sign_extend(xmm2/m128[95:88]) + sign_extend(xmm2/m128[103:96]) + sign_extend(xmm2/m128[111:104]) + sign_extend(xmm2/m128[119:112]) + sign_extend(xmm2/m128[127:120])", "example": "VPHADDBQ xmm1, xmm2/m128" }, { "mnemonic": "vphaddwd", "architecture": "x86", "full_name": "Vector Packed Horizontal Add Word to Doubleword", "summary": "Adds adjacent words to doublewords.", "syntax": "VPHADDWD xmm1, xmm2/m128", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.09.W0 C6 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Horizontally adds adjacent pairs of signed 16-bit words from xmm2/m128, accumulating results as 32-bit doublewords in xmm1. Each pair of words produces one 32-bit doubleword result; the operation doubles the data width. This XOP extension instruction does not affect EFLAGS and performs signed arithmetic.", "pseudocode": "for i = 0 to 3 {\n xmm1[32*i:32*i+31] ← sign_extend(xmm2/m128[16*(2*i):16*(2*i)+15]) + sign_extend(xmm2/m128[16*(2*i+1):16*(2*i+1)+15])\n}", "example": "VPHADDWD xmm1, xmm2/m128" }, { "mnemonic": "vphaddwq", "architecture": "x86", "full_name": "Vector Packed Horizontal Add Word to Quadword", "summary": "Adds adjacent words to quadwords.", "syntax": "VPHADDWQ xmm1, xmm2/m128", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.09.W0 C7 /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Horizontally adds adjacent groups of four signed 16-bit words from xmm2/m128, accumulating results as 64-bit quadwords in xmm1. Four consecutive words are summed to produce one 64-bit result. This XOP extension instruction does not affect EFLAGS and performs signed arithmetic.", "pseudocode": "for i = 0 to 1 {\n xmm1[64*i:64*i+63] ← sign_extend(xmm2/m128[16*(4*i):16*(4*i)+15]) + sign_extend(xmm2/m128[16*(4*i+1):16*(4*i+1)+15]) + sign_extend(xmm2/m128[16*(4*i+2):16*(4*i+2)+15]) + sign_extend(xmm2/m128[16*(4*i+3):16*(4*i+3)+15])\n}", "example": "VPHADDWQ xmm1, xmm2/m128" }, { "mnemonic": "vphadddq", "architecture": "x86", "full_name": "Vector Packed Horizontal Add Doubleword to Quadword", "summary": "Adds adjacent doublewords to quadwords.", "syntax": "VPHADDDQ xmm1, xmm2/m128", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.09.W0 CB /r", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src", "type": "xmm2/m128", "desc": "128-bit XMM SIMD register or Memory operand" } ], "description": "Adds pairs of adjacent 32-bit signed integers and stores the 64-bit sums in the destination XMM register. This is a horizontal operation that processes two 32-bit elements from each 64-bit lane, producing one 64-bit result per lane. No flags are affected.", "pseudocode": "for i = 0 to 1:\n result[i*64:(i*64)+63] ← sign_extend_64(src[(i*2)*32:(i*2)*32+31]) +\n sign_extend_64(src[(i*2+1)*32:(i*2+1)*32+31])\ndest ← result", "example": "VPHADDDQ xmm1, xmm2/m128" }, { "mnemonic": "vpmacsww", "architecture": "x86", "full_name": "Vector Packed Multiply Accumulate Signed Word", "summary": "Multiply-accumulate signed words.", "syntax": "VPMACSWW xmm1, xmm2, xmm3, xmm4", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.08.W0 95 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3", "desc": "128-bit XMM SIMD register" }, { "name": "src3", "type": "xmm4", "desc": "128-bit XMM SIMD register" } ], "description": "Multiplies pairs of signed 16-bit integers, accumulates the 32-bit products, and stores results in the destination XMM register without saturation. This is a 4-operand instruction encoding multiply-accumulate semantics: dest = src1 * src2 + src3. No flags are affected.", "pseudocode": "for i = 0 to 7:\n product ← sign_extend_32(src1[i*16:(i*16)+15]) *\n sign_extend_32(src2[i*16:(i*16)+15])\n result[i*32:(i*32)+31] ← product + sign_extend_32(src3[i*16:(i*16)+15])\ndest ← result", "example": "VPMACSWW xmm1, xmm2, xmm3, xmm4" }, { "mnemonic": "vpmacssww", "architecture": "x86", "full_name": "Vector Packed Multiply Accumulate Signed Saturate Word", "summary": "Multiply-accumulate signed words with saturation.", "syntax": "VPMACSSWW xmm1, xmm2, xmm3, xmm4", "encoding": { "format": "XOP", "hex_opcode": "XOP.128.08.W0 85 /r ib", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "XOP", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2", "desc": "128-bit XMM SIMD register" }, { "name": "src2", "type": "xmm3", "desc": "128-bit XMM SIMD register" }, { "name": "src3", "type": "xmm4", "desc": "128-bit XMM SIMD register" } ], "description": "Multiplies pairs of signed 16-bit integers, accumulates the 32-bit products with saturation to signed 32-bit range, and stores results in the destination XMM register. This saturating variant clamps results to [-2³¹, 2³¹-1]. No flags are affected.", "pseudocode": "for i = 0 to 7:\n product ← sign_extend_32(src1[i*16:(i*16)+15]) *\n sign_extend_32(src2[i*16:(i*16)+15])\n sum ← product + sign_extend_32(src3[i*16:(i*16)+15])\n result[i*32:(i*32)+31] ← saturate_signed_32(sum)\ndest ← result", "example": "VPMACSSWW xmm1, xmm2, xmm3, xmm4" }, { "mnemonic": "vgatherpf0dps", "architecture": "x86", "full_name": "Gather Prefetch Packed Single (L1)", "summary": "Prefetches floats to L1 cache using indices.", "syntax": "VGATHERPF0DPS {k1}, [base+zmm_idx]", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 C6 /1 /vsib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512PF", "operands": [ { "name": "dest", "type": "[base+zmm_idx]", "desc": "AVX-512 gather/scatter: base register + ZMM vector index" } ], "description": "Prefetches cache lines to L1 for single-precision floats using 32-bit dword indices from a vector register. The instruction performs a gather-style prefetch where each ZMM element acts as an index offset from a base address, but does not load data into registers. The opmask register {k1} controls which prefetch operations execute. No flags are affected.", "pseudocode": "for i = 0 to 15:\n if k1[i] == 1:\n addr ← base + zmm_idx[i*32:(i*32)+31] * scale\n prefetch_L1(addr)\n endif", "example": "VGATHERPF0DPS {k1}, [base+zmm_idx]" }, { "mnemonic": "vgatherpf0qps", "architecture": "x86", "full_name": "Gather Prefetch Packed Single (L1, Qword Indices)", "summary": "Prefetches floats to L1 using 64-bit indices.", "syntax": "VGATHERPF0QPS {k1}, [base+zmm_idx]", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 C7 /1 /vsib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512PF", "operands": [ { "name": "dest", "type": "[base+zmm_idx]", "desc": "AVX-512 gather/scatter: base register + ZMM vector index" } ], "description": "Prefetches cache lines to L1 for single-precision floats using 64-bit qword indices from a vector register. Each element of the ZMM vector is treated as a 64-bit index offset from a base address for gather-prefetch semantics. The opmask {k1} selects which prefetch operations occur. No flags are affected.", "pseudocode": "for i = 0 to 7:\n if k1[i] == 1:\n addr ← base + zmm_idx[i*64:(i*64)+63] * scale\n prefetch_L1(addr)\n endif", "example": "VGATHERPF0QPS {k1}, [base+zmm_idx]" }, { "mnemonic": "vgatherpf0dpd", "architecture": "x86", "full_name": "Gather Prefetch Packed Double (L1)", "summary": "Prefetches doubles to L1 cache using indices.", "syntax": "VGATHERPF0DPD {k1}, [base+ymm_idx]", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 C6 /1 /vsib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512PF", "operands": [ { "name": "dest", "type": "[base+ymm_idx]", "desc": "AVX gather/scatter: base register + YMM vector index" } ], "description": "Prefetches cache lines to L1 for double-precision floats using 32-bit dword indices from a vector register. Each 32-bit index in the YMM register is scaled and added to a base address for gathering-style prefetch operations. The opmask {k1} gates which prefetch operations execute. No flags are affected.", "pseudocode": "for i = 0 to 7:\n if k1[i] == 1:\n addr ← base + ymm_idx[i*32:(i*32)+31] * scale\n prefetch_L1(addr)\n endif", "example": "VGATHERPF0DPD {k1}, [base+ymm_idx]" }, { "mnemonic": "vgatherpf0qpd", "architecture": "x86", "full_name": "Gather Prefetch Packed Double (L1, Qword Indices)", "summary": "Prefetches doubles to L1 using 64-bit indices.", "syntax": "VGATHERPF0QPD {k1}, [base+zmm_idx]", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 C7 /1 /vsib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512PF", "operands": [ { "name": "dest", "type": "[base+zmm_idx]", "desc": "AVX-512 gather/scatter: base register + ZMM vector index" } ], "description": "Prefetches cache lines to L1 for double-precision floats using 64-bit qword indices from a vector register. Each 64-bit element in the ZMM index register is scaled and added to a base address for gather-prefetch semantics. The opmask {k1} controls which prefetch operations are active. No flags are affected.", "pseudocode": "for i = 0 to 7:\n if k1[i] == 1:\n addr ← base + zmm_idx[i*64:(i*64)+63] * scale\n prefetch_L1(addr)\n endif", "example": "VGATHERPF0QPD {k1}, [base+zmm_idx]" }, { "mnemonic": "vscatterpf0dps", "architecture": "x86", "full_name": "Scatter Prefetch Packed Single (L1)", "summary": "Prefetches cache lines for scatter write (L1).", "syntax": "VSCATTERPF0DPS {k1}, [base+zmm_idx]", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 C6 /5 /vsib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512PF", "operands": [ { "name": "dest", "type": "[base+zmm_idx]", "desc": "AVX-512 gather/scatter: base register + ZMM vector index" } ], "description": "Prefetches cache lines to L1 in preparation for scatter write operations on single-precision floats using 32-bit dword indices. Unlike gather prefetch, this operation optimizes cache behavior for subsequent scatter stores. The opmask {k1} selects which prefetch operations occur. No flags are affected.", "pseudocode": "for i = 0 to 15:\n if k1[i] == 1:\n addr ← base + zmm_idx[i*32:(i*32)+31] * scale\n prefetch_L1_for_write(addr)\n endif", "example": "VSCATTERPF0DPS {k1}, [base+zmm_idx]" }, { "mnemonic": "vscatterpf0qps", "architecture": "x86", "full_name": "Scatter Prefetch Packed Single (L1, Qword Indices)", "summary": "Prefetches lines for scatter write (L1, 64-bit idx).", "syntax": "VSCATTERPF0QPS {k1}, [base+zmm_idx]", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W0 C7 /5 /vsib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512PF", "operands": [ { "name": "dest", "type": "[base+zmm_idx]", "desc": "AVX-512 gather/scatter: base register + ZMM vector index" } ], "description": "Prefetches cache lines for scatter write operations using 64-bit (qword) indices into a ZMM vector, with L1 cache as the target. This is a non-faulting prefetch hint that does not load data or raise exceptions; it only triggers hardware prefetch logic based on the indexed addresses. Execution is masked by the k1 opmask register, and no flags are affected.", "pseudocode": "for (i = 0; i < 8; i++) {\n if (k1[i]) {\n addr = base + ZMM_idx[i];\n prefetch_l1(addr);\n }\n}", "example": "VSCATTERPF0QPS {k1}, [base+zmm_idx]" }, { "mnemonic": "vscatterpf0dpd", "architecture": "x86", "full_name": "Scatter Prefetch Packed Double (L1)", "summary": "Prefetches lines for scatter write (L1, Double).", "syntax": "VSCATTERPF0DPD {k1}, [base+ymm_idx]", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 C6 /5 /vsib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512PF", "operands": [ { "name": "dest", "type": "[base+ymm_idx]", "desc": "AVX gather/scatter: base register + YMM vector index" } ], "description": "Prefetches cache lines for scatter write operations using 32-bit (dword) indices into a YMM vector containing doubles, with L1 cache as the target. This is a non-faulting prefetch hint that does not load data or raise exceptions; masked execution by k1 is supported. No flags are affected.", "pseudocode": "for (i = 0; i < 4; i++) {\n if (k1[i]) {\n addr = base + ZeroExtend64(YMM_idx[i*32:i*32+31]);\n prefetch_l1(addr);\n }\n}", "example": "VSCATTERPF0DPD {k1}, [base+ymm_idx]" }, { "mnemonic": "vscatterpf0qpd", "architecture": "x86", "full_name": "Scatter Prefetch Packed Double (L1, Qword Indices)", "summary": "Prefetches lines for scatter write (L1, Double, 64-bit idx).", "syntax": "VSCATTERPF0QPD {k1}, [base+zmm_idx]", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 C7 /5 /vsib", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512PF", "operands": [ { "name": "dest", "type": "[base+zmm_idx]", "desc": "AVX-512 gather/scatter: base register + ZMM vector index" } ], "description": "Prefetches cache lines for scatter write operations using 64-bit (qword) indices into a ZMM vector containing doubles, with L1 cache as the target. This non-faulting prefetch hint is masked by the k1 opmask and does not load data or raise exceptions. No flags are affected.", "pseudocode": "for (i = 0; i < 8; i++) {\n if (k1[i]) {\n addr = base + ZMM_idx[i];\n prefetch_l1(addr);\n }\n}", "example": "VSCATTERPF0QPD {k1}, [base+zmm_idx]" }, { "mnemonic": "vp4dpwssd", "architecture": "x86", "full_name": "Dot Product Signed Word to Signed Doubleword (4-iterations)", "summary": "Neural Net 4-way dot product.", "syntax": "VP4DPWSSD zmm1 {k1}, zmm2+3, m128", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F2.0F38.W0 52 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512-4VNNIW", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2+3", "desc": "ZMM register pair (consecutive even+odd registers, for 4-iteration FMA)" }, { "name": "src2", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Performs four iterations of fused multiply-add on signed word operands, accumulating into 32-bit signed doubleword results in zmm1. The instruction reads from a consecutive register pair (zmm2:zmm3) and a 128-bit memory operand, executing four parallel dot products per iteration. Masked by k1; no flags are affected; saturation does not occur (results wrap on overflow).", "pseudocode": "for (j = 0; j < 4; j++) {\n for (i = 0; i < 16; i++) {\n zmm1[i*32:(i*32)+31] += (int32_t)(zmm2[(j*4+i)*16:(j*4+i)*16+15]) * (int32_t)(m128[(j*16+i*2):(j*16+i*2)+15]);\n }\n}", "example": "VP4DPWSSD zmm1, zmm2+3, [rbp-16]" }, { "mnemonic": "vp4dpwssds", "architecture": "x86", "full_name": "Dot Product Signed Word to Signed Doubleword Saturate (4-iter)", "summary": "Neural Net 4-way dot product with saturation.", "syntax": "VP4DPWSSDS zmm1 {k1}, zmm2+3, m128", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F2.0F38.W0 53 /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512-4VNNIW", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2+3", "desc": "ZMM register pair (consecutive even+odd registers, for 4-iteration FMA)" }, { "name": "src2", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Performs four iterations of fused multiply-add on signed word operands, accumulating into 32-bit signed doubleword results in zmm1 with saturation. The instruction reads from a consecutive register pair (zmm2:zmm3) and a 128-bit memory operand, executing four parallel dot products per iteration. Results saturate to INT32_MIN/INT32_MAX on overflow; masked by k1; no flags are affected.", "pseudocode": "for (j = 0; j < 4; j++) {\n for (i = 0; i < 16; i++) {\n temp = (int64_t)(zmm2[(j*4+i)*16:(j*4+i)*16+15]) * (int64_t)(m128[(j*16+i*2):(j*16+i*2)+15]);\n zmm1[i*32:(i*32)+31] = SaturateSigned32(zmm1[i*32:(i*32)+31] + temp);\n }\n}", "example": "VP4DPWSSDS zmm1, zmm2+3, [rbp-16]" }, { "mnemonic": "v4fmaddps", "architecture": "x86", "full_name": "Fused Multiply-Add Packed Single (4-iterations)", "summary": "4-way FMA for Neural Nets (Single).", "syntax": "V4FMADDPS zmm1 {k1}, zmm2+3, m128", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F2.0F38.W0 9A /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512-4FMAPS", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2+3", "desc": "ZMM register pair (consecutive even+odd registers, for 4-iteration FMA)" }, { "name": "src2", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Performs four iterations of fused multiply-add on packed single-precision floating-point operands, accumulating results into zmm1. The instruction reads from a consecutive ZMM register pair (zmm2:zmm3) and a 128-bit memory operand, computing four parallel multiply-accumulate chains. Masked by k1; floating-point exceptions (precision, underflow, overflow, denormal) may be signaled; rounding is per MXCSR.", "pseudocode": "for (j = 0; j < 4; j++) {\n for (i = 0; i < 16; i++) {\n float mul = zmm2[(j*4+i)*32:(j*4+i)*32+31] * m128[(j*16+i*4):(j*16+i*4)+31];\n zmm1[i*32:(i*32)+31] = FP_ADD(zmm1[i*32:(i*32)+31], mul);\n }\n}", "example": "V4FMADDPS zmm1, zmm2+3, [rbp-16]" }, { "mnemonic": "v4fmaddss", "architecture": "x86", "full_name": "Fused Multiply-Add Scalar Single (4-iterations)", "summary": "4-way FMA for Neural Nets (Scalar).", "syntax": "V4FMADDSS xmm1 {k1}, xmm2+3, m128", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.F2.0F38.W0 9B /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512-4FMAPS", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2+3", "desc": "XMM register pair (consecutive even+odd registers)" }, { "name": "src2", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Performs four iterations of fused multiply-add on scalar single-precision floating-point operands, accumulating results into the low dword of xmm1. The instruction reads from a consecutive XMM register pair (xmm2:xmm3) and a 128-bit memory operand, computing four parallel multiply-accumulate operations into the scalar. Masked by k1; floating-point exceptions may be signaled; rounding is per MXCSR; high 96 bits of xmm1 are cleared.", "pseudocode": "temp = xmm1[0:31];\nfor (j = 0; j < 4; j++) {\n float mul = ((j == 0) ? xmm2[0:31] : xmm3[0:31]) * *(float*)&m128[(j*4):(j*4)+31];\n temp = FP_ADD(temp, mul);\n}\nxmm1[0:31] = temp;\nxmm1[32:127] = 0;", "example": "V4FMADDSS xmm1, xmm2+3, [rbp-16]" }, { "mnemonic": "v4fnmaddps", "architecture": "x86", "full_name": "Fused Negative Multiply-Add Packed Single (4-iterations)", "summary": "4-way Negative FMA for Neural Nets (Single).", "syntax": "V4FNMADDPS zmm1 {k1}, zmm2+3, m128", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F2.0F38.W0 AA /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512-4FMAPS", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2+3", "desc": "ZMM register pair (consecutive even+odd registers, for 4-iteration FMA)" }, { "name": "src2", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Performs four iterations of fused negative multiply-add on packed single-precision floating-point operands, computing -(zmm2×m128) + zmm1, accumulating results into zmm1. The instruction reads from a consecutive ZMM register pair (zmm2:zmm3) and a 128-bit memory operand, executing four parallel negated multiply-accumulate chains. Masked by k1; floating-point exceptions may be signaled; rounding is per MXCSR.", "pseudocode": "for (j = 0; j < 4; j++) {\n for (i = 0; i < 16; i++) {\n float mul = -(zmm2[(j*4+i)*32:(j*4+i)*32+31] * m128[(j*16+i*4):(j*16+i*4)+31]);\n zmm1[i*32:(i*32)+31] = FP_ADD(zmm1[i*32:(i*32)+31], mul);\n }\n}", "example": "V4FNMADDPS zmm1, zmm2+3, [rbp-16]" }, { "mnemonic": "v4fnmaddss", "architecture": "x86", "full_name": "Fused Negative Multiply-Add Scalar Single (4-iterations)", "summary": "4-way Negative FMA for Neural Nets (Scalar).", "syntax": "V4FNMADDSS xmm1 {k1}, xmm2+3, m128", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.F2.0F38.W0 AB /r", "visual_parts": [], "binary_pattern": "EVEX | opcode | ModRM", "bit_positions": "+0 | +4 | +5" }, "extension": "AVX-512-4FMAPS", "operands": [ { "name": "dest", "type": "xmm1", "desc": "128-bit XMM SIMD register" }, { "name": "src1", "type": "xmm2+3", "desc": "XMM register pair (consecutive even+odd registers)" }, { "name": "src2", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Performs four iterations of fused negative multiply-add on scalar single-precision floating-point values, computing -(src1[i] * src2[i]) + dest for four pairs of operands. This instruction is specialized for neural network operations and executes within a single macro-op, improving throughput for repeated FMA patterns. All MXCSR exception flags may be set based on intermediate results; the result is written to dest with optional write-masking via k1.", "pseudocode": "for i in 0 to 3:\n temp ← -(xmm2[i] * m128[i])\n xmm1[i] ← temp + xmm1[i]\n update_MXCSR_flags(temp, xmm1[i])", "example": "V4FNMADDSS xmm1, xmm2+3, [rbp-16]" }, { "mnemonic": "vcvtdq2ps", "architecture": "x86", "full_name": "Convert Packed Doubleword to Packed Single", "summary": "Converts four 32-bit integers to floats.", "syntax": "VCVTDQ2PS ymm1, ymm2/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.0F.WIG 5B /r", "visual_parts": [], "binary_pattern": "VEX | 0F | 5B", "bit_positions": "+0 | +3 | +4" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src", "type": "ymm2/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Converts four packed 32-bit signed doubleword integers to four packed single-precision floating-point values. The conversion uses the current MXCSR rounding mode; inexact results may set the PE (precision exception) flag in MXCSR. Available in 128-bit (XMM) and 256-bit (YMM) variants; the 256-bit form converts eight integers. No legacy flags are modified.", "pseudocode": "if VEX.L = 0:\n for i in 0 to 1:\n xmm1[i] ← convert_dword_to_float(xmm2[i])\nelse:\n for i in 0 to 3:\n ymm1[i] ← convert_dword_to_float(ymm2[i])\nupdate_MXCSR_flags()", "example": "VCVTDQ2PS ymm1, ymm2/m256" }, { "mnemonic": "vcvtps2dq", "architecture": "x86", "full_name": "Convert Packed Single to Packed Doubleword", "summary": "Converts four floats to 32-bit integers (Rounded).", "syntax": "VCVTPS2DQ ymm1, ymm2/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F.WIG 5B /r", "visual_parts": [], "binary_pattern": "VEX | 66 | 0F | 5B", "bit_positions": "+0 | +3 | +4 | +5" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src", "type": "ymm2/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Converts four packed single-precision floating-point values to four packed 32-bit signed doubleword integers using the current MXCSR rounding mode. Overflowing results saturate to INT32_MIN or INT32_MAX; inexact results may set the PE flag in MXCSR. Available in 128-bit (XMM) and 256-bit (YMM) variants; the 256-bit form converts eight floats. No legacy x86 flags are modified.", "pseudocode": "if VEX.L = 0:\n for i in 0 to 1:\n xmm1[i] ← convert_float_to_dword_rounded(xmm2[i])\nelse:\n for i in 0 to 3:\n ymm1[i] ← convert_float_to_dword_rounded(ymm2[i])\nupdate_MXCSR_flags()", "example": "VCVTPS2DQ ymm1, ymm2/m256" }, { "mnemonic": "vcvttps2dq", "architecture": "x86", "full_name": "Convert with Truncation Packed Single to Doubleword", "summary": "Converts four floats to 32-bit integers (Truncated).", "syntax": "VCVTTPS2DQ ymm1, ymm2/m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.F3.0F.WIG 5B /r", "visual_parts": [], "binary_pattern": "VEX | F3 | 0F | 5B", "bit_positions": "+0 | +3 | +4 | +5" }, "extension": "AVX", "operands": [ { "name": "dest", "type": "ymm1", "desc": "256-bit YMM AVX register" }, { "name": "src", "type": "ymm2/m256", "desc": "256-bit YMM AVX register or Memory operand" } ], "description": "Converts four packed single-precision floating-point values to four packed 32-bit signed doubleword integers by truncating toward zero (ignoring MXCSR rounding mode). Overflowing results saturate to INT32_MIN or INT32_MAX; inexact results may set the PE flag in MXCSR. Available in 128-bit (XMM) and 256-bit (YMM) variants; the 256-bit form converts eight floats. No legacy x86 flags are modified.", "pseudocode": "if VEX.L = 0:\n for i in 0 to 1:\n xmm1[i] ← convert_float_to_dword_truncate(xmm2[i])\nelse:\n for i in 0 to 3:\n ymm1[i] ← convert_float_to_dword_truncate(ymm2[i])\nupdate_MXCSR_flags()", "example": "VCVTTPS2DQ ymm1, ymm2/m256" }, { "mnemonic": "iret", "architecture": "x86", "full_name": "Interrupt Return", "summary": "Returns from an interrupt, exception, or task handler.", "syntax": "IRET", "encoding": { "format": "Legacy", "hex_opcode": "CF", "visual_parts": [], "binary_pattern": "CF", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Returns from an interrupt handler, exception handler, or nested task by popping the return address and EFLAGS from the stack and resuming execution at the interrupted instruction. In protected mode, also restores CPL and task context; in 64-bit mode (IRETQ), pops a 64-bit return address. This instruction performs memory serialization and may reload segment registers, making it a heavy-weight operation that flushes pending stores.", "pseudocode": "if OperandSize = 16:\n temp_IP ← [SP]; SP ← SP + 2\n temp_CS ← [SP]; SP ← SP + 2\n EFLAGS ← [SP]; SP ← SP + 2\nelse if OperandSize = 32:\n temp_EIP ← [ESP]; ESP ← ESP + 4\n temp_CS ← [ESP]; ESP ← ESP + 4\n EFLAGS ← [ESP]; ESP ← ESP + 4\nelse if OperandSize = 64:\n temp_RIP ← [RSP]; RSP ← RSP + 8\n temp_CS ← [RSP]; RSP ← RSP + 8\n EFLAGS ← [RSP]; RSP ← RSP + 8\nCS ← temp_CS\nIP/EIP/RIP ← temp_IP/EIP/RIP", "example": "IRET" }, { "mnemonic": "iretd", "architecture": "x86", "full_name": "Interrupt Return Doubleword", "summary": "Returns from interrupt (32-bit operand size).", "syntax": "IRETD", "encoding": { "format": "Legacy", "hex_opcode": "CF", "visual_parts": [], "binary_pattern": "CF", "bit_positions": "+0" }, "extension": "Base", "operands": [], "description": "Returns from an interrupt handler by explicitly using 32-bit operand size, popping the 32-bit return address (EIP) and EFLAGS from the stack. In protected mode, also restores the code segment (CS) and CPL; in real mode, only pops EIP and EFLAGS. This instruction serializes memory and may trigger privilege-level transitions or task switches, causing pipeline flushing.", "pseudocode": "temp_EIP ← [ESP]; ESP ← ESP + 4\ntemp_CS ← [ESP]; ESP ← ESP + 4\ntemp_EFLAGS ← [ESP]; ESP ← ESP + 4\nCS ← temp_CS\nEIP ← temp_EIP\nEFLAGS ← temp_EFLAGS", "example": "IRETD" }, { "mnemonic": "iretq", "architecture": "x86", "full_name": "Interrupt Return Quadword", "summary": "Returns from interrupt (64-bit operand size).", "syntax": "IRETQ", "encoding": { "format": "Legacy", "hex_opcode": "REX.W + CF", "visual_parts": [], "binary_pattern": "CF", "bit_positions": "+0" }, "extension": "Base (64-bit)", "operands": [], "description": "Returns from an interrupt handler using 64-bit operand size, popping the 64-bit return address (RIP), code segment (CS), and RFLAGS from the stack. Exclusively available in 64-bit long mode; enables return to user-mode code and handles CPL transitions. This is a heavy-weight serializing instruction that flushes pending operations and may reload hidden segment state.", "pseudocode": "temp_RIP ← [RSP]; RSP ← RSP + 8\ntemp_CS ← [RSP]; RSP ← RSP + 8\ntemp_RFLAGS ← [RSP]; RSP ← RSP + 8\nCS ← temp_CS\nRIP ← temp_RIP\nRFLAGS ← temp_RFLAGS", "example": "IRETQ" }, { "mnemonic": "in", "architecture": "x86", "full_name": "Input from Port (Variable)", "summary": "Reads data from I/O port specified in DX.", "syntax": "IN AL/AX/EAX, DX", "encoding": { "format": "Legacy", "hex_opcode": "ED", "visual_parts": [], "binary_pattern": "EC", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "AL/AX/EAX", "desc": "Implicit accumulator: AL, AX, or EAX (depends on operand size)" }, { "name": "src", "type": "DX", "desc": "Implicit DX register (I/O port address)" } ], "description": "Reads 8, 16, or 32 bits from an I/O port whose address is specified in the DX register and stores the result in the AL, AX, or EAX accumulator respectively. The port number in DX is zero-extended to a full I/O address; I/O addressing and privilege checks are performed according to the IOPL field and TSS I/O bitmap. This instruction does not modify any flag bits and may have side effects on the I/O device.", "pseudocode": "port_address ← DX\nif operand_size = 8:\n AL ← I/O_Read(port_address, 1)\nelse if operand_size = 16:\n AX ← I/O_Read(port_address, 2)\nelse if operand_size = 32:\n EAX ← I/O_Read(port_address, 4)", "example": "IN AL/AX/EAX, DX" }, { "mnemonic": "out", "architecture": "x86", "full_name": "Output to Port (Variable)", "summary": "Writes data to I/O port specified in DX.", "syntax": "OUT DX, AL/AX/EAX", "encoding": { "format": "Legacy", "hex_opcode": "EF", "visual_parts": [], "binary_pattern": "EE", "bit_positions": "+0" }, "extension": "Base", "operands": [ { "name": "dest", "type": "DX", "desc": "Implicit DX register (I/O port address)" }, { "name": "src", "type": "AL/AX/EAX", "desc": "Implicit accumulator: AL, AX, or EAX (depends on operand size)" } ], "description": "Writes data from the accumulator (AL, AX, or EAX depending on operand size) to an I/O port whose address is specified in the DX register. This instruction is used for legacy port-based I/O and requires I/O privilege level (IOPL) in protected/long modes. No CPU flags are affected.", "pseudocode": "port_address ← DX; if (operand_size == 8) { I/O[port_address] ← AL; } else if (operand_size == 16) { I/O[port_address] ← AX; } else if (operand_size == 32) { I/O[port_address] ← EAX; }", "example": "OUT DX, AL/AX/EAX" }, { "mnemonic": "vpopcntq", "architecture": "x86", "full_name": "Packed Population Count Quadword", "summary": "Counts set bits in each quadword element.", "syntax": "VPOPCNTQ zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 55 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 55", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VPOPCNTDQ", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Counts the number of set bits (population count) in each 64-bit quadword element of the source operand and stores the result in the destination ZMM register. This is an AVX-512-VPOPCNTDQ instruction that operates on 512-bit vectors (8 quadwords). Masking via the opmask register k1 can selectively update or zero destination elements; no CPU arithmetic flags are modified.", "pseudocode": "for i ← 0 to 7 do { if (k1[i] or not_masked) { dst.qword[i] ← popcount(src.qword[i]); } else { dst.qword[i] ← 0; } }", "example": "VPOPCNTQ zmm1, zmm2/m512" }, { "mnemonic": "vpopcntw", "architecture": "x86", "full_name": "Packed Population Count Word", "summary": "Counts set bits in each word element.", "syntax": "VPOPCNTW zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 54 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 54", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-BITALG", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "zmm2/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Counts the number of set bits (population count) in each 16-bit word element of the source operand and stores the result in the destination ZMM register. This is an AVX-512-BITALG instruction that operates on 512-bit vectors (32 words). Masking via opmask register k1 allows selective element updates; no CPU arithmetic flags are modified.", "pseudocode": "for i ← 0 to 31 do { if (k1[i] or not_masked) { dst.word[i] ← popcount(src.word[i]); } else { dst.word[i] ← 0; } }", "example": "VPOPCNTW zmm1, zmm2/m512" }, { "mnemonic": "vpcompressw", "architecture": "x86", "full_name": "Store Sparse Packed Word Integer Values", "summary": "Compresses active words from ZMM to memory.", "syntax": "VPCOMPRESSW m512 {k1}, zmm1", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 63 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 63", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VBMI2", "operands": [ { "name": "dest", "type": "m512", "desc": "512-bit memory operand" }, { "name": "src", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" } ], "description": "Compresses active 16-bit word elements from the source ZMM register into contiguous locations in memory, guided by the opmask register k1. Only elements where the corresponding mask bit is set are written to memory in order; unmasked elements are skipped. This is an AVX-512-VBMI2 instruction; no CPU flags are affected.", "pseudocode": "mem_offset ← 0; for i ← 0 to 31 do { if (k1[i]) { [dest + mem_offset] ← src.word[i]; mem_offset ← mem_offset + 2; } }", "example": "VPCOMPRESSW [rbp-64], zmm1" }, { "mnemonic": "vpexpandw", "architecture": "x86", "full_name": "Load Sparse Packed Word Integer Values", "summary": "Expands words from memory into sparse locations in ZMM.", "syntax": "VPEXPANDW zmm1 {k1}, m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 62 /r", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 62", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VBMI2", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src", "type": "m512", "desc": "512-bit memory operand" } ], "description": "Expands 16-bit word elements from memory into sparse positions within the destination ZMM register, guided by the opmask register k1. Words are read sequentially from memory and written to destination positions where the corresponding mask bit is set. This is an AVX-512-VBMI2 instruction; no CPU flags are affected.", "pseudocode": "mem_offset ← 0; for i ← 0 to 31 do { if (k1[i]) { dst.word[i] ← [src + mem_offset]; mem_offset ← mem_offset + 2; } else { dst.word[i] ← 0; } }", "example": "VPEXPANDW zmm1, [rbp-64]" }, { "mnemonic": "vpshldw", "architecture": "x86", "full_name": "Packed Shift Left Word Concatenate", "summary": "Funnel shift left of words.", "syntax": "VPSHLDW zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 70 /r /ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 70", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VBMI2", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs a funnel (concatenate and shift) left operation on pairs of 16-bit word elements: the result is (src1 || src2) shifted left by the count specified in imm8 modulo 16. This is an AVX-512-VBMI2 instruction operating on 32 word elements per 512-bit vector. Masking via k1 allows selective updates; no CPU arithmetic flags are modified.", "pseudocode": "for i ← 0 to 31 do { if (k1[i] or not_masked) { combined ← (src1.word[i] << 16) | src2.word[i]; shift_count ← imm8 & 0xF; dst.word[i] ← (combined >> (16 - shift_count)) & 0xFFFF; } }", "example": "VPSHLDW zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpshldq", "architecture": "x86", "full_name": "Packed Shift Left Quadword Concatenate", "summary": "Funnel shift left of quadwords.", "syntax": "VPSHLDQ zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 71 /r /ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 71", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VBMI2", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs a funnel (concatenate and shift) left operation on pairs of 64-bit quadword elements: the result is (src1 || src2) shifted left by the count specified in imm8 modulo 64. This is an AVX-512-VBMI2 instruction operating on 8 quadword elements per 512-bit vector. Masking via k1 allows selective updates; no CPU arithmetic flags are modified.", "pseudocode": "for i ← 0 to 7 do { if (k1[i] or not_masked) { combined_hi ← src1.qword[i]; combined_lo ← src2.qword[i]; shift_count ← imm8 & 0x3F; if (shift_count == 0) { dst.qword[i] ← combined_lo; } else if (shift_count < 64) { dst.qword[i] ← (combined_lo >> (64 - shift_count)) | (combined_hi << shift_count); } else { dst.qword[i] ← combined_hi << (shift_count - 64); } } }", "example": "VPSHLDQ zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpshrdw", "architecture": "x86", "full_name": "Packed Shift Right Word Concatenate", "summary": "Funnel shift right of words.", "syntax": "VPSHRDW zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 72 /r /ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 72", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VBMI2", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs a funnel (concatenate and shift) right operation on pairs of 16-bit word elements: the result is (src1 || src2) shifted right by the count specified in imm8 modulo 16. This is an AVX-512-VBMI2 instruction operating on 32 word elements per 512-bit vector. Masking via k1 allows selective updates; no CPU arithmetic flags are modified.", "pseudocode": "for i ← 0 to 31 do { if (k1[i] or not_masked) { combined ← (src1.word[i] << 16) | src2.word[i]; shift_count ← imm8 & 0xF; dst.word[i] ← (combined >> shift_count) & 0xFFFF; } }", "example": "VPSHRDW zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vpshrdq", "architecture": "x86", "full_name": "Packed Shift Right Quadword Concatenate", "summary": "Funnel shift right of quadwords.", "syntax": "VPSHRDQ zmm1 {k1}, zmm2, zmm3/m512, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F3A.W1 73 /r /ib", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 3A | 73", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VBMI2", "operands": [ { "name": "dest", "type": "zmm1", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" }, { "name": "src3", "type": "imm8", "desc": "8-bit signed immediate" } ], "description": "Performs a funnel shift right operation on packed 64-bit quadwords across two source operands. Each 64-bit element in zmm2 is concatenated with the corresponding element in zmm3/m512, and the result is shifted right by the amount specified in imm8 (modulo 64), with the lower bits written to zmm1. No flags are affected by this instruction.", "pseudocode": "for i = 0 to 7 {\n concatenated = (zmm3[i+1] << 64) | zmm2[i];\n zmm1[i] = (concatenated >> (imm8 % 64)) & 0xFFFFFFFFFFFFFFFF;\n}", "example": "VPSHRDQ zmm1, zmm2, zmm3/m512, 3" }, { "mnemonic": "vp2intersectq", "architecture": "x86", "full_name": "Compute Intersection Pair Quadwords", "summary": "Computes intersection of two ZMM registers into mask pair.", "syntax": "VP2INTERSECTQ k1+1, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.NDS.512.F2.0F38.W1 68 /r", "visual_parts": [], "binary_pattern": "EVEX | F2 | 0F | 38 | 68", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "extension": "AVX-512-VP2INTERSECT", "operands": [ { "name": "dest", "type": "k1+1", "desc": "Opmask register pair (k1 and the next adjacent register)" }, { "name": "src1", "type": "zmm2", "desc": "512-bit ZMM AVX-512 register" }, { "name": "src2", "type": "zmm3/m512", "desc": "512-bit ZMM AVX-512 register or Memory operand" } ], "description": "Computes the intersection of two sets of 64-bit quadwords, producing a pair of opmask registers (k1 and k1+1) indicating which elements from the first operand have matches in the second operand. The instruction uses special hardware logic to compare quadwords and set mask bits accordingly. No arithmetic flags are affected.", "pseudocode": "for i = 0 to 7 {\n found_in_src2 = 0;\n for j = 0 to 7 {\n if (zmm2[i] == zmm3[j]) {\n found_in_src2 = 1;\n break;\n }\n }\n if (found_in_src2) k1[i] = 1; else k1[i] = 0;\n // k1+1 contains further comparison results or inverted results\n}", "example": "VP2INTERSECTQ k1+1, zmm2, zmm3/m512" }, { "mnemonic": "tdpbuud", "architecture": "x86", "full_name": "Tile Dot Product Byte Unsigned Unsigned Doubleword", "summary": "Matrix multiply (Unsigned * Unsigned) accumulating to Int32.", "syntax": "TDPBUUD tmm1, tmm2, tmm3", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.NP.0F38.W0 5E 11:rrr:bbb", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AMX-INT8", "operands": [ { "name": "dest", "type": "tmm1", "desc": "AMX tile register" }, { "name": "src1", "type": "tmm2", "desc": "AMX tile register" }, { "name": "src2", "type": "tmm3", "desc": "AMX tile register" } ], "description": "Performs a tile-based dot product operation on 8×32 unsigned byte matrix tmm2 and 32×8 unsigned byte matrix tmm3, accumulating the 32-bit unsigned results into 8×8 doubleword tile tmm1. The instruction uses specialized AMX hardware for fast matrix multiplication without affecting EFLAGS.", "pseudocode": "for i = 0 to 7 {\n for j = 0 to 7 {\n product = 0;\n for k = 0 to 31 {\n product += (unsigned)tmm2[i][k] * (unsigned)tmm3[k][j];\n }\n tmm1[i][j] += product;\n }\n}", "example": "TDPBUUD tmm1, tmm2, tmm3" }, { "mnemonic": "tdpbusd", "architecture": "x86", "full_name": "Tile Dot Product Byte Unsigned Signed Doubleword", "summary": "Matrix multiply (Unsigned * Signed) accumulating to Int32.", "syntax": "TDPBUSD tmm1, tmm2, tmm3", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.66.0F38.W0 5E 11:rrr:bbb", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AMX-INT8", "operands": [ { "name": "dest", "type": "tmm1", "desc": "AMX tile register" }, { "name": "src1", "type": "tmm2", "desc": "AMX tile register" }, { "name": "src2", "type": "tmm3", "desc": "AMX tile register" } ], "description": "Performs a tile-based dot product operation multiplying 8×32 unsigned byte matrix tmm2 by 32×8 signed byte matrix tmm3, accumulating the 32-bit signed results into 8×8 doubleword tile tmm1. This is the unsigned-by-signed variant of tile dot product, useful for mixed-precision neural network operations without affecting EFLAGS.", "pseudocode": "for i = 0 to 7 {\n for j = 0 to 7 {\n product = 0;\n for k = 0 to 31 {\n product += (unsigned)tmm2[i][k] * (signed)tmm3[k][j];\n }\n tmm1[i][j] += product;\n }\n}", "example": "TDPBUSD tmm1, tmm2, tmm3" }, { "mnemonic": "tileloaddt1", "architecture": "x86", "full_name": "Load Tile Data (T1 Hint)", "summary": "Loads data into an AMX tile register with T1 hint.", "syntax": "TILELOADDT1 tmm1, m", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.66.0F38.W0 4B !(11):rrr:100", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "extension": "AMX-TILE", "operands": [ { "name": "dest", "type": "tmm1", "desc": "AMX tile register" }, { "name": "src", "type": "m", "desc": "Memory operand" } ], "description": "Loads tile data from memory into an AMX tile register with a T1 (temporal) cache hint, indicating the data is likely to be used soon. The memory operand is typically addressed via a base register and optional displacement, and the tile dimensions are pre-configured via TILECONFIG. No flags are affected.", "pseudocode": "tmm1 = load_from_memory_with_t1_hint(m);\n// Tile shape determined by previously configured palette and TILECFG register", "example": "TILELOADDT1 tmm1, [rbp-8]" }, { "mnemonic": "aesdecwide128kl", "architecture": "x86", "full_name": "AES Decrypt Wide 128-bit Key Locker", "summary": "Decrypts 8 blocks using 128-bit Key Locker handle.", "syntax": "AESDECWIDE128KL m128", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 D8 !(11):001:bbb", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | D8", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "KEYLOCKER_WIDE", "operands": [ { "name": "dest", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Decrypts 8 AES blocks (128 bits each) in parallel using a 128-bit Key Locker encrypted key handle stored at the memory operand. The ciphertext blocks are implicit in XMM0-XMM7 (input) and plaintext results are written back to XMM0-XMM7 (output). The ZF flag is set to 0 on success or 1 if the key handle is invalid.", "pseudocode": "key_handle = load_from_memory_128bit(m128);\nif (key_handle_invalid(key_handle)) {\n ZF = 1;\n} else {\n for i = 0 to 7 {\n XMM[i] = AES_decrypt_block(XMM[i], key_handle);\n }\n ZF = 0;\n}", "example": "AESDECWIDE128KL [rbp-16]" }, { "mnemonic": "aesdecwide256kl", "architecture": "x86", "full_name": "AES Decrypt Wide 256-bit Key Locker", "summary": "Decrypts 8 blocks using 256-bit Key Locker handle.", "syntax": "AESDECWIDE256KL m128", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 D8 !(11):011:bbb", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | D8", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "KEYLOCKER_WIDE", "operands": [ { "name": "dest", "type": "m128", "desc": "128-bit memory operand" } ], "description": "Decrypts 8 AES blocks (128 bits each) in parallel using a 256-bit Key Locker encrypted key handle stored at the memory operand. The ciphertext blocks are implicit in XMM0-XMM7 (input) and plaintext results are written back to XMM0-XMM7 (output). The ZF flag is set to 0 on success or 1 if the key handle is invalid.", "pseudocode": "key_handle = load_from_memory_128bit(m128);\nif (key_handle_invalid(key_handle)) {\n ZF = 1;\n} else {\n for i = 0 to 7 {\n XMM[i] = AES_decrypt_block_256bit_key(XMM[i], key_handle);\n }\n ZF = 0;\n}", "example": "AESDECWIDE256KL [rbp-16]" }, { "mnemonic": "encodekey256", "architecture": "x86", "full_name": "Encode 256-bit Key", "summary": "Wraps a 256-bit AES key into a handle.", "syntax": "ENCODEKEY256 r32, r32", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 FB", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | FB", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "KEYLOCKER", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" } ], "description": "Wraps a 256-bit AES key (provided in XMM registers via the second operand's implicit XMM context) into an encrypted handle stored in memory. This instruction is part of Intel Key Locker and requires the KEYLOCKER CPU feature. It performs cryptographic key material encoding that protects against certain side-channel attacks. No flags are modified.", "pseudocode": "handle ← AES_KW_Wrap_256bit(key_material)\ndest ← handle\n// XMM registers implicitly contain the 256-bit key to be encoded", "example": "ENCODEKEY256 eax, eax" }, { "mnemonic": "aesenc256kl", "architecture": "x86", "full_name": "AES Encrypt 256-bit Key Locker", "summary": "Encrypts data using 256-bit Key Locker handle.", "syntax": "AESENC256KL m128, xmm", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 DE !(11):rrr:bbb", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | DC", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "KEYLOCKER", "operands": [ { "name": "dest", "type": "m128", "desc": "128-bit memory operand" }, { "name": "src", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" } ], "description": "Encrypts a 128-bit plaintext block (from XMM register) using a 256-bit Key Locker handle (from memory), storing the ciphertext back into the XMM register. This requires KEYLOCKER support and performs AES-256 encryption with hardware-protected key material. Sets ZF to indicate success/failure of the operation; other flags undefined.", "pseudocode": "handle ← [dest]\nciphertext ← AES_Encrypt_256(plaintext=src, key_handle=handle)\nsrc ← ciphertext\nZF ← (operation_successful ? 0 : 1)", "example": "AESENC256KL [rbp-16], xmm0" }, { "mnemonic": "aesdec256kl", "architecture": "x86", "full_name": "AES Decrypt 256-bit Key Locker", "summary": "Decrypts data using 256-bit Key Locker handle.", "syntax": "AESDEC256KL m128, xmm", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 DF !(11):rrr:bbb", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | DD", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "KEYLOCKER", "operands": [ { "name": "dest", "type": "m128", "desc": "128-bit memory operand" }, { "name": "src", "type": "xmm", "desc": "128-bit SSE/AVX register (XMM)" } ], "description": "Decrypts a 128-bit ciphertext block (from XMM register) using a 256-bit Key Locker handle (from memory), storing the plaintext back into the XMM register. This requires KEYLOCKER support and performs AES-256 decryption with hardware-protected key material. Sets ZF to indicate success/failure of the operation; other flags undefined.", "pseudocode": "handle ← [dest]\nplaintext ← AES_Decrypt_256(ciphertext=src, key_handle=handle)\nsrc ← plaintext\nZF ← (operation_successful ? 0 : 1)", "example": "AESDEC256KL [rbp-16], xmm0" }, { "mnemonic": "enqcmds", "architecture": "x86", "full_name": "Enqueue Command Supervisor", "summary": "Writes a command to a device (Supervisor mode).", "syntax": "ENQCMDS r32, m512", "encoding": { "format": "Legacy", "hex_opcode": "F3 0F 38 F8", "visual_parts": [], "binary_pattern": "F3 | 0F | 38 | F8", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "ENQCMD", "operands": [ { "name": "dest", "type": "r32", "desc": "32-bit general-purpose register (e.g. EAX)" }, { "name": "src", "type": "m512", "desc": "512-bit memory operand" } ], "description": "Enqueues a 512-bit command descriptor to a device queue in supervisor mode only (requires CPL=0). The command is read from memory and written to a device via a memory-mapped queue; requires ENQCMD CPU feature. Sets ZF and CF flags: ZF=1 if queue is full, CF=1 if access denied or invalid descriptor format. Other flags undefined.", "pseudocode": "if (CPL != 0) { fault ← true; return; }\ndescriptor ← [src]\nstatus ← enqueue_device_command(descriptor)\ndest ← status\nZF ← (queue_full ? 1 : 0)\nCF ← (access_denied_or_invalid ? 1 : 0)", "example": "ENQCMDS eax, [rbp-64]" }, { "mnemonic": "xsusldtrk", "architecture": "x86", "full_name": "Suspend Tracking Load Addresses", "summary": "Suspends tracking of load addresses in a TSX suspend-tracking region (resumed with XRESLDTRK).", "syntax": "XSUSLDTRK", "encoding": { "format": "Legacy", "hex_opcode": "F2 0F 01 E8", "visual_parts": [], "binary_pattern": "F2 | 0F | 01 | E8", "bit_positions": "+0 | +1 | +2 | +3" }, "extension": "TSXLDTRK", "operands": [], "description": "Suspends or resumes tracking of load operations within a TSX (Transactional Synchronization Extensions) transaction. Requires TSX support and TSX_LDTRK feature flag. Does not modify any flags. This instruction helps fine-tune transaction conflict detection by toggling whether loads are monitored for abort conditions.", "pseudocode": "if (in_transaction) {\n TSX_load_tracking_enabled ← !TSX_load_tracking_enabled\n}", "example": "XSUSLDTRK" }, { "mnemonic": "syscall", "architecture": "x86", "full_name": "System Call", "summary": "Fast call to privilege level 0 system procedures.", "syntax": "SYSCALL", "encoding": { "format": "System", "hex_opcode": "0F 05", "length": "2", "visual_parts": [], "binary_pattern": "0F | 05", "bit_positions": "+0 | +1" }, "operands": [], "extension": "System (64-bit)", "description": "Fast low-latency call to a privilege level 0 system procedure (64-bit mode only). Loads the system call target address from IA32_LSTAR MSR, saves the return address (RIP+2) into RCX, and sets RFLAGS according to IA32_FMASK MSR. Does not set any condition flags; acts as a serializing operation. Requires 64-bit mode and supervisor software setup.", "pseudocode": "RCX ← RIP + 2\nRIP ← IA32_LSTAR\nRFLAGS ← RFLAGS & ~IA32_FMASK\n// Transition to CPL 0 with user code segment", "example": "SYSCALL" }, { "mnemonic": "sysret", "architecture": "x86", "full_name": "Return from System Call", "summary": "Fast return to privilege level 3 user code.", "syntax": "SYSRET", "encoding": { "format": "System", "hex_opcode": "0F 07", "length": "2", "visual_parts": [], "binary_pattern": "0F | 07", "bit_positions": "+0 | +1" }, "operands": [], "extension": "System (64-bit)", "description": "Fast return from a system call invoked via SYSCALL, transitioning from CPL 0 back to CPL 3. Restores the user RIP from RCX and re-enables interrupts/flags as appropriate. Requires 64-bit mode and can only be executed at CPL 0. Does not modify condition flags; serializes instruction stream.", "pseudocode": "RIP ← RCX\n// Transition to CPL 3 with user code segment\n// Restore RFLAGS state (interrupts re-enabled per IA32_FMASK)", "example": "SYSRET" }, { "mnemonic": "sal", "architecture": "x86", "full_name": "Shift Arithmetic Left", "summary": "Shifts bits left (Alias for SHL).", "syntax": "SAL r/m, imm8", "encoding": { "format": "Legacy", "hex_opcode": "C1 /4", "length": "3+", "visual_parts": [], "binary_pattern": "C1 | ModRM", "bit_positions": "+0 | +1" }, "operands": [ { "name": "dest", "desc": "Reg/Mem" }, { "name": "count", "desc": "Immediate" } ], "extension": "Base", "description": "Shifts the bits of the destination operand left by the count specified (immediate or ECX). Each shifted-out bit is moved into CF; vacated bits are filled with zeros. Sets OF if the sign bit changed after the shift, CF from the last shifted bit, ZF and SF based on the result, and PF is undefined. Available in 8/16/32/64-bit variants across all modes.", "pseudocode": "if (count > 0) {\n temp_cf ← dest >> (operand_width - count)\n dest ← (dest << count) & ((1 << operand_width) - 1)\n CF ← temp_cf\n ZF ← (dest == 0 ? 1 : 0)\n SF ← (dest >> (operand_width - 1)) & 1\n if (count == 1) { OF ← (SF != CF ? 1 : 0) }\n else { OF ← undefined }\n PF ← undefined\n}", "example": "SAL rbx, 3" }, { "mnemonic": "cmpsw", "architecture": "x86", "full_name": "Compare String Word", "summary": "Compares word at [ESI] with [EDI].", "syntax": "CMPSW", "encoding": { "format": "Legacy", "hex_opcode": "A7", "length": "2", "visual_parts": [], "binary_pattern": "66 | A7", "bit_positions": "+0 | +1" }, "operands": [ { "name": "DS:[ESI]", "type": "m16", "desc": "First memory operand at DS:ESI (source index register, typically data segment)." }, { "name": "ES:[EDI]", "type": "m16", "desc": "Second memory operand at ES:EDI (destination index register, typically extra segment)." } ], "extension": "Base", "description": "Compares a word (16-bit) at memory address [ESI] with a word at [EDI] by performing an implicit subtraction ([ESI] - [EDI]), updates the EFLAGS register with the result, and increments or decrements both ESI and EDI by 2 depending on the direction flag (DF). The comparison affects OF, SF, ZF, AF, PF, and CF flags but does not modify either operand. Often used with repeat prefixes (REP, REPE, REPNE) for string comparison operations.", "pseudocode": "temp ← [ESI] - [EDI];\nOF ← overflow of subtraction;\nSF ← temp[15];\nZF ← (temp == 0);\nAF ← auxiliary carry of subtraction;\nPF ← parity of temp;\nCF ← borrow;\nif (DF == 0) {\n ESI ← ESI + 2;\n EDI ← EDI + 2;\n} else {\n ESI ← ESI - 2;\n EDI ← EDI - 2;\n}", "example": "CMPSW" }, { "mnemonic": "cmpsd", "architecture": "x86", "full_name": "Compare String Doubleword", "summary": "Compares doubleword at [ESI] with [EDI].", "syntax": "CMPSD", "encoding": { "format": "Legacy", "hex_opcode": "A7", "length": "1", "visual_parts": [], "binary_pattern": "A7", "bit_positions": "+0" }, "operands": [ { "name": "DS:[ESI]", "type": "m32", "desc": "First memory operand at DS:ESI (source index register)." }, { "name": "ES:[EDI]", "type": "m32", "desc": "Second memory operand at ES:EDI (destination index register)." } ], "extension": "Base", "description": "Compares a doubleword (32-bit) at memory address [ESI] with a doubleword at [EDI] by performing an implicit subtraction ([ESI] - [EDI]), updates the EFLAGS register with the result, and increments or decrements both ESI and EDI by 4 depending on the direction flag (DF). The comparison affects OF, SF, ZF, AF, PF, and CF flags but does not modify either operand. Commonly used in 32-bit protected mode or with repeat prefixes for string operations.", "pseudocode": "temp ← [ESI] - [EDI];\nOF ← overflow of subtraction;\nSF ← temp[31];\nZF ← (temp == 0);\nAF ← auxiliary carry of subtraction;\nPF ← parity of temp;\nCF ← borrow;\nif (DF == 0) {\n ESI ← ESI + 4;\n EDI ← EDI + 4;\n} else {\n ESI ← ESI - 4;\n EDI ← EDI - 4;\n}", "example": "CMPSD" }, { "mnemonic": "cmpsq", "architecture": "x86", "full_name": "Compare String Quadword", "summary": "Compares quadword at [RSI] with [RDI].", "syntax": "CMPSQ", "encoding": { "format": "Legacy", "hex_opcode": "REX.W + A7", "length": "2", "visual_parts": [], "binary_pattern": "48 | A7", "bit_positions": "+0 | +1" }, "operands": [ { "name": "DS:[RSI]", "type": "m64", "desc": "First memory operand at DS:RSI (source index register in 64-bit mode)." }, { "name": "DS:[RDI]", "type": "m64", "desc": "Second memory operand at DS:RDI (destination index register in 64-bit mode)." } ], "extension": "Base (64-bit)", "description": "Compares a quadword (64-bit) at memory address [RSI] with a quadword at [RDI] by performing an implicit subtraction ([RSI] - [RDI]), updates the EFLAGS register with the result, and increments or decrements both RSI and RDI by 8 depending on the direction flag (DF). The comparison affects OF, SF, ZF, AF, PF, and CF flags but does not modify either operand. Available only in 64-bit mode; operand size defaults to 64 bits.", "pseudocode": "temp ← [RSI] - [RDI];\nOF ← overflow of subtraction;\nSF ← temp[63];\nZF ← (temp == 0);\nAF ← auxiliary carry of subtraction;\nPF ← parity of temp;\nCF ← borrow;\nif (DF == 0) {\n RSI ← RSI + 8;\n RDI ← RDI + 8;\n} else {\n RSI ← RSI - 8;\n RDI ← RDI - 8;\n}", "example": "CMPSQ" }, { "mnemonic": "scasw", "architecture": "x86", "full_name": "Scan String Word", "summary": "Compares AX with memory at [EDI].", "syntax": "SCASW", "encoding": { "format": "Legacy", "hex_opcode": "AF", "length": "2", "visual_parts": [], "binary_pattern": "66 | AF", "bit_positions": "+0 | +1" }, "operands": [ { "name": "AX", "type": "r16", "desc": "Implicit source register (accumulator) containing the value to be compared." }, { "name": "ES:[EDI]", "type": "m16", "desc": "Memory operand at ES:EDI (destination index register) to be compared against AX." } ], "extension": "Base", "description": "Compares the word in AX with a word at memory address [EDI] by performing an implicit subtraction (AX - [EDI]), updates the EFLAGS register with the result, and increments or decrements EDI by 2 depending on the direction flag (DF). The comparison affects OF, SF, ZF, AF, PF, and CF flags but does not modify either operand. Often used with repeat prefixes (REPE, REPNE) for scanning strings in memory.", "pseudocode": "temp ← AX - [EDI];\nOF ← overflow of subtraction;\nSF ← temp[15];\nZF ← (temp == 0);\nAF ← auxiliary carry of subtraction;\nPF ← parity of temp;\nCF ← borrow;\nif (DF == 0) {\n EDI ← EDI + 2;\n} else {\n EDI ← EDI - 2;\n}", "example": "SCASW" }, { "mnemonic": "scasd", "architecture": "x86", "full_name": "Scan String Doubleword", "summary": "Compares EAX with memory at [EDI].", "syntax": "SCASD", "encoding": { "format": "Legacy", "hex_opcode": "AF", "length": "1", "visual_parts": [], "binary_pattern": "AF", "bit_positions": "+0" }, "operands": [ { "name": "EAX", "type": "r32", "desc": "Implicit source register (accumulator) containing the value to be compared." }, { "name": "ES:[EDI]", "type": "m32", "desc": "Memory operand at ES:EDI (destination index register) to be compared against EAX." } ], "extension": "Base", "description": "Compares the doubleword in EAX with a doubleword at memory address [EDI] by performing an implicit subtraction (EAX - [EDI]), updates the EFLAGS register with the result, and increments or decrements EDI by 4 depending on the direction flag (DF). The comparison affects OF, SF, ZF, AF, PF, and CF flags but does not modify either operand. Commonly used in 32-bit protected mode with repeat prefixes for memory scanning.", "pseudocode": "temp ← EAX - [EDI];\nOF ← overflow of subtraction;\nSF ← temp[31];\nZF ← (temp == 0);\nAF ← auxiliary carry of subtraction;\nPF ← parity of temp;\nCF ← borrow;\nif (DF == 0) {\n EDI ← EDI + 4;\n} else {\n EDI ← EDI - 4;\n}", "example": "SCASD" }, { "mnemonic": "scasq", "architecture": "x86", "full_name": "Scan String Quadword", "summary": "Compares RAX with memory at [RDI].", "syntax": "SCASQ", "encoding": { "format": "Legacy", "hex_opcode": "REX.W + AF", "length": "2", "visual_parts": [], "binary_pattern": "48 | AF", "bit_positions": "+0 | +1" }, "operands": [ { "name": "RAX", "type": "r64", "desc": "Implicit source register (accumulator in 64-bit mode) containing the value to be compared." }, { "name": "DS:[RDI]", "type": "m64", "desc": "Memory operand at DS:RDI (destination index register in 64-bit mode) to be compared against RAX." } ], "extension": "Base (64-bit)", "description": "Compares the quadword in RAX with a quadword at memory address [RDI] by performing an implicit subtraction (RAX - [RDI]), updates the EFLAGS register with the result, and increments or decrements RDI by 8 depending on the direction flag (DF). The comparison affects OF, SF, ZF, AF, PF, and CF flags but does not modify either operand. Available only in 64-bit mode; commonly used with repeat prefixes for scanning 64-bit values in memory.", "pseudocode": "temp ← RAX - [RDI];\nOF ← overflow of subtraction;\nSF ← temp[63];\nZF ← (temp == 0);\nAF ← auxiliary carry of subtraction;\nPF ← parity of temp;\nCF ← borrow;\nif (DF == 0) {\n RDI ← RDI + 8;\n} else {\n RDI ← RDI - 8;\n}", "example": "SCASQ" }, { "mnemonic": "lodsw", "architecture": "x86", "full_name": "Load String Word", "summary": "Loads word from [ESI] into AX.", "syntax": "LODSW", "encoding": { "format": "Legacy", "hex_opcode": "AD", "length": "2", "visual_parts": [], "binary_pattern": "66 | AC", "bit_positions": "+0 | +1" }, "operands": [ { "name": "AX", "type": "r16", "desc": "Implicit destination register (accumulator) where the loaded word is stored." }, { "name": "DS:[ESI]", "type": "m16", "desc": "Memory operand at DS:ESI (source index register) from which the word is loaded." } ], "extension": "Base", "description": "Loads a word (16-bit) from memory at address [ESI] into the AX register, then increments or decrements ESI by 2 depending on the direction flag (DF). No flags are affected by this instruction. Often used with repeat prefix (REP) to load successive words from memory into AX, though the repeat would only load the final value.", "pseudocode": "AX ← [ESI];\nif (DF == 0) {\n ESI ← ESI + 2;\n} else {\n ESI ← ESI - 2;\n}", "example": "LODSW" }, { "mnemonic": "lodsd", "architecture": "x86", "full_name": "Load String Doubleword", "summary": "Loads doubleword from [ESI] into EAX.", "syntax": "LODSD", "encoding": { "format": "Legacy", "hex_opcode": "AD", "length": "1", "visual_parts": [], "binary_pattern": "AC", "bit_positions": "+0" }, "operands": [ { "name": "EAX", "type": "r32", "desc": "Implicit destination register (accumulator) where the loaded doubleword is stored." }, { "name": "DS:[ESI]", "type": "m32", "desc": "Memory operand at DS:ESI (source index register) from which the doubleword is loaded." } ], "extension": "Base", "description": "Loads a doubleword (32-bit) from memory at address [ESI] into the EAX register, then increments or decrements ESI by 4 depending on the direction flag (DF). No flags are affected by this instruction. Commonly used in 32-bit protected mode or with repeat prefix (REP) to load successive doublewords, though the repeat would only retain the final value in EAX.", "pseudocode": "EAX ← [ESI];\nif (DF == 0) {\n ESI ← ESI + 4;\n} else {\n ESI ← ESI - 4;\n}", "example": "LODSD" }, { "mnemonic": "lodsq", "architecture": "x86", "full_name": "Load String Quadword", "summary": "Loads quadword from [RSI] into RAX.", "syntax": "LODSQ", "encoding": { "format": "Legacy", "hex_opcode": "REX.W + AD", "length": "2", "visual_parts": [], "binary_pattern": "48 | AC", "bit_positions": "+0 | +1" }, "operands": [], "extension": "Base (64-bit)", "description": "Loads a 64-bit value from memory at [RSI] into RAX, then adjusts RSI by ±8 based on the direction flag (DF). This is a string primitive operation commonly used in loops with REP prefix. No flags are affected by this instruction itself.", "pseudocode": "RAX ← [RSI];\nif (DF == 0) RSI ← RSI + 8;\nelse RSI ← RSI - 8;", "example": "LODSQ" }, { "mnemonic": "stosw", "architecture": "x86", "full_name": "Store String Word", "summary": "Stores AX to memory at [EDI].", "syntax": "STOSW", "encoding": { "format": "Legacy", "hex_opcode": "AB", "length": "2", "visual_parts": [], "binary_pattern": "66 | AA", "bit_positions": "+0 | +1" }, "operands": [], "extension": "Base", "description": "Stores the 16-bit value in AX to memory at [EDI], then adjusts EDI by ±2 based on the direction flag (DF). This is a string primitive typically used with REP prefix for bulk memory fills. No flags are affected.", "pseudocode": "[EDI] ← AX;\nif (DF == 0) EDI ← EDI + 2;\nelse EDI ← EDI - 2;", "example": "STOSW" }, { "mnemonic": "stosd", "architecture": "x86", "full_name": "Store String Doubleword", "summary": "Stores EAX to memory at [EDI].", "syntax": "STOSD", "encoding": { "format": "Legacy", "hex_opcode": "AB", "length": "1", "visual_parts": [], "binary_pattern": "AA", "bit_positions": "+0" }, "operands": [], "extension": "Base", "description": "Stores the 32-bit value in EAX to memory at [EDI], then adjusts EDI by ±4 based on the direction flag (DF). This is a string primitive commonly used with REP prefix for fast memory initialization. No flags are affected.", "pseudocode": "[EDI] ← EAX;\nif (DF == 0) EDI ← EDI + 4;\nelse EDI ← EDI - 4;", "example": "STOSD" }, { "mnemonic": "stosq", "architecture": "x86", "full_name": "Store String Quadword", "summary": "Stores RAX to memory at [RDI].", "syntax": "STOSQ", "encoding": { "format": "Legacy", "hex_opcode": "REX.W + AB", "length": "2", "visual_parts": [], "binary_pattern": "48 | AA", "bit_positions": "+0 | +1" }, "operands": [], "extension": "Base (64-bit)", "description": "Stores the 64-bit value in RAX to memory at [RDI], then adjusts RDI by ±8 based on the direction flag (DF). Available only in 64-bit mode, this is a string primitive typically used with REP prefix for bulk memory operations. No flags are affected.", "pseudocode": "[RDI] ← RAX;\nif (DF == 0) RDI ← RDI + 8;\nelse RDI ← RDI - 8;", "example": "STOSQ" }, { "mnemonic": "movsw", "architecture": "x86", "full_name": "Move String Word", "summary": "Moves word from [ESI] to [EDI].", "syntax": "MOVSW", "encoding": { "format": "Legacy", "hex_opcode": "A5", "length": "2", "visual_parts": [], "binary_pattern": "66 | A5", "bit_positions": "+0 | +1" }, "operands": [], "extension": "Base", "description": "Copies a 16-bit word from memory at [ESI] to memory at [EDI], then adjusts both ESI and EDI by ±2 based on the direction flag (DF). This is a string primitive commonly used with REP prefix for memory-to-memory block moves. No flags are affected.", "pseudocode": "[EDI] ← [ESI];\nif (DF == 0) { ESI ← ESI + 2; EDI ← EDI + 2; }\nelse { ESI ← ESI - 2; EDI ← EDI - 2; }", "example": "MOVSW" }, { "mnemonic": "movsd", "architecture": "x86", "full_name": "Move String Doubleword", "summary": "Moves doubleword from [ESI] to [EDI].", "syntax": "MOVSD", "encoding": { "format": "Legacy", "hex_opcode": "A5", "length": "1", "visual_parts": [], "binary_pattern": "A5", "bit_positions": "+0" }, "operands": [], "extension": "Base", "description": "Copies a 32-bit doubleword from memory at [ESI] to memory at [EDI], then adjusts both ESI and EDI by ±4 based on the direction flag (DF). This is a string primitive frequently used with REP prefix for fast memory copy operations. No flags are affected.", "pseudocode": "[EDI] ← [ESI];\nif (DF == 0) { ESI ← ESI + 4; EDI ← EDI + 4; }\nelse { ESI ← ESI - 4; EDI ← EDI - 4; }", "example": "MOVSD" }, { "mnemonic": "movsq", "architecture": "x86", "full_name": "Move String Quadword", "summary": "Moves quadword from [RSI] to [RDI].", "syntax": "MOVSQ", "encoding": { "format": "Legacy", "hex_opcode": "REX.W + A5", "length": "2", "visual_parts": [], "binary_pattern": "48 | A5", "bit_positions": "+0 | +1" }, "operands": [], "extension": "Base (64-bit)", "description": "Copies a 64-bit quadword from memory at [RSI] to memory at [RDI], then adjusts both RSI and RDI by ±8 based on the direction flag (DF). Available only in 64-bit mode, this string primitive is commonly used with REP prefix for optimized memory block copies. No flags are affected.", "pseudocode": "[RDI] ← [RSI];\nif (DF == 0) { RSI ← RSI + 8; RDI ← RDI + 8; }\nelse { RSI ← RSI - 8; RDI ← RDI - 8; }", "example": "MOVSQ" }, { "mnemonic": "insw", "architecture": "x86", "full_name": "Input String Word from Port", "summary": "Reads word from I/O port to memory at [EDI].", "syntax": "INSW", "encoding": { "format": "Legacy", "hex_opcode": "6D", "length": "2", "visual_parts": [], "binary_pattern": "66 | 6D", "bit_positions": "+0 | +1" }, "operands": [], "extension": "Base", "description": "Reads a 16-bit word from the I/O port specified in DX into memory at [EDI], then adjusts EDI by ±2 based on the direction flag (DF). This instruction is privileged and typically used with REP prefix for bulk I/O input operations. No flags are affected.", "pseudocode": "[EDI] ← IO_PORT[DX];\nif (DF == 0) EDI ← EDI + 2;\nelse EDI ← EDI - 2;", "example": "INSW" }, { "mnemonic": "insd", "architecture": "x86", "full_name": "Input String Doubleword from Port", "summary": "Reads doubleword from I/O port to memory at [EDI].", "syntax": "INSD", "encoding": { "format": "Legacy", "hex_opcode": "6D", "length": "1", "visual_parts": [], "binary_pattern": "6D", "bit_positions": "+0" }, "operands": [ { "name": "DX", "type": "implicit", "desc": "The 16-bit port address register, implicitly selects the I/O port." }, { "name": "EDI", "type": "implicit", "desc": "The destination memory address register; auto-incremented or auto-decremented based on DF." } ], "extension": "Base", "description": "Reads a 32-bit doubleword from the I/O port specified by the DX register and stores it in memory at the linear address [EDI]. The EDI register is then incremented or decremented based on the DF (Direction Flag); DF=0 increments EDI by 4, DF=1 decrements by 4. This instruction is typically used within a REP prefix loop for block I/O transfers and requires I/O privilege level in protected mode.", "pseudocode": "memory[EDI] ← IO_PORT[DX];\nif (DF == 0) {\n EDI ← EDI + 4;\n} else {\n EDI ← EDI - 4;\n}", "example": "INSD" }, { "mnemonic": "outsw", "architecture": "x86", "full_name": "Output String Word to Port", "summary": "Writes word from memory at [ESI] to I/O port.", "syntax": "OUTSW", "encoding": { "format": "Legacy", "hex_opcode": "6F", "length": "2", "visual_parts": [], "binary_pattern": "66 | 6F", "bit_positions": "+0 | +1" }, "operands": [ { "name": "DX", "type": "implicit", "desc": "The 16-bit port address register, implicitly selects the I/O port." }, { "name": "ESI", "type": "implicit", "desc": "The source memory address register; auto-incremented or auto-decremented based on DF." } ], "extension": "Base", "description": "Reads a 16-bit word from memory at the linear address [ESI] and writes it to the I/O port specified by the DX register. The ESI register is then incremented or decremented based on the DF flag; DF=0 increments ESI by 2, DF=1 decrements by 2. This instruction is typically used within a REP prefix loop for block I/O transfers and requires I/O privilege level in protected mode.", "pseudocode": "IO_PORT[DX] ← memory[ESI];\nif (DF == 0) {\n ESI ← ESI + 2;\n} else {\n ESI ← ESI - 2;\n}", "example": "OUTSW" }, { "mnemonic": "outsd", "architecture": "x86", "full_name": "Output String Doubleword to Port", "summary": "Writes doubleword from memory at [ESI] to I/O port.", "syntax": "OUTSD", "encoding": { "format": "Legacy", "hex_opcode": "6F", "length": "1", "visual_parts": [], "binary_pattern": "6F", "bit_positions": "+0" }, "operands": [ { "name": "DX", "type": "implicit", "desc": "The 16-bit port address register, implicitly selects the I/O port." }, { "name": "ESI", "type": "implicit", "desc": "The source memory address register; auto-incremented or auto-decremented based on DF." } ], "extension": "Base", "description": "Reads a 32-bit doubleword from memory at the linear address [ESI] and writes it to the I/O port specified by the DX register. The ESI register is then incremented or decremented based on the DF flag; DF=0 increments ESI by 4, DF=1 decrements by 4. This instruction is typically used within a REP prefix loop for block I/O transfers and requires I/O privilege level in protected mode.", "pseudocode": "IO_PORT[DX] ← memory[ESI];\nif (DF == 0) {\n ESI ← ESI + 4;\n} else {\n ESI ← ESI - 4;\n}", "example": "OUTSD" }, { "mnemonic": "fld1", "architecture": "x86", "full_name": "Load Constant 1.0", "summary": "Pushes +1.0 onto the FPU register stack.", "syntax": "FLD1", "encoding": { "format": "Legacy", "hex_opcode": "D9 E8", "length": "2", "visual_parts": [], "binary_pattern": "D9 | E8", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Decrements the FPU stack pointer (ST(7)→ST(0)), then loads the constant +1.0 (extended precision double) into the top of the x87 FPU register stack (ST(0)). The instruction sets the C1 flag to 0 and leaves other status flags unchanged unless a stack overflow occurs (C0, C2, C3 may be set on exception). No CPU integer flags are affected.", "pseudocode": "FPU_TOP ← FPU_TOP - 1;\nif (FPU_TOP overflow) {\n raise FPU_EXCEPTION;\n}\nST(0) ← +1.0;", "example": "FLD1" }, { "mnemonic": "fldz", "architecture": "x86", "full_name": "Load Constant +0.0", "summary": "Pushes +0.0 onto the FPU register stack.", "syntax": "FLDZ", "encoding": { "format": "Legacy", "hex_opcode": "D9 EE", "length": "2", "visual_parts": [], "binary_pattern": "D9 | EE", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Decrements the FPU stack pointer (ST(7)→ST(0)), then loads the constant +0.0 (extended precision double) into the top of the x87 FPU register stack (ST(0)). The instruction sets the C1 flag to 0 and leaves other status flags unchanged unless a stack overflow occurs. No CPU integer flags are affected.", "pseudocode": "FPU_TOP ← FPU_TOP - 1;\nif (FPU_TOP overflow) {\n raise FPU_EXCEPTION;\n}\nST(0) ← +0.0;", "example": "FLDZ" }, { "mnemonic": "fldpi", "architecture": "x86", "full_name": "Load Constant Pi", "summary": "Pushes Pi onto the FPU register stack.", "syntax": "FLDPI", "encoding": { "format": "Legacy", "hex_opcode": "D9 EB", "length": "2", "visual_parts": [], "binary_pattern": "D9 | EB", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Decrements the FPU stack pointer (ST(7)→ST(0)), then loads the constant Pi (π ≈ 3.14159265..., extended precision) into the top of the x87 FPU register stack (ST(0)). The instruction sets the C1 flag to 0 and leaves other status flags unchanged unless a stack overflow occurs. No CPU integer flags are affected.", "pseudocode": "FPU_TOP ← FPU_TOP - 1;\nif (FPU_TOP overflow) {\n raise FPU_EXCEPTION;\n}\nST(0) ← π;", "example": "FLDPI" }, { "mnemonic": "fldl2e", "architecture": "x86", "full_name": "Load Constant log2(e)", "summary": "Pushes log2(e) onto the FPU register stack.", "syntax": "FLDL2E", "encoding": { "format": "Legacy", "hex_opcode": "D9 EA", "length": "2", "visual_parts": [], "binary_pattern": "D9 | EA", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Decrements the FPU stack pointer (ST(7)→ST(0)), then loads the constant log₂(e) (≈ 1.44269504..., extended precision) into the top of the x87 FPU register stack (ST(0)). This constant is useful for logarithm and exponential calculations. The instruction sets the C1 flag to 0 and leaves other status flags unchanged unless a stack overflow occurs.", "pseudocode": "FPU_TOP ← FPU_TOP - 1;\nif (FPU_TOP overflow) {\n raise FPU_EXCEPTION;\n}\nST(0) ← log₂(e);", "example": "FLDL2E" }, { "mnemonic": "fldl2t", "architecture": "x86", "full_name": "Load Constant log2(10)", "summary": "Pushes log2(10) onto the FPU register stack.", "syntax": "FLDL2T", "encoding": { "format": "Legacy", "hex_opcode": "D9 E9", "length": "2", "visual_parts": [], "binary_pattern": "D9 | E9", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Decrements the FPU stack pointer (ST(7)→ST(0)), then loads the constant log₂(10) (≈ 3.32192809..., extended precision) into the top of the x87 FPU register stack (ST(0)). This constant is useful for base-10 logarithm calculations. The instruction sets the C1 flag to 0 and leaves other status flags unchanged unless a stack overflow occurs.", "pseudocode": "FPU_TOP ← FPU_TOP - 1;\nif (FPU_TOP overflow) {\n raise FPU_EXCEPTION;\n}\nST(0) ← log₂(10);", "example": "FLDL2T" }, { "mnemonic": "fldlg2", "architecture": "x86", "full_name": "Load Constant log10(2)", "summary": "Pushes log10(2) onto the FPU register stack.", "syntax": "FLDLG2", "encoding": { "format": "Legacy", "hex_opcode": "D9 EC", "length": "2", "visual_parts": [], "binary_pattern": "D9 | EC", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Pushes the constant log₁₀(2) ≈ 0.30103 onto the FPU register stack, incrementing the stack pointer (TOP). This is a zero-operand x87 FPU instruction that loads a precomputed constant into ST(0). No flags are modified by this instruction.", "pseudocode": "TOP ← (TOP - 1) mod 8; ST(0) ← log10(2);", "example": "FLDLG2" }, { "mnemonic": "fldln2", "architecture": "x86", "full_name": "Load Constant ln(2)", "summary": "Pushes ln(2) onto the FPU register stack.", "syntax": "FLDLN2", "encoding": { "format": "Legacy", "hex_opcode": "D9 ED", "length": "2", "visual_parts": [], "binary_pattern": "D9 | ED", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Pushes the constant ln(2) ≈ 0.69315 onto the FPU register stack, incrementing the stack pointer (TOP). This is a zero-operand x87 FPU instruction that loads a precomputed constant into ST(0). No flags are modified by this instruction.", "pseudocode": "TOP ← (TOP - 1) mod 8; ST(0) ← ln(2);", "example": "FLDLN2" }, { "mnemonic": "fincstp", "architecture": "x86", "full_name": "Increment Stack-Top Pointer", "summary": "Increments the TOP field in the FPU status word.", "syntax": "FINCSTP", "encoding": { "format": "Legacy", "hex_opcode": "D9 F7", "length": "2", "visual_parts": [], "binary_pattern": "D9 | F7", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Increments the TOP field (bits 13:11) of the x87 FPU status word, rotating the register stack pointer forward by one position. This is a zero-operand instruction that does not modify CPU EFLAGS. It is used to manually adjust the FPU stack pointer without popping data.", "pseudocode": "TOP ← (TOP + 1) mod 8;", "example": "FINCSTP" }, { "mnemonic": "fdecstp", "architecture": "x86", "full_name": "Decrement Stack-Top Pointer", "summary": "Decrements the TOP field in the FPU status word.", "syntax": "FDECSTP", "encoding": { "format": "Legacy", "hex_opcode": "D9 F6", "length": "2", "visual_parts": [], "binary_pattern": "D9 | F6", "bit_positions": "+0 | +1" }, "operands": [], "extension": "x87 FPU", "description": "Decrements the TOP field (bits 13:11) of the x87 FPU status word, rotating the register stack pointer backward by one position. This is a zero-operand instruction that does not modify CPU EFLAGS. It is used to manually adjust the FPU stack pointer without pushing data.", "pseudocode": "TOP ← (TOP - 1) mod 8;", "example": "FDECSTP" }, { "mnemonic": "ffree", "architecture": "x86", "full_name": "Free Floating-Point Register", "summary": "Sets the tag for ST(i) to empty.", "syntax": "FFREE ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "DD C0+i", "length": "2", "visual_parts": [], "binary_pattern": "DD", "bit_positions": "+0" }, "operands": [ { "name": "dest", "desc": "Register" } ], "extension": "x87 FPU", "description": "Sets the tag bits for the specified FPU register to 11b (empty), marking it as unused without removing its value from the register. This instruction does not pop the stack or modify EFLAGS. It is commonly used to release floating-point registers for reuse.", "pseudocode": "Tag[ST(i)] ← 11b;", "example": "FFREE st(1)" }, { "mnemonic": "fcmovb", "architecture": "x86", "full_name": "Floating-Point Conditional Move If Below", "summary": "Moves ST(i) to ST(0) if CF=1.", "syntax": "FCMOVB ST(0), ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "DA C0+i", "length": "2", "visual_parts": [], "binary_pattern": "DA", "bit_positions": "+0" }, "operands": [ { "name": "src", "desc": "Register" } ], "extension": "x87 FPU (P6+)", "description": "Conditionally moves ST(i) to ST(0) if the carry flag (CF) is set, based on a prior integer comparison or EFLAGS state. This x87 instruction available on Pentium Pro and later does not modify EFLAGS; it only reads CF to determine whether to execute the move. If CF=0, no move occurs and ST(0) remains unchanged.", "pseudocode": "if (CF == 1) { ST(0) ← ST(i); }", "example": "FCMOVB st(0), st(1)" }, { "mnemonic": "fcmove", "architecture": "x86", "full_name": "Floating-Point Conditional Move If Equal", "summary": "Moves ST(i) to ST(0) if ZF=1.", "syntax": "FCMOVE ST(0), ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "DA C8+i", "length": "2", "visual_parts": [], "binary_pattern": "DA", "bit_positions": "+0" }, "operands": [ { "name": "src", "desc": "Register" } ], "extension": "x87 FPU (P6+)", "description": "Conditionally moves ST(i) to ST(0) if the zero flag (ZF) is set, based on a prior integer comparison or EFLAGS state. This x87 instruction available on Pentium Pro and later does not modify EFLAGS; it only reads ZF to determine whether to execute the move. If ZF=0, no move occurs and ST(0) remains unchanged.", "pseudocode": "if (ZF == 1) { ST(0) ← ST(i); }", "example": "FCMOVE st(0), st(1)" }, { "mnemonic": "fcmovbe", "architecture": "x86", "full_name": "Floating-Point Conditional Move If Below or Equal", "summary": "Moves ST(i) to ST(0) if CF=1 or ZF=1.", "syntax": "FCMOVBE ST(0), ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "DA D0+i", "length": "2", "visual_parts": [], "binary_pattern": "DA", "bit_positions": "+0" }, "operands": [ { "name": "src", "desc": "Register" } ], "extension": "x87 FPU (P6+)", "description": "Conditionally moves ST(i) to ST(0) if the carry flag (CF) is set or the zero flag (ZF) is set, based on a prior integer comparison or EFLAGS state. This x87 instruction available on Pentium Pro and later does not modify EFLAGS; it only reads CF and ZF to determine whether to execute the move. If neither CF nor ZF is set, no move occurs.", "pseudocode": "if ((CF == 1) || (ZF == 1)) { ST(0) ← ST(i); }", "example": "FCMOVBE st(0), st(1)" }, { "mnemonic": "fcmovu", "architecture": "x86", "full_name": "Floating-Point Conditional Move If Unordered", "summary": "Moves ST(i) to ST(0) if PF=1.", "syntax": "FCMOVU ST(0), ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "DA D8+i", "length": "2", "visual_parts": [], "binary_pattern": "DA", "bit_positions": "+0" }, "operands": [ { "name": "src", "desc": "Register" } ], "extension": "x87 FPU (P6+)", "description": "Conditionally moves the value in ST(i) to ST(0) if the parity flag (PF) is set, indicating an unordered comparison result (one or both operands are NaN). This instruction is part of the x87 FPU conditional move family introduced in P6 and later processors. No flags are modified by this instruction.", "pseudocode": "if (PF == 1) { ST(0) ← ST(i); }", "example": "FCMOVU st(0), st(1)" }, { "mnemonic": "fcmovnb", "architecture": "x86", "full_name": "Floating-Point Conditional Move If Not Below", "summary": "Moves ST(i) to ST(0) if CF=0.", "syntax": "FCMOVNB ST(0), ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "DB C0+i", "length": "2", "visual_parts": [], "binary_pattern": "DB", "bit_positions": "+0" }, "operands": [ { "name": "src", "desc": "Register" } ], "extension": "x87 FPU (P6+)", "description": "Conditionally moves the value in ST(i) to ST(0) if the carry flag (CF) is clear, indicating the first operand is not below the second in an x87 FPU comparison context. This is part of the x87 conditional move instruction set available on P6 and later processors. No flags are modified by this instruction.", "pseudocode": "if (CF == 0) { ST(0) ← ST(i); }", "example": "FCMOVNB st(0), st(1)" }, { "mnemonic": "fcmovne", "architecture": "x86", "full_name": "Floating-Point Conditional Move If Not Equal", "summary": "Moves ST(i) to ST(0) if ZF=0.", "syntax": "FCMOVNE ST(0), ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "DB C8+i", "length": "2", "visual_parts": [], "binary_pattern": "DB", "bit_positions": "+0" }, "operands": [ { "name": "src", "desc": "Register" } ], "extension": "x87 FPU (P6+)", "description": "Conditionally moves the value in ST(i) to ST(0) if the zero flag (ZF) is clear, indicating the operands are not equal in an x87 FPU comparison context. This instruction is part of the x87 conditional move family on P6 and later processors. No flags are modified by this instruction.", "pseudocode": "if (ZF == 0) { ST(0) ← ST(i); }", "example": "FCMOVNE st(0), st(1)" }, { "mnemonic": "fcmovnbe", "architecture": "x86", "full_name": "Floating-Point Conditional Move If Not Below or Equal", "summary": "Moves ST(i) to ST(0) if CF=0 and ZF=0.", "syntax": "FCMOVNBE ST(0), ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "DB D0+i", "length": "2", "visual_parts": [], "binary_pattern": "DB", "bit_positions": "+0" }, "operands": [ { "name": "src", "desc": "Register" } ], "extension": "x87 FPU (P6+)", "description": "Conditionally moves the value in ST(i) to ST(0) if both the carry flag (CF) and zero flag (ZF) are clear, indicating the first operand is greater than the second in an x87 FPU comparison context. This instruction is part of the x87 conditional move set on P6 and later processors. No flags are modified by this instruction.", "pseudocode": "if (CF == 0 && ZF == 0) { ST(0) ← ST(i); }", "example": "FCMOVNBE st(0), st(1)" }, { "mnemonic": "fcmovnu", "architecture": "x86", "full_name": "Floating-Point Conditional Move If Not Unordered", "summary": "Moves ST(i) to ST(0) if PF=0.", "syntax": "FCMOVNU ST(0), ST(i)", "encoding": { "format": "Legacy", "hex_opcode": "DB D8+i", "length": "2", "visual_parts": [], "binary_pattern": "DB", "bit_positions": "+0" }, "operands": [ { "name": "src", "desc": "Register" } ], "extension": "x87 FPU (P6+)", "description": "Conditionally moves the value in ST(i) to ST(0) if the parity flag (PF) is clear, indicating an ordered comparison result (neither operand is NaN) in x87 FPU context. This instruction is part of the x87 conditional move family on P6 and later processors. No flags are modified by this instruction.", "pseudocode": "if (PF == 0) { ST(0) ← ST(i); }", "example": "FCMOVNU st(0), st(1)" }, { "mnemonic": "packuswb", "architecture": "x86", "full_name": "Pack with Unsigned Saturation Word to Byte", "summary": "Converts signed words to unsigned bytes with saturation.", "syntax": "PACKUSWB xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 67", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | 67", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Converts four signed 16-bit words from each of two XMM registers or memory into eight unsigned 8-bit bytes with unsigned saturation, storing the result in the destination XMM register. Values greater than 255 saturate to 255, and negative values saturate to 0. No flags are affected by this instruction; it is an SSE2 SIMD operation.", "pseudocode": "for (i = 0; i < 4; i++) {\n temp1[i] = (dest[i*16:i*16+15] < 0) ? 0 : ((dest[i*16:i*16+15] > 255) ? 255 : dest[i*16:i*16+15]);\n temp2[i] = (src[i*16:i*16+15] < 0) ? 0 : ((src[i*16:i*16+15] > 255) ? 255 : src[i*16:i*16+15]);\n}\ndest[0:7] = temp1[0]; dest[8:15] = temp1[1]; dest[16:23] = temp1[2]; dest[24:31] = temp1[3];\ndest[32:39] = temp2[0]; dest[40:47] = temp2[1]; dest[48:55] = temp2[2]; dest[56:63] = temp2[3];", "example": "PACKUSWB xmm1, xmm2/m128" }, { "mnemonic": "punpckhbw", "architecture": "x86", "full_name": "Unpack High Data Bytes", "summary": "Interleaves high bytes from two sources.", "syntax": "PUNPCKHBW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 68", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | 68", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Interleaves the high-order bytes from corresponding positions in the destination and source XMM registers, storing bytes from the destination in even-indexed positions and source bytes in odd-indexed positions of the result. This SSE2 instruction performs no flag modifications and operates on 128-bit packed data.", "pseudocode": "for (i = 0; i < 8; i++) {\n result[i*2] = dest[i*8+64:i*8+71];\n result[i*2+1] = src[i*8+64:i*8+71];\n}\ndest ← result;", "example": "PUNPCKHBW xmm1, xmm2/m128" }, { "mnemonic": "punpckhwd", "architecture": "x86", "full_name": "Unpack High Data Words", "summary": "Interleaves high words.", "syntax": "PUNPCKHWD xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 69", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | 69", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Interleaves the high-order words from corresponding positions in the destination and source XMM registers, storing words from the destination in even-indexed positions and source words in odd-indexed positions of the result. This SSE2 instruction performs no flag modifications and operates on 128-bit packed data.", "pseudocode": "for (i = 0; i < 4; i++) {\n result[i*2] = dest[i*16+64:i*16+79];\n result[i*2+1] = src[i*16+64:i*16+79];\n}\ndest ← result;", "example": "PUNPCKHWD xmm1, xmm2/m128" }, { "mnemonic": "punpckhdq", "architecture": "x86", "full_name": "Unpack High Data Doublewords", "summary": "Interleaves high doublewords.", "syntax": "PUNPCKHDQ xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 6A", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | 6A", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Unpacks and interleaves the high-order 32-bit doublewords from the destination and source XMM registers into the destination. The instruction treats the 128-bit XMM register as four 32-bit elements, selects elements 1 and 3 (the high two), and interleaves them as [src[3], dest[3], src[1], dest[1]]. No flags are affected.", "pseudocode": "dest[0:31] ← dest[63:32]\ndest[32:63] ← src[63:32]\ndest[64:95] ← dest[127:96]\ndest[96:127] ← src[127:96]", "example": "PUNPCKHDQ xmm1, xmm2/m128" }, { "mnemonic": "punpckhqdq", "architecture": "x86", "full_name": "Unpack High Data Quadwords", "summary": "Interleaves high quadwords.", "syntax": "PUNPCKHQDQ xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 6D", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | 6D", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Unpacks and interleaves the high-order 64-bit quadwords from the destination and source XMM registers into the destination. The instruction treats the 128-bit XMM register as two 64-bit elements, selects element 1 (the high half), and interleaves them as [src[1], dest[1]]. No flags are affected.", "pseudocode": "dest[0:63] ← dest[127:64]\ndest[64:127] ← src[127:64]", "example": "PUNPCKHQDQ xmm1, xmm2/m128" }, { "mnemonic": "psadbw", "architecture": "x86", "full_name": "Compute Sum of Absolute Differences", "summary": "Computes absolute differences of bytes and sums them to words.", "syntax": "PSADBW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F F6", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | F6", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Computes the absolute value of the difference for each of 16 packed unsigned bytes in the destination and source, then sums those differences within 64-bit groups and stores the results as two 64-bit values. Useful for motion estimation and SAD (Sum of Absolute Differences) operations. No flags are affected.", "pseudocode": "sum_low ← 0\nsum_high ← 0\nfor i in 0..7:\n sum_low ← sum_low + abs(dest[i*8 + 7:i*8] - src[i*8 + 7:i*8])\nfor i in 8..15:\n sum_high ← sum_high + abs(dest[i*8 + 7:i*8] - src[i*8 + 7:i*8])\ndest[0:63] ← sum_low\ndest[64:127] ← sum_high", "example": "PSADBW xmm1, xmm2/m128" }, { "mnemonic": "pmaxub", "architecture": "x86", "full_name": "Maximum of Packed Unsigned Byte Integers", "summary": "Returns maximum of unsigned bytes.", "syntax": "PMAXUB xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F DE", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | DE", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Compares each of 16 packed unsigned bytes in the destination and source registers and stores the maximum value of each pair into the destination. This is an element-wise unsigned 8-bit maximum operation. No flags are affected.", "pseudocode": "for i in 0..15:\n dest[i*8 + 7:i*8] ← max(dest[i*8 + 7:i*8], src[i*8 + 7:i*8])", "example": "PMAXUB xmm1, xmm2/m128" }, { "mnemonic": "pminub", "architecture": "x86", "full_name": "Minimum of Packed Unsigned Byte Integers", "summary": "Returns minimum of unsigned bytes.", "syntax": "PMINUB xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F DA", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | DA", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Compares each of 16 packed unsigned bytes in the destination and source registers and stores the minimum value of each pair into the destination. This is an element-wise unsigned 8-bit minimum operation. No flags are affected.", "pseudocode": "for i in 0..15:\n dest[i*8 + 7:i*8] ← min(dest[i*8 + 7:i*8], src[i*8 + 7:i*8])", "example": "PMINUB xmm1, xmm2/m128" }, { "mnemonic": "pmaxsw", "architecture": "x86", "full_name": "Maximum of Packed Signed Word Integers", "summary": "Returns maximum of signed words.", "syntax": "PMAXSW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F EE", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | EE", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Compares each of 8 packed signed words in the destination and source registers and stores the maximum value of each pair into the destination. This is an element-wise signed 16-bit maximum operation. No flags are affected.", "pseudocode": "for i in 0..7:\n dest[i*16 + 15:i*16] ← max_signed(dest[i*16 + 15:i*16], src[i*16 + 15:i*16])", "example": "PMAXSW xmm1, xmm2/m128" }, { "mnemonic": "pminsw", "architecture": "x86", "full_name": "Minimum of Packed Signed Word Integers", "summary": "Returns minimum of signed words.", "syntax": "PMINSW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F EA", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | EA", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Compares each of 8 packed signed words in the destination and source registers and stores the minimum value of each pair into the destination. This is an element-wise signed 16-bit minimum operation. No flags are affected.", "pseudocode": "for i in 0..7:\n dest[i*16 + 15:i*16] ← min_signed(dest[i*16 + 15:i*16], src[i*16 + 15:i*16])", "example": "PMINSW xmm1, xmm2/m128" }, { "mnemonic": "pavgb", "architecture": "x86", "full_name": "Average Packed Integers (Byte)", "summary": "Averages packed unsigned bytes (rounded up).", "syntax": "PAVGB xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F E0", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | E0", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Computes the average of each pair of 16 packed unsigned bytes in the destination and source registers, rounding up (toward positive infinity), and stores the results into the destination. The formula is (a + b + 1) >> 1 for each byte pair. No flags are affected.", "pseudocode": "for i in 0..15:\n dest[i*8 + 7:i*8] ← (dest[i*8 + 7:i*8] + src[i*8 + 7:i*8] + 1) >> 1", "example": "PAVGB xmm1, xmm2/m128" }, { "mnemonic": "pavgw", "architecture": "x86", "full_name": "Average Packed Integers (Word)", "summary": "Averages packed unsigned words (rounded up).", "syntax": "PAVGW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F E3", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | E3", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Averages packed unsigned 16-bit integers element-wise, rounding up by adding 1 before shifting right. Each pair of corresponding 16-bit words from the destination and source are averaged independently and stored back in the destination. No flags are affected; this is a data-parallel operation with no special side effects.", "pseudocode": "for i = 0 to 7:\n dest.word[i] ← (dest.word[i] + src.word[i] + 1) >> 1", "example": "PAVGW xmm1, xmm2/m128" }, { "mnemonic": "pmulhuw", "architecture": "x86", "full_name": "Packed Multiply High Unsigned", "summary": "Multiplies unsigned words, keeps high 16 bits.", "syntax": "PMULHUW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F E4", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | E4", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Multiplies packed unsigned 16-bit integers and stores the high 16 bits of each 32-bit product. Each pair of corresponding 16-bit unsigned words from destination and source are multiplied (producing 32-bit results), and only the upper 16 bits are retained. No flags are affected.", "pseudocode": "for i = 0 to 7:\n product ← (uint32_t)dest.word[i] * (uint32_t)src.word[i]\n dest.word[i] ← (uint16_t)(product >> 16)", "example": "PMULHUW xmm1, xmm2/m128" }, { "mnemonic": "pmulhw", "architecture": "x86", "full_name": "Packed Multiply High Signed", "summary": "Multiplies signed words, keeps high 16 bits.", "syntax": "PMULHW xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F E5", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | E5", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Multiplies packed signed 16-bit integers and stores the high 16 bits of each 32-bit product. Each pair of corresponding 16-bit signed words from destination and source are multiplied (producing 32-bit results), and only the upper 16 bits are retained. No flags are affected.", "pseudocode": "for i = 0 to 7:\n product ← (int32_t)dest.sword[i] * (int32_t)src.sword[i]\n dest.sword[i] ← (int16_t)(product >> 16)", "example": "PMULHW xmm1, xmm2/m128" }, { "mnemonic": "psubq", "architecture": "x86", "full_name": "Packed Subtract Quadword", "summary": "Subtracts packed quadwords.", "syntax": "PSUBQ xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F FB", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | FB", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Subtracts packed 64-bit integers element-wise without saturation. The two 64-bit integers in the destination are each subtracted from by the corresponding 64-bit integers in the source, and results wrap on overflow. No flags are affected; wrapping behavior is identical to 64-bit integer subtraction.", "pseudocode": "for i = 0 to 1:\n dest.quad[i] ← dest.quad[i] - src.quad[i]", "example": "PSUBQ xmm1, xmm2/m128" }, { "mnemonic": "pmuludq", "architecture": "x86", "full_name": "Multiply Packed Unsigned Doubleword Integers", "summary": "Multiplies low 32-bits of each 64-bit chunk to 64-bit result.", "syntax": "PMULUDQ xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F F4", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | F4", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Multiplies the low 32-bit doublewords of packed unsigned integers, producing 64-bit products. The even-indexed 32-bit elements (0, 2) from destination and source are multiplied, and the 64-bit results are written back to the even positions. No flags are affected.", "pseudocode": "dest.quad[0] ← (uint64_t)dest.dword[0] * (uint64_t)src.dword[0]\ndest.quad[1] ← (uint64_t)dest.dword[2] * (uint64_t)src.dword[2]", "example": "PMULUDQ xmm1, xmm2/m128" }, { "mnemonic": "pslldq", "architecture": "x86", "full_name": "Shift Double Quadword Left Logical", "summary": "Shifts the entire 128-bit register left by bytes.", "syntax": "PSLLDQ xmm1, imm8", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 73 /7", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 73 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "count", "desc": "Imm" } ], "extension": "SSE2", "description": "Shifts the entire 128-bit value in the destination XMM register left by a byte count, filling with zeros from the right. The shift count is specified as an 8-bit immediate and is applied to the whole register as a unit, not element-wise. No flags are affected.", "pseudocode": "shift_count ← imm8\nif shift_count >= 16:\n dest ← 0\nelse:\n dest ← dest << (shift_count * 8)", "example": "PSLLDQ xmm1, 3" }, { "mnemonic": "psrldq", "architecture": "x86", "full_name": "Shift Double Quadword Right Logical", "summary": "Shifts the entire 128-bit register right by bytes.", "syntax": "PSRLDQ xmm1, imm8", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 73 /3", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 73 | ModRM", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "count", "desc": "Imm" } ], "extension": "SSE2", "description": "Shifts the entire 128-bit value in the destination XMM register right by a byte count, filling with zeros from the left. The shift count is specified as an 8-bit immediate and is applied to the whole register as a unit, not element-wise. No flags are affected.", "pseudocode": "shift_count ← imm8\nif shift_count >= 16:\n dest ← 0\nelse:\n dest ← dest >> (shift_count * 8)", "example": "PSRLDQ xmm1, 3" }, { "mnemonic": "cvtdq2ps", "architecture": "x86", "full_name": "Convert Packed Doubleword Integers to Packed Single-Precision", "summary": "Converts four 32-bit integers to floats.", "syntax": "CVTDQ2PS xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "NP 0F 5B /r", "length": "3+", "visual_parts": [], "binary_pattern": "0F | 5B", "bit_positions": "+0 | +1" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Converts four packed 32-bit signed doubleword integers to four packed single-precision floating-point values. Conversion uses the current rounding mode from MXCSR. Precision may be lost for very large integers; no flags are explicitly set, but the instruction may generate floating-point exceptions via MXCSR.", "pseudocode": "for i = 0 to 3:\n dest.float[i] ← (float)src.dword[i]", "example": "CVTDQ2PS xmm1, xmm2/m128" }, { "mnemonic": "cvtps2dq", "architecture": "x86", "full_name": "Convert Packed Single-Precision to Packed Doubleword Integers", "summary": "Converts four floats to 32-bit integers (Rounded).", "syntax": "CVTPS2DQ xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 5B", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | 5B", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Converts four packed single-precision floating-point values to four packed signed 32-bit integers using the rounding mode specified in MXCSR. If any input is NaN, the result is the minimum signed 32-bit integer (0x80000000). Operates on 128-bit XMM registers and sets ZF, PF, CF based on rounding exceptions in MXCSR.", "pseudocode": "dest[0:31] ← RoundToNearest(src[0:31]); dest[32:63] ← RoundToNearest(src[32:63]); dest[64:95] ← RoundToNearest(src[64:95]); dest[96:127] ← RoundToNearest(src[96:127]);", "example": "CVTPS2DQ xmm1, xmm2/m128" }, { "mnemonic": "cvttps2dq", "architecture": "x86", "full_name": "Convert with Truncation Packed Single-Precision to Packed Doubleword Integers", "summary": "Converts four floats to 32-bit integers (Truncated).", "syntax": "CVTTPS2DQ xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "F3 0F 5B", "length": "4+", "visual_parts": [], "binary_pattern": "F3 | 0F | 5B", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Converts four packed single-precision floating-point values to four packed signed 32-bit integers by truncating toward zero (discarding fractional part). If any input is NaN or out of range, the result is 0x80000000. Operates on 128-bit XMM registers without using MXCSR rounding mode.", "pseudocode": "dest[0:31] ← Truncate(src[0:31]); dest[32:63] ← Truncate(src[32:63]); dest[64:95] ← Truncate(src[64:95]); dest[96:127] ← Truncate(src[96:127]);", "example": "CVTTPS2DQ xmm1, xmm2/m128" }, { "mnemonic": "movmskps", "architecture": "x86", "full_name": "Extract Packed Single-Precision Mask", "summary": "Extracts sign bits from four floats into low 4 bits of register.", "syntax": "MOVMSKPS r32, xmm", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 50 /r", "length": "3", "visual_parts": [], "binary_pattern": "0F | 50", "bit_positions": "+0 | +1" }, "operands": [ { "name": "dest", "desc": "Reg" }, { "name": "src", "desc": "XMM" } ], "extension": "SSE", "description": "Extracts the sign bit (bit 31) from each of four packed single-precision floating-point values in an XMM register and packs them into the low 4 bits of a general-purpose 32-bit register. The upper 28 bits of the destination are cleared. No flags are modified.", "pseudocode": "dest ← 0; dest[0] ← src[31]; dest[1] ← src[63]; dest[2] ← src[95]; dest[3] ← src[127];", "example": "MOVMSKPS eax, xmm0" }, { "mnemonic": "movmskpd", "architecture": "x86", "full_name": "Extract Packed Double-Precision Mask", "summary": "Extracts sign bits from two doubles into low 2 bits of register.", "syntax": "MOVMSKPD r32, xmm", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 50", "length": "4", "visual_parts": [], "binary_pattern": "66 | 0F | 50", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "Reg" }, { "name": "src", "desc": "XMM" } ], "extension": "SSE2", "description": "Extracts the sign bit (bit 63) from each of two packed double-precision floating-point values in an XMM register and packs them into the low 2 bits of a general-purpose 32-bit register. The upper 30 bits of the destination are cleared. No flags are modified.", "pseudocode": "dest ← 0; dest[0] ← src[63]; dest[1] ← src[127];", "example": "MOVMSKPD eax, xmm0" }, { "mnemonic": "comiss", "architecture": "x86", "full_name": "Compare Scalar Ordered Single-Precision", "summary": "Compares low float and sets EFLAGS (Signaling NaN raises exception).", "syntax": "COMISS xmm1, xmm2/m32", "encoding": { "format": "SSE", "hex_opcode": "NP 0F 2F /r", "length": "3+", "visual_parts": [], "binary_pattern": "0F | 2F", "bit_positions": "+0 | +1" }, "operands": [ { "name": "src1", "desc": "XMM" }, { "name": "src2", "desc": "XMM/Mem" } ], "extension": "SSE", "description": "Performs an ordered comparison of the low single-precision floating-point values in two XMM registers or memory, setting EFLAGS (ZF, PF, CF) accordingly. Signals invalid operation exception if either operand is a signaling NaN; quiet NaNs set ZF=1, PF=1, CF=1. Does not modify the XMM registers.", "pseudocode": "src1_val ← src1[0:31] (as float); src2_val ← src2[0:31] (as float); if (IsNaN(src1_val) || IsNaN(src2_val)) { ZF ← 1; PF ← 1; CF ← 1; OF ← 0; AF ← 0; SF ← 0; } else if (src1_val < src2_val) { CF ← 1; ZF ← 0; PF ← 0; OF ← 0; AF ← 0; SF ← 0; } else if (src1_val == src2_val) { ZF ← 1; CF ← 0; PF ← 0; OF ← 0; AF ← 0; SF ← 0; } else { ZF ← 0; CF ← 0; PF ← 0; OF ← 0; AF ← 0; SF ← 0; }", "example": "COMISS xmm1, xmm2/m32" }, { "mnemonic": "comisd", "architecture": "x86", "full_name": "Compare Scalar Ordered Double-Precision", "summary": "Compares low double and sets EFLAGS (Signaling NaN raises exception).", "syntax": "COMISD xmm1, xmm2/m64", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 2F", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | 2F", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "src1", "desc": "XMM" }, { "name": "src2", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Performs an ordered comparison of the low double-precision floating-point values in two XMM registers or memory, setting EFLAGS (ZF, PF, CF) accordingly. Signals invalid operation exception if either operand is a signaling NaN; quiet NaNs set ZF=1, PF=1, CF=1. Does not modify the XMM registers.", "pseudocode": "src1_val ← src1[0:63] (as double); src2_val ← src2[0:63] (as double); if (IsNaN(src1_val) || IsNaN(src2_val)) { ZF ← 1; PF ← 1; CF ← 1; OF ← 0; AF ← 0; SF ← 0; } else if (src1_val < src2_val) { CF ← 1; ZF ← 0; PF ← 0; OF ← 0; AF ← 0; SF ← 0; } else if (src1_val == src2_val) { ZF ← 1; CF ← 0; PF ← 0; OF ← 0; AF ← 0; SF ← 0; } else { ZF ← 0; CF ← 0; PF ← 0; OF ← 0; AF ← 0; SF ← 0; }", "example": "COMISD xmm1, xmm2/m64" }, { "mnemonic": "unpcklpd", "architecture": "x86", "full_name": "Unpack Low Packed Double-Precision", "summary": "Interleaves low doubles from two sources.", "syntax": "UNPCKLPD xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 14", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | 14", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Unpacks and interleaves the low-order 64-bit double-precision values from the destination and source XMM registers, placing the result back in the destination. Destination element 0 receives the low double from dest, element 1 receives the low double from src. No flags are modified.", "pseudocode": "temp ← dest; dest[0:63] ← temp[0:63]; dest[64:127] ← src[0:63];", "example": "UNPCKLPD xmm1, xmm2/m128" }, { "mnemonic": "unpckhpd", "architecture": "x86", "full_name": "Unpack High Packed Double-Precision", "summary": "Interleaves high doubles from two sources.", "syntax": "UNPCKHPD xmm1, xmm2/m128", "encoding": { "format": "SSE2", "hex_opcode": "66 0F 15", "length": "4+", "visual_parts": [], "binary_pattern": "66 | 0F | 15", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE2", "description": "Unpacks and interleaves the high-order 64-bit double-precision values from the destination and source XMM registers, placing the result back in the destination. Destination element 0 receives the high double from dest, element 1 receives the high double from src. No flags are modified.", "pseudocode": "temp ← dest; dest[0:63] ← temp[64:127]; dest[64:127] ← src[64:127];", "example": "UNPCKHPD xmm1, xmm2/m128" }, { "mnemonic": "movshdup", "architecture": "x86", "full_name": "Move Packed Single-FP High and Duplicate", "summary": "Duplicates high element of each qword pair.", "syntax": "MOVSHDUP xmm1, xmm2/m128", "encoding": { "format": "SSE3", "hex_opcode": "F3 0F 16", "length": "4+", "visual_parts": [], "binary_pattern": "F3 | 0F | 16", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE3", "description": "Moves and duplicates the high 32-bit single-precision FP value from each 64-bit pair in the source to both elements of the corresponding pair in the destination. This SSE3 instruction operates on 128-bit XMM registers and does not modify flags. It is used for efficient duplication of high elements in packed FP data.", "pseudocode": "dest[127:96] ← src[127:96];\ndest[95:64] ← src[127:96];\ndest[63:32] ← src[63:32];\ndest[31:0] ← src[63:32];", "example": "MOVSHDUP xmm1, xmm2/m128" }, { "mnemonic": "movsldup", "architecture": "x86", "full_name": "Move Packed Single-FP Low and Duplicate", "summary": "Duplicates low element of each qword pair.", "syntax": "MOVSLDUP xmm1, xmm2/m128", "encoding": { "format": "SSE3", "hex_opcode": "F3 0F 12", "length": "4+", "visual_parts": [], "binary_pattern": "F3 | 0F | 12", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE3", "description": "Moves and duplicates the low 32-bit single-precision FP value from each 64-bit pair in the source to both elements of the corresponding pair in the destination. This SSE3 instruction operates on 128-bit XMM registers and does not modify flags. It is the complement to MOVSHDUP, duplicating low rather than high elements.", "pseudocode": "dest[127:96] ← src[95:64];\ndest[95:64] ← src[95:64];\ndest[63:32] ← src[31:0];\ndest[31:0] ← src[31:0];", "example": "MOVSLDUP xmm1, xmm2/m128" }, { "mnemonic": "phsubw", "architecture": "x86", "full_name": "Packed Horizontal Subtract Word", "summary": "Subtracts adjacent 16-bit integers horizontally.", "syntax": "PHSUBW xmm1, xmm2/m128", "encoding": { "format": "SSSE3", "hex_opcode": "66 0F 38 05", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 05", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSSE3", "description": "Subtracts horizontally adjacent 16-bit signed integers within each 128-bit operand, producing 16-bit results. This SSSE3 instruction performs eight parallel subtractions (higher element minus lower element in each pair) and does not modify EFLAGS. Results that overflow wrap with two's-complement semantics.", "pseudocode": "dest[15:0] ← (int16_t)src[31:16] - (int16_t)src[15:0];\ndest[31:16] ← (int16_t)src[63:48] - (int16_t)src[47:32];\ndest[47:32] ← (int16_t)src[95:80] - (int16_t)src[79:64];\ndest[63:48] ← (int16_t)src[127:112] - (int16_t)src[111:96];", "example": "PHSUBW xmm1, xmm2/m128" }, { "mnemonic": "phsubd", "architecture": "x86", "full_name": "Packed Horizontal Subtract Doubleword", "summary": "Subtracts adjacent 32-bit integers horizontally.", "syntax": "PHSUBD xmm1, xmm2/m128", "encoding": { "format": "SSSE3", "hex_opcode": "66 0F 38 06", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 06", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSSE3", "description": "Subtracts horizontally adjacent 32-bit signed integers within each 128-bit operand, producing 32-bit results. This SSSE3 instruction performs four parallel subtractions (higher element minus lower element in each pair) and does not modify EFLAGS. Results wrap with two's-complement semantics on overflow.", "pseudocode": "dest[31:0] ← (int32_t)src[63:32] - (int32_t)src[31:0];\ndest[63:32] ← (int32_t)src[127:96] - (int32_t)src[95:64];", "example": "PHSUBD xmm1, xmm2/m128" }, { "mnemonic": "pmaddubsw", "architecture": "x86", "full_name": "Multiply and Add Packed Signed and Unsigned Bytes", "summary": "Multiplies signed/unsigned bytes and adds pairs to words.", "syntax": "PMADDUBSW xmm1, xmm2/m128", "encoding": { "format": "SSSE3", "hex_opcode": "66 0F 38 04", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 04", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSSE3", "description": "Multiplies unsigned bytes from the destination by signed bytes from the source, then adds the products pairwise to produce signed 16-bit results with saturation. This SSSE3 instruction performs eight parallel multiply-add operations on byte pairs and does not modify EFLAGS. Results are clamped to the signed 16-bit range [-32768, 32767].", "pseudocode": "for i = 0 to 7:\n prod0 ← (uint8_t)dest[8*i+7:8*i] × (int8_t)src[8*i+7:8*i];\n prod1 ← (uint8_t)dest[8*i+15:8*i+8] × (int8_t)src[8*i+15:8*i+8];\n sum ← (int32_t)prod0 + (int32_t)prod1;\n dest[16*i+15:16*i] ← saturate_to_i16(sum);", "example": "PMADDUBSW xmm1, xmm2/m128" }, { "mnemonic": "phminposuw", "architecture": "x86", "full_name": "Packed Horizontal Minimum", "summary": "Finds minimum word and its index.", "syntax": "PHMINPOSUW xmm1, xmm2/m128", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 41", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 41", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE4.1", "description": "Finds the minimum unsigned 16-bit word among eight packed values and returns the minimum value in the low word of the destination with its index (0-7) in bits 16-18. This SSE4.1 instruction clears bits 19-127 of the destination and does not modify EFLAGS. It is useful for finding the position of minimum values in packed word arrays.", "pseudocode": "min_val ← src[15:0];\nmin_idx ← 0;\nfor i = 1 to 7:\n if (uint16_t)src[16*i+15:16*i] < min_val:\n min_val ← (uint16_t)src[16*i+15:16*i];\n min_idx ← i;\ndest[15:0] ← min_val;\ndest[18:16] ← min_idx;\ndest[127:19] ← 0;", "example": "PHMINPOSUW xmm1, xmm2/m128" }, { "mnemonic": "mpsadbw", "architecture": "x86", "full_name": "Compute Multiple Sums of Absolute Differences", "summary": "Computes multiple SADs of byte blocks.", "syntax": "MPSADBW xmm1, xmm2/m128, imm8", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 3A 42", "length": "6+", "visual_parts": [], "binary_pattern": "66 | 0F | 3A | 42", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" }, { "name": "sel", "desc": "Imm" } ], "extension": "SSE4.1", "description": "Computes multiple sums of absolute differences between corresponding bytes of two blocks selected by an immediate operand. This SSE4.1 instruction computes four parallel SADs, each summing the absolute differences across a byte block, and produces four 16-bit results. EFLAGS is not modified.", "pseudocode": "offset_dest ← (sel & 0x4) ? 4 : 0;\noffset_src ← (sel & 0x3) ? 4 * (sel & 0x3) : 0;\nfor k = 0 to 3:\n sum ← 0;\n for j = 0 to 3:\n idx_d ← offset_dest + 8*k + 8*j;\n idx_s ← offset_src + 8*j;\n sum ← sum + |dest[idx_d+7:idx_d] - src[idx_s+7:idx_s]|;\n dest[16*k+15:16*k] ← sum;", "example": "MPSADBW xmm1, xmm2/m128, 3" }, { "mnemonic": "pmovsxbq", "architecture": "x86", "full_name": "Packed Move with Sign Extend Byte to Quadword", "summary": "Sign extends 8-bit integers to 64-bit.", "syntax": "PMOVSXBQ xmm1, xmm2/m16", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 22", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 22", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE4.1", "description": "Sign-extends the low four bytes of the source to four 64-bit signed integers in the destination. This SSE4.1 instruction operates on 128-bit XMM registers and does not modify EFLAGS. The source may be a 16-bit memory operand or an XMM register; destination bits are filled with the sign bit of each source byte.", "pseudocode": "dest[63:0] ← sign_extend_64((int8_t)src[7:0]);\ndest[127:64] ← sign_extend_64((int8_t)src[15:8]);", "example": "PMOVSXBQ xmm1, xmm2/m16" }, { "mnemonic": "pmovsxwd", "architecture": "x86", "full_name": "Packed Move with Sign Extend Word to Doubleword", "summary": "Sign extends 16-bit integers to 32-bit.", "syntax": "PMOVSXWD xmm1, xmm2/m64", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 23", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 23", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE4.1", "description": "Sign-extends four packed 16-bit signed integers from the source operand to four packed 32-bit signed integers in the destination XMM register. The source is a 64-bit value (lower 64 bits of XMM or 64-bit memory location) containing four 16-bit elements; the destination is an 128-bit XMM register. No flags are affected.", "pseudocode": "xmm1[31:0] ← sign_extend_32(src[15:0]); xmm1[63:32] ← sign_extend_32(src[31:16]); xmm1[95:64] ← sign_extend_32(src[47:32]); xmm1[127:96] ← sign_extend_32(src[63:48]);", "example": "PMOVSXWD xmm1, xmm2/m64" }, { "mnemonic": "pmovsxwq", "architecture": "x86", "full_name": "Packed Move with Sign Extend Word to Quadword", "summary": "Sign extends 16-bit integers to 64-bit.", "syntax": "PMOVSXWQ xmm1, xmm2/m32", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 24", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 24", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE4.1", "description": "Sign-extends two packed 16-bit signed integers from the source operand to two packed 64-bit signed integers in the destination XMM register. The source is a 32-bit value (lower 32 bits of XMM or 32-bit memory location) containing two 16-bit elements; the destination is an 128-bit XMM register. No flags are affected.", "pseudocode": "xmm1[63:0] ← sign_extend_64(src[15:0]); xmm1[127:64] ← sign_extend_64(src[31:16]);", "example": "PMOVSXWQ xmm1, xmm2/m32" }, { "mnemonic": "pmovsxdq", "architecture": "x86", "full_name": "Packed Move with Sign Extend Doubleword to Quadword", "summary": "Sign extends 32-bit integers to 64-bit.", "syntax": "PMOVSXDQ xmm1, xmm2/m64", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 25", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 25", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE4.1", "description": "Sign-extends two packed 32-bit signed integers from the source operand to two packed 64-bit signed integers in the destination XMM register. The source is a 64-bit value (lower 64 bits of XMM or 64-bit memory location) containing two 32-bit elements; the destination is an 128-bit XMM register. No flags are affected.", "pseudocode": "xmm1[63:0] ← sign_extend_64(src[31:0]); xmm1[127:64] ← sign_extend_64(src[63:32]);", "example": "PMOVSXDQ xmm1, xmm2/m64" }, { "mnemonic": "pmovzxbd", "architecture": "x86", "full_name": "Packed Move with Zero Extend Byte to Doubleword", "summary": "Zero extends 8-bit integers to 32-bit.", "syntax": "PMOVZXBD xmm1, xmm2/m32", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 31", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 31", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE4.1", "description": "Zero-extends four packed 8-bit unsigned integers from the source operand to four packed 32-bit unsigned integers in the destination XMM register. The source is a 32-bit value (lower 32 bits of XMM or 32-bit memory location) containing four 8-bit elements; the destination is an 128-bit XMM register. No flags are affected.", "pseudocode": "xmm1[31:0] ← zero_extend_32(src[7:0]); xmm1[63:32] ← zero_extend_32(src[15:8]); xmm1[95:64] ← zero_extend_32(src[23:16]); xmm1[127:96] ← zero_extend_32(src[31:24]);", "example": "PMOVZXBD xmm1, xmm2/m32" }, { "mnemonic": "pmovzxbq", "architecture": "x86", "full_name": "Packed Move with Zero Extend Byte to Quadword", "summary": "Zero extends 8-bit integers to 64-bit.", "syntax": "PMOVZXBQ xmm1, xmm2/m16", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 32", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 32", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE4.1", "description": "Zero-extends two packed 8-bit unsigned integers from the source operand to two packed 64-bit unsigned integers in the destination XMM register. The source is a 16-bit value (lower 16 bits of XMM or 16-bit memory location) containing two 8-bit elements; the destination is an 128-bit XMM register. No flags are affected.", "pseudocode": "xmm1[63:0] ← zero_extend_64(src[7:0]); xmm1[127:64] ← zero_extend_64(src[15:8]);", "example": "PMOVZXBQ xmm1, xmm2/m16" }, { "mnemonic": "pmovzxwd", "architecture": "x86", "full_name": "Packed Move with Zero Extend Word to Doubleword", "summary": "Zero extends 16-bit integers to 32-bit.", "syntax": "PMOVZXWD xmm1, xmm2/m64", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 33", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 33", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE4.1", "description": "Zero-extends four packed 16-bit unsigned integers from the source operand to four packed 32-bit unsigned integers in the destination XMM register. The source is a 64-bit value (lower 64 bits of XMM or 64-bit memory location) containing four 16-bit elements; the destination is an 128-bit XMM register. No flags are affected.", "pseudocode": "xmm1[31:0] ← zero_extend_32(src[15:0]); xmm1[63:32] ← zero_extend_32(src[31:16]); xmm1[95:64] ← zero_extend_32(src[47:32]); xmm1[127:96] ← zero_extend_32(src[63:48]);", "example": "PMOVZXWD xmm1, xmm2/m64" }, { "mnemonic": "pmovzxwq", "architecture": "x86", "full_name": "Packed Move with Zero Extend Word to Quadword", "summary": "Zero extends 16-bit integers to 64-bit.", "syntax": "PMOVZXWQ xmm1, xmm2/m32", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 34", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 34", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE4.1", "description": "Zero-extends two packed 16-bit unsigned integers from the source operand to two packed 64-bit unsigned integers in the destination XMM register. The source is a 32-bit value (lower 32 bits of XMM or 32-bit memory location) containing two 16-bit elements; the destination is an 128-bit XMM register. No flags are affected.", "pseudocode": "xmm1[63:0] ← zero_extend_64(src[15:0]); xmm1[127:64] ← zero_extend_64(src[31:16]);", "example": "PMOVZXWQ xmm1, xmm2/m32" }, { "mnemonic": "pmovzxdq", "architecture": "x86", "full_name": "Packed Move with Zero Extend Doubleword to Quadword", "summary": "Zero extends 32-bit integers to 64-bit.", "syntax": "PMOVZXDQ xmm1, xmm2/m64", "encoding": { "format": "SSE4.1", "hex_opcode": "66 0F 38 35", "length": "5+", "visual_parts": [], "binary_pattern": "66 | 0F | 38 | 35", "bit_positions": "+0 | +1 | +2 | +3" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "SSE4.1", "description": "Zero-extends two packed 32-bit unsigned integers from the source operand to two packed 64-bit unsigned integers in the destination XMM register. The source is a 64-bit value (lower 64 bits of XMM or 64-bit memory location) containing two 32-bit elements; the destination is an 128-bit XMM register. No flags are affected.", "pseudocode": "xmm1[63:0] ← zero_extend_64(src[31:0]); xmm1[127:64] ← zero_extend_64(src[63:32]);", "example": "PMOVZXDQ xmm1, xmm2/m64" }, { "mnemonic": "vbroadcastsd", "architecture": "x86", "full_name": "Broadcast Scalar Double", "summary": "Broadcasts a double to all elements of YMM.", "syntax": "VBROADCASTSD ymm1, m64", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 19 /r", "length": "5+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "Destination YMM register; all four 64-bit lanes receive the value" }, { "name": "src", "desc": "64-bit memory location holding the double-precision value to broadcast" } ], "extension": "AVX2", "description": "Broadcasts a 64-bit double-precision floating-point value from memory to all four 64-bit elements of a 256-bit YMM register. This is a non-temporal data movement that replicates a single FP64 value across the entire YMM destination. No flags are affected.", "pseudocode": "ymm1[63:0] ← m64\nymm1[127:64] ← m64\nymm1[191:128] ← m64\nymm1[255:192] ← m64", "example": "VBROADCASTSD ymm1, [rbp-8]" }, { "mnemonic": "vbroadcastf128", "architecture": "x86", "full_name": "Broadcast 128-bit Floating-Point", "summary": "Broadcasts 128-bit FP block to YMM.", "syntax": "VBROADCASTF128 ymm1, m128", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 1A /r", "length": "5+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "YMM" }, { "name": "src", "desc": "Memory" } ], "extension": "AVX", "description": "Broadcasts a 128-bit floating-point block from memory to both 128-bit halves of a 256-bit YMM register, replicating the 16-byte XMM-sized value twice. This instruction operates on floating-point data and does not affect any flags. Available in AVX mode and higher.", "pseudocode": "ymm1[127:0] ← m128\nymm1[255:128] ← m128", "example": "VBROADCASTF128 ymm1, [rbp-16]" }, { "mnemonic": "vbroadcasti128", "architecture": "x86", "full_name": "Broadcast 128-bit Integer", "summary": "Broadcasts 128-bit integer block to YMM.", "syntax": "VBROADCASTI128 ymm1, m128", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 5A /r", "length": "5+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "YMM" }, { "name": "src", "desc": "Memory" } ], "extension": "AVX2", "description": "Broadcasts a 128-bit integer block from memory to both 128-bit halves of a 256-bit YMM register, replicating the 16-byte value as integer data. This is the integer-domain equivalent of VBROADCASTF128 and does not affect any CPU flags.", "pseudocode": "ymm1[127:0] ← m128\nymm1[255:128] ← m128", "example": "VBROADCASTI128 ymm1, [rbp-16]" }, { "mnemonic": "vpbroadcastw", "architecture": "x86", "full_name": "Broadcast Word", "summary": "Broadcasts a word to all elements of YMM.", "syntax": "VPBROADCASTW ymm1, xmm2/m16", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 79 /r", "length": "5+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "YMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "AVX2", "description": "Broadcasts a 16-bit word value from either an XMM register or memory to all 16-bit elements of a YMM register (16 copies total). The source operand can be a 16-bit memory location or the low word of an XMM register. No flags are modified.", "pseudocode": "val ← (src[15:0])\nfor i ← 0 to 15 do\n ymm1[i*16+15:i*16] ← val\nend for", "example": "VPBROADCASTW ymm1, xmm2/m16" }, { "mnemonic": "vpbroadcastq", "architecture": "x86", "full_name": "Broadcast Quadword", "summary": "Broadcasts a quadword to all elements of YMM.", "syntax": "VPBROADCASTQ ymm1, xmm2/m64", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 59 /r", "length": "5+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "YMM" }, { "name": "src", "desc": "XMM/Mem" } ], "extension": "AVX2", "description": "Broadcasts a 64-bit quadword value from either an XMM register or memory to all 64-bit elements of a YMM register (four copies total). The source can be a 64-bit memory location or the low quadword of an XMM register. No flags are affected.", "pseudocode": "val ← (src[63:0])\nfor i ← 0 to 3 do\n ymm1[i*64+63:i*64] ← val\nend for", "example": "VPBROADCASTQ ymm1, xmm2/m64" }, { "mnemonic": "vmaskmovps", "architecture": "x86", "full_name": "Conditional Move Packed Single-Precision", "summary": "Conditionally loads/stores floats based on mask.", "syntax": "VMASKMOVPS ymm1, ymm2, m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 2C /r", "length": "5+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "YMM" }, { "name": "mask", "desc": "YMM" }, { "name": "src", "desc": "Mem" } ], "extension": "AVX", "description": "Conditionally loads single-precision floating-point values from memory into a YMM register based on per-element mask bits; unset mask bits leave destination elements unchanged. This is a masked memory read operation where the high bit of each 32-bit mask element controls whether the corresponding FP32 is loaded. No flags are modified.", "pseudocode": "for i ← 0 to 7 do\n if ymm2[i*32+31] == 1 then\n ymm1[i*32+31:i*32] ← [memory_address + i*4]\n end if\nend for", "example": "VMASKMOVPS ymm1, ymm2, [rbp-32]" }, { "mnemonic": "vmaskmovpd", "architecture": "x86", "full_name": "Conditional Move Packed Double-Precision", "summary": "Conditionally loads/stores doubles based on mask.", "syntax": "VMASKMOVPD ymm1, ymm2, m256", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 2D /r", "length": "5+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "YMM" }, { "name": "mask", "desc": "YMM" }, { "name": "src", "desc": "Mem" } ], "extension": "AVX", "description": "Conditionally loads double-precision floating-point values from memory into a YMM register based on per-element mask bits; unset mask bits leave destination elements unchanged. This is the FP64 variant of VMASKMOVPS where the high bit of each 64-bit mask element controls the corresponding load. No flags are affected.", "pseudocode": "for i ← 0 to 3 do\n if ymm2[i*64+63] == 1 then\n ymm1[i*64+63:i*64] ← [memory_address + i*8]\n end if\nend for", "example": "VMASKMOVPD ymm1, ymm2, [rbp-32]" }, { "mnemonic": "vpgatherdd", "architecture": "x86", "full_name": "Gather Packed Doubleword with Signed Doubleword Indices", "summary": "Gathers 32-bit integers using 32-bit indices.", "syntax": "VPGATHERDD ymm1, [base+ymm_idx*scale], ymm_mask", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W0 90 /r", "length": "5+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "YMM" }, { "name": "mem", "desc": "Base+Idx" }, { "name": "mask", "desc": "YMM" } ], "extension": "AVX2", "description": "Gathers four doubleword (32-bit) integers from memory using 32-bit sign-extended indices in a YMM register, with per-element masking to conditionally perform each load. Each element of the destination YMM is loaded from [base + ymm_index[i] * scale] if the corresponding mask bit is set; mask elements are zeroed after a successful gather. This instruction serializes memory operations and sets mask elements to zero for loaded lanes.", "pseudocode": "for i ← 0 to 3 do\n if mask_ymm[i*32+31] == 1 then\n ymm1[i*32+31:i*32] ← [base + sign_extend(ymm_idx[i*32+31:i*32]) * scale]\n mask_ymm[i*32+31:i*32] ← 0\n end if\nend for", "example": "VPGATHERDD ymm1, [base+ymm_idx*scale], ymm_mask" }, { "mnemonic": "vpgatherdq", "architecture": "x86", "full_name": "Gather Packed Quadword with Signed Doubleword Indices", "summary": "Gathers 64-bit integers using 32-bit indices.", "syntax": "VPGATHERDQ ymm1, [base+xmm_idx*scale], ymm_mask", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W1 90 /r", "length": "5+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "YMM" }, { "name": "mem", "desc": "Base+Idx" }, { "name": "mask", "desc": "YMM" } ], "extension": "AVX2", "description": "Gathers eight 64-bit integers from memory using four 32-bit signed indices packed in an XMM register, with scale and base address, into a YMM destination. The mask register (YMM) controls which elements are gathered; masked-out elements in the destination are zeroed. All memory access and mask updates occur in parallel, and the instruction serializes the CPU pipeline during execution.", "pseudocode": "for i in 0 to 3:\n if mask[2*i+1:2*i] == all_ones_64bit:\n addr ← base + sign_extend_32_to_64(index[i*32+31:i*32]) * scale\n dest[64*i+63:64*i] ← [addr]\n mask[64*i+63:64*i] ← all_ones_64bit\n else:\n dest[64*i+63:64*i] ← 0\n mask[64*i+63:64*i] ← 0", "example": "VPGATHERDQ ymm1, [base+xmm_idx*scale], ymm_mask" }, { "mnemonic": "vpgatherqd", "architecture": "x86", "full_name": "Gather Packed Doubleword with Signed Quadword Indices", "summary": "Gathers 32-bit integers using 64-bit indices.", "syntax": "VPGATHERQD xmm1, [base+ymm_idx*scale], xmm_mask", "encoding": { "format": "VEX", "hex_opcode": "VEX.128.66.0F38.W0 91 /r", "length": "5+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "mem", "desc": "Base+Idx" }, { "name": "mask", "desc": "XMM" } ], "extension": "AVX2", "description": "Gathers four 32-bit integers from memory using four 64-bit signed indices packed in a YMM register, with scale and base address, into an XMM destination (lower half). The mask register (XMM) controls which elements are gathered; masked-out elements are zeroed and their corresponding mask bits are cleared. The instruction serializes execution and performs all memory accesses in parallel.", "pseudocode": "for i in 0 to 3:\n if mask[32*i+31:32*i] == all_ones_32bit:\n addr ← base + index[64*i+63:64*i] * scale\n dest[32*i+31:32*i] ← [addr]\n mask[32*i+31:32*i] ← all_ones_32bit\n else:\n dest[32*i+31:32*i] ← 0\n mask[32*i+31:32*i] ← 0", "example": "VPGATHERQD xmm1, [base+ymm_idx*scale], xmm_mask" }, { "mnemonic": "vpgatherqq", "architecture": "x86", "full_name": "Gather Packed Quadword with Signed Quadword Indices", "summary": "Gathers 64-bit integers using 64-bit indices.", "syntax": "VPGATHERQQ ymm1, [base+ymm_idx*scale], ymm_mask", "encoding": { "format": "VEX", "hex_opcode": "VEX.256.66.0F38.W1 91 /r", "length": "5+", "visual_parts": [], "binary_pattern": "VEX | opcode | ModRM", "bit_positions": "+0 | +3 | +4" }, "operands": [ { "name": "dest", "desc": "YMM" }, { "name": "mem", "desc": "Base+Idx" }, { "name": "mask", "desc": "YMM" } ], "extension": "AVX2", "description": "Gathers four 64-bit integers from memory using four 64-bit signed indices packed in a YMM register, with scale and base address, into a YMM destination. The mask register (YMM) controls which elements are gathered; masked-out elements are zeroed and their corresponding mask bits are cleared. All memory accesses execute in parallel, and the instruction causes pipeline serialization.", "pseudocode": "for i in 0 to 3:\n if mask[64*i+63:64*i] == all_ones_64bit:\n addr ← base + index[64*i+63:64*i] * scale\n dest[64*i+63:64*i] ← [addr]\n mask[64*i+63:64*i] ← all_ones_64bit\n else:\n dest[64*i+63:64*i] ← 0\n mask[64*i+63:64*i] ← 0", "example": "VPGATHERQQ ymm1, [base+ymm_idx*scale], ymm_mask" }, { "mnemonic": "vpabsq", "architecture": "x86", "full_name": "Packed Absolute Value Quadword", "summary": "Computes absolute value of 64-bit integers.", "syntax": "VPABSQ zmm1 {k1}, zmm2/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 1F /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 1F", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src", "desc": "ZMM/Mem" } ], "extension": "AVX-512F", "description": "Computes the absolute value of eight packed 64-bit signed integers from the source operand, storing the results in the destination ZMM register. Opmask register k1 selectively updates destination elements (merging or zeroing based on the mask mode). The operation handles the extreme case where abs(INT64_MIN) = INT64_MIN with wraparound; no overflow flags are set.", "pseudocode": "for i in 0 to 7:\n if k1[i] or not masked:\n src_val ← src[64*i+63:64*i]\n if src_val < 0:\n dest[64*i+63:64*i] ← -src_val\n else:\n dest[64*i+63:64*i] ← src_val\n else if zeroing:\n dest[64*i+63:64*i] ← 0", "example": "VPABSQ zmm1, zmm2/m512" }, { "mnemonic": "vpmaxsq", "architecture": "x86", "full_name": "Maximum of Packed Signed Quadword Integers", "summary": "Returns maximum of signed 64-bit integers.", "syntax": "VPMAXSQ zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 3D /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 3D", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src1", "desc": "ZMM" }, { "name": "src2", "desc": "ZMM/Mem" } ], "extension": "AVX-512F", "description": "Computes the element-wise maximum of eight packed 64-bit signed integers from two source operands, storing results in the destination ZMM register. Opmask register k1 selectively updates destination elements. The operation compares signed values and has no effect on EFLAGS; results are computed in parallel.", "pseudocode": "for i in 0 to 7:\n if k1[i] or not masked:\n src1_val ← src1[64*i+63:64*i]\n src2_val ← src2[64*i+63:64*i]\n if src1_val >_signed src2_val:\n dest[64*i+63:64*i] ← src1_val\n else:\n dest[64*i+63:64*i] ← src2_val\n else if zeroing:\n dest[64*i+63:64*i] ← 0", "example": "VPMAXSQ zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpmaxuq", "architecture": "x86", "full_name": "Maximum of Packed Unsigned Quadword Integers", "summary": "Returns maximum of unsigned 64-bit integers.", "syntax": "VPMAXUQ zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 3F /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 3F", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src1", "desc": "ZMM" }, { "name": "src2", "desc": "ZMM/Mem" } ], "extension": "AVX-512F", "description": "Computes the element-wise maximum of eight packed 64-bit unsigned integers from two source operands, storing results in the destination ZMM register. Opmask register k1 selectively updates destination elements. The operation compares unsigned values and does not affect EFLAGS; all comparisons execute in parallel.", "pseudocode": "for i in 0 to 7:\n if k1[i] or not masked:\n src1_val ← src1[64*i+63:64*i]\n src2_val ← src2[64*i+63:64*i]\n if src1_val >_unsigned src2_val:\n dest[64*i+63:64*i] ← src1_val\n else:\n dest[64*i+63:64*i] ← src2_val\n else if zeroing:\n dest[64*i+63:64*i] ← 0", "example": "VPMAXUQ zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpminsq", "architecture": "x86", "full_name": "Minimum of Packed Signed Quadword Integers", "summary": "Returns minimum of signed 64-bit integers.", "syntax": "VPMINSQ zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 39 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 39", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src1", "desc": "ZMM" }, { "name": "src2", "desc": "ZMM/Mem" } ], "extension": "AVX-512F", "description": "Computes the element-wise minimum of eight packed 64-bit signed integers from two source operands, storing results in the destination ZMM register. Opmask register k1 selectively updates destination elements. The operation compares signed values and does not modify EFLAGS; all comparisons are performed in parallel.", "pseudocode": "for i in 0 to 7:\n if k1[i] or not masked:\n src1_val ← src1[64*i+63:64*i]\n src2_val ← src2[64*i+63:64*i]\n if src1_val <_signed src2_val:\n dest[64*i+63:64*i] ← src1_val\n else:\n dest[64*i+63:64*i] ← src2_val\n else if zeroing:\n dest[64*i+63:64*i] ← 0", "example": "VPMINSQ zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vpminuq", "architecture": "x86", "full_name": "Minimum of Packed Unsigned Quadword Integers", "summary": "Returns minimum of unsigned 64-bit integers.", "syntax": "VPMINUQ zmm1 {k1}, zmm2, zmm3/m512", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F38.W1 3B /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 38 | 3B", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src1", "desc": "ZMM" }, { "name": "src2", "desc": "ZMM/Mem" } ], "extension": "AVX-512F", "description": "Computes the element-wise minimum of eight packed 64-bit unsigned integers from two source operands, storing results in the destination ZMM register. Opmask register k1 selectively updates destination elements. The operation compares unsigned values and leaves EFLAGS unchanged; all comparisons execute in parallel.", "pseudocode": "for i in 0 to 7:\n if k1[i] or not masked:\n src1_val ← src1[64*i+63:64*i]\n src2_val ← src2[64*i+63:64*i]\n if src1_val <_unsigned src2_val:\n dest[64*i+63:64*i] ← src1_val\n else:\n dest[64*i+63:64*i] ← src2_val\n else if zeroing:\n dest[64*i+63:64*i] ← 0", "example": "VPMINUQ zmm1, zmm2, zmm3/m512" }, { "mnemonic": "vprolq", "architecture": "x86", "full_name": "Rotate Left Quadword", "summary": "Rotates 64-bit integers left.", "syntax": "VPROLQ zmm1 {k1}, zmm2, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F.W1 72 /1 ib", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 72 | ModRM", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src", "desc": "ZMM" }, { "name": "count", "desc": "Imm" } ], "extension": "AVX-512F", "description": "Rotates each 64-bit quadword in the source ZMM register left by an immediate count, writing the result to the destination ZMM register under write-mask control. This is a vectorized rotate-left operation with no effect on EFLAGS. Available only in 64-bit mode and requires AVX-512F support.", "pseudocode": "for i = 0 to 7:\n if k1[i]:\n zmm1[64*i : 64*i+63] ← (zmm2[64*i : 64*i+63] << count) | (zmm2[64*i : 64*i+63] >> (64 - count))\n else if zeroing:\n zmm1[64*i : 64*i+63] ← 0", "example": "VPROLQ zmm1, zmm2, 3" }, { "mnemonic": "vprorq", "architecture": "x86", "full_name": "Rotate Right Quadword", "summary": "Rotates 64-bit integers right.", "syntax": "VPRORQ zmm1 {k1}, zmm2, imm8", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.66.0F.W1 72 /0 ib", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 66 | 0F | 72 | ModRM", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "ZMM" }, { "name": "src", "desc": "ZMM" }, { "name": "count", "desc": "Imm" } ], "extension": "AVX-512F", "description": "Rotates each 64-bit quadword in the source ZMM register right by an immediate count, writing the result to the destination ZMM register under write-mask control. This is a vectorized rotate-right operation with no effect on EFLAGS. Available only in 64-bit mode and requires AVX-512F support.", "pseudocode": "for i = 0 to 7:\n if k1[i]:\n zmm1[64*i : 64*i+63] ← (zmm2[64*i : 64*i+63] >> count) | (zmm2[64*i : 64*i+63] << (64 - count))\n else if zeroing:\n zmm1[64*i : 64*i+63] ← 0", "example": "VPRORQ zmm1, zmm2, 3" }, { "mnemonic": "vpmovswb", "architecture": "x86", "full_name": "Truncate Signed Word to Byte", "summary": "Down-converts 16-bit integers to 8-bit signed saturate.", "syntax": "VPMOVSWB xmm1/m128 {k1}, zmm2", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.256.F3.0F38.W0 20 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | F3 | 0F | 38 | 20", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "ZMM" } ], "extension": "AVX-512F", "description": "Truncates 16-bit signed words from a ZMM register to 8-bit signed bytes with saturation, storing the result in an XMM register or 128-bit memory location under write-mask control. Out-of-range values saturate to the signed byte limits (-128 to 127). No flags are affected. This instruction requires AVX-512F and operates only in 64-bit mode.", "pseudocode": "for i = 0 to 31:\n temp ← zmm2[16*i : 16*i+15]\n if temp > 127:\n xmm1[8*i : 8*i+7] ← 127 (under mask k1[i])\n else if temp < -128:\n xmm1[8*i : 8*i+7] ← -128 (under mask k1[i])\n else:\n xmm1[8*i : 8*i+7] ← temp[7:0] (under mask k1[i])\n if not k1[i] and zeroing:\n xmm1[8*i : 8*i+7] ← 0", "example": "VPMOVSWB xmm1/m128, zmm2" }, { "mnemonic": "vpmovsqb", "architecture": "x86", "full_name": "Truncate Signed Quadword to Byte", "summary": "Down-converts 64-bit integers to 8-bit signed saturate.", "syntax": "VPMOVSQB xmm1/m128 {k1}, zmm2", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.512.F3.0F38.W0 22 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | F3 | 0F | 38 | 22", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "ZMM" } ], "extension": "AVX-512F", "description": "Truncates 64-bit signed quadwords from a ZMM register to 8-bit signed bytes with saturation, storing the result in an XMM register or 128-bit memory location under write-mask control. Out-of-range values saturate to signed byte limits (-128 to 127). No flags are affected. This instruction requires AVX-512F and operates only in 64-bit mode.", "pseudocode": "for i = 0 to 7:\n temp ← zmm2[64*i : 64*i+63]\n if temp > 127:\n xmm1[8*i : 8*i+7] ← 127 (under mask k1[i])\n else if temp < -128:\n xmm1[8*i : 8*i+7] ← -128 (under mask k1[i])\n else:\n xmm1[8*i : 8*i+7] ← temp[7:0] (under mask k1[i])\n if not k1[i] and zeroing:\n xmm1[8*i : 8*i+7] ← 0", "example": "VPMOVSQB xmm1/m128, zmm2" }, { "mnemonic": "vpmovuswb", "architecture": "x86", "full_name": "Truncate Unsigned Word to Byte", "summary": "Down-converts 16-bit integers to 8-bit unsigned saturate.", "syntax": "VPMOVUSWB xmm1/m128 {k1}, zmm2", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.256.F3.0F38.W0 10 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | F3 | 0F | 38 | 10", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "ZMM" } ], "extension": "AVX-512F", "description": "Truncates 16-bit unsigned words from a ZMM register to 8-bit unsigned bytes with saturation, storing the result in an XMM register or 128-bit memory location under write-mask control. Out-of-range values saturate to the unsigned byte limit (0 to 255). No flags are affected. This instruction requires AVX-512F and operates only in 64-bit mode.", "pseudocode": "for i = 0 to 31:\n temp ← zmm2[16*i : 16*i+15]\n if temp > 255:\n xmm1[8*i : 8*i+7] ← 255 (under mask k1[i])\n else:\n xmm1[8*i : 8*i+7] ← temp[7:0] (under mask k1[i])\n if not k1[i] and zeroing:\n xmm1[8*i : 8*i+7] ← 0", "example": "VPMOVUSWB xmm1/m128, zmm2" }, { "mnemonic": "vpmovusqb", "architecture": "x86", "full_name": "Truncate Unsigned Quadword to Byte", "summary": "Down-converts 64-bit integers to 8-bit unsigned saturate.", "syntax": "VPMOVUSQB xmm1/m128 {k1}, zmm2", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.128.F3.0F38.W0 12 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | F3 | 0F | 38 | 12", "bit_positions": "+0 | +4 | +5 | +6 | +7" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src", "desc": "ZMM" } ], "extension": "AVX-512F", "description": "Truncates 64-bit unsigned quadwords from a ZMM register to 8-bit unsigned bytes with saturation, storing the result in an XMM register or 128-bit memory location under write-mask control. Out-of-range values saturate to the unsigned byte limit (0 to 255). No flags are affected. This instruction requires AVX-512F and operates only in 64-bit mode.", "pseudocode": "for i = 0 to 7:\n temp ← zmm2[64*i : 64*i+63]\n if temp > 255:\n xmm1[8*i : 8*i+7] ← 255 (under mask k1[i])\n else:\n xmm1[8*i : 8*i+7] ← temp[7:0] (under mask k1[i])\n if not k1[i] and zeroing:\n xmm1[8*i : 8*i+7] ← 0", "example": "VPMOVUSQB xmm1/m128, zmm2" }, { "mnemonic": "kaddw", "architecture": "x86", "full_name": "Add Masks Word", "summary": "Adds two 16-bit mask registers.", "syntax": "KADDW k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.0F.W0 4A /r", "length": "3+", "visual_parts": [], "binary_pattern": "EVEX | 0F | 4A", "bit_positions": "+0 | +4 | +5" }, "operands": [ { "name": "dest", "desc": "k-reg" }, { "name": "src1", "desc": "k-reg" }, { "name": "src2", "desc": "k-reg" } ], "extension": "AVX-512DQ", "description": "Adds two 16-bit mask registers and stores the result in a third 16-bit mask register, with write-mask control applied. The addition is performed on the full 16-bit width of each mask operand; no carry is defined beyond bit 15. No EFLAGS are modified. This instruction requires AVX-512DQ and operates only in 64-bit mode.", "pseudocode": "k1 ← (k2 + k3)[15:0]", "example": "KADDW k1, k2, k3" }, { "mnemonic": "kaddb", "architecture": "x86", "full_name": "Add Masks Byte", "summary": "Adds two 8-bit mask registers.", "syntax": "KADDB k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.66.0F.W0 4A /r", "length": "3+", "visual_parts": [], "binary_pattern": "EVEX | 0F | 4A", "bit_positions": "+0 | +4 | +5" }, "operands": [ { "name": "dest", "desc": "k-reg" }, { "name": "src1", "desc": "k-reg" }, { "name": "src2", "desc": "k-reg" } ], "extension": "AVX-512DQ", "description": "Adds two 8-bit mask registers and stores the result in a third 8-bit mask register, with write-mask control applied. The addition is performed on the full 8-bit width of each mask operand; no carry is defined beyond bit 7. No EFLAGS are modified. This instruction requires AVX-512DQ and operates only in 64-bit mode.", "pseudocode": "k1 ← (k2 + k3)[7:0]", "example": "KADDB k1, k2, k3" }, { "mnemonic": "kunpckbw", "architecture": "x86", "full_name": "Unpack and Interleave Masks Byte to Word", "summary": "Interleaves 8-bit masks into 16-bit mask.", "syntax": "KUNPCKBW k1, k2, k3", "encoding": { "format": "EVEX", "hex_opcode": "VEX.L1.66.0F.W0 4B /r", "length": "3+", "visual_parts": [], "binary_pattern": "EVEX | 0F | 4B", "bit_positions": "+0 | +4 | +5" }, "operands": [ { "name": "dest", "desc": "k-reg" }, { "name": "src1", "desc": "k-reg" }, { "name": "src2", "desc": "k-reg" } ], "extension": "AVX-512", "description": "Unpacks and interleaves two 8-bit mask register values into a 16-bit mask register. The operation treats the 8-bit sources as packed bit fields and expands them with interleaving to produce a 16-bit result. No flags are affected by this operation.", "pseudocode": "k1[15:8] ← k3[7:0]\nk1[7:0] ← k2[7:0]", "example": "KUNPCKBW k1, k2, k3" }, { "mnemonic": "vaddss", "architecture": "x86", "full_name": "Add Scalar Single-Precision (EVEX)", "summary": "Adds scalar single precision (EVEX encoded with masking).", "syntax": "VADDSS xmm1 {k1}, xmm2, xmm3/m32", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.F3.0F.W0 58 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 58", "bit_positions": "+0 | +4" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src1", "desc": "XMM" }, { "name": "src2", "desc": "XMM/Mem" } ], "extension": "AVX-512F", "description": "Adds the low 32-bit single-precision floating-point operands of xmm2 and xmm3/m32, stores the result in xmm1, and leaves bits 127:32 of xmm1 unchanged. Supports EVEX encoding with optional write-mask (k1) and zeroing behavior. No integer flags are affected.", "pseudocode": "xmm1[31:0] ← xmm2[31:0] + xmm3/m32[31:0]\nxmm1[127:32] ← (k1 is used) ? (zeroing ? 0 : xmm1[127:32]) : xmm1[127:32]", "example": "VADDSS xmm1, xmm2, xmm3/m32" }, { "mnemonic": "vmulss", "architecture": "x86", "full_name": "Multiply Scalar Single-Precision (EVEX)", "summary": "Multiplies scalar single precision (EVEX encoded with masking).", "syntax": "VMULSS xmm1 {k1}, xmm2, xmm3/m32", "encoding": { "format": "EVEX", "hex_opcode": "EVEX.LLIG.F3.0F.W0 59 /r", "length": "6+", "visual_parts": [], "binary_pattern": "EVEX | 59", "bit_positions": "+0 | +4" }, "operands": [ { "name": "dest", "desc": "XMM" }, { "name": "src1", "desc": "XMM" }, { "name": "src2", "desc": "XMM/Mem" } ], "extension": "AVX-512F", "description": "Multiplies the low 32-bit single-precision floating-point operands of xmm2 and xmm3/m32, stores the result in xmm1, and leaves bits 127:32 of xmm1 unchanged. Supports EVEX encoding with optional write-mask (k1) and zeroing behavior. No integer flags are affected.", "pseudocode": "xmm1[31:0] ← xmm2[31:0] * xmm3/m32[31:0]\nxmm1[127:32] ← (k1 is used) ? (zeroing ? 0 : xmm1[127:32]) : xmm1[127:32]", "example": "VMULSS xmm1, xmm2, xmm3/m32" }, { "mnemonic": "xsaveopt", "architecture": "x86", "full_name": "Save Processor Extended States Optimized", "summary": "Saves state components (optimized for Modified state).", "syntax": "XSAVEOPT m", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F AE /6", "length": "3+", "visual_parts": [], "binary_pattern": "0F | AE | ModRM", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "Memory" } ], "extension": "XSAVEOPT", "description": "Saves processor extended state components (FPU, SSE, AVX, etc.) to the memory location specified by EDX:EAX, using an optimized algorithm that tracks which state components have been modified. Requires XSAVEOPT feature support (CPUID EAX=0DH:EAX bit 0). No flags are modified; this instruction serializes execution and may cause VM exits in virtualized environments.", "pseudocode": "mem[EDX:EAX] ← XSTATE_COMPONENTS_PER_XCRF_BITMASK(ECX)\nXSTATE_HEADER[EDX:EAX + 512] ← MODIFIED_STATE_TRACKING", "example": "XSAVEOPT [rbp-8]" }, { "mnemonic": "xsavec", "architecture": "x86", "full_name": "Save Processor Extended States with Compaction", "summary": "Saves state components using compaction.", "syntax": "XSAVEC m", "encoding": { "format": "Legacy", "hex_opcode": "NP 0F C7 /4", "length": "3+", "visual_parts": [], "binary_pattern": "0F | C7 | ModRM", "bit_positions": "+0 | +1 | +2" }, "operands": [ { "name": "dest", "desc": "Memory" } ], "extension": "XSAVEC", "description": "Saves processor extended state components to the memory location specified by EDX:EAX using compaction, removing unused state and reducing the saved data size. Requires XSAVEC feature support (CPUID EAX=0DH, ECX=1:EAX bit 1). No flags are modified; this instruction serializes execution and may trigger VM exits in virtualized environments.", "pseudocode": "mem[EDX:EAX] ← COMPACT_XSTATE_COMPONENTS()\nXSTATE_HEADER[EDX:EAX + 512] ← COMPACTED_SIZE_AND_LAYOUT", "example": "XSAVEC [rbp-8]" }, { "mnemonic": "vmfunc", "architecture": "x86", "full_name": "Virtual Machine Function", "summary": "Invoke VM function specified in EAX.", "syntax": "VMFUNC", "encoding": { "format": "VMX", "hex_opcode": "NP 0F 01 D4", "length": "3", "visual_parts": [], "binary_pattern": "0F | 01 | D4", "bit_positions": "+0 | +1 | +2" }, "operands": [], "extension": "VMX", "description": "Invokes a VM function as specified by the function number in EAX and additional parameters in ECX. Only valid in VMX non-root operation (guest mode) and transitions control to the host via VM exit. Privilege level: VMX non-root; will raise #UD if not in VMX operation or if called in root mode.", "pseudocode": "FUNC_NUM ← EAX\nFUNC_PARAM ← ECX\nINVOKE_VMFUNCTION(FUNC_NUM, FUNC_PARAM)\nVMEXIT_TO_HOST", "example": "VMFUNC" }, { "mnemonic": "ud0", "architecture": "x86", "full_name": "Undefined Instruction 0", "summary": "Generates invalid opcode exception.", "syntax": "UD0", "encoding": { "format": "Legacy", "hex_opcode": "0F FF /r", "length": "2", "visual_parts": [], "binary_pattern": "0F | FF", "bit_positions": "+0 | +1" }, "operands": [], "extension": "Base", "description": "Generates an invalid opcode exception (#UD). This instruction is reserved for generating intentional undefined instruction exceptions in all processor modes, useful for debugging and kernel routines. No flags are modified; execution terminates with a #UD fault.", "pseudocode": "RAISE_EXCEPTION(#UD)", "example": "UD0" } ] }