_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q253600 | X86Cpu.AAD | validation | def AAD(cpu, imm=None):
"""
ASCII adjust AX before division.
Adjusts two unpacked BCD digits (the least-significant digit in the
AL register and the most-significant digit in the AH register) so that
a division operation performed on the result will yield a correct unpacked
... | python | {
"resource": ""
} |
q253601 | X86Cpu.AAM | validation | def AAM(cpu, imm=None):
"""
ASCII adjust AX after multiply.
Adjusts the result of the multiplication of two unpacked BCD values
to create a pair of unpacked (base 10) BCD values. The AX register is
the implied source and destination operand for this instruction. The AAM
... | python | {
"resource": ""
} |
q253602 | X86Cpu.AAS | validation | def AAS(cpu):
"""
ASCII Adjust AL after subtraction.
Adjusts the result of the subtraction of two unpacked BCD values to create a unpacked
BCD result. The AL register is the implied source and destination operand for this instruction.
The AAS instruction is only useful when it ... | python | {
"resource": ""
} |
q253603 | X86Cpu.ADC | validation | def ADC(cpu, dest, src):
"""
Adds with carry.
Adds the destination operand (first operand), the source operand (second operand),
and the carry (CF) flag and stores the result in the destination operand. The state
of the CF flag represents a carry from a previous addition. When a... | python | {
"resource": ""
} |
q253604 | X86Cpu.CMP | validation | def CMP(cpu, src1, src2):
"""
Compares two operands.
Compares the first source operand with the second source operand and sets the status flags
in the EFLAGS register according to the results. The comparison is performed by subtracting
the second operand from the first operand a... | python | {
"resource": ""
} |
q253605 | X86Cpu.CMPXCHG | validation | def CMPXCHG(cpu, dest, src):
"""
Compares and exchanges.
Compares the value in the AL, AX, EAX or RAX register (depending on the
size of the operand) with the first operand (destination operand). If
the two values are equal, the second operand (source operand) is loaded
... | python | {
"resource": ""
} |
q253606 | X86Cpu.CMPXCHG8B | validation | def CMPXCHG8B(cpu, dest):
"""
Compares and exchanges bytes.
Compares the 64-bit value in EDX:EAX (or 128-bit value in RDX:RAX if
operand size is 128 bits) with the operand (destination operand). If
the values are equal, the 64-bit value in ECX:EBX (or 128-bit value in
RC... | python | {
"resource": ""
} |
q253607 | X86Cpu.DAA | validation | def DAA(cpu):
"""
Decimal adjusts AL after addition.
Adjusts the sum of two packed BCD values to create a packed BCD result. The AL register
is the implied source and destination operand. If a decimal carry is detected, the CF
and AF flags are set accordingly.
The CF and... | python | {
"resource": ""
} |
q253608 | X86Cpu.DAS | validation | def DAS(cpu):
"""
Decimal adjusts AL after subtraction.
Adjusts the result of the subtraction of two packed BCD values to create a packed BCD result.
The AL register is the implied source and destination operand. If a decimal borrow is detected,
the CF and AF flags are set accor... | python | {
"resource": ""
} |
q253609 | X86Cpu.DIV | validation | def DIV(cpu, src):
"""
Unsigned divide.
Divides (unsigned) the value in the AX register, DX:AX register pair,
or EDX:EAX or RDX:RAX register pair (dividend) by the source operand
(divisor) and stores the result in the AX (AH:AL), DX:AX, EDX:EAX or
RDX:RAX registers. The ... | python | {
"resource": ""
} |
q253610 | X86Cpu.IDIV | validation | def IDIV(cpu, src):
"""
Signed divide.
Divides (signed) the value in the AL, AX, or EAX register by the source
operand and stores the result in the AX, DX:AX, or EDX:EAX registers.
The source operand can be a general-purpose register or a memory
location. The action of t... | python | {
"resource": ""
} |
q253611 | X86Cpu.IMUL | validation | def IMUL(cpu, *operands):
"""
Signed multiply.
Performs a signed multiplication of two operands. This instruction has
three forms, depending on the number of operands.
- One-operand form. This form is identical to that used by the MUL
instruction. Here, the sourc... | python | {
"resource": ""
} |
q253612 | X86Cpu.INC | validation | def INC(cpu, dest):
"""
Increments by 1.
Adds 1 to the destination operand, while preserving the state of the
CF flag. The destination operand can be a register or a memory location.
This instruction allows a loop counter to be updated without disturbing
the CF flag. (Us... | python | {
"resource": ""
} |
q253613 | X86Cpu.MUL | validation | def MUL(cpu, src):
"""
Unsigned multiply.
Performs an unsigned multiplication of the first operand (destination
operand) and the second operand (source operand) and stores the result
in the destination operand. The destination operand is an implied operand
located in reg... | python | {
"resource": ""
} |
q253614 | X86Cpu.NEG | validation | def NEG(cpu, dest):
"""
Two's complement negation.
Replaces the value of operand (the destination operand) with its two's complement.
(This operation is equivalent to subtracting the operand from 0.) The destination operand is
located in a general-purpose register or a memory lo... | python | {
"resource": ""
} |
q253615 | X86Cpu.SBB | validation | def SBB(cpu, dest, src):
"""
Integer subtraction with borrow.
Adds the source operand (second operand) and the carry (CF) flag, and
subtracts the result from the destination operand (first operand). The
result of the subtraction is stored in the destination operand. The
... | python | {
"resource": ""
} |
q253616 | X86Cpu.XADD | validation | def XADD(cpu, dest, src):
"""
Exchanges and adds.
Exchanges the first operand (destination operand) with the second operand
(source operand), then loads the sum of the two values into the destination
operand. The destination operand can be a register or a memory location;
... | python | {
"resource": ""
} |
q253617 | X86Cpu.BSWAP | validation | def BSWAP(cpu, dest):
"""
Byte swap.
Reverses the byte order of a 32-bit (destination) register: bits 0 through
7 are swapped with bits 24 through 31, and bits 8 through 15 are swapped
with bits 16 through 23. This instruction is provided for converting little-endian
val... | python | {
"resource": ""
} |
q253618 | X86Cpu.CMOVG | validation | def CMOVG(cpu, dest, src):
"""
Conditional move - Greater.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
| python | {
"resource": ""
} |
q253619 | X86Cpu.CMOVO | validation | def CMOVO(cpu, dest, src):
"""
Conditional move - Overflow.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
| python | {
"resource": ""
} |
q253620 | X86Cpu.CMOVNO | validation | def CMOVNO(cpu, dest, src):
"""
Conditional move - Not overflow.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
| python | {
"resource": ""
} |
q253621 | X86Cpu.LAHF | validation | def LAHF(cpu):
"""
Loads status flags into AH register.
Moves the low byte of the EFLAGS register (which includes status flags
SF, ZF, AF, PF, and CF) to the AH register. Reserved bits 1, 3, and 5
of the EFLAGS register are set in the AH register::
AH = EFLAGS... | python | {
"resource": ""
} |
q253622 | X86Cpu.LEA | validation | def LEA(cpu, dest, src):
"""
Loads effective address.
Computes the effective address of the second operand (the source operand) and stores it in the first operand
(destination operand). The source operand is a memory address (offset part) specified with one of the processors
add... | python | {
"resource": ""
} |
q253623 | X86Cpu.MOVBE | validation | def MOVBE(cpu, dest, src):
"""
Moves data after swapping bytes.
Performs a byte swap operation on the data copied from the second operand (source operand) and store the result
in the first operand (destination operand). The source operand can be a general-purpose register, or memory loc... | python | {
"resource": ""
} |
q253624 | X86Cpu.SAHF | validation | def SAHF(cpu):
"""
Stores AH into flags.
Loads the SF, ZF, AF, PF, and CF flags of the EFLAGS register with values
from the corresponding bits in the AH register (bits 7, 6, 4, 2, and 0,
respectively). Bits 1, 3, and 5 of register AH are ignored; the corresponding | python | {
"resource": ""
} |
q253625 | X86Cpu.SETA | validation | def SETA(cpu, dest):
"""
Sets byte if above.
Sets the destination operand to 0 or 1 depending on the settings of the status flags (CF, SF, OF, ZF, and PF, 1, 0) in the
EFLAGS register. The destination operand points to a byte register or a byte in memory. The condition code suffix
... | python | {
"resource": ""
} |
q253626 | X86Cpu.SETB | validation | def SETB(cpu, dest):
"""
Sets byte if below.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253627 | X86Cpu.SETBE | validation | def SETBE(cpu, dest):
"""
Sets byte if below or equal.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253628 | X86Cpu.SETC | validation | def SETC(cpu, dest):
"""
Sets if carry.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253629 | X86Cpu.SETE | validation | def SETE(cpu, dest):
"""
Sets byte if equal.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253630 | X86Cpu.SETGE | validation | def SETGE(cpu, dest):
"""
Sets byte if greater or equal.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253631 | X86Cpu.SETNAE | validation | def SETNAE(cpu, dest):
"""
Sets byte if not above or equal.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253632 | X86Cpu.SETNB | validation | def SETNB(cpu, dest):
"""
Sets byte if not below.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253633 | X86Cpu.SETNBE | validation | def SETNBE(cpu, dest):
"""
Sets byte if not below or equal.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253634 | X86Cpu.SETNG | validation | def SETNG(cpu, dest):
"""
Sets byte if not greater.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253635 | X86Cpu.SETNLE | validation | def SETNLE(cpu, dest):
"""
Sets byte if not less or equal.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253636 | X86Cpu.SETNO | validation | def SETNO(cpu, dest):
"""
Sets byte if not overflow.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253637 | X86Cpu.SETNS | validation | def SETNS(cpu, dest):
"""
Sets byte if not sign.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253638 | X86Cpu.SETNZ | validation | def SETNZ(cpu, dest):
"""
Sets byte if not zero.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253639 | X86Cpu.SETO | validation | def SETO(cpu, dest):
"""
Sets byte if overflow.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253640 | X86Cpu.SETP | validation | def SETP(cpu, dest):
"""
Sets byte if parity.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253641 | X86Cpu.SETPE | validation | def SETPE(cpu, dest):
"""
Sets byte if parity even.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253642 | X86Cpu.SETPO | validation | def SETPO(cpu, dest):
"""
Sets byte if parity odd.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253643 | X86Cpu.SETS | validation | def SETS(cpu, dest):
"""
Sets byte if sign.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253644 | X86Cpu.SETZ | validation | def SETZ(cpu, dest):
"""
Sets byte if zero.
:param cpu: current CPU.
:param dest: destination operand.
| python | {
"resource": ""
} |
q253645 | X86Cpu.LEAVE | validation | def LEAVE(cpu):
"""
High level procedure exit.
Releases the stack frame set up by an earlier ENTER instruction. The
LEAVE instruction copies the frame pointer (in the EBP register) into
the stack pointer register (ESP), which releases the stack space allocated
to the sta... | python | {
"resource": ""
} |
q253646 | X86Cpu.PUSH | validation | def PUSH(cpu, src):
"""
Pushes a value onto the stack.
Decrements the stack pointer and then stores the source operand on the top of the stack.
:param cpu: current CPU.
:param src: source operand.
"""
# http://stackoverflow.com/questions/11291151/how-push-imm-en... | python | {
"resource": ""
} |
q253647 | X86Cpu.CALL | validation | def CALL(cpu, op0):
"""
Procedure call.
Saves procedure linking information on the stack and branches to the called procedure specified using the target
operand. The target operand specifies the address of the first instruction in the called procedure. The operand can
be an imme... | python | {
"resource": ""
} |
q253648 | X86Cpu.RET | validation | def RET(cpu, *operands):
"""
Returns from procedure.
Transfers program control to a return address located on the top of
the stack. The address is usually placed on the stack by a CALL instruction,
and the return is made to the instruction that follows the CALL instruction.
... | python | {
"resource": ""
} |
q253649 | X86Cpu.JA | validation | def JA(cpu, target):
"""
Jumps short if above.
:param cpu: current CPU.
:param target: destination operand.
"""
| python | {
"resource": ""
} |
q253650 | X86Cpu.JB | validation | def JB(cpu, target):
"""
Jumps short if below.
:param cpu: current CPU.
:param target: destination operand.
| python | {
"resource": ""
} |
q253651 | X86Cpu.JBE | validation | def JBE(cpu, target):
"""
Jumps short if below or equal.
:param cpu: current CPU.
:param target: destination operand.
| python | {
"resource": ""
} |
q253652 | X86Cpu.JC | validation | def JC(cpu, target):
"""
Jumps short if carry.
:param cpu: current CPU.
:param target: destination operand.
| python | {
"resource": ""
} |
q253653 | X86Cpu.JCXZ | validation | def JCXZ(cpu, target):
"""
Jumps short if CX register is 0.
:param cpu: current CPU.
:param target: destination operand.
| python | {
"resource": ""
} |
q253654 | X86Cpu.JECXZ | validation | def JECXZ(cpu, target):
"""
Jumps short if ECX register is 0.
:param cpu: current CPU.
:param target: destination operand.
| python | {
"resource": ""
} |
q253655 | X86Cpu.JRCXZ | validation | def JRCXZ(cpu, target):
"""
Jumps short if RCX register is 0.
:param cpu: current CPU.
:param target: destination operand.
| python | {
"resource": ""
} |
q253656 | X86Cpu.JG | validation | def JG(cpu, target):
"""
Jumps short if greater.
:param cpu: current CPU.
:param target: destination operand.
"""
| python | {
"resource": ""
} |
q253657 | X86Cpu.JGE | validation | def JGE(cpu, target):
"""
Jumps short if greater or equal.
:param cpu: current CPU.
| python | {
"resource": ""
} |
q253658 | X86Cpu.JNB | validation | def JNB(cpu, target):
"""
Jumps short if not below.
:param cpu: current CPU.
| python | {
"resource": ""
} |
q253659 | X86Cpu.JNE | validation | def JNE(cpu, target):
"""
Jumps short if not equal.
:param cpu: current CPU.
| python | {
"resource": ""
} |
q253660 | X86Cpu.JNG | validation | def JNG(cpu, target):
"""
Jumps short if not greater.
:param cpu: current CPU.
:param target: destination operand.
"""
| python | {
"resource": ""
} |
q253661 | X86Cpu.JNO | validation | def JNO(cpu, target):
"""
Jumps short if not overflow.
:param cpu: current CPU.
| python | {
"resource": ""
} |
q253662 | X86Cpu.JNP | validation | def JNP(cpu, target):
"""
Jumps short if not parity.
:param cpu: current CPU.
| python | {
"resource": ""
} |
q253663 | X86Cpu.JNS | validation | def JNS(cpu, target):
"""
Jumps short if not sign.
:param cpu: current CPU.
| python | {
"resource": ""
} |
q253664 | X86Cpu.JO | validation | def JO(cpu, target):
"""
Jumps short if overflow.
:param cpu: current CPU.
:param target: destination operand.
| python | {
"resource": ""
} |
q253665 | X86Cpu.JP | validation | def JP(cpu, target):
"""
Jumps short if parity.
:param cpu: current CPU.
:param target: destination operand.
| python | {
"resource": ""
} |
q253666 | X86Cpu.JS | validation | def JS(cpu, target):
"""
Jumps short if sign.
:param cpu: current CPU.
:param target: destination operand.
| python | {
"resource": ""
} |
q253667 | X86Cpu.JZ | validation | def JZ(cpu, target):
"""
Jumps short if zero.
:param cpu: current CPU.
:param target: destination operand.
| python | {
"resource": ""
} |
q253668 | X86Cpu.LJMP | validation | def LJMP(cpu, cs_selector, target):
"""
We are just going to ignore the CS selector for now.
"""
logger.info("LJMP: | python | {
"resource": ""
} |
q253669 | X86Cpu.LOOP | validation | def LOOP(cpu, dest):
"""
Loops according to ECX counter.
Performs a loop operation using the ECX or CX register as a counter.
Each time the LOOP instruction is executed, the count register is decremented,
then checked for 0. If the count is 0, the loop is terminated and program
... | python | {
"resource": ""
} |
q253670 | X86Cpu.LOOPNZ | validation | def LOOPNZ(cpu, target):
"""
Loops if ECX counter is nonzero.
:param cpu: current CPU.
:param target: destination operand.
"""
counter_name = {16: 'CX', 32: 'ECX', 64: 'RCX'}[cpu.address_bit_size]
counter = cpu.write_register(counter_name, cpu.read_register(count... | python | {
"resource": ""
} |
q253671 | X86Cpu.RCL | validation | def RCL(cpu, dest, src):
"""
Rotates through carry left.
Shifts (rotates) the bits of the first operand (destination operand) the number of bit positions specified in the
second operand (count operand) and stores the result in the destination operand. The destination operand can be
... | python | {
"resource": ""
} |
q253672 | X86Cpu.SAR | validation | def SAR(cpu, dest, src):
"""
Shift arithmetic right.
The shift arithmetic right (SAR) and shift logical right (SHR) instructions shift the bits of the destination operand to
the right (toward less significant bit locations). For each shift count, the least significant bit of the destina... | python | {
"resource": ""
} |
q253673 | X86Cpu.SHR | validation | def SHR(cpu, dest, src):
"""
Shift logical right.
The shift arithmetic right (SAR) and shift logical right (SHR)
instructions shift the bits of the destination operand to the right
(toward less significant bit locations). For each shift count, the
least significant bit o... | python | {
"resource": ""
} |
q253674 | X86Cpu.SHLD | validation | def SHLD(cpu, dest, src, count):
"""
Double precision shift right.
Shifts the first operand (destination operand) to the left the number of bits specified by the third operand
(count operand). The second operand (source operand) provides bits to shift in from the right (starting with
... | python | {
"resource": ""
} |
q253675 | X86Cpu.BSF | validation | def BSF(cpu, dest, src):
"""
Bit scan forward.
Searches the source operand (second operand) for the least significant
set bit (1 bit). If a least significant 1 bit is found, its bit index
is stored in the destination operand (first operand). The source operand
can be a r... | python | {
"resource": ""
} |
q253676 | X86Cpu.BSR | validation | def BSR(cpu, dest, src):
"""
Bit scan reverse.
Searches the source operand (second operand) for the most significant
set bit (1 bit). If a most significant 1 bit is found, its bit index is
stored in the destination operand (first operand). The source operand
can be a reg... | python | {
"resource": ""
} |
q253677 | X86Cpu.BT | validation | def BT(cpu, dest, src):
"""
Bit Test.
Selects the bit in a bit string (specified with the first operand, called the bit base) at the
bit-position designated by the bit offset (specified by the second operand) and stores the value
of the bit in the CF flag. The bit base operand c... | python | {
"resource": ""
} |
q253678 | X86Cpu.BTC | validation | def BTC(cpu, dest, src):
"""
Bit test and complement.
Selects the bit in a bit string (specified with the first operand, called
the bit base) at the bit-position designated by the bit offset operand
(second operand), stores the value of the bit in the CF flag, and complements
... | python | {
"resource": ""
} |
q253679 | X86Cpu.CMPS | validation | def CMPS(cpu, dest, src):
"""
Compares string operands.
Compares the byte, word, double word or quad specified with the first source
operand with the byte, word, double or quad word specified with the second
source operand and sets the status flags in the EFLAGS register accordi... | python | {
"resource": ""
} |
q253680 | X86Cpu.LODS | validation | def LODS(cpu, dest, src):
"""
Loads string.
Loads a byte, word, or doubleword from the source operand into the AL, AX, or EAX register, respectively. The
source operand is a memory location, the address of which is read from the DS:ESI or the DS:SI registers
(depending on the ad... | python | {
"resource": ""
} |
q253681 | X86Cpu.MOVS | validation | def MOVS(cpu, dest, src):
"""
Moves data from string to string.
Moves the byte, word, or doubleword specified with the second operand (source operand) to the location specified
with the first operand (destination operand). Both the source and destination operands are located in memory. ... | python | {
"resource": ""
} |
q253682 | X86Cpu.SCAS | validation | def SCAS(cpu, dest, src):
"""
Scans String.
Compares the byte, word, or double word specified with the memory operand
with the value in the AL, AX, EAX, or RAX register, and sets the status flags
according to the results. The memory operand address is read from either
th... | python | {
"resource": ""
} |
q253683 | X86Cpu.STOS | validation | def STOS(cpu, dest, src):
"""
Stores String.
Stores a byte, word, or doubleword from the AL, AX, or EAX register,
respectively, into the destination operand. The destination operand is
a memory location, the address of which is read from either the ES:EDI
or the ES:DI re... | python | {
"resource": ""
} |
q253684 | X86Cpu.SARX | validation | def SARX(cpu, dest, src, count):
"""
The shift arithmetic right.
:param cpu: current CPU.
:param dest: destination operand.
:param src: count operand.
"""
OperandSize = dest.size
count = count.read()
countMask = {8: 0x1f,
16: ... | python | {
"resource": ""
} |
q253685 | X86Cpu.PSHUFW | validation | def PSHUFW(cpu, op0, op1, op3):
"""
Packed shuffle words.
Copies doublewords from source operand (second operand) and inserts them in the destination operand
(first operand) at locations selected with the order operand (third operand).
:param cpu: current CPU.
:param op... | python | {
"resource": ""
} |
q253686 | X86Cpu.PSHUFD | validation | def PSHUFD(cpu, op0, op1, op3):
"""
Packed shuffle doublewords.
Copies doublewords from source operand (second operand) and inserts them in the destination operand
(first operand) at locations selected with the order operand (third operand).
:param cpu: current CPU.
:pa... | python | {
"resource": ""
} |
q253687 | X86Cpu.PMOVMSKB | validation | def PMOVMSKB(cpu, op0, op1):
"""
Moves byte mask to general-purpose register.
Creates an 8-bit mask made up of the most significant bit of each byte of the source operand
(second operand) and stores the result in the low byte or word of the destination operand
(first operand). T... | python | {
"resource": ""
} |
q253688 | X86Cpu.PSRLDQ | validation | def PSRLDQ(cpu, dest, src):
"""
Packed shift right logical double quadword.
Shifts the destination operand (first operand) to the right by the number
of bytes specified in the count operand (second operand). The empty high-order
bytes are cleared (set to all 0s). If the value sp... | python | {
"resource": ""
} |
q253689 | X86Cpu.MOVZX | validation | def MOVZX(cpu, op0, op1):
"""
Moves with zero-extend.
Copies the contents of the source operand (register or memory location) to the destination
operand (register) and zero extends the value to 16 or 32 bits. The size of the converted value
depends on the operand-size attribute:... | python | {
"resource": ""
} |
q253690 | X86Cpu.MOVSX | validation | def MOVSX(cpu, op0, op1):
"""
Moves with sign-extension.
Copies the contents of the source operand (register or memory location) to the destination
operand (register) and sign extends the value to 16::
OP0 = SignExtend(OP1);
| python | {
"resource": ""
} |
q253691 | X86Cpu.CWDE | validation | def CWDE(cpu):
"""
Converts word to doubleword.
::
DX = sign-extend of AX.
:param cpu: current | python | {
"resource": ""
} |
q253692 | X86Cpu.RDTSC | validation | def RDTSC(cpu):
"""
Reads time-stamp counter.
Loads the current value of the processor's time-stamp counter into the
EDX:EAX registers. The time-stamp counter is contained in a 64-bit
MSR. The high-order 32 bits of the MSR are loaded into the EDX
register, and the low-o... | python | {
"resource": ""
} |
q253693 | X86Cpu.MOVLPD | validation | def MOVLPD(cpu, dest, src):
"""
Moves low packed double-precision floating-point value.
Moves a double-precision floating-point value from the source operand (second operand) and the
destination operand (first operand). The source and destination operands can be an XMM register
... | python | {
"resource": ""
} |
q253694 | X86Cpu.MOVHPD | validation | def MOVHPD(cpu, dest, src):
"""
Moves high packed double-precision floating-point value.
Moves a double-precision floating-point value from the source operand (second operand) and the
destination operand (first operand). The source and destination operands can be an XMM register
... | python | {
"resource": ""
} |
q253695 | X86Cpu.PSUBB | validation | def PSUBB(cpu, dest, src):
"""
Packed subtract.
Performs a SIMD subtract of the packed integers of the source operand (second operand) from the packed
integers of the destination operand (first operand), and stores the packed integer results in the
destination operand. The sourc... | python | {
"resource": ""
} |
q253696 | X86Cpu.MOVQ | validation | def MOVQ(cpu, dest, src):
"""
Move quadword.
Copies a quadword from the source operand (second operand) to the destination operand (first operand).
The source and destination operands can be MMX(TM) technology registers, XMM registers, or 64-bit memory
locations. This instructio... | python | {
"resource": ""
} |
q253697 | X86Cpu.MOVSD | validation | def MOVSD(cpu, dest, src):
"""
Move Scalar Double-Precision Floating-Point Value
Moves a scalar double-precision floating-point value from the source
operand (second operand) to the destination operand (first operand).
The source and destination operands can be XMM registers or ... | python | {
"resource": ""
} |
q253698 | X86Cpu.MOVSS | validation | def MOVSS(cpu, dest, src):
"""
Moves a scalar single-precision floating-point value
Moves a scalar single-precision floating-point value from the source operand (second operand)
to the destination operand (first operand). The source and destination operands can be XMM
registers ... | python | {
"resource": ""
} |
q253699 | X86Cpu.VEXTRACTF128 | validation | def VEXTRACTF128(cpu, dest, src, offset):
"""Extract Packed Floating-Point Values
Extracts 128-bits of packed floating-point values from the source
operand (second operand) at an 128-bit offset from imm8[0] into the
destination operand (first operand). The destination may be either an
... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.