# 680x0:Simple calculations

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

## Examples

Whe'll start of with some examples before starting to discuss the sublities of doing calculations in assembler.

Simple calculations: ``` move.l #5,d0 ; d0 = \$00000005 add.l #1,d0 ; d0 = d0 + 1 (d0 is now \$00000006) sub.l #2,d0 ; d0 = d0 - 2 (d0 is now \$00000004) rts ```

Multiplying/dividing: ``` move.l #5,d0 ; d0 = \$00000005 mulu.w #4,d0 ; d0 = d0 * 4 divu.w #2,d0  ; d0 = d0 / 2 rts ```

Bit shifts: ``` move.l #%11101,d0  ; d0 = %11101 asl.l #3,d0  ; d0 = d0 << 3 = %11101000 ```

## Multiplying and dividing

Multiplying and dividing can be very usefull. But also keep in mind these are very slow to perform for a MC680x0 processor. For that reason democoders often try to find ways to find a quicker way to get comparable results or use a different way of doing the multiplication/division (for example with bitshifting).

### Multiplication

For multiplication there's mulu (MULtiply Unsigned) and muls (MULtiply Signed). The standard mulu.w or muls.w can only multiply 16-bit numbers and although the result too is 16-bit, the result will be stored as a longword (32-bit). This means the upper part of the register will be cleared.

An example: ``` move.l #\$FFFFFFFF,d0  ; d0 = \$FFFF.FFFF move.l #5,d1 move.l #8,d2 mulu.w d1,d2  ; d0 = \$0000.0028 ```

As you can see:

• the upper part will be cleared
• mulu.w (MULtiply Unsigned) can only handle up to 65,535
• muls.w (MULtiply Signed) can only handle from -32,768 to +32,767

For 68020+ processors there's mulu.l and muls.l which can multiply two longwords (32-bit) and store the result into one register (only the low 32-bit) or two (for 64-bit).

``` TODO ```

### Dividing

TODO ... divu uses the lower word to store the quotient (the result) and the upper word to store the remainder.