343 lines
17 KiB
NASM
343 lines
17 KiB
NASM
|
;===============================================================
|
||
|
|
; nanoTest.asm
|
||
|
|
; Used for checking the NanoBlaze instruction set
|
||
|
|
;===============================================================
|
||
|
|
; 1) Test logical operations with direct values
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s7, 01
|
||
|
|
CONSTANT testPattern, 0F
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "LOAD", "AND"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, testPattern
|
||
|
|
AND s0, 33
|
||
|
|
COMPARE s0, 03
|
||
|
|
JUMP NZ, error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "OR"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s1, testPattern
|
||
|
|
OR s1, 33
|
||
|
|
COMPARE s1, 3F
|
||
|
|
JUMP NZ, error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "XOR"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s2, testPattern
|
||
|
|
XOR s2, 33
|
||
|
|
COMPARE s2, 3C
|
||
|
|
JUMP NZ, error
|
||
|
|
;===============================================================
|
||
|
|
; 2) Test logical operations with registers
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s7, 01
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "LOAD"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, 33
|
||
|
|
LOAD s3, s0
|
||
|
|
COMPARE s3, 33
|
||
|
|
JUMP NZ, error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "AND"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, 0F
|
||
|
|
AND s0, s3
|
||
|
|
COMPARE s0, 03
|
||
|
|
JUMP NZ, error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "OR"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s1, 0F
|
||
|
|
OR s1, s3
|
||
|
|
COMPARE s1, 3F
|
||
|
|
JUMP NZ, error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "XOR"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s2, 0F
|
||
|
|
XOR s2, s3
|
||
|
|
COMPARE s2, 3C
|
||
|
|
JUMP NZ, error
|
||
|
|
;===============================================================
|
||
|
|
; 3) Test arithmetic operations with constants
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s7, 01
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "ADD" and "ADDCY"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, 0F
|
||
|
|
ADD s0, 31 ; 40
|
||
|
|
ADDCY s0, F0 ; 130
|
||
|
|
ADDCY s0, F0 ; 121
|
||
|
|
ADD s0, 0F ; 30
|
||
|
|
COMPARE s0, 30
|
||
|
|
JUMP NZ, error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "SUB" and "SUBCY"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s1, 0F
|
||
|
|
SUB s1, 0C ; 03
|
||
|
|
SUBCY s1, F0 ; 113
|
||
|
|
SUBCY s1, F0 ; 22
|
||
|
|
SUB s1, 01 ; 21
|
||
|
|
COMPARE s1, 21
|
||
|
|
JUMP NZ, error
|
||
|
|
;===============================================================
|
||
|
|
; 4) Test arithmetic operations with registers
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s7, 01
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "ADD" and "ADDCY"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, 0F
|
||
|
|
LOAD s1, 31
|
||
|
|
LOAD s2, F0
|
||
|
|
LOAD s3, 0F
|
||
|
|
ADD s0, s1 ; 40
|
||
|
|
ADDCY s0, s2 ; 130
|
||
|
|
ADDCY s0, s2 ; 121
|
||
|
|
ADD s0, s3 ; 30
|
||
|
|
COMPARE s0, 30
|
||
|
|
JUMP NZ, error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "SUB" and "SUBCY"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s1, 0F
|
||
|
|
LOAD s0, 0C
|
||
|
|
LOAD s2, F0
|
||
|
|
LOAD s3, 01
|
||
|
|
SUB s1, s0 ; 03
|
||
|
|
SUBCY s1, s2 ; 113
|
||
|
|
SUBCY s1, s2 ; 22
|
||
|
|
SUB s1, s3 ; 21
|
||
|
|
COMPARE s1, 21
|
||
|
|
JUMP NZ, error
|
||
|
|
;===============================================================
|
||
|
|
; 5) Test shifts
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s7, 01
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test shift right
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, 0F ; 0F
|
||
|
|
SR0 s0 ; 07
|
||
|
|
SRX s0 ; 03
|
||
|
|
SR1 s0 ; 81
|
||
|
|
SRX s0 ; C0, C=1
|
||
|
|
SRA s0 ; E0, C=0
|
||
|
|
SRA s0 ; 70
|
||
|
|
COMPARE s0, 70
|
||
|
|
JUMP NZ, error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test shift left
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s1, F0 ; FO
|
||
|
|
SL0 s1 ; E0
|
||
|
|
SLX s1 ; C0
|
||
|
|
SL1 s1 ; 81
|
||
|
|
SLX s1 ; 03, C=1
|
||
|
|
SLA s1 ; 07, C=0
|
||
|
|
SLA s1 ; 0E
|
||
|
|
COMPARE s1, 0E
|
||
|
|
JUMP NZ, error
|
||
|
|
;===============================================================
|
||
|
|
; 6) Test comparison operators
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s7, 01
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "COMPARE"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, 0F
|
||
|
|
COMPARE s0, F0 ; A < B => C=1
|
||
|
|
JUMP NC, error
|
||
|
|
COMPARE s0, F0 ; A < B => Z=0
|
||
|
|
JUMP Z, error
|
||
|
|
COMPARE s0, s0 ; A = B => Z=1
|
||
|
|
JUMP NZ, error
|
||
|
|
COMPARE s0, 08 ; A > B => C=0
|
||
|
|
JUMP C, error
|
||
|
|
COMPARE s0, 08 ; A > B => Z=0
|
||
|
|
JUMP Z, error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "TEST"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, 0F
|
||
|
|
TEST s0, F0 ; AND is 00 => Z=1
|
||
|
|
JUMP NZ, error
|
||
|
|
TEST s0, FF ; AND is 0F => Z=0
|
||
|
|
JUMP Z, error
|
||
|
|
;===============================================================
|
||
|
|
; 7) Test INPUT and OUTPUT operators
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s7, 01
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "INPUT" and "OUTPUT" direct
|
||
|
|
;
|
||
|
|
; The testbench should invert the word written at address FC.
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, AA
|
||
|
|
OUTPUT s0, FC
|
||
|
|
INPUT s1, FC
|
||
|
|
COMPARE s1, 55
|
||
|
|
JUMP NZ, error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "INPUT" and "OUTPUT" indexed
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, CC
|
||
|
|
LOAD s2, FC
|
||
|
|
OUTPUT s0, (s2)
|
||
|
|
INPUT s1, (s2)
|
||
|
|
COMPARE s1, 33
|
||
|
|
JUMP NZ, error
|
||
|
|
;===============================================================
|
||
|
|
; 8) Test STORE and FETCH operators
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s7, 01
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "STORE" and "FETCH" direct
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, 0F
|
||
|
|
STORE s0, 03
|
||
|
|
FETCH s1, 03
|
||
|
|
COMPARE s1, 0F
|
||
|
|
JUMP NZ, error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "STORE" and "FETCH" indexed
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, F0
|
||
|
|
LOAD s2, 04
|
||
|
|
STORE s0, (s2)
|
||
|
|
FETCH s1, (s2)
|
||
|
|
COMPARE s1, F0
|
||
|
|
JUMP NZ, error
|
||
|
|
;===============================================================
|
||
|
|
; 9) Test JUMP instructions
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s7, 01
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "JUMP NC"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, F0
|
||
|
|
ADD s0, 00 ; s0=F0, C=0, Z=0
|
||
|
|
JUMP NC, continue1
|
||
|
|
JUMP error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "JUMP NZ"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
continue1: ADD s0, 00 ; s0=F0, C=0, Z=0
|
||
|
|
JUMP NZ, continue2
|
||
|
|
JUMP error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "JUMP C"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
continue2: ADD s0, F0 ; s0=E0, C=1, Z=0
|
||
|
|
JUMP C, continue3
|
||
|
|
JUMP error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "JUMP Z"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
continue3: SUB s0, E0 ; s0=00, C=0, Z=1
|
||
|
|
JUMP Z, continue4
|
||
|
|
JUMP error
|
||
|
|
continue4: NOP
|
||
|
|
;===============================================================
|
||
|
|
; 10) Test call instructions
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s7, 01
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; define subroutine
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
JUMP continue5
|
||
|
|
subRetDo: ADD s0, 01
|
||
|
|
RETURN
|
||
|
|
JUMP error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "CALL"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
continue5: LOAD s0, 00
|
||
|
|
LOAD s1, F0
|
||
|
|
CALL subRetDo ; s0=01
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "CALL NC"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s1, 00 ; s1=F0, C=0, Z=0
|
||
|
|
CALL NC, subRetDo ; s0=02
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "CALL NZ"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s1, 00 ; s1=F0, C=0, Z=0
|
||
|
|
CALL NZ, subRetDo ; s0=03
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "CALL C"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s1, F0 ; s0=E0, C=1, Z=0
|
||
|
|
CALL C, subRetDo ; s0=04
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "CALL Z"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
SUB s1, E0 ; s0=00, C=0, Z=1
|
||
|
|
CALL Z, subRetDo ; s0=05
|
||
|
|
COMPARE s0, 05
|
||
|
|
jump nz, error
|
||
|
|
;===============================================================
|
||
|
|
; 11) Test call return instructions
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADD s7, 01
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; define subroutines
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
JUMP continue6
|
||
|
|
subRetNC: ADD s0, 01
|
||
|
|
RETURN NC
|
||
|
|
JUMP error
|
||
|
|
subRetNZ: ADD s0, 01
|
||
|
|
RETURN NZ
|
||
|
|
JUMP error
|
||
|
|
subRetC: ADD s0, 01
|
||
|
|
RETURN C
|
||
|
|
JUMP error
|
||
|
|
subRetZ: ADD s0, 01
|
||
|
|
RETURN Z
|
||
|
|
JUMP error
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "RETURN NC"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
continue6: LOAD s0, 00 ; increment will give C=0, Z=0
|
||
|
|
CALL NC, subRetNC
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "RETURN NZ"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, 00 ; increment will give C=0, Z=0
|
||
|
|
CALL NZ, subRetNZ
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "RETURN C"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, FF ; increment will give C=1, Z=1
|
||
|
|
CALL C, subRetC
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
; Test "RETURN Z"
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, FF ; increment will give C=1, Z=1
|
||
|
|
CALL Z, subRetZ
|
||
|
|
;===============================================================
|
||
|
|
; End of tests
|
||
|
|
;
|
||
|
|
; The testbench should react if value 1 is written to address 00.
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
LOAD s0, 01
|
||
|
|
OUTPUT s0, 00
|
||
|
|
JUMP endOfMemory
|
||
|
|
;===============================================================
|
||
|
|
; Assert error
|
||
|
|
;
|
||
|
|
; The testbench should react if value 0 is written to address 00.
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
ADDRESS 3FD
|
||
|
|
error: LOAD s0, 00
|
||
|
|
OUTPUT s0, 00
|
||
|
|
;===============================================================
|
||
|
|
; End of instruction memory
|
||
|
|
;---------------------------------------------------------------
|
||
|
|
endOfMemory: JUMP endOfMemory
|