[<< wikibooks] X86 Assembly/Arithmetic
All arithmetic instructions are executed in (one of) the ALUs.
The ALU can only perform integer arithmetics, for floating point instructions see chapter “Floating Point”.


== Basic operations ==
Arithmetic instructions take two operands: a destination and a source.

The destination must be a register or a memory location.
The source may be either a memory location, a register, or a constant value.Note that at least one of the two must be a register, because operations may not use a memory location as both a source and a destination.


=== Addition and Subtraction ===
This adds addend to destination and stores the result in destination.

Like add, only it subtracts subtrahend from destination instead.
In C: destination -= subtrahend;


=== Multiplication ===


==== Unsigned Multiplication ====

This multiplies multiplicand by the value of corresponding byte-length in the accumulator.

In the second case, the target is not EAX for backward compatibility with code written for older processors.
Affected flags are:

OF ≔ higher part of product ≠ 0
CF ≔ higher part of product ≠ 0All other flags are undefined.


==== Signed Multiplication ====

This instruction is almost like mul, but it treats the sign bit (the MSB), differently.
The imul instruction also accepts two other formats:

This multiplies destination by multiplicand and puts the result, the product, in destination

This multiplies multiplier by multiplicand and places it into product.


=== Division ===

This divides the value in the dividend register(s) by divisor, see table below.

The circle (○) means concatenation.
With divisor size 4, this means that EDX are the bits 32-63 and EAX are bits 0-31 of the input number (with lower bit numbers being less significant, in this example).
As you typically have 32-bit input values for division, you often need to use CDQ to sign-extend EAX into EDX just before the division.
If quotient does not fit into quotient register, arithmetic overflow interrupt occurs.
All flags are in undefined state after the operation.

As div, only signed.


=== Sign Inversion ===

Arithmetically negates the argument (i.e. two's complement negation).


== Carry Arithmetic Instructions ==

Add with carry. Adds src + CF to dest, storing result in dest. Usually follows a normal add instruction to deal with values twice as large as the size of the register. In the following example, source contains a 64-bit number which will be added to destination.

Subtract with borrow. Subtracts src + CF from dest, storing result in dest. Usually follows a normal sub instruction to deal with values twice as large as the size of the register.


== Increment and Decrement ==


=== Increment ===

Increments the register value in the argument by 1.
Performs much faster than add arg, 1.


=== Decrement ===


==== Operation ====
Decrements the value in minuend by 1, but this is much faster than the equivalent sub minuend, 1.


==== Operands ====
Minuend may be either a register or memory operand.


==== Application ====
Some programming language represent Boolean values with either all bits zero, or all bits set to one. When you are programming Boolean functions you need to take account of this. The dec instruction can help you with this. Very often you set the final (Boolean) result based on flags. By choosing an instruction that is opposite of the intended and then decrementing the resulting value you will obtain a value satisfying the programming language’s requirements. Here is a trivial example testing for zero. If you intend to set false the “erroneously” set 1 will be “fixed” by dec. If you intend to set true, which is represented by −1, you will decrement the value zero.


== Pointer arithmetic ==
The lea instruction can be used for arithmetic, especially on pointers.
See chapter “data transfer”, § “load effective address”.