Initial commit
This commit is contained in:
github-classroom[bot]
GitHub
342
Libs/NanoBlaze/hdl/nanoTest.asm
Normal file
342
Libs/NanoBlaze/hdl/nanoTest.asm
Normal file
@@ -0,0 +1,342 @@
|
||||
;===============================================================
|
||||
; 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
|
||||
Reference in New Issue
Block a user