1290 lines
41 KiB
Text
1290 lines
41 KiB
Text
SUBTTL DIAGNOSTIC PARAMETERS
|
|
|
|
;ACCUMULATOR ASSIGNMENTS
|
|
|
|
;CONTROL WORDS
|
|
|
|
AROV=400000 ;ARITHMETIC OVERFLOW
|
|
CRY0=200000 ;CARRY 0
|
|
CRY1=100000 ;CARRY 1
|
|
FOV=40000 ;FLOATING OVERFLOW
|
|
BIS=20000 ;BYTE INTERRUPT
|
|
USERF=10000 ;USER MODE FLAG
|
|
EXIOT=4000 ;USER PRIV I/O FLAG
|
|
FXU=100 ;FLOATING UNDERFLOW
|
|
DCK=40 ;DIVIDE CHECK
|
|
|
|
;MACROS
|
|
|
|
; STOP - USED FOR SCOPE LOOP, IF INSTRUCTION FAILS, CHANGE (JUMPA .+1)
|
|
; TO A (JUMPA X) TO CYCLE ON FAILING INSTRUCTION
|
|
|
|
DEFINE STOP (A)<
|
|
HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE
|
|
JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1)
|
|
;TO JUMPA X(X IS THE ADDRESS OF THE FIRST
|
|
;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR
|
|
;AND CHANGE HALT INSTRUCTION TO JUMPA .+1>
|
|
|
|
; SFLAG - USED TO CLEAR ALL FLAGS THEN TO SET REQUESTED FLAG
|
|
|
|
DEFINE SFLAG (A)<
|
|
MOVSI 1,A
|
|
JFCL 17,.+1 ;RESET ALL FLAGS
|
|
JRST 2,.+1(1) ;SET A FLAG>
|
|
|
|
SUBTTL DIAGNOSTIC SECTION
|
|
|
|
START: ;SETZM USER# ;CLEAR USER CONTROL WORD
|
|
;JSP 0,.+1 ;GET FLAGS
|
|
;TLNE USERF ;IN USER MODE?
|
|
;SETOM USER ;YES, SET USER CONTROL WORD
|
|
;SKIPN MONFLG ;SPECIAL USER MODE?
|
|
;SETZM USER ;YES, CLEAR USER CONTROL WORD
|
|
;SKIPN USER
|
|
;JRST STARTA
|
|
;SKIPL MONCTL
|
|
;TTCALL 3,PGMNAM ;MENTION OUR NAME
|
|
JRST STARTA
|
|
|
|
PGMNAM: ASCIZ/
|
|
PDP-10 KI10 BASIC INSTRUCTION DIAGNOSTIC (7) [DAKAG]
|
|
/
|
|
|
|
STARTA: JRST .+1
|
|
SUBTTL TEST OF PUSH INSTRUCTION
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT PUSH DECODES CORRECTLY.
|
|
;IF PUSH DECODES AS PUSHJ, THIS TEST FAILS.
|
|
|
|
C27200: SETZ 2, ;CLEAR AC
|
|
PUSH 2,.+2 ;*PUSH SHOULD NOT JUMP
|
|
SKIPA ;PASS IF PUSH DID NOT JUMP
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT PUSH DOES NOT MODIFY C(E).
|
|
;CLEAR E AND AC; THEN, EXECUTE PUSH.
|
|
;CHECK E FOR ORIGINAL CONTENTS ,0.
|
|
;PASS IF C(E)=0.
|
|
|
|
C27300: SETZB 2 ;CLEAR AC,E
|
|
PUSH 2, ;*PUSH SHOULD NOT ALTER C(E)
|
|
SKIPE ;PASS IF C(E)=0,,0
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC.
|
|
;FIRST THE AC IS CLEARED; THEN PUSH IS EXECUTED.
|
|
;THE AC IS CHECKED FOR 1,,1. IF C(AC)=1,,1, THIS TEST PASSES.
|
|
|
|
C27400: SETZ 2, ;CLEAR AC
|
|
PUSH 2,.+1 ;*PUSH SHOULD ADD 1,,1 TO C(AC)
|
|
CAME 2,[XWD 1,1] ;PASS IF C(AC)=1,,1
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC BEFORE MODIFYING C(C(AC-RIGHT)).
|
|
;FIRST, THE AC AND AC0 ARE ZEROED; THEN PUSH IS EXECUTED.
|
|
;C(C(AC-RIGHT)) [BEFORE AC UPDATING] (AC0) IS CHECKED FOR THE INITIAL VALUE, 0.
|
|
;IF C(AC0)=0, THIS TEST PASSES
|
|
|
|
C27500: SETZB 2 ;CLEAR AC AND AC0
|
|
PUSH 2,[16541320] ;*PUSH SHOULD NOT MODIFY C(AC0)
|
|
SKIPE ;PASS IF C(AC0)=0
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC BEFORE MODIFYING C(C(AC-RIGHT)).
|
|
;FIRST, THE AC AND AC0 ARE ZEROED; THEN PUSH IS EXECUTED.
|
|
;C(C(AC-RIGHT)) [BEFORE AC UPDATING] (AC0) IS CHECKED FOR
|
|
;IF C(AC0)IS NOT EQUAL TO E, THIS TEST PASSES
|
|
|
|
C27600: SETZB 1,2 ;CLEAR AC AND AC0
|
|
PUSH 2,.+1 ;*PUSH SHOULD NOT MODIFY C(AC0)
|
|
CAIN . ;FAIL IF C(AC0)=E
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC; THEN, MOVES C(E) INTO
|
|
;THE LOCATION SPECIFIED BY C(AC-RIGHT). IN THIS CASE, AC AND THE LOCATION SPECIFIED
|
|
;BY UPDATING C(AC-RIGHT) ARE CLEARED; THEN, PUSH IS EXECUTED WITH C(E)=-1,,-1.
|
|
;THE LOCATION SPECIFIED BY C(AC-RIGHT) IS THEN CHECKED FOR -1,,-1, THE
|
|
;ORIGINAL C(E). IF C(C(AC-RIGHT))=-1,,-1, THIS TEST PASSES.
|
|
|
|
C27700: SETZB 1,2 ;CLEAR AC, C(AC-RIGHT)
|
|
PUSH 2,[-1] ;*PUSH SHOULD PLACE -1,,-1 INTO AC1
|
|
CAME 1,[-1] ;PASS IF C(1)=-1,,-1
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC; THEN, MOVES C(E) INTO
|
|
;THE LOCATION SPECIFIED BY C(AC-RIGHT). IN THIS CASE, AC
|
|
;IS CLEARED; THEN, PUSH IS EXECUTED WITH C(E)=0.
|
|
;THE LOCATION SPECIFIED BY C(AC-RIGHT) IS THEN CHECKED FOR 0, THE
|
|
;ORIGINAL C(E). IF C(C(AC-RIGHT))=0, THIS TEST PASSES.
|
|
|
|
C30000: SETZM 2 ;CLEAR AC
|
|
PUSH 2,[0] ;*PUSH SHOULD PLACE 0 INTO AC1
|
|
SKIPE 1 ;PASS IF C(1)=0
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC; THEN, MOVES C(E) INTO
|
|
;THE LOCATION SPECIFIED BY C(AC-RIGHT). IN THIS CASE,
|
|
;AC IS PRELOADED WITH 0,,-1, AND THE LOCATION SPECIFIED
|
|
;BY UPDATING C(AC-RIGHT) IS CLEARED; THEN, PUSH IS EXECUTED WITH C(E)=-1,,-1.
|
|
;THE LOCATION SPECIFIED BY C(AC-RIGHT) IS THEN CHECKED FOR -1,,-1, THE
|
|
;ORIGINAL C(E). IF C(C(AC-RIGHT))=-1,,-1, THIS TEST PASSES.
|
|
|
|
C30100: MOVEI 2,-1 ;PRELOAD AC WITH 0,,-1
|
|
SETZ ;CLEAR AC, C(AC-RIGHT)
|
|
PUSH 2,[-1] ;*PUSH SHOULD PLACE -1,,-1 INTO AC0
|
|
CAME [-1] ;PASS IF C(0)=-1,,-1
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT THERE IS A CARRY FROM AC BIT 18 TO BIT 17 OF THE AC ON PUSH.
|
|
;THE AC IS PRELOADED WITH 0,,-1; THEN PUSH IS EXECUTED. PUSH SHOULD ADD ONE TO BOTH
|
|
;HALVES OF THE AC, GENERATING A CARRY FROM BIT 18 TO BIT 17. IF A CARRY WAS GENERATED,
|
|
;THIS TEST PASSES.
|
|
|
|
C30101: MOVEI 2,-1 ;PRELOAD AC WITH 0,,-1
|
|
PUSH 2,0 ;*PUSH SHOULD GENERATE A CARRY FROM BIT 18 TO BIT 17
|
|
CAME 2,[2,,0] ;PASS IF C(AC)=2,,0 (CARRY WAS GENERATED)
|
|
STOP
|
|
|
|
;*************
|
|
SUBTTL TEST OF PUSHJ INSTRUCTION
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT PUSHJ TRANSFERS CONTROL TO THE LOCATION ADDRESSED BY E.
|
|
;IF PUSHJ DOES NOT JUMP, THIS TEST FAILS
|
|
|
|
C30200: SFLAG CRY0 ;SETS CRY0 FLAG
|
|
SETZ ;CLEAR AC
|
|
PUSHJ .+2 ;*PUSHJ SHOULD JUMP TO LOCATION E
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT PUSHJ DOES NOT MODIFY C(PC) WHERE PC IS ONE GREATER
|
|
;THAN THE LOCATION OF THE PUSHJ INSTRUCTION.
|
|
;IF PUSHJ MODIFIES C(PC), THIS TEST FAILS
|
|
|
|
C30300: SFLAG CRY0 ;SET CRY0
|
|
SETZB 1,.+2 ;CLEAR C(AC-RIGHT) AND C(PC)
|
|
PUSHJ .+3 ;*PUSHJ SHOULD NOT MODIFY C(PC)
|
|
0 ;THIS LOCATION SHOULD NOT BE MODIFIED BY PUSHJ
|
|
CAM ;PUSHJ SHOULD JUMP OVER THIS LOCATION
|
|
SKIPE .-2 ;PASS IF PUSHJ DID NOT MODIFY C(PC)
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT PUSHJ DOES NOT STORE IN E
|
|
;IF PUSHJ STORED IN E, THIS TEST FAILS
|
|
|
|
C30400: SFLAG CRY0 ;SET CRY0
|
|
SETZB 1 ;CLEAR AC AND C(AC-RIGHT
|
|
PUSHJ .+1 ;*PUSHJ SHOULD NOT STORE IN E
|
|
MOVE 2,. ;SAVE C(E)
|
|
CAME 2,.-1 ;FAIL IF PUSHJ STORED IN E
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT PUSHJ DOES NOT STORE IN LOC 0
|
|
;PUSHJ SHOULD STORE PC IN C(AC-RIGHT) - LOCATION 2.
|
|
;IF PUSHJ STORES IN LOCATION 0, THIS TEST FAILS
|
|
|
|
C30500: MOVEI 2,1 ;PRELOAD AC WITH 0,,1
|
|
SETZ 0 ;CLEAR 0
|
|
PUSHJ 2,.+1 ;*PUSHJ SHOULD NOT STORE IN LOCATION 0
|
|
SKIPE ;FAIL IF PUSHJ STORED IN LOCATION 0
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT PUSHJ STORES THE PC IN THE LOCATION SPECIFIED
|
|
;BY C(AC-RIGHT) AFTER INCREMENTING AC.
|
|
;IN THIS TEST, AC AND C(AC-RIGHT) ARE CLEARED; THEN, PUSHJ IS EXECUTED.
|
|
;C(C(AC-RIGHT))IS THEN COMPARED TO ZERO. IF C(C(AC-RIGHT)) IS NON-ZERO,
|
|
;A PC WAS STORED AND THIS TEST PASSES.
|
|
|
|
C30600: SETZB 1 ;CLEAR AC, C(AC-RIGHT)
|
|
PUSHJ .+2 ;*PUSHJ SHOULD STORE PC IN RIGHT HALF OF C(AC-RIGHT)
|
|
HALT . ;PUSHJ SHOULD JUMP OVER THIS INSTRUCTION
|
|
ANDI 1,-1 ;SAVE C(C(AC-RIGHT))
|
|
CAIN 1,.-1 ;FAIL IF PC WAS NOT STORED IN C(AC-RIGHT)
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT PUSHJ ADDS 1,,1 TO THE AC
|
|
;THE AC IS CLEARED AND PUSHJ IS EXECUTED
|
|
;AC IS CHECKED FOR 1,,1 IF C(AC)=1,,1, THIS TEST PASSES
|
|
|
|
C31000: SETZ ;CLEAR AC
|
|
PUSHJ .+1 ;*PUSHJ SHOULD PLACE 1,,1 INTO THE AC
|
|
CAME [1,,1] ;PASS IF C(AC)=1,,1
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT PUSHJ STORES THE FLAGS IN LEFT HALF OF C(AC-RIGHT)
|
|
;FIRST, CRY0 IS SET AND AC AND C(AC-RIGHT) ARE CLEARED; THEN, PUSHJ IS EXECUTED.
|
|
;C(C(AC-RIGHT)) IS THEN CHECKED FOR CRY0. IF CRY0 IS SET, THIS TEST PASSES.
|
|
|
|
C31100: SFLAG CRY0 ;SET CRY0
|
|
SETZB 1 ;CLEAR AC AND C(AC-RIGHT)
|
|
PUSHJ .+1 ;*PUSHJ SHOULD STORE FLAGS IN LEFT HALF OF C(AC-RIGHT)
|
|
TLNN 1,CRY0 ;PASS IF CRY0 STORED CORRECTLY
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT PUSHJ ADDS 1,,1 TO THE AC
|
|
;THE AC IS PRELOADED WITH 0,,1 AND PUSHJ IS EXECUTED
|
|
;AC IS CHECKED FOR 1,,2 IF C(AC)=1,,2, THIS TEST PASSES
|
|
|
|
C31400: MOVEI 1,1 ;PRELOAD AC WITH 0,,1
|
|
PUSHJ 1,.+2 ;*PUSHJ SHOULD PLACE 1,,2 INTO THE AC
|
|
HALT ;PUSHJ SHOULD JUMP OVER THIS INSTRUCTION
|
|
CAME 1,[XWD 1,2] ;PASS IF AC WAS INCREMENTED CORRECTLY
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT PUSHJ STORES THE PC IN RIGHT HALF OF C(AC-RIGHT)
|
|
;THIS TEST PASSES IF THE PC WAS STORED CORRECTLY.
|
|
|
|
C31500: MOVEI 1,1 ;PLACE 0,,1 INTO AC
|
|
PUSHJ 1,.+2 ;*PUSHJ SHOULD STORE .+1 INTO RIGHT HALF OF C(AC-RIGHT)
|
|
HALT ;PUSHJ SHOULD JUMP OVER THIS PC
|
|
ANDI 2,-1 ;SAVE RIGHT HALF OF C(AC-RIGHT)
|
|
CAIE 2,.-2 ;PASS IF PC STORED CORRECTLY
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT PUSHJ ALWAYS RESETS BIS.
|
|
;FIRST BIS IS SET; THEN PUSHJ IS EXECUTED. THE FLAGS ARE
|
|
;THEN SAVED AND CHECKED. IF BIS WAS RESET VIA PUSHJ, THIS TEST PASSES.
|
|
|
|
C31501: SFLAG BIS ;SET BIS
|
|
SETZ ;CLEAR AC
|
|
PUSHJ .+1 ;*PUSHJ SHOULD RESET BIS
|
|
JSP .+1 ;SAVE FLAGS
|
|
TLNE BIS ;PASS IF BIS FLAG IS RESET
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT THERE IS A CARRY FROM BIT18 TO BIT17 OF THE AC ON PUSHJ.
|
|
;THE AC IS PRELOADED WITH 0,,-1; THEN PUSHJ IS EXECUTED. PUSHJ SHOULD ADD ONE TO
|
|
;BOTH HALVES OF THE AC, GENERATING A CARRY FROM BIT18 TO BIT17. IF A
|
|
;CARRY WAS GENERATED, THE TEST PASSES.
|
|
|
|
C31502: MOVEI 2,-1 ;PRELOAD AC WITH 0,,-1
|
|
PUSHJ 2,.+1 ;*PUSHJ SHOULD GENERATE A CARRY FROM BIT18 TO BIT17
|
|
CAME 2,[2,,0] ;PASS IF C(AC)=2,,0 (CARRY WAS GENERATED)
|
|
STOP
|
|
|
|
;****************
|
|
SUBTTL TEST OF POP INSTRUCTION
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT POP SUBTRACTS 1,,1 FROM THE AC
|
|
;THE AC IS PRELOADED WITH 1,,1; THEN, POP IS EXECUTED.
|
|
;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES.
|
|
|
|
C31600: MOVE [XWD 1,1] ;PRELOAD AC WITH 1,,1
|
|
POP 1 ;*POP SHOULD SUBTRACT 1,,1 FROM THE AC
|
|
SKIPE ;PASS IF AC WAS DECREMENTED CORRECTLY
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT POP SUBTRACTS 1,,1 FROM THE AC
|
|
;THE AC IS PRELOADED WITH 2,,2; THEN, POP IS EXECUTED.
|
|
;THE AC IS CHECKED FOR 1,,1. IF C(AC)=1,,1, THIS TEST PASSES.
|
|
|
|
C31700: MOVE [XWD 2,2] ;PRELOAD AC WITH E,,E WHERE E=2
|
|
MOVEI 2,5 ;PRELOAD 2 WITH 0,,5
|
|
POP 2 ;*POP SHOULD SUBTRACT 1,,1 FROM THE AC
|
|
CAME [1,,1] ;PASS IF AC WAS DECREMENTED CORRECTLY
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT POP STORES C(C(AC-RIGHT)) INTO E
|
|
;IN THIS CASE, AC=0 AND AC IS PRELOADED WITH 2,,2; E=2 AND IS PRELOADED WITH 0.
|
|
;POP IS THEN EXECUTED. POP SHOULD PLACE 0 INTO E. IF C(E)=0, THIS TEST PASSES.
|
|
|
|
C32300: MOVE [XWD 2,2] ;PRELOAD AC WITH 2,,2
|
|
SETZM 2 ;CLEAR E AND C(AC-RIGHT)
|
|
POP 2 ;*POP SHOULD PLACE 0 INTO E
|
|
SKIPE 2 ;PASS IF C(E)=0
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT POP DOES NOT MODIFY C(C(AC-RIGHT)-1).
|
|
;THIS TEST FAILS IF C(C(AC-RIGHT)-1) IS MODIFIED BY POP.
|
|
|
|
C32400: MOVE [XWD 2,2] ;PRELOAD AC WITH 2,,2
|
|
MOVEI 2,17 ;PRELOAD 2 WITH 0,,17
|
|
SETZM 1 ;CLEAR C(C(AC-RIGHT)-1)
|
|
POP 2 ;*POP SHOULD NOT MODIFY C(C(AC-RIGHT)-1)
|
|
SKIPE 1 ;PASS IF C(C(AC-RIGHT)-1) WAS UNALTERED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT POP STORES C(C(AC-RIGHT)) INTO E.
|
|
;IN THIS CASE, AC IS PRELOADED WITH 2,,2 AND AC2 [C(AC-RIGHT)] IS PRELOADED WITH 0,,3.
|
|
;E IS CLEARED AND POP IS EXECUTED. E IS THEN CHECKED FOR 0,,3 [C(C(AC-RIGHT))] .
|
|
;IF C(E)=0,,3, THIS TEST PASSES.
|
|
|
|
C32500: MOVE [XWD 2,2] ;PRELOAD AC WITH 2,,2
|
|
MOVEI 2,3 ;PRELOAD C(AC-RIGHT) WITH 0,,3
|
|
SETZM 3 ;CLEAR E
|
|
POP 3 ;*POP SHOULD PLACE 0,,3 INTO E
|
|
CAIE 3,3 ;PASS IF C(E)=0,,3
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT POP STORES C(C(AC-RIGHT)) INTO E. IN THIS CASE,
|
|
;AC IS PRELOADED WITH 2,,2 AND AC2 [C(AC-RIGHT)] IS PRELOADED WITH 0,,17.
|
|
;E IS CLEARED AND POP IS EXECUTED. E IS THEN CHECKED FOR 0,,17 [C(C(AC-RIGHT))] .
|
|
;IF C(E)=0,,17, THIS TEST PASSES.
|
|
|
|
C32600: SETZM 2 ;CLEAR E
|
|
MOVE [XWD 2,2] ;PRELOAD AC WITH 2,,2
|
|
MOVEI 2,17 ;PRELOAD C(AC-RIGHT) WITH 0,,17
|
|
POP 2 ;*POP SHOULD PLACE 0,,17 INTO E
|
|
CAIE 2,17 ;PASS IF C(E)=0,,17
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT POP STORES C(C(AC-RIGHT)) INTO E. IN THIS CASE,
|
|
;AC IS PRELOADED WITH 2,,2 AND AC2 [C(AC-RIGHT)] IS PRELOADED WITH -1,,-1.
|
|
;E IS CLEARED AND POP IS EXECUTED. E IS THEN CHECKED FOR -1,,-1 [C(C(AC-RIGHT))] .
|
|
;IF C(E)=0,,3, THIS TEST PASSES.
|
|
|
|
C33100: MOVE [XWD 2,2] ;PRELOAD AC WITH 2,,2
|
|
SETOM 2 ;PRELOAD C(AC-RIGHT) WITH -1,,-1
|
|
SETZM 3 ;CLEAR E
|
|
POP 3 ;*POP SHOULD PLACE -1,,-1 INTO E
|
|
CAME 3,[-1] ;PASS IF C(E)=-1,,-1
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT POP PLACES C(C(AC-RIGHT)) INTO E AND ADDS 1,,1 TO AC.
|
|
;IN THIS CASE, THE AC IS PRELOADED WITH 1,,17; E=1 AND E IS PRELOADED WITH 0;
|
|
;C(AC-RIGHT) IS PRELOADED WITH -1,,-1; AND POP IS EXECUTED. POP SHOULD PLACE -1,,-1
|
|
;INTO E AND 0,,16 INTO AC. IF AC AND E ARE UPDATED CORRECTLY, THIS TEST PASSES.
|
|
|
|
C33300: MOVE [XWD 1,17] ;PRELOAD AC WITH 1,,17
|
|
SETZM 1 ;PRELOAD E WITH 0
|
|
SETOM 17 ;PRELOAD C(AC-RIGHT) WITH 1,,1
|
|
POP 1 ;*POP SHOULD PLACE -1,,-1 INTO E AND 0,,16 INTO AC
|
|
CAME 1,[-1] ;PASS IF C(E)=-1,,-1
|
|
STOP
|
|
C33310: CAIE 16 ;PASS IF C(AC)=0,,16
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT POP PLACES C(C(AC-RIGHT)) INTO E AND ADDS 1,,1 TO AC
|
|
;IN THIS CASE, THE AC IS PRELOADED WITH -1,,0; E=17
|
|
;C(AC-RIGHT) IS PRELOADED WITH 0; AND POP IS EXECUTED. POP SHOULD PLACE 0
|
|
;INTO E. IF AC IS UPDATED CORRECTLY, THIS TEST PASSES.
|
|
|
|
C33400: MOVSI 1,-1 ;PRELOAD AC WITH -1,,0
|
|
SETZ ;CLEAR C(AC-RIGHT)
|
|
POP 1,17 ;*POP SHOULD PLACE 0 INTO E
|
|
SKIPE 17 ;PASS IF C(E)=0
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT THERE IS A CARRY FROM BIT18 TO BIT17 OF THE AC ON POP.
|
|
;THE AC IS PRELOADED WITH 2,,0; THEN POP IS EXECUTED. POP SHOULD SUBTRACT ONE FROM
|
|
;BOTH HALVES OF THE AC, GENERATING A CARRY FROM BIT18 TO BIT17.
|
|
;IF A CARRY WAS GENERATED, THIS TEST PASSES.
|
|
|
|
C33401: HRLZI 2,2 ;PRELOAD AC WITH 2,,0
|
|
POP 2,0 ;*POP SHOULD GENERATE A CARRY FROM BIT18 TO BIT17
|
|
CAIE 2,-1 ;PASS IF C(AC) = 0,,-1 (CARRY WAS GENERATED)
|
|
STOP
|
|
|
|
;************
|
|
SUBTTL TEST OF POPJ INSTRUCTION
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT POPJ JUMPS TO THE LOCATION ADDRESSED BY RIGHT HALF OF
|
|
;C(C(AC-RIGHT)) BEFORE POPJ DECREMENTED THE AC.
|
|
;THIS TEST PASSES IF POPJ JUMPS CORRECTLY.
|
|
|
|
C33500: MOVE [XWD 1,1] ;PRELOAD AC WITH 1,,1
|
|
MOVEI 1,.+3 ;PRELOAD C(AC-RIGHT) WITH .+3
|
|
POPJ .+2 ;*POPJ SHOULD JUMP TO LOCATION
|
|
;ADDRESSED BY C(C(AC-RIGHT))
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT POPJ SUBTRACTS 1,,1 FROM THE AC
|
|
;THIS AC IS PRELOADED WITH 1,,1; THEN,POPJ IS EXECUTED.
|
|
;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES.
|
|
|
|
C33600: MOVE [XWD 1,1] ;PRELOAD AC WITH 1,,1
|
|
MOVEI 1,.+2 ;PRELOAD C(AC-NIGHT)WITH .+2
|
|
POPJ .+1 ;*POPJ SHOULD SUBTRACT 1,,1 FROM AC
|
|
CAME [0] ;PASS IF C(AC)=0
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT POPJ JUMPS TO THE LOCATION ADDRESSED BY RIGHT HALF OF
|
|
;C(C(AC-RIGHT)) BEFORE POPJ DECREMENTED THE AC.
|
|
;THIS TEST PASSES IF POPJ JUMPS CORRECTLY.
|
|
|
|
C33700: MOVE [XWD 1,1] ;PRELOAD AC WITH 1,,1
|
|
MOVEI 1,.+2 ;PRELOAD C(AC-RIGHT) WITH C33700+3
|
|
POPJ .+2 ;*POPJ SHOULD JUMP TO C33700+3
|
|
SKIPA ;PASS IF POPJ JUMPED CORRECTLY
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT THERE IS A CARRY FROM BIT18 TO BIT17 OF THE AC ON POPJ.
|
|
;THE AC IS PRELOADED WITH 2,,0; THEN POPJ IS EXECUTED POPJ SHOULD SUBTRACT ONE FROM
|
|
;BOTH HALVES OF THE AC, GENERATING A CARRY FROM BIT18 TO BIT17.
|
|
;IF A CARRY WAS GENERATED, THIS TEST PASSES.
|
|
|
|
C33701: HRLZI 2,2 ;PRELOAD AC WITH 2,,0
|
|
MOVEI 0,.+2 ;PRELOAD RH(AC) WITH C33701: +3
|
|
POPJ 2,0 ;*POPJ SHOULD GENERATE A CARRY FROM BIT18 TO BIT17
|
|
CAIE 2,-1 ;PASS IF C(AC)=0,,-1 (CARRY WAS GENERATED)
|
|
STOP
|
|
|
|
;*************
|
|
SUBTTL XCT INSTRUCTION - ADDITIONAL TESTS
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A SKIP INSTRUCTION, THE SKIP IS RELATIVE
|
|
;TO THE LOCATION OF THE XCT.
|
|
|
|
C34000: SETOB 1
|
|
XCT [CAME 0,1] ;*CAME SHOULD SKIP TO C34000+3
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A SKIP INSTRUCTION, THE SKIP IS RELATIVE
|
|
;TO THE LOCATION OF THE XCT.
|
|
|
|
C34100: SETOB 1
|
|
XCT [XCT[XCT[CAME 0,1]]] ;*CAME SHOULD SKIP TO C34100+3
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A JUMP, PROGRAM FLOW IS ALTERED AS
|
|
;SPECIFIED BY THE JUMP.
|
|
|
|
C34200: XCT [JRST .+4] ;*JRST SHOULD JUMP TO C34200+4
|
|
HALT ;JRST SHOULD JUMP OVER THIS LOCATION
|
|
HALT ;JRST SHOULD JUMP OVER THIS LOCATION
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A JUMP, PROGRAM FLOW IS ALTERED AS
|
|
;SPECIFIED BY THE JUMP AND THAT WHEN THE PC IS SAVED IT CONTAINS AN
|
|
;ADDRESS ONE GREATER THAN THE LOCATION OF FIRST XCT OF THE CHAIN.
|
|
|
|
C34300: SETZM 3 ;CLEAR AC OF JSP
|
|
XCT [XCT[XCT[JSP 3,.+3]]] ;*JSP SHOULD JUMP TO C34300+4 AND
|
|
HALT ;THE SAVED PC SHOULD BE C 34300+2
|
|
HALT ;PASS IF JSP JUMPED CORRECTLY
|
|
TRZ 3,.-2 ;AND SAVED PC=C34300+2
|
|
TRNE 3,-1
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A SKIP INSTRUCTION, THE SKIP IS RELATIVE
|
|
;TO THE LOCATION OF THE XCT.
|
|
;IN THIS CASE, NO SKIP SHOULD OCCUR ;HENCE, THE INSTRUCTION
|
|
;FOLLOWING XCT SHOULD BE EXECUTED AFTER 'CAME' IS EXECUTED.
|
|
|
|
C34400: SETZB 0 ;SET-UP AC,E SO THAT
|
|
SETOM 1 ;CAME WILL NOT SKIP
|
|
XCT [CAME 0,1] ;*CAME SHOULD CAUSE EXECUTION
|
|
;OF INSTRUCTION FOLLOWING XCT
|
|
JRST .+2 ;PASS IF THIS INSTRUCTION IS EXECUTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES INDEXING FOR XCT OF AN ADD INSTRUCTION
|
|
;C(4)=10, AND C(6)=3, SO THE RESULT IN 6 (THE AC) SHOULD BE 16
|
|
;C(11)=13
|
|
|
|
C34500: MOVEI 4,10 ;PRELOAD INDEX REG WITH 10
|
|
MOVEI 11,13 ;PRELOAD EFFECTIVE ADDRESS WITH 13
|
|
MOVEI 6,3 ;PRELOAD AC WITH 3
|
|
XCT [ADD 6,1(4)] ;*ADD SHOULD PLACE 16 IN AC
|
|
CAIE 6,16 ;PASS IF C(AC)=16
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A SKIP INSTRUCTION, THE SKIP IS RELATIVE
|
|
;TO THE LOCATION OF THE XCT
|
|
;IN THIS CASE, NO SKIP SHOULD OCCUR ;HENCE, THE INSTRUCTION
|
|
;FOLLOWING XCT SHOULD BE EXECUTED AFTER CAME IS EXECUTED.
|
|
|
|
C34600: SETZM 2 ;SETUP E SO THAT SKIPL WILL NOT SKIP
|
|
XCT [SKIPL 1,2] ;*SKIPL SHOULD CAUSE INSTRUCTION
|
|
;OF FOLLOWING INSTRUCTION
|
|
JRST .+2 ;PASS IF THIS INSTRUCTION IS EXECUTED.
|
|
STOP
|
|
C34610: SKIPE 1 ;*SKIPE SHOULD SKIP BECAUSE XCT OF SKIPL
|
|
;PLACED 0 INTO AC1
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A SKIP INSTRUCTION, THE SKIP IS RELATIVE
|
|
;TO THE LOCATION OF THE XCT.
|
|
|
|
C34700: SETOM 6 ;SETUP E SO THAT SKIPL WILL SKIP
|
|
XCT [SKIPL 3,6] ;*SKIPL SHOULD SKIP TO C34700+3
|
|
STOP
|
|
C34710: SKIPL 3 ;*SKIPE SHOULD SKIP BECAUSE XCT OF SKIPL
|
|
;PLACED 0 INTO AC1
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A JUMP, PROGRAM FLOW IS ALTERED AS
|
|
;SPECIFIED BY THE JUMP.
|
|
;THIS TEST ALSO VERIFIES CORRECT UPDATING OF THE AC FOR AOBJN
|
|
|
|
C35000: MOVE 3,[-2,,5] ;SETUP AC SO THAT AOBJN WILL JUMP
|
|
XCT [AOBJN 3,.+3] ;*JUMP SHOULD BE TO C35000+4
|
|
HALT ;JUMP OVER THIS INSTRUCTION
|
|
HALT ;JUMP OVER THIS INSTRUCTION
|
|
CAME 3,[-1,,6] ;PASS IF C(AC)=-1,,6 AND AOBJN JUMPED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A JUMP, PROGRAM FLOW IS ALTERED AS
|
|
;SPECIFIED BY THE JUMP.
|
|
;THIS TEST ALSO VERIFIES CORRECT UPDATING OF THE AC FOR AOBJN
|
|
|
|
C35100: MOVE 3,[-1,,6] ;SETUP AC SO THAT AOBJN WILL NOT JUMP
|
|
XCT [AOBJN 3,.+2] ;*AOBJN SHOULD NOT JUMP
|
|
CAME 3,[0,,7] ;PASS IF AOBJN DID NOT JUMP AND C(AC)=0,,7
|
|
STOP
|
|
|
|
;**********
|
|
SUBTTL TEST XCT INSTRUCTION WITH INDIRECT ADDRESSING AND INDEXING
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT XCT WILL EXECUTE AN INSTRUCTION
|
|
;FROM AN INDIRECTLY ADDRESSED LOCATION
|
|
|
|
C35200: SETZB 2
|
|
JRST .+3
|
|
.+1
|
|
SETOM 2 ;THIS INSTRUCTION SHOULD BE EXECUTED
|
|
XCT @.-2
|
|
CAME 2,[-1,,-1] ;PASS IF 'SETOM 2' WAS EXECUTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT XCT WILL EXECUTE AN INSTRUCTION
|
|
;FROM AN INDEXED LOCATION
|
|
|
|
C35300: MOVEI 4,.+1
|
|
JRST .+2
|
|
CAIE 4,.-1 ;THIS INSTRUCTION SHOULD BE EXECUTED
|
|
XCT 1(4)
|
|
STOP ;PASS IF 'CAIE 4,,-1' WAS EXECUTED
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT XCT WILL EXECUTE AN INSTRUCTION
|
|
;FROM AN INDIRECTLY ADDRESSED AND INDEXED LOCATION
|
|
|
|
C35400: SETZM 5
|
|
MOVEI 3,.+3
|
|
JRST .+2
|
|
MOVEI 5,.+3
|
|
XCT @-1(3)
|
|
JRST .+2
|
|
SETOM 5 ;THIS INSTRUCTION SHOULD BE EXECUTED
|
|
CAME 5,[-1,,-1] ;PASS IF 'SETOM 5' WAS EXECUTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT XCT WILL EXECUTE AN INDIRECTLY ADDRESSED
|
|
;AND INDEXED INSTRUCTION
|
|
|
|
C35500: SETZM 3
|
|
MOVEI 10,3
|
|
JRST .+5
|
|
HALT
|
|
HALT
|
|
MOVE 3,@.-2(10) ;THIS INSTRUCTION SHOULD BE EXECUTED
|
|
HALT [0,,707070]
|
|
XCT .-2
|
|
CAIE 3,707070 ;PASS IF 'MOVE 3,@.-2(10)' WAS EXECUTED
|
|
STOP
|
|
|
|
;**********
|
|
SUBTTL TEST OF SHIFT/ROTATE INSTRUCTIONS USED IN THE ERROR HANDLER
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 0,,0 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,0.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C35600: MOVE 0,[0,,0] ;PRELOAD AC WITH 0,,0
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 0,-3 ;*ROT SHOULD ROTATE 0,,0 RIGHT 3 BIT POSITIONS
|
|
CAME 0,[0,,0] ;PASS IF C(AC)=0,,0
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, -1,,-1 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=-1,,-1.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C35700: MOVE 0,[-1,,-1] ;PRELOAD AC WITH 0,,0
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 0,-3 ;*ROT SHOULD ROTATE -1,,-1 RIGHT 3 BIT POSITIONS
|
|
CAME 0,[-1,,-1] ;PASS IF C(AC)=-1,,-1
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 252525,,252525 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=525252,,525252.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C36000: MOVE 0,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 0,-3 ;*ROT SHOULD ROTATE 252525,,252525
|
|
;RIGHT 3 BIT POSITIONS
|
|
CAME 0,[525252,,525252] ;PASS IF C(AC)=525252,,525252
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 525252,,525252 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=252525,,252525.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C36100: MOVE 0,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 0,-3 ;*ROT SHOULD ROTATE 525252,,525252
|
|
;RIGHT 3 BIT POSITIONS
|
|
CAME 0,[252525,,252525] ;PASS IF C(AC)=252525,,252525
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 230703,,603700 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=023070,,360370.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C36200: MOVE 0,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 0,-3 ;*ROT SHOULD ROTATE 230703,,603700
|
|
;RIGHT 3 BIT POSITIONS
|
|
CAME 0,[023070,,360370] ;PASS IF C(AC)=023070,,360370
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 007603,,607062 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=200760,,360706.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C36300: MOVE 0,[007603,,607062] ;PRELOAD AC WITH 007603,,607062
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 0,-3 ;*ROT SHOULD ROTATE 007603,,607062
|
|
;RIGHT 3 BIT POSITIONS
|
|
CAME 0,[200760,,360706] ;PASS IF C(AC)=200760,,360706
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 0,,0 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,0.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C36400: MOVE 2,[0,,0] ;PRELOAD AC WITH 0,,0
|
|
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 2,15 ;*ROT SHOULD ROTATE 0,,0 LEFT 15 BIT POSITIONS
|
|
CAME 2,[0,,0] ;PASS IF C(AC)=0,,0
|
|
STOP
|
|
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, -1,,-1 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=-1,,-1.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C36500: MOVE 2,[-1,,-1] ;PRELOAD AC WITH -1,,-1
|
|
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 2,15 ;*ROT SHOULD ROTATE -1,,-1 LEFT 15 BIT POSITIONS
|
|
CAME 2,[-1,,-1] ;PASS IF C(AC)=-1,,-1
|
|
STOP
|
|
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 252525,,252525 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=525252,,525252.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C36600: MOVE 2,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
|
|
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 2,15 ;*ROT SHOULD ROTATE 252525,,252525
|
|
;LEFT 15 BIT POSITIONS
|
|
CAME 2,[525252,,525252] ;PASS IF C(AC)=525252,,525252
|
|
STOP
|
|
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 525252,,525252 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=252525,,252525.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C36700: MOVE 2,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
|
|
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 2,15 ;*ROT SHOULD ROTATE 525252,,525252
|
|
;LEFT 15 BIT POSITIONS
|
|
CAME 2,[252525,,252525] ;PASS IF C(AC)=252525,,252525
|
|
STOP
|
|
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 230703,,603700 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)074076,,004616.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C37000: MOVE 2,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
|
|
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 2,15 ;*ROT SHOULD ROTATE 230703,,603700
|
|
;LEFT 15 BIT POSITIONS
|
|
CAME 2,[074076,,004616] ;PASS IF C(AC)074076,,004616
|
|
STOP
|
|
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 007603,,607062 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)074161,,440174.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED.
|
|
|
|
C37100: MOVE 2,[007603,,607062] ;PRELOAD AC WITH 007603,,607062
|
|
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
ROT 2,15 ;*ROT SHOULD ROTATE 007603,,607062
|
|
;LEFT 15 BIT POSITIONS
|
|
CAME 2,[074161,,440174] ;PASS IF C(AC)074161,,440174
|
|
STOP
|
|
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 0,,0 0,,0 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,0 AND FINAL C(AC+1)=0,,0
|
|
|
|
C37200: MOVE 0,[0,,0] ;PRELOAD AC WITH 0,,0
|
|
MOVE 1,[0,,0] ;PRELOAD AC+1 WITH 0,,0
|
|
ROTC 0,3 ;*ROTC SHOULD ROTATE 0,,0 0,,0 LEFT 3 BIT POSITIONS
|
|
CAME 0,[0,,0] ;PASS IF C(AC)=0,,0
|
|
STOP
|
|
CAME 1,[0,,0] ;PASS IF C(AC+1)=0,,0
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, -1,,-1 -1,,-1 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=-1,,-1 AND FINAL C(AC+1)=-1,,-1
|
|
|
|
C37300: MOVE 0,[-1,,-1] ;PRELOAD AC WITH -1,,-1
|
|
MOVE 1,[-1,,-1] ;PRELOAD AC+1 WITH -1,,-1
|
|
ROTC 0,3 ;*ROTC SHOULD ROTATE -1,,-1
|
|
;-1,,-1 LEFT 3 BIT POSITIONS
|
|
CAME 0,[-1,,-1] ;PASS IF C(AC)=-1,,-1
|
|
STOP
|
|
CAME 0,[-1,,-1] ;PASS IF C(AC+1)=-1,,-1
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 252525,,252525 252525,,252525 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=525252,,525252 AND FINAL C(AC+1)=525252,,525252
|
|
|
|
C37400: MOVE 0,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
|
|
MOVE 1,[252525,,252525] ;PRELOAD AC+1 WITH 252525,,252525
|
|
ROTC 0,3 ;*ROTC SHOULD ROTATE 252525,,252525
|
|
;252525,,252525 LEFT 3 BIT POSITIONS
|
|
CAME 0,[525252,,525252] ;PASS IF C(AC)=525252,,525252
|
|
STOP
|
|
CAME 1,[525252,,525252] ;PASS IF C(AC+1)=525252,,525252
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 525252,,525252 525252,,525252 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=252525,,252525 AND FINAL C(AC+1)=252525,,252525
|
|
|
|
C37500: MOVE 0,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
|
|
MOVE 1,[525252,,525252] ;PRELOAD AC+1 WITH 525252,,525252
|
|
ROTC 0,3 ;*ROTC SHOULD ROTATE 525252,,525252
|
|
;525252,,525252 LEFT 3 BIT POSITIONS
|
|
CAME 0,[252525,,252525] ;PASS IF C(AC)=252525,,252525
|
|
STOP
|
|
CAME 1,[252525,,252525] ;PASS IF C(AC+1)=252525,,252525
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 230703,,603700 770037,,600377 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=307036,,37007 AND FINAL C(AC+1)=700376,,003772
|
|
|
|
C37600: MOVE 0,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
|
|
MOVE 1,[770037,,600377] ;PRELOAD AC+1 WITH 770037,,600377
|
|
ROTC 0,3 ;*ROTC SHOULD ROTATE 230703,,603700
|
|
;770037,,600377 LEFT 3 BIT POSITIONS
|
|
CAME 0,[307036,,037007] ;PASS IF C(AC)=307036,,37007
|
|
STOP
|
|
CAME 1,[700376,,003772] ;PASS IF C(AC+1)=700376,,003772
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 776003,,760077 007603,,607062 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=760037,,600770 AND FINAL C(AC+1)=076036,,070627
|
|
|
|
C37700: MOVE 0,[776003,,760077] ;PRELOAD AC WITH 776003,,760077
|
|
MOVE 1,[007603,,607062] ;PRELOAD AC+1 WITH 007603,,607062
|
|
ROTC 0,3 ;*ROTC SHOULD ROTATE 776003,,760077
|
|
;007603,,607062 LEFT 3 BIT POSITIONS
|
|
CAME 0,[760037,,600770] ;PASS IF C(AC)=076036,,070627
|
|
STOP
|
|
CAME 1,[076036,,070627] ;PASS IF C(AC+1)=760037,,600770
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 0,,0 0,,0 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,0 AND FINAL C(AC+1)=0,,0
|
|
|
|
C40000: MOVE 0,[0,,0] ;PRELOAD AC WITH 0,,0
|
|
MOVE 1,[0,,0] ;PRELOAD AC+1 WITH 0,,0
|
|
ROTC 0,7 ;*ROTC SHOULD ROTATE 0,,0 0,,0 LEFT 7 BIT POSITIONS
|
|
CAME 0,[0,,0] ;PASS IF C(AC)=0,,0
|
|
STOP
|
|
CAME 1,[0,,0] ;PASS IF C(AC+1)=0,,0
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, -1,,-1 -1,,-1 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=-1,,-1 AND FINAL C(AC+1)=-1,,-1
|
|
|
|
C40100: MOVE 0,[-1,,-1] ;PRELOAD AC WITH -1,,-1
|
|
MOVE 1,[-1,,-1] ;PRELOAD AC+1 WITH -1,,-1
|
|
ROTC 0,7 ;*ROTC SHOULD ROTATE -1,,-1
|
|
;-1,,-1 LEFT 7 BIT POSITIONS
|
|
CAME 0,[-1,,-1] ;PASS IF C(AC)=-1,,-1
|
|
STOP
|
|
CAME 1,[-1,,-1] ;PASS IF C(AC+1)=-1,,-1
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 252525,,252525 252525,,252525 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=525252,,525252 AND FINAL C(AC+1)=525252,,525252
|
|
|
|
C40200: MOVE 0,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
|
|
MOVE 1,[252525,,252525] ;PRELOAD AC+1 WITH 252525,,252525
|
|
ROTC 0,7 ;*ROTC SHOULD ROTATE 252525,,252525
|
|
;252525,,252525 LEFT 7 BIT POSITIONS
|
|
CAME 0,[525252,,525252] ;PASS IF C(AC)=525252,,525252
|
|
STOP
|
|
CAME 1,[525252,,525252] ;PASS IF C(AC+1)=525252,,525252
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 525252,,525252 525252,,525252 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=252525,,252525 AND FINAL C(AC+1)=252525,,252525
|
|
|
|
C40300: MOVE 0,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
|
|
MOVE 1,[525252,,525252] ;PRELOAD AC+1 WITH 525252,,525252
|
|
ROTC 0,7 ;*ROTC SHOULD ROTATE 525252,,525252
|
|
;525252,,525252 LEFT 7 BIT POSITIONS
|
|
CAME 0,[252525,,252525] ;PASS IF C(AC)=252525,,252525
|
|
STOP
|
|
CAME 1,[252525,,252525] ;PASS IF C(AC+1)=252525,,252525
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 230703,,603700 770037,,600377 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=160740,,760176 AND FINAL C(AC+1)=007740,,077646
|
|
|
|
C40400: MOVE 0,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
|
|
MOVE 1,[770037,,600377] ;PRELOAD AC+1 WITH 770037,,600377
|
|
ROTC 0,7 ;*ROTC SHOULD ROTATE 230703,,603700
|
|
;770037,,600377 LEFT 7 BIT POSITIONS
|
|
CAME 0,[160740,,760176] ;PASS IF C(AC)=160740,,760176
|
|
STOP
|
|
CAME 1,[007740,,077646] ;PASS IF C(AC+1)=007740,,077646
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
|
|
;IN THIS CASE, 776003,,760077 007603,,607063 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=400774,,017610 AND FINAL C(AC+1)=740741,,614577
|
|
|
|
C40500: MOVE 0,[776003,,760077] ;PRELOAD AC WITH 776003,,760077
|
|
MOVE 1,[007603,,607062] ;PRELOAD AC+1 WITH 007603,,607062
|
|
ROTC 0,7 ;*ROTC SHOULD ROTATE 776003,,760077
|
|
;007603,,607062 LEFT 7 BIT POSITIONS
|
|
CAME 0,[400774,,017601] ;PASS IF C(AC)=400774,,017601
|
|
STOP
|
|
CAME 1,[740741,,614577] ;PASS IF C(AC+1)=740741,,614577
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 0,,0 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,0.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C40600: MOVE 0,[0,,0] ;PRELOAD AC WITH 0,,0
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT 0,,0
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 0,[0,,0] ;PASS IF C(AC)=0,,0
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN -1,,-1 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,777.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C40700: MOVE 0,[-1,,-1] ;PRELOAD AC WITH -1,,-1
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT -1,,-1
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 0,[0,777] ;PASS IF C(AC)=0,,777
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN 252525,,252525 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,252.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C41000: MOVE 0,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT 252525,,252525
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 0,[0,,252] ;PASS IF C(AC)=0,,252
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 525252,,525252 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,525.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C41100: MOVE 0,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT 525252,,525252
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 0,[0,,525] ;PASS IF C(AC)=0,,525
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 230703,,603700 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,230.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C41200: MOVE 0,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT 230703,,603700
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 0,[0,,230] ;PASS IF C(AC)=230703,,603700
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 007603,,607062 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,7.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C41300: MOVE 0,[007603,,607062] ;PRELOAD AC WITH 007603,,607062
|
|
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
|
|
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT 007603,,6070062
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 0,[0,,7] ;PASS IF C(AC)=0,,7
|
|
STOP
|
|
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 0,,0 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,0.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C41400: MOVE 1,[0,,0] ;PRELOAD AC WITH 0,,0
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT 0,,0
|
|
;RIGHT 27 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,0] ;PASS IF C(AC)=0,,0
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, -1,,-1 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,17777.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C41500: MOVE 1,[-1,,-1] ;PRELOAD AC WITH -1,,-1
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT -1,,-1
|
|
;RIGHT 27 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,17777] ;PASS IF C(AC)=0,17777
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 252525,,252525 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,5252.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C41600: MOVE 1,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT 252525,,252525
|
|
;RIGHT 27 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,5252] ;PASS IF C(AC)=0,,5252
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 525252,,525252 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,12525.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C41700: MOVE 1,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT 525252,,525252
|
|
;RIGHT 27 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,12525] ;PASS IF C(AC)=0,,12525
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 230703,602700 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,4616.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C42000: MOVE 1,[230703,,603700] ;PRELOAD AC WITH 230703,603700
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT 230703,,603700
|
|
;RIGHT 27 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,4616] ;PASS IF C(AC)=0,,4616
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 007603,,607062 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,174.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C42100: MOVE 1,[007603,,607062] ;PRELOAD AC WITH 007603,,607062
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT 007603,,607062
|
|
;RIGHT 27 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,174] ;PASS IF C(AC)=0,,174
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 0,,0 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,0.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C42200: MOVE 1,[0,0] ;PRELOAD AC WITH 0,,0
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT 0,,0
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,0] ;PASS IF C(AC)=0,,0
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, -1,,-1 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,777.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C42300: MOVE 1,[-1,,-1] ;PRELOAD AC WITH -1,,-1
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT -1,,-1
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,777] ;PASS IF C(AC)=0,,777
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 252525,,252525 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,252.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C42400: MOVE 1,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT 252525,,252525
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,252] ;PASS IF C(AC)=0,,252
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 525252,,525252 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,525.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C42500: MOVE 1,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT 525252,,525252
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,525] ;PASS IF C(AC)=0,525
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 230703,,603700 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,230.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C42600: MOVE 1,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT 230703,,603700
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,230] ;PASS IF C(AC)=0,,230
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;**********
|
|
|
|
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
|
|
;IN THIS CASE, 007603,,607062 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
|
|
;SO THAT FINAL C(AC)=0,,7.
|
|
;C(AC+1) SHOULD NOT BE AFFECTED
|
|
|
|
C42700: MOVE 1,[007603,,607062] ;PRELOAD AC WITH 007603,,607062
|
|
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
|
|
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT 007603,,607062
|
|
;RIGHT 33 OCTAL BIT POSITIONS
|
|
CAME 1,[0,,7] ;PASS IF C(AC)=0,,7
|
|
STOP
|
|
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
|
|
STOP
|
|
|
|
;JRST BEGEND ;REPEAT TEST
|