z80 » Beginner
start: ;label 'start' given the ; address of the following ; byte in memory (in ; this case the 'ld a,__' ;comments ; comments ;comments ;comments ;comments....more comments;;;;more comments ;the assembler doesn't even see this ld a,23 ;store 23 in a ld b,45 ;store 45 in b add a,b ;23+45=68 stored in a ld hl,$fc00 ;store $fc00 in hl ld de,23 ;store 23 in de add hl,de ;$fc00+23=$fc17 call _clrLCD ;clear the screen cp b ;is a=b? cp 3 ;is a=3? ld b,4 loop: call _clrLCD ;clear screen 4 times djnz loop ;b-1 stored in b ;if b=0...we're done ret ;return from where we ; came from
This is a listing of the most commonly used assembler instructions. Depending upon your type of assembler, you may need to insert white-space (leading spaces or tabs) before instructions. Labels and comments do not require white-space.
arg1:- The colon after a non-spaced, 31 or less name is a label. The assembler uses it as a reference point for calls and jumps. It can contain underscores (
_). Labels are given the value of the address of the following byte of code. They take up zero space in the program so you can have as many labels as you want. You need to put no spaces between the left margin of the source code and the label name, or the assembler won't recognize it.
label: boring_label: a: run_to_me_now: this_label_is_too_long_to_be_a_label:
; comments- The semi-colon tells the processor "Ignore the rest of this line". It is useful for adding little reminders as to what code may do so that later readers understand complex routines.
ld bc,$0303 ;load b with 3, c with 3 ;this is all ignored
ld arg1, arg2- Copies arg2 into arg1. You can either copy a register's value into an address or an address into a register's value, but you can not copy a value directly into a memory address, the value needs to go through a register first. It's like when you eat: the food can't go directly from your plate to your stomach, it has to go through your mouth (that was cheesy).
ld hl,(256*2)+1 ;same as $0201 ld b,$3 ld a,%01101001 ld a,%010 ;same as %00000010 ld (hl),$35 ;load byte at address ; hl ld (de),a ;ld into address at de ld ($80df),hl ld ($fc00),a ;load a into first ; byte of video memory ld a,b ld a,($8100) ld ($8309),%10011100 ;CAN'T do this! ld (_textShadow),$a4 ;CAN'T do this!
call addr1- Processor goes to the specified address (addr1) and starts executing code until it is told to go back. There are two types of calls: a ROM call and an address call. ROM calls go to an area in the TI86's own memory whereas an address call will jump to an address in your program or in the asm program. Most frequent ROM calls and asm calls are listed in
ti86asm.inc. They are listed as aliases to addresses in the TI86's memory. ROM calls and address calls are not different. I just made the distinction to show you that some people refer to calls made to an address in TI-OS's own memory instead of the actual program running.
call _clrLCD call $4a7e ;$4a7e is address of ; _clrLCD call my_routine ;routine somewhere in your ; programCall's made inside the program are called absolute calls because they require the exact, absolute, position of the label in the memory. Calls made to parts of the program itself are absolute also. At the start of almost all your programs will be the line of code
.org _asm_exec_ramwhich was an alias saying
.org $d748. This tells the assembler to make all the label referencing while considering that the program is at address $d748. The processor encounters
call my_routine, which is inside the program. It then takes the address of the my_routine label, for example $0034 and adds that to $d748 to get $d77c. Then it returns to where it encountered
call my_routineand substitutes that with
call $d77c. When it encounters
call _clrLCD, which it knows to be an alias, it just substitutes the alias for
call $4a7e. Can be used with flags and conditions.
cp arg1- Compares whatever is in the
aregister to arg1. Arg1 can be either a value, a register that points to an address, or another register. Modifies the processor flags accordingly.
cp h ;compare h to a cp $03 cp 250 cp %00000111 cp (hl)
add arg1, arg2- Adds the value of arg2 to the value of arg1 and stores the result into arg1. Arg1 and arg2 can be either a register pointing to an address and a register, a register and a register, or a register and a value. Arg2 does not change.
add a,(hl) ;add contents of memory at ; address hl with a and store ; result in a add hl,de add a,b add a,$23
sub arg1- Subtracts the value of arg1, or the register to which it is refering, from
aand stores the result in
a. Arg1 does not change.
sub 32 sub (hl) sub c
inc arg1- Increases the value of, or address pointed to by, arg1 by one. Arg1 can be a register or a pointer to a register.
inc (hl) ;increase byte at address hl inc a inc bc inc e
dec arg1- Decreases the value, or address pointed to by arg1, by one. Arg1 can be a register or a pointer to a register.
dec (hl) ;decrease byte at address hl dec a dec b dec de
djnz addr1- Similar to a "For()" loop in TI-BASIC, djnz stands for "Decrease register
bby one and Jump if Not Zero to addr1". This decreases the value of register
bby one and jumps to start executing code at addr1 if
bis not zero yet, but if
bhas hit zero, it will just continue on in the code.
djnz LabelToSomewhereHere it is in context with other code. This is just to give you the basic idea of its use:
ld b,10 ;number of iterations in ; loop BeginningOfForLoop: . . . ;code to be executed in ; For() loop djnz BeginningOfForLoop . . . ;code to be executed once ; For() loop is done
jr addr1- Jumps to addr1 and starts executing code. Addr1 must be within about 120 bytes from the
jr addr1instruction. Assembly Studio should give you an error if the address is too far away.
jr Label_To_Somewhere_Before_This_Command jr Label_To_Somewhere_After_This_CommandRelative jumps move to an address relative to where the processor is executing code. The jump may tell the processor to "move to the label that is 35 bytes backwards from where you are now". That is why they are relative to the current position of where the processor is executing code. Can be used with flags and conditions.
jp addr1- Jumps to addr1 and starts executing code. Addr1 can be any distance from the
jp addr1instruction. It is best to use
jr addr1instead wherever possible because
jp addr1takes up one byte more byte in memory.
jp $01be ;jump to address $01be jp LabelToSomewhereAbsolute jumps made inside the program are called absolute calls because they require the exact, absolute, position of the label in the memory distance wise from zero, or the beginning of the memory at $0000. Can be used with flags and conditions.
ret- Used with
call addr1. Tells the processor to go back to wherever it was called from and continue executing the code following the call. Can be used with flags and conditions.
More from z80 » Beginner
Aliases // Convert from decimal to hexadecimal or binary // Flags and Conditions // Format and Compiling // Instructions // Math // Number Bases // Oh, No! It Crashed! // Registers // TI-BASIC to Asm Comparisons // TI86 Specifications // Two's Compliment // z80 Processor