GameBoy

Load instruction : ld

Load - moving data between memory and CPU

e.g. ld a, 30 => a = 30

Load High - moving data between HRAM memory and CPU.

Takes fewer cycles and bytes than ld. the 0xFF high byte is implied.

Can indirect through [c] for even more savings

Can use it for indirection when using LDH

Jump to address.

No built-in indirection for the address (can do the stack tricks with RET)

Can use the conditional form

Jump Relative - jump +127 / -128 bytes from current location.

Save a cycle and a byte _(maybe more?)_

Prefer JR untill the assembler gripes at you

can use the conditional form

Jump to subroutine.

Pushes next address to execute on the stack pointed to by SP

can use the conditional form

Z : zero flag is set

NZ: zero flag clear

C : carry flag is set

CZ: carry flag clear

Return from subroutine - pops address off the stack

Can use the conditional form

Return from subroutine and enable interrupts

Jump through Restart Vector

8 vectors, with 8 bytes available for eacah

$10 $18

$20 $28

$30 $38

$40 $48

Save two bytes / two cycles by jumping through these.

One byte operand, 0x00 is prepended to it.

Add with carry

Add without carry

Decrement operand

Increment operand

compare with accumulator - Acc - operand, and set Z and C flags

Subtract with carry

Subtract without carry

bitwise AND of accumulator with operand

bitwise OR of accumulator with operand

bitwise XOR of accumulator with operand.

Use XOR a to zero accumulator and clear carry flag

xor a

(there is no specific instruction)

Test a bit in the operand. Sets Z to 1 if it is clear (so sets z to the NOT of the tested bit…)

Reset (clear) a speciifc bit in the operand

Set a specific bit in the operand

exchange the nybbles of a byte

Roll left / Roll left accumulator (short form instruction)

Roll into carry, carry put into bit zero

Rotate Left CIRCULAR / Rotate Left Curcular accumulator (short form instruction)

NOT carry

The carry bit is set, but never used.

Rotate Right / Rotate Right accumulator (short form instruction)

Carry is involved in the bits

Rotate Right CIRCULAR / Rotate Right Circular accumulator (short form instruction)

(not Carry)

Carry is set from the rotation, but does not contribute.

Shift Left Arithmetic (not accumulator-specific)

Zero shifted in, high bit goes to carry

Shift Right Arthimetic (not accumulator-specific)

High bit duplicated, bit zero goes into carry

Shift RIght Logical

Zero shifted in, bit zero goes into carry

Take 16 bits from SP and putting into the operand. Updates SP

Move 16 bits from operand onto the stack. Updates SP

GB’s SP style. Starts at high memory and fills down. Lower addresses are newer values on the stack.

Complement Carry Flag

(there is no clear carry flag instruction)

Set carry flag

Complement accumulator

Convert value to BCD

Disable Interrupts

Enable Interrupts

NOP!

Go to low-power state

Go to very low power state.

DO NOT USE (unless you’re doing CGB games), it can damage the screen

If the stop happens during a screen update (which is trickling voltage to the screen), then the voltage never stops, eventually causing a permanent black line as the LCD cells get burned out.

Tick states. There are four ticks for each machine cycle

Machine cycles - four ticks each. Instructions execute in complete machine cycles, and is a more convenient metric for cost of instructions

Each instruction is 1-6 machine cycles

Sharp LR35902 - 4.19 mhz T-States, 1.049 M-Cycles

Z - Zero

C - Carry

(BCD flags, not really used)

N - Negative

H - Half-carry from nybble to nybble

Indirection syntax

af - accumulator + flags

bc - generic 8/16. C used in LDH indirection

de - generic 8/16

hl - generic 8/16. Primary indirection register (High / Low)

sp

pc

Interrupt Master Enable

when indirect, [HLI] will use HL, but increment after use

[HLD] will use HL. but increment after use

Other syntaxes:

[HL+] [HL-] // I like this one

LDI / LDD as pseudo instructions

There are five interrupt vectors

$40 - VBlank

$48 - LCD Status

$50 - TImer overflow

$58 - serial transfer completion

$60 - joypad transition

macro name

ld high(\1), high(\2)

ld low(\1), low(\2)

jr nz oop_ack\@

…

oop_ack\@:

endm

def OOP_ACK equ $1234

def BORK equ (5+7)

global labels:

label: …

local labels:

.label: …

Local labels only have to be unique in regions bounded by global labels

section “name”, rom0[$1000]

Name is just used to connect sections. does not survive to ROM

the [$1000] is start address, and is optinal. otherwise the toolcahin will pick a space

Can use FRAGMENT for cross-source-file sections

rom0 is the type (There are other types, TBD), and the zero is the bani (details TBD)

add a,b

jp z, zero

…something…

zero:

…

add a,b

jp nz, not_zero

something-1

jp zero__check_end

not_zero:

something-2

zero__check_end:

…

ld c,8

loop:

something

dec c

jp nz, noop

…