Unsigned Integer Addition With Overflow Flag

Opcode	Encoding	16 bit	32 bit	64 bit	`CPUID` Feature Flag(s)	Description
`F3 0F 38 F6 /r` `ADOX r32, r/m32`	`rm`	Valid	Valid	Valid	`adx`	Add r32, the overflow flag, and r/m32 into r32. Sets only the overflow flag for overflow.
Opcode: `F3 0F 38 F6 /r` Mnemonic: `ADOX r32, r/m32` Encoding: `rm` Validity (16/32/64 bit): valid, valid, valid `CPUID` Feature Flag(s): `adx` Add r32, the overflow flag, and r/m32 into r32. Sets only the overflow flag for overflow.
`F3 REX.W 0F 38 F6 /r` `ADOX r64, r/m64`	`rm`	N/E	N/E	Valid	`adx`	Add r64, the overflow flag, and r/m64 into r64. Sets only the overflow flag for overflow.
Opcode: `F3 REX.W 0F 38 F6 /r` Mnemonic: `ADOX r64, r/m64` Encoding: `rm` Validity (16/32/64 bit): N/E, N/E, valid `CPUID` Feature Flag(s): `adx` Add r64, the overflow flag, and r/m64 into r64. Sets only the overflow flag for overflow.

Encoding

Encoding	Operand 1	Operand 2
`rm`	`ModRM.reg[rw]`	`ModRM.r/m[rw]`

Description

The ADCX instruction adds the source operand, the destination operand, and the overflow flag. The result is stored in the destination operand. Only the overflow flag is affected.

This instruction is designed for use in multibyte additions such as in arbitrary precision arithmetic. The difference between this instruction and ADC (Add with Carry) is that this one allows the creation of two "carry chains" – one using OF (this one) and one using CF (ADCX (Unsigned Integer Addition with Carry Flag)).

Operation

public void ADOX(ref U32 dest, U32 src)
{
    dest += src + EFLAGS.OF;
}

public void ADOX(ref U64 dest, U64 src)
{
    dest += src + EFLAGS.OF;
}

Flags Affected

CF (carry flag): Unmodified.
PF (parity flag): Unmodified.
AF (auxiliary flag): Unmodified.
ZF (zero flag): Unmodified.
SF (sign flag): Unmodified.
OF (overflow flag): Set if an unsigned overflow occurs. Cleared otherwise.

Intrinsics

uint8_t _addcarryx_u32(uint8_t c_in, uint32_t src1, uint32_t src2, uint32_t *sum_out)
uint8_t _addcarryx_u64(uint8_t c_in, uint64_t src1, uint64_t src2, uint64_t *sum_out)

Exceptions

Real-Address Mode

#UD

If the LOCK prefix is used, but the destination is not a memory operand.

#SS(0)

If a memory operand using the SS segment has an effective address that is outside the SS segment's limit.

#GP(0)

If a memory operand (using a segment other than SS) has an effective address that is outside the segment's limit.

Virtual-8086 Mode

#UD

If the LOCK prefix is used, but the destination is not a memory operand.

#SS(0)

If a memory operand using the SS segment has an effective address that is outside the SS segment's limit.

#GP(0)

If a memory operand (using a segment other than SS) has an effective address that is outside the segment's limit.

#PF(fc)

If a page fault occurs.

#AC(0)

If alignment checking is enabled while the current privilege level is 3 and an unaligned memory access is made.

Protected Mode

#UD

If the LOCK prefix is used, but the destination is not a memory operand.

#SS(0)

If a memory operand using the SS segment has an effective address that is outside the SS segment's limit.

#GP(0)

If the destination is located in a non-writable segment.
If a memory operand uses a segment containing a NULL selector.
If a memory operand (using a segment other than SS) has an effective address that is outside the segment's limit.

#PF(fc)

If a page fault occurs.

#AC(0)

If alignment checking is enabled while the current privilege level is 3 and an unaligned memory access is made.

Compatibility Mode

#UD

If the LOCK prefix is used, but the destination is not a memory operand.

#SS(0)

If a memory operand using the SS segment has an effective address that is outside the SS segment's limit.

#GP(0)

If the destination is located in a non-writable segment.
If a memory operand uses a segment containing a NULL selector.
If a memory operand (using a segment other than SS) has an effective address that is outside the segment's limit.

#PF(fc)

If a page fault occurs.

#AC(0)

If alignment checking is enabled while the current privilege level is 3 and an unaligned memory access is made.

Long Mode

#UD

If the LOCK prefix is used, but the destination is not a memory operand.

#SS(0)

If a memory operand using the SS segment is in non-canonical form.
If a memory operand using the SS segment has an effective address that is outside the SS segment's limit.

#GP(0)

If a memory operand (using a segment other than SS) is in non-canonical form.
If the destination is located in a non-writable segment.
If a memory operand uses a segment containing a NULL selector.
If a memory operand (using a segment other than SS) has an effective address that is outside the segment's limit.

#PF(fc)

If a page fault occurs.

#AC(0)

If alignment checking is enabled while the current privilege level is 3 and an unaligned memory access is made.