PM Opc CALL

CALL = Call routine

Hex	Mnemonic	Condition	Cycles,True	or False
E0 ss	CALLC short #ss	Carry=1	20	8
E1 ss	CALLNC short #ss	Carry=0	20	8
E2 ss	CALLZ short #ss	Zero=1	20	8
E3 ss	CALLNZ short #ss	Zero=0	20	8
E8 ss ss	CALLC long #ssss	Carry=1	24	12
E9 ss ss	CALLNC long #ssss	Carry=0	24	12
EA ss ss	CALLZ long #ssss	Zero=1	24	12
EB ss ss	CALLNZ long #ssss	Zero=0	24	12
F0 ss	CALL short #ss	None	20	None
F2 ss ss	CALL long #ssss	None	24	None
FB ss ss	CALL [#nnnn]	None	20	None
FC ss	CINT #nn	None	20	None
CE F0 ss	CALLL short #ss	Overflow != Sign	24	12
CE F1 ss	CALLLE short #ss	(Overflow != Sign) OR (Zero=1)	24	12
CE F2 ss	CALLG short #ss	(Overflow == Sign) OR (Zero=0)	24	12
CE F3 ss	CALLGE short #ss	Overflow == Sign	24	12
CE F4 ss	CALLO short #ss	Overflow=1	24	12
CE F5 ss	CALLNO short #ss	Overflow=0	24	12
CE F6 ss	CALLP short #ss	Sign=0	24	12
CE F7 ss	CALLNP short #ss	Sign=1	24	12
CE F8 ss	CALLNX0 short #ss	??	24	12
CE F9 ss	CALLNX1 short #ss	??	24	12
CE FA ss	CALLNX2 short #ss	??	24	12
CE FB ss	CALLNX3 short #ss	??	24	12
CE FC ss	CALLX0 short #ss	??	24	12
CE FD ss	CALLX1 short #ss	??	24	12
CE FE ss	CALLX2 short #ss	??	24	12
CE FF ss	CALLX3 short #ss	??	24	12

Execute

#nn      = Immediate unsigned 8-Bits
#ss      = Immediate signed 8-Bits
#ssss    = Immediate signed 16-Bits
U/V      = Register U or V
SP       = Register SP (Stack Pointer)
[#nnnn]  = Memory: (I shl 16) or #nnnn

; CALL* #ss

IF (Condition) THEN
  SP = SP - 3
  Memory[SP+2] = V
  Memory[SP+1] = PC SHR 8
  Memory[SP]   = PC AND 0x00FF
  V = U
  PC = PC + #ss - 1
ENDIF

; CALL* #ssss

IF (Condition) THEN
  SP = SP - 3
  Memory[SP+2] = V
  Memory[SP+1] = PC SHR 8
  Memory[SP]   = PC AND 0x00FF
  V = U
  PC = PC + #ssss - 1
ENDIF

; CALL #ss

SP = SP - 3
Memory[SP+2] = V
Memory[SP+1] = PC SHR 8
Memory[SP]   = PC AND 0x00FF
V = U
PC = PC + #ss - 1

; CALL #ssss

SP = SP - 3
Memory[SP+2] = V
Memory[SP+1] = PC SHR 8
Memory[SP]   = PC AND 0x00FF
V = U
PC = PC + #ssss - 1

; CALL [#nnnn]

SP = SP - 3
Memory[SP+2] = V
Memory[SP+1] = PC SHR 8
Memory[SP]   = PC AND 0x00FF
V = U
PC = Memory16[(I SHL 16) + #nnnn]

; CINT #nn (not fully tested)

SP = SP - 4
Memory[SP+3] = V
Memory[SP+2] = PC SHR 8
Memory[SP+1] = PC AND 0x00FF
Memory[SP]   = F
V = U
PC = Memory16[#nn SHL 1]

Description

Call a subroutine (CALL or CALL*) or a interrupt vector (CINT).

Use RET to return from a subroutine and RETI from a interrupt.

NOTE: All non-branch instructions does "U = V" causing U to be restored, any branch that require banking needs "MOV U, A" or "MOV U, #nn" before it...

Conditions

None

Examples

 ; A = 0x10
 ; B = 0x10
 CALL somefunction
 ; A = 0x11
 ; B = 0x0F
 TST B, #0x10
 ; F = (Zero=0):(Sign=0)
 CALLZ somefunction    ; Condition fail, call not taken
 ; A = 0x11
 ; B = 0x0F
 ; F = (Zero=0):(Sign=0)
 CALLP somefunction    ; Condition succeed
 ; A = 0x12
 ; B = 0x0E

 (...)

somefunction:
 INC A
 DEC B
 RET                   ; Return from the call

; Calling a subroutine at different bank
MOV U, $0F
CALL function_at_bank_16

« Back to Instruction set