# 1. Arithmetic operation

We will now focus on arithmetic operations, such as additions and subtractions.

This is the first time since the beginning of the tutorial that FLAGS have been used. Therefore, I give you the picture.

To make additions and subtractions, we will use the following instructions:

- ADD / SUB
- ADC / SBB -> involves the use of the carry flag (CF)
- INC / DEC

## 1.1 Example

Once is not customary, here is a sample code:

```
global _start
section .text
_start:
mov rax, 0x12
mov rbx, 0x32
add rax, rbx
sub rax, 0x21
; test carry flag
mov rax, 0xffffffffffffffff
add rax, 0x1
adc rax, 0x2 ; add rax with 0x2 + 1 due to CF
mov rax, qword [var1]
add qword [var2], rax
add qword [var2], 0x02
clc ; clear carry flag
stc ; set carry flag
cmc ; complement carry flag
stc
sbb rax, 0x12
inc rax
dec rbx
; exit
mov rax, 60
syscall
section .data
var1: db 0x1
var2: dq 0xaa
```

## 1.2 Multiplication and division

We will now see how multiplications and divisions in ASM work.

To achieve them we will need the following instructions:

- MUL / IMUL (signed)
- DIV / IDIV (signed)

Before going further, it's interesting to look at the differences between a signed and an unsigned value.

The difference between the two is that the most significant bit serves as a bit to sign. That is, if this bit goes to 1, all the resulting values will be negative values.

Perfect. Before going into practice, it is important to understand how registers work during multiplication and division operations.

Note in the image below that if the operation is too large, the RAX register will contain the result of the operation while the RDX register contains the remainder of it.

To better understand this, nothing beats the practice.

### 1.2.1 Example

```
global _start
section .text
_start:
mov rax, 0x12
mov rbx, 0x2
mul rbx
mov rax, 0xffffffff12
mov rbx, 0x1234556788
mul rbx
mov rax, 0x12
mul byte [var1]
mul dword [var2]
; exit
mov rax, 60
syscall
section .data
var1: db 0x11
var2: dq 0x12345678
```

I let you practice to experience divisions.

# 2. Logical operation

For those who have not made electronics, logical operations consist of performing bitwise operations to modify their values.

## 2.1. AND

Value 1 | Value 2 | Result |
---|---|---|

0 | 0 | 0 |

0 | 1 | 0 |

1 | 0 | 0 |

1 | 1 | 1 |

## 2.2. OR

Value 1 | Value 2 | Result |
---|---|---|

0 | 0 | 0 |

0 | 1 | 1 |

1 | 0 | 1 |

1 | 1 | 1 |

## 2.3. XOR

Value 1 | Value 2 | Result |
---|---|---|

0 | 0 | 0 |

0 | 1 | 1 |

1 | 0 | 1 |

1 | 1 | 0 |

## 2.4. NOT

NOT allows you to invert the bit values.

## 2.5. Example

```
global _start
section .text
_start:
mov rax, qword [var1]
not rax
xor rax, rax ; set rax to 0
mov rax, qword [var2]
xor rax, qword [var1]
and rax, 0x7812
or rax, 0x1
; exit
mov rax, 60
syscall
section .data
var1: dq 0x1111111111111111
var2: dq 0x123456789abcdef0
```

# 3. Bit shifting

## 3.1. Shifting instruction

The shift instructions move a bit string (or the operand processed as a bit string) to the right or to the left, with excess bits discarded (although one or more bits may be stored in flags) . In left arithmetic shift or logical shift, the leading zeros are shifted to the low-order bit. In right arithmetic shift, the sign bit (most significant bit) is shifted to the most significant bit. In logical shift, the zeros on the right are shifted into the most significant bit.

There are several instructions for performing these operations, the most common being:

- SHL / SAL (signed)
- SHR / SAR (signed)

The image below is extracted from the intel manual and explains the operation of bit shifts:

It can be seen that depending on the value of the shifted bit, the carry flag can then be activated or not.

The operation is identical for shifting left and right.

The image below explains the operation of the instruction **SAR**:

Note that this instruction is used to perform the shift on the signed values. The first two diagrams show the operation when the value is unsigned, which does not charge the operation seen previously. On the other hand, when the value is signed, it is found that the most significant bit remains at 1, to indicate that the value is signed.

## 3.2. Rotation instructions

The rotation instructions are similar to the shifting instructions except that the rotation instructions are circular, with the bits being shifted from one end to the other end. Rotations can be left or right. Rotations can also use an extended bit for multi-precision rotations..

As for the shift, there are plenty of instructions but the most common ones are :

- ROL / ROR
- RCL / RCR

It is important to know that when you want to change position a value, it is necessary to perform a rotation of 8 bits, which corresponds to 1 byte. Otherwise we will not have the desired values.

## 3.3. Example

```
global _start
section .text
_start:
mov rax, 0xffffffff
sal rax, 32
sal rax, 1
clc
mov rax, 0xffffffff
shr rax, 1
shr rax, 31
clc
mov rax, 0xffffffff
sar rax, 1
clc
mov rax, 0xffffffffffffffff
sar rax, 1
clc
mov rax, 0xabcdef0123456789
ror rax, 8
ror rax, 16
; exit
mov rax, 60
syscall
```

# 4. References

- Sign/Unsigned image Find it on slideshare
- Multiplication imag Find it on strchr.com
- Shifting Image Intel manual