Anonymous user
GB Programming: Difference between revisions
→Credits & Resources
>ISSOtm (→Flags: Remove flags that don't exist on Game Boy) |
|||
| (7 intermediate revisions by 5 users not shown) | |||
Line 48:
* A group of 32 bits is called a '''double word''' or '''dword'''.
* A group of 64 bits is called a '''quadruple word''' or '''qword'''.
We will mostly be working with bytes, sometimes with words and rarely with nibbles. It is
Now, let's talk about '''hexadecimal'''. It is '''base 16''', so we will be working with 16 symbols : 0 1 2 3 4 5 6 7 8 9 A B C D E F. Again, we will prepend hex numbers with a $ to differentiate them.
Line 123:
|DE
|HL
|
|
|
|
|-
|A
Line 288:
|Yes
|-
|
|Yes
|No
Line 304:
|No
|-
|
|Yes
|No
Line 320:
|No
|-
|
|Yes
|Yes
Line 336:
|No
|-
|
|Yes
|No
Line 396:
|Store value of register B into register D.
|-
|''ld
|Store the value of register A into memory address $8325.
|}
Line 444:
So, how does running a program works? What happens is that a special register is incremented (its value is raised by one), then the processor fetches the byte located at the address held by that register, and processes it as an opcode ; when done, everything is repeated. Instructions can be one to three opcodes (bytes) large, so this cycle may repeat for a single instruction.
So now, how to access memory? With
To access the memory location pointed to by HL, just do...
So, to retrieve the value at memory address $6511 into register A : ''ld a,
And to store the value of register C into the memory pointed to by HL : ''ld
Remember to refer to the chart above for the legal LD combinations.
Obviously, ''ld
For those wondering, ''ld a,
==Flags==
Line 494:
!C
|-
|INC <nowiki>{reg8 | reg16 |
|Adds one to the operand ("increments" it)
|Affected, except for reg16
|Not affected
|-
|DEC <nowiki>{reg8 | reg16 |
|Subtracts one to the operand ("decrements" it)
|Affected, except for reg16
|Not affected
|-
|ADD A, <nowiki>{reg8 | imm8 |
|Adds the operand to the accumulator
|Affected
Line 514:
|Not affected
|-
|SUB <nowiki>{reg8 | imm8 |
|Subtracts the operand from the accumulator. The syntax SUB A, <nowiki>{...}</nowiki> is also valid but less common.
|Affected
Line 525:
A : Nowhere :D To multiply, you must write your own routines! However, a nice lil' trick : to do A <- A*2, simply ''add a, a''! To do A <- A*3, do ''ld b, a'', ''add a, a'', ''add a, b'' (you can swap B with any other register, of course). I'll leave you A <- A*4, A*5, A*6 and A*7 as an exercise.
For the rest of the tutorial, you'll see some text prefixed by a ";". These are comments, and are NOT part of the code. This line : "ld
Also, the Game Boy's CPU as four very specific instructions :
{| class="wikitable"
|ld
|Equivalent to ''ld
|-
|ld
|Equivalent to ''ld
|-
|ld a,
|Equivalent to ''ld a,
|-
|ld a,
|Equivalent to ''ld a,
|}
These are often used to operate on
===Overflow===
Line 558:
Because two hex digits mean one byte, $D3, as well as $61, is a byte. Since $D3 and H are leftmost in both cases, ld hl, $D361 is actually a shorter form of ld h, $D3 then ld l, $61.
Let's say the following instruction is ld
Stop here, and remember this until it becomes natural to you. Because this "little-endian"ness is very tricky for beginners. It is ''very'' important when working with memory.
Here is an exercise : what values will
Initial values :
Line 573:
<pre>
ld hl, $C303
ld a,
ld b, 3
add a, b
ld c, 0
sbc hl, bc
ld
inc hl
ld b,
sub a, b
inc
inc hl
ld
ld bc, 9
add hl, bc
ld
ld
</pre>
Line 633:
To push register DE :
<pre>
ld hl,
ld
inc hl ; Move stack pointer
ld
inc hl
ld
</pre>
To pop into register DE :
<pre>
ld hl,
dec hl ; Move stack pointer
ld d,
dec hl ; Repeat
ld e,
ld
</pre>
Line 673:
where reg16 is any 16-bit register pair. AF can be used here.
Also meet SP, which makes all of this possible. SP is the '''hardware Stack Pointer'''. You can INC and DEC it, and you can't use it as a source in LD. Here are equivalents of ''push hl'' and ''pop hl'' (assuming we could use
{| class="wikitable"
|PUSH HL
|<pre>
dec sp
ld
dec sp
ld
</pre>
|-
|POP HL
|<pre>
ld l,
inc sp
ld h,
inc sp
</pre>
Line 696:
<pre>
push af
ld a,
pop de
</pre>
Line 770:
There is one special case of jp, though !
{| class="wikitable"
|JP
|Has execution jumping to the address pointed to by hl.<br/>Does not accept any conditionals.
|}
Line 776:
<pre>
ld hl, $2457
jp
</pre>
will jump to $2457. Some might argue that "jp $2457" is better, as it'd save 1 byte and preserve the hl register.
However, "jp
===Comparing stuff===
Line 810:
Example :
<pre>
ld a,
cp $63
jr z, placeItems
Line 817:
jr someplace
placeItems:
ld b,
</pre>
If
Otherwise, executions continues through, increments hl twice, then jumps to "someplace"
Line 1,054:
ld hl, $C303 ; Now H = $C3 and L = $03
ld a,
ld b, 3 ; B = $03
Line 1,064:
sbc hl, bc ; HL = HL - (BC + C flag) = $C303 - ($0300 + $00) = $C003
ld
inc hl ; HL = $C004
ld b,
sub a, b ; A = A - B = $06 - $DE = $06 + (-$DE) = $06 + ($21 + $01) = $28, C flag = 0
Line 1,074:
Notice here that doing ''sub a, b'' actually increased A's value!
inc
inc hl ; HL = $C005
ld
ld bc, 9 ; B = $00, C = $09
Line 1,084:
add hl, bc ; HL = HL + BC = $C005 + $0009 = $C00E
ld
ld
Initial values :
Line 1,150:
Heavily using [http://gbdev.gg8.se/wiki/articles/Pan_Docs the Pan Docs] for GameBoy-specific stuff.
The [http://marc.rawer.de/Gameboy/Docs/GBCPU_Instr.html GCISheet] is useful for understanding CPU instructions and can be combined with [https://iimarckus.org/etc/asmopcodes.txt IIMarckus's opcode to instruction page] or the copy on [[The Big HEX List]].
[https://tcrf.net/Help:Contents/Finding_Content/Debugger_guide/BGB Torchickens has started a tutorial for BGB emulator's debugger at The Cutting Room Floor]
[[Category:Arbitrary code execution]]
| |||