adox

Unsigned Integer Addition of Two Operands with Overflow Flag

ADOX r32, r/m32

Adds with Overflow Flag (Parallel addition with ADCX).

Details

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 Operation

temp ← dest + src + OF;
OF ← (signed_overflow(dest, src, temp)) ? 1 : 0;
dest ← temp & 0xFFFFFFFF;

Example

ADOX eax, ebx

Encoding

Binary Layout
F3
+0
0F
+1
38
+2
F6
+3
 
Format Legacy
Opcode F3 0F 38 F6
Extension ADX

Operands

  • dest
    32-bit general-purpose register (e.g. EAX)
  • src
    32-bit register or memory

Reference (Intel® SDM)

Instruction Forms

Opcode Instruction Op/En 64/32-bit Mode CPUID Description
F3 0F 38 F6 /r ADOX r32, r/m32 RM V/V ADX RM ADX Unsigned addition of r32 with OF, r/m32 to r32, writes OF. F3 REX.w 0F 38 F6 /r V/N.E. Unsigned addition of r64 with OF, r/m64 to r64, writes OF. ADOX r64, r/m64

Description

Performs an unsigned addition of the destination operand (first operand), the source operand (second operand) and the overflow-flag (OF) and stores the result in the destination operand. The destination operand is a generalpurpose register, whereas the source operand can be a general-purpose register or memory location. The state of OF represents a carry from a previous addition. The instruction sets the OF flag with the carry generated by the unsigned addition of the operands. The ADOX instruction is executed in the context of multi-precision addition, where we add a series of operands with a carry-chain. At the beginning of a chain of additions, we execute an instruction to zero the OF (e.g. XOR). This instruction is supported in real mode and virtual-8086 mode. The operand size is always 32 bits if not in 64bit mode. In 64-bit mode, the default operation size is 32 bits. Using a REX Prefix in the form of REX.R permits access to additional registers (R8-15). Using REX Prefix in the form of REX.W promotes operation to 64-bits. ADOX executes normally either inside or outside a transaction region. Note: ADOX defines the CF and OF flags differently than the ADD/ADC instructions as defined in Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 2A.

Operation

IF OperandSize is 64-bit
THEN OF:DEST[63:0] := DEST[63:0] + SRC[63:0] + OF;
ELSE OF:DEST[31:0] := DEST[31:0] + SRC[31:0] + OF;
FI;

Intel C/C++ Compiler Intrinsic Equivalent

unsigned char _addcarryx_u32 (unsigned char c_in, unsigned int src1, unsigned int src2, unsigned int *sum_out);
unsigned char _addcarryx_u64 (unsigned char c_in, unsigned __int64 src1, unsigned __int64 src2, unsigned __int64 *sum_out);

Flags Affected

OF is updated based on result. CF, SF, ZF, AF, and PF flags are unmodified.

Exceptions

SIMD Floating-Point Exceptions

None. ADOX — Unsigned Integer Addition of Two Operands With Overflow Flag Vol. 2A 3-31

Protected Mode Exceptions

#UD If the LOCK prefix is used. If CPUID.07H.00H:EBX.ADX[19] = 0. #SS(0) For an illegal address in the SS segment. #GP(0) For an illegal memory operand effective address in the CS, DS, ES, FS or GS segments. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector. #PF(fault-code) For a page fault. #AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3.

Real-Address Mode Exceptions

#UD If the LOCK prefix is used. If CPUID.07H.00H:EBX.ADX[19] = 0. #SS(0) For an illegal address in the SS segment. #GP(0) If any part of the operand lies outside the effective address space from 0 to FFFFH.

Virtual-8086 Mode Exceptions

#UD If the LOCK prefix is used. If CPUID.07H.00H:EBX.ADX[19] = 0. #SS(0) For an illegal address in the SS segment. #GP(0) If any part of the operand lies outside the effective address space from 0 to FFFFH. #PF(fault-code) For a page fault. #AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3.

Compatibility Mode Exceptions

Same exceptions as in protected mode.

64-Bit Mode Exceptions

#UD If the LOCK prefix is used. If CPUID.07H.00H:EBX.ADX[19] = 0. #SS(0) If a memory address referencing the SS segment is in a non-canonical form. #GP(0) If the memory address is in a non-canonical form. #PF(fault-code) For a page fault. #AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3. ADOX — Unsigned Integer Addition of Two Operands With Overflow Flag Vol. 2A 3-32