Trailing-Edge
-
PDP-10 Archives
-
klad_sources
-
klad.sources/dakadm.mac
There are no other files named dakadm.mac in the archive.
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 C00
SKIPL MONCTL
TTCALL 3,PGMNAM ;MENTION OUR NAME
JRST STARTA
PGMNAM: ASCIZ/
PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (4) [DAKAD]
/
;BASIC INSTRUCTION TEST (3)
;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF
;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES
;IN THE FIELD.
STARTA: JRST .+1
C00:
;TESTING BEGINS HERE
;IF ANY LOADING PROBLEMS OCCUR, START PROGRAM HERE.
;NOTE: AN "*" IN THE COMMENT FIELD OF AN INSTRUCTION INDICATES THAT
; IT IS THE TESTED INSTRUCTION.
SUBTTL TEST OF AC HARDWARE AND INDEX REGISTERS
;**********
;THIS TEST VERIFIES THAT AC1 IS ACCESSABLE
;IN THIS CASE, AC1 IS PRELOADED WITH 1.
;C(AC1) IS THEN CHECKED FOR A1. THIS TEST PASSES IF C(AC1)=1.
;IF THIS TEST FAILS, THE AC HARDWARE IS PROBABLY FAULTY
C100: SETZ ;CLEAR AC0
MOVEI 1,1 ;PRELOAD AC1 WITH 1
CAIE 1,1 ;PASS IF C(AC1)=1
STOP
;**********
;THIS TEST VERIFIES THAT AC2 IS ACCESSABLE.
;IN THIS CASE, AC2 IS PRELOADED WITH 2.
;C(AC2) IS THEN CHECKED FOR 2. THIS TEST PASSES IF C(AC2)=2.
;IF THIS TEST FAILS, THE AC HARDWARE IS PROBABLY FAULTY
C200: MOVEI 2,2 ;PRELOAD AC2 WITH 2
CAIE 2,2 ;PASS IF C(AC2)=2
STOP
;**********
;THIS TEST VERIFIES THAT AC4 IS ACCESSABLE.
;IN THIS CASE, AC4 IS PRELOADED WITH 4.
;C(AC4) IS THEN CHECKED FOR 4. THIS TEST PASSES IF C(AC4)=4.
;IF THIS TEST FAILS, THE AC HARDWARE IS PROBABLY FAULTY
C300: MOVEI 4,4 ;PRELOAD AC4 WITH 4
CAIE 4,4 ;PASS IF C(AC4)=4
STOP
;**********
;THIS TEST VERIFIES THAT AC10 IS ACCESSABLE.
;IN THIS CASE, AC10 IS PRELOADED WITH 10.
;C(AC10) IS THEN CHECKED FOR 10. THIS TEST PASSES IF C(AC10)=10.
;IF THIS TEST FAILS, THE AC HARDWARE IS PROBABLY FAULTY
C400: MOVEI 10,10 ;PRELOAD AC10 WITH 10
CAIE 10,10 ;PASS IF C(AC10)=10
STOP
;**********
SN=500
ZZ=-1
;THIS TEST VERIFIES THAT ALL ACS EXIST
;FIRST, EACH AC IS PRELOADED WITH ITS OWN ADDRESS;
;THEN, THE CONTENTS OF EACH AC IS CHECKED FOR ITS ADDRESS.
;IF ANY AC DOES NOT CONTAIN ITS ADDRESS, THIS TEST FAILS
C500: REPEAT ^D16,
< ZZ=ZZ+1
MOVEI ZZ,ZZ ;PRELOAD EACH AC WITH ITS ADDR>
PAGE
ZZ=20
REPEAT ^D16,<
;THIS TEST VERIFIES THAT ALL ACS EXIST.
;FIRST, EACH AC IS PRELOADED WITH ITS OWN ADDRESS;
;THEN, THE CONTENTS OF EACH AC IS CHECKED FOR ITS ADDRESS.
;IF ANY AC DOES NOT CONTAIN ITS ADDRESS, THIS TEST FAILS
SN=SN+1
ZZ=ZZ-1
CAIE ZZ,ZZ ;CHECK THAT EACH AC CONTAINS ITS OWN ADDRESS
STOP
;IN CASE OF FAILURE, LOOP TO C500 ADDRESS
;**********
>
SN=600
ZZ=0
;THIS TEST VERIFIES THAT AN ADDRESS WITHIN THE AC RANGE MAY BE ACCESSED AS
;EITHER AN AC OR A MEMORY LOCATION AND THAT EITHER REFERENCE REFERS TO THE
;SAME HARDWARE. EACH AC IS PRELOADED WITH ITS ADDRESS; THEN THE CONTENTS OF EACH
;AC IS CHECKED FOR ITS ADDRESS. IF ANY AC DOES NOT CONTAIN ITS ADDRESS, THIS TEST FAILS.
C600: REPEAT ^D15,
< ZZ=ZZ+1
MOVEI ZZ ;PRELOAD EACH AC WITH ITS ADDRESS
MOVEM ZZ ;BY REFERENCING EACH AC AS MEMORY.>
ZZ=20
REPEAT ^D15,<
;THIS TEST VERIFIES THAT AN ADDRESS WITHIN THE AC RANGE MAY BE ACCESSED AS
;EITHER AN AC OR A MEMORY LOCATION AND THAT EITHER REFERENCE REFERS TO THE
;SAME HARDWARE. EACH AC IS PRELOADED WITH ITS ADDRESS
;THEN THE CONTENTS OF EACH AC IS CHECKED FOR ITS ADDRESS.
;IF ANY AC DOES NOT CONTAIN ITS ADDRESS, THIS TEST FAILS.
SN=SN+1
ZZ=ZZ-1
CAIE ZZ,ZZ ;CHECK THAT EACH AC CONTAINS ITS OWN ADDRESS
STOP
;IN CASE OF FAILURE, LOOP TO C600 ADDRESS
;**********
>
SN=700
ZZ=0
C700: REPEAT ^D15,<
;THIS TEST VERIFIES THAT THE INDEX REGISTERS ARE ACCESSABLE.
;FIRST, AN INDEX REGISTER IS PRELOADED WITH ITS ADDRESS; THEN,
;IT IS REFERENCED AS AN INDEX REGISTER. IF IT CONTAINS ITS ADDRESS, THIS TEST PASSES.
;THIS TEST IS REPEATED 15 TIMES IN ORDER TO TEST EACH INDEX REGISTER.
SN=SN+1
ZZ=ZZ+1
MOVEI ZZ,ZZ ;PRELOAD INDEX REGISTER WITH ITS ADDRESS
CAIE ZZ,(ZZ) ;PASS IF INDEX REGISTER CONTAINS ITS ADDRESS
STOP
;**********
>
SN=1000
ZZ=0
C1000: REPEAT ^D15,<
;THIS TEST VERIFIES THAT ALL INDEX REGISTERS INDEX CORRECTLY.
;FIRST, BOTH HALVES OF THE INDEX REGISTER ARE PRELOADED WITH ITS ADDRESS.
;THEN, THE INDEX REGISTER IS REFERENCED. IT IS THEN CHECKED FOR ITS ADDRESS IN BOTH HALVES.
;IF IT CONTAINS ITS ADDRESS IN BOTH HALVES THIS TEST PASSES.
;THIS TEST IS REPEATED 15 TIMES IN ORDER TO TEST EACH INDEX REGISTER
SN=SN+1
ZZ=ZZ+1
MOVEI ZZ,ZZ ;PRELOAD BOTH HALVES OF INDEX REG WITH ITS ADDRESS
HRLI ZZ,ZZ ;PASS IF INDEX REGISTER CONTAINS ITS ADDRESS
CAME ZZ,(ZZ) ;IN BOTH HALVES
STOP
;**********
>
SUBTTL TEST OF INDEX REGISTER ADDRESSING
;**********
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED. THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH A 0,
;THE FINAL RESULT IN AC3 SHOULD BE 0. IF C(AC3)=0, THIS TEST PASSES.
C1100: SETOM 3 ;PRELOAD AC3 WITH -1,,1
SETZM 1 ;PRELOAD AC1 WITH 0
MOVEI 2,1 ;SETUP INDEX REGISTER 2 WITH 1
MOVE 3,(2) ;*FWT FROM INDEXED LOCATION
SKIPE 3 ;TEST INDEXING
STOP
;**********
SN=1200
ZZ=0
C1200: REPEAT ^D18,<
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED. THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH A
;FLOATING 1. THE FINAL RESULT IN AC3 SHOULD BE A FLOATING 1.
;IF C(AC3)=A FLOATING 1, THIS TEST PASSES.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
SETOM 3 ;PRELOAD AC3 WITH -1,,-1
MOVEI 1,ZZ ;PRELOAD AC1 WITH FLOATING 1
MOVEI 2,1 ;SETUP INDEX REGISTER
MOVE 3,(2) ;*FWT FROM INDEXED LOCATION
CAIE 3,ZZ ;TEST INDEXING
STOP
;**********
>
SN=1300
ZZ=0
C1300: REPEAT ^D18,<
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED. THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH A
;FLOATING 1, THE FINAL RESULT IN AC3 SHOULD BE A FLOATING 1.
;IF C(AC3)=A FLOATING 1, THIS TEST PASSES.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
SETOM 3 ;PRELOAD AC3 WITH -1,,-1
MOVSI 1,ZZ ;PRELOAD AC1 WITH FLOATING 1
MOVEI 2,1 ;SETUP INDEX REGISTER
MOVE 3,(2) ;*FWT FROM INDEXED LOCATION
CAME 3,[ZZ,,0] ;TEST INDEXING
STOP
;**********
>
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED. THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH -1,,-1,
;THE FINAL RESULT IN AC3 SHOULD BE -1,,-1. IF C(AC3)=-1,,-1, THIS TEST PASSES.
C1400: SETZM 3 ;PRELOAD AC3 WITH 0
SETOM 1 ;PRELOAD AC1 WITH -1,,-1
MOVEI 2,1 ;SETUP INDEX REGISTER
MOVE 3,(2) ;*FWT FROM INDEXED LOCATION
CAME 3,[-1,,-1] ;TEST INDEXING
STOP
;**********
SN=1500
ZZ=0
C1500: REPEAT ^D18,<
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED. THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH A
;FLOATING 0, THE FINAL RESULT IN AC3 SHOULD BE A FLOATING 0.
;IF C(AC3)=A FLOATING 0, THIS TEST PASSES.
SN=SN+1
ZZ=<ZZ+ZZ+1>&777777
IFE <ZZ-1>,<ZZ=777776>
SETZM 3 ;PRELOAD AC3 WITH 0
HRROI 1,ZZ ;PRELOAD AC1 WITH FLOATING 0
MOVEI 2,1 ;SETUP INDEX REGISTER
MOVE 3,(2) ;*FWT FROM INDEXED LOCATION
CAME 3,[-1,,ZZ] ;TEST INDEXING
STOP
;**********
>
SN=1600
ZZ=0
C1600: REPEAT ^D18,<
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED. THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH A
;FLOATING 0, THE FINAL RESULT IN AC3 SHOULD BE A FLOATING 0.
;IF C(AC3)=A FLOATING 0, THIS TEST PASSES.
SN=SN+1
ZZ=<ZZ+ZZ+1>&777777
IFE <ZZ-1>,<ZZ=777776>
SETZM 3 ;PRELOAD AC3 WITH 0
HRLOI 1,ZZ ;PRELOAD AC1 WITH FLOATING 0
MOVEI 2,1 ;SETUP INDEX REGISTER
MOVE 3,(2) ;*FWT FROM INDEXED LOCATION
CAME 3,[ZZ,,-1] ;TEST INDEXING
STOP
;**********
>
;VERIFY INDEXING WHERE 'E' IS NON-ZERO
SN=1700
ZZ=-1
XX=-10
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, THE INDEX REG IS SET-UP WITH MOVEI ZZ+1,ZZ-XX,
;WHERE ZZ+1 IS THE INDEX REG. THE AC IS PRELOADED WITH ITS OWN ADDRESS, 0,,ZZ.
;CAIE IS USED TO TEST THE INDEXING OPERATION.
;IF THE RESULT IN C(AC)=XX+C(ZZ+1 - RIGHT), THIS TEST PASSES.
;XX+C(ZZ+1 - RIGHT) SHOULD = ZZ.
C1700: REPEAT ^D15,
<SN=SN+1
ZZ=ZZ+1
XX=XX+3
MOVEI ZZ+1,ZZ-XX ;SETUP INDEX REGISTER
MOVEI ZZ,ZZ ;PRELOAD AC WITH 0,,ZZ
CAIE ZZ,XX(ZZ+1) ;*TEST INDEXING
STOP
;**********
>
PAGE
SN=2000
ZZ=-1
XX=-20
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, THE INDEX REG IS SET-UP WITH MOVEI ZZ+1,ZZ-XX,
;WHERE ZZ+1 IS THE INDEX REG. INDEXING IS TESTED BY LOADING
;THE AC VIA MOVEI ZZ,XX(ZZ+1), WHERE XX+C(ZZ+1)=ZZ.
;IF THE RESULT IN THE AC EQUALS 0,,ZZ, THIS TEST PASSES.
C2000: REPEAT ^D15,
<SN=SN+1
ZZ=ZZ+1
XX=XX+5
MOVEI ZZ+1,ZZ-XX ;SETUP INDEX REGISTER
MOVEI ZZ,XX(ZZ+1) ;*TEST INDEXING
CAIE ZZ,ZZ ;PASS IF C(AC)=0,,ADDRESS OF AC
STOP
;**********
>
SUBTTL TEST OF EXCH INSTRUCTION
;**********
;THIS TEST VERIFIES THAT EXCH MOVES C(E) INTO AC AND
;MOVES C(AC) INTO E.
;IN THIS CASE, AC=E=0 AND C(AC)=C(E). HENCE, THE FINAL RESULT
;IN AC0 SHOULD BE 0. IF C(AC)=0, THE TEST PASSES.
C2100: SETZ ;PRELOAD AC,E WITH 0
EXCH ;*EXCH SHOULD PLACE 0 INTO AC0
SKIPE ;PASS IF C(AC0)=0
STOP
;**********
;THIS TEST VERIFIES THAT EXCH MOVES C(E) INTO AC AND
;MOVES C(AC) INTO E.
;IN THIS CASE, AC=E=-1,,-1 AND C(AC)=C(E). HENCE, THE FINAL RESULT
;IN AC0 SHOULD BE -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES.
C2200: SETO ;PRELOAD AC,E WITH -1,,-1
EXCH ;*EXCH SHOULD PLACE -1,,-1 INTO AC0
CAME [-1] ;PASS IF C(AC0)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT EXCH MOVES C(E) INTO AC AND
;MOVES C(AC) INTO E.
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0,,-1. HENCE, THE FINAL RESULT
;IN THE AC SHOULD BE 0,,-1 AND THE RESULT IN E SHOULD BE -1,,0,
;IF THESE RESULTS OCCUR, THE TEST PASSES.
C2400: MOVSI -1 ;PRELOAD AC WITH -1,,0
MOVEI 1,-1 ;PRELOAD E WITH 0,,-1
EXCH 1 ;*EXCH SHOULD PLACE 0,,-1 INTO THE AC AND -1,,0 INTO E
CAME 1,[-1,,0] ;PASS IF C(E)=-1,,0
STOP
C2410: CAME 0,[0,,-1] ;PASS IF C(AC)=0,,-1
STOP
;**********
;THIS TEST VERIFIES THAT EXCH MOVES C(E) INTO AC AND
;MOVES C(AC) INTO E.
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,0. HENCE, THE FINAL RESULT
;IN THE AC SHOULD BE -1,,0 AND THE RESULT IN E SHOULD BE 0,,-1.
;IF THESE RESULTS OCCUR, THE TEST PASSES.
C2700: MOVEI -1 ;PRELOAD AC WITH 0,,-1
MOVSI 1,-1 ;PRELOAD E WITH -1,,0
EXCH 1 ;*EXCH SHOULD PLACE -1,,0 INTO THE AC AND 0,,-1 INTO E
CAIE 1,-1 ;PASS IF C(E)=0,,-1
STOP
C2710: CAME ,[XWD -1,0] ;PASS IF C(AC)=-1,,0
STOP
;**********
;THIS TEST IS A RELIABILITY CHECK OF EXCH.
;FIRST, AC, E ARE PRELOADED WITH 252525,,252525. THERE, EXCH IS
;EXECUTED 7 TIMES. THE AC IS THEN CHECKED FOR 252525,,252525.
;IF C(AC)=C(E)=252525,,252525, THIS TEST PASSES.
;IN THIS TEST AC=E=AC0
C3000: MOVE [252525252525] ;PRELOAD AC,E WITH 252525,,252525
REPEAT 7,
< EXCH ;*EXCH SHOULD PLACE 252525,,252525 INTO AC0>
CAME [252525252525] ;PASS IF C(AC0)=252525,,252525
STOP
;**********
PAGE
;THIS TEST VERIFIES THAT EXCH MOVES C(AC) INTO E AND C(E) INTO THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. EXCH IS EXECUTED 7 TIMES; THEN,
;THE AC IS CHECKED FOR -1,,-1 AND E IS CHECKED FOR 0. IF EITHER OF THESE
;RESULTS ARE NOT FOUND, THIS TEST FAILS.
C3100: SETZ ;PRELOAD AC WITH 0
SETO 1,0 ;PRELOAD E WITH -1,,-1
REPEAT 7,
< EXCH 1 ;*EXCH SHOULD EXCHANGE C(AC) AND C(E)>
CAME [-1] ;PASS IF C(AC)=-1,,-1
STOP
C3110: CAME 1,[0] ;PASS IF C(E)=0
STOP
;**********
SUBTTL TEST OF MOVEM INSTRUCTION
;THIS TEST VERIFIES THAT MOVEM PLACES C(AC) INTO E AND DOES NOT MODIFY C(AC)
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN AC AND E SHOULD
;BE -1,,-1. IF C(AC) AND C(E)=-1,,-1, THIS TEST PASSES
C3200: SETO ;PRELOAD AC WITH -1,,-1
SETZ 1,0 ;PRELOAD E WITH 0
MOVEM 1 ;*MOVEM SHOULD PLACE -1,,-1 INTO E
CAME 1,[-1] ;PASS IF C(E)=-1,,-1
STOP
C3210: CAME 0,[-1] ;PASS IF C(AC)=-1,,-1
STOP
;**********
SUBTTL TEST OF JFCL INSTRUCTION AND ARITHMETIC FLAGS
;**********
;THIS TEST VERIFIES THAT JFCL 17,.+1 ALWAYS RETURNS TO THE NEXT SEQUENTIAL INSTRUCTION
;IF JFCL SKIPS THE NEXT INSTRUCTION, THIS TEST FAILS
C3300: MOVE [HALT .+3] ;THIS INSTRUCTION SHOULD NOT AFFECT THE TEST
JFCL 17,.+1 ;*JFCL SHOULD RETURN TO NEXT SEQUENTIAL INSTRUCTION
CAIA ;SKIP HALT INSTRUCTION IF JFCL PASSES
STOP
;**********
;THIS TEST VERIFIES THAT JFCL 17,.+1 ALWAYS CLEARS THE CRY0 FLAG.
;ADDI IS USED TO SET CRY0. THEN, JFCL 17,.+1 IS EXECUTED TO CLEAR CRY0.
;JFCL 4,.+2 IS EXECUTED TO DETERMINE WHETHER CRY0 WAS RESET BY THE PREVIOUS JFCL.
;THIS TEST FAILS IF JFCL 17,.+1 DID NOT CLEAR CRY0
C3400: MOVE [-1] ;PRELOAD AC WITH -1,,-1
ADDI 1 ;SET CRY0 FLAG
JFCL 17,.+1 ;*CLEAR ARITHMETIC FLAGS
JFCL 4,.+2 ;PASS IF CRY0 WAS RESET BY PREVIOUS INSTRUCTION
SKIPA ;SKIP HALT IF CRY0 WAS CLEARED
STOP
;**********
;THIS TEST VERIFIES THAT JFCL 17,.+1 ALWAYS CLEARS THE CRY1 FLAG.
;ADDI IS USED TO SET CRY1. THEN, JFCL 17,.+1 IS EXECUTED TO CLEAR CRY1.
;JFCL 4,.+2 IS EXECUTED TO DETERMINE WHETHER CRY1 WAS RESET BY THE PREVIOUS JFCL.
;THIS TEST FAILS IF JFCL 17,.+1 DID NOT CLEAR CRY1
C3500: MOVE [-1] ;PRELOAD AC WITH -1,,-1
ADDI 1 ;SET CRY1 FLAG
JFCL 17,.+1 ;*CLEAR ARITHMETIC FLAGS
JFCL 2,.+2 ;PASS IF CRY1 WAS RESET BY PREVIOUS INSTRUCTION
SKIPA ;SKIP HALT IF CRY1 WAS CLEARED
STOP
;**********
;THIS TEST VERIFIES THAT JFCL 17,.+1 ALWAYS CLEARS THE AROV FLAG.
;ADDI IS USED TO SET AROV. THEN, JFCL 17,.+1 IS EXECUTED TO CLEAR AROV.
;JFCL 4,.+2 IS EXECUTED TO DETERMINE WHETHER AROV WAS RESET BY THE PREVIOUS JFCL.
;THIS TEST FAILS IF JFCL 17,.+1 DID NOT CLEAR AROV
C3600: MOVSI 400000 ;PRELOAD AC WITH -1,,-1
ADD [XWD 400000,0] ;SET AROV FLAG
JFCL 17,.+1 ;*CLEAR ARITHMETIC FLAGS
JFCL 10,.+2 ;PASS IF AROV WAS RESET BY PREVIOUS INSTRUCTION
SKIPA ;SKIP HALT IF AROV WAS CLEARED
STOP
;**********
;THIS TEST VERIFIES THAT JFCL 0, IS A NO-OP.
;IN THIS TEST, ADD IS USED TO SET CRY0. THEN JFCL 0,.+2 IS EXECUTED.
;IF JFCL 0,.+2 DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES
C3700: MOVSI 400000 ;PRELOAD AC WITH MOST NEGATIVE NUMBER
ADD [-1] ;SET CRY0 FLAG
JFCL .+2 ;*JFCL SHOULD RETURN TO NEXT SEQUENTIAL INSTRUCTION
SKIPA ;PASS IF JFCL DID NOT SKIP
STOP
;**********
;THIS TEST VERIFIES THAT JFCL 0, IS A NO-OP.
;IN THIS TEST, ADD IS USED TO SET CRY1. THEN JFCL 0,.+2 IS EXECUTED.
;IF JFCL 0,.+2 DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES
C4000: MOVSI 200000 ;PRELOAD AC WITH MOST NEGATIVE NUMBER
ADD [XWD 200000,0] ;SET CRY1 FLAG
JFCL .+2 ;*JFCL SHOULD RETURN TO NEXT SEQUENTIAL INSTRUCTION
SKIPA ;PASS IF JFCL DID NOT SKIP
STOP
;**********
;THIS TEST VERIFIES THAT ADDI HAS THE ABILITY TO SET AN ARITHMETIC FLAG AND
;THAT 'JFCL 17,.+2' JUMPS WHENEVER ANY ARITHMETIC FLAG IS SET.
;IN THIS TEST, ADDI SHOULD SET CRY0 AND CRY1. THEN, JFCL SHOULD SKIP
;BECAUSE A FLAG WAS SET BY ADDI
;IF THIS TEST FAILS, ADDI COULD HAVE FAILED TO SET A FLAG OR
;JFCL COULD HAVE FAILED TO JUMP WHEN A FLAG WAS SET
C4100: MOVE [-1] ;PRELOAD AC WITH ALL ONES
ADDI 1 ;*ADDI SHOULD SET CRY0/1 FLAGS
JFCL 17,.+2 ;*JFCL SHOULD JUMP BECAUSE FLAGS ARE SET
STOP
;**********
;THIS TEST VERIFIES THAT CAI DOES NOT CLEAR ANY ARITHMETIC FLAGS.
;FIRST, CRY0 AND CRY1 ARE SET BY ADDI; THEN CAI IS EXECUTED.
;JFCL SHOULD JUMP BECAUSE FLAGS ARE SET. IF JFCL DOES NOT JUMP,
;THE FLAGS WERE CLEARED BY CAI. HENCE, CAI FAILED
C4200: MOVE [-1] ;PRELOAD AC WITH -1,,-1
ADDI 1 ;SET CYR0/1 FLAGS
CAI 17,17 ;*CAI SHOULD NOT CLEAR FLAGS
JFCL 17,.+2 ;PASS IF CAI CLEARED FLAGS
STOP
;**********
;THIS TEST VERIFIES THAT ADDI HAS THE ABILITY TO SET AN ARITHMETIC FLAG AND
;THAT 'JFCL 17,.+2' JUMPS WHENEVER ANY ARITHMETIC FLAG IS SET.
;IN THIS TEST, ADDI SHOULD SET CRY0 AND CRY1. THEN JFCL SHOULD SKIP
;BECAUSE A FLAG WAS SET BY ADDI
;IF THIS TEST FAILS, ADDI COULD HAVE FAILED TO SET A FLAG OR
;JFCL COULD HAVE FAILED TO JUMP WHEN A FLAG WAS SET
C4300: MOVE [-1] ;PRELOAD AC WITH ALL ONES
ADDI 1 ;*ADDI SHOULD SET CRY1 FLAGS
JFCL 2,.+2 ;*JFCL SHOULD JUMP BECAUSE CRY1 FLAG IS SET
STOP
;**********
;THIS TEST VERIFIES THAT ADDI HAS THE ABILITY TO SET AN ARITHMETIC FLAG AND
;THAT 'JFCL 17,.+2' JUMPS WHENEVER ANY ARITHMETIC FLAG IS SET.
;IN THIS TEST, ADDI SHOULD SET CRY0 AND CRY1. THEN, JFCL SHOULD SKIP
;BECAUSE A FLAG WAS SET BY ADDI
;IF THIS TEST FAILS, ADDI COULD HAVE FAILED TO SET A FLAG OR
;JFCL COULD HAVE FAILED TO JUMP WHEN A FLAG WAS SET
C4400: MOVE [-1] ;PRELOAD AC WITH ALL ONES
ADDI 1 ;*ADDI SHOULD SET CRY0 FLAG
JFCL 4,.+2 ;*JFCL SHOULD JUMP BECAUSE CRY0 FLAG IS SET
STOP
;**********
;THIS TEST VERIFIES THAT ADDI HAS THE ABILITY TO SET AN ARITHMETIC FLAG AND
;THAT 'JFCL 17,.+2' JUMPS WHENEVER ANY ARITHMETIC FLAG IS SET.
;BECAUSE A FLAG WAS SET BY ADD
;IF THIS TEST FAILS, ADDI COULD HAVE FAILED TO SET A FLAG OR
;JFCL COULD HAVE FAILED TO JUMP WHEN A FLAG WAS SET
C4500: MOVSI 400000 ;PRELOAD AC WITH ALL ONES
ADD [XWD 400000,0] ;*ADD SHOULD SET AROV FLAG
JFCL 10,.+2 ;*JFCL SHOULD JUMP BECAUSE AROV FLAG IS SET
STOP
;**********
;THIS TEST VERIFIES THAT JFCL 17,.+1 ALWAYS CLEARS THE FLOATING OVERFLOW FLAG (FOV).
;FIRST JFCL 17,.+1 IS EXECUTED TO CLEAR FOV. THEN, JFCL 1,.+2 IS EXECUTED TO DETERMINE
;WHETHER FOV WAS CLEARED. IF FOV WAS CLEAR, THIS TEST PASSES
C4600: JFCL 17,.+1 ;*CLEAR ARITHMETIC FLAGS
JFCL 1,.+2 ;PASS IF FOV WAS CLEARED
SKIPA ;SKIP HALT IF TEST PASSED
STOP
;**********
;THIS TEST VERIFIES THAT JFCL 13, DOES NOT RESET CRY0.
;FIRST CRY0 AND CRY1 ARE SET BY ADDI; THEN, JFCL 13,.+2 IS EXECUTED
;TO CLEAR ALL ARITHMETIC FLAGS EXCEPT CRY0.
;THIS TEST PASSES IF JFCL 13,.+1 DID NOT RESET CRY0.
C4700: MOVE [-1] ;RELOAD AC WITH -1,,-1
ADDI 1 ;SET CRY0/1
JFCL 13,.+1 ;*JFCL 13, SHOULD NOT RESET CRY0
JFCL 4,.+2 ;FAIL IF CRY 0 WAS RESET
STOP
;**********
;THIS TEST VERIFIES THAT JFCL 15, DOES NOT RESET CRY1.
;FIRST CRY0 AND CRY1 ARE SET BY ADDI; THEN, JFCL15,.+2 IS EXECUTED
;TO CLEAR ALL ARITHMETIC FLAGS EXCEPT CRY1.
;THIS TEST PASSES IF JFCL 15,.+1 DID NOT RESET CRY1.
C5000: MOVE [-1] ;PRELOAD AC WITH -1,,-1
ADDI 1 ;SET CRY0/1
JFCL 15,.+1 ;*JFCL15, SHOULD NOT RESET CRY0
JFCL 2,.+2 ;FAIL IF CRY1 WAS RESET
STOP
;**********
;THIS TEST VERIFIES THAT JFCL 17, DOES NOT RESET AROV.
;FIRST AROV IS SET BY ADD; THEN, JFCL 17,.+2 IS EXECUTED
;TO CLEAR ALL ARITHMETIC FLAGS EXCEPT AROV.
;THIS TEST PASSES IF JFCL 17,.+1 DID NOT RESET AROV.
C5100: MOVSI 400000 ;PRELOAD AC WITH -1,,-1
ADD [XWD 400000,0] ;SET AROV
JFCL 7,.+1 ;*JFCL 17, SHOULD NOT RESET AROV
JFCL 10,.+2 ;FAIL IF AROV WAS RESET
STOP
;**********
;THIS TEST VERIFIES THAT ADD OF 0 TO 0 WILL NOT SET AROV.
;FIRST, ALL FLAGS ARE RESET, THEN 0 IS ADDED TO 0 VIA ADD.
;AROV IS THEN CHECKED. IF AROV IS SET, THIS TEST FAILS.
C5200: JFCL 17,.+1 ;RESET ARITHMETIC FLAGS
SETZ ;PRELOAD AC,E WITH 0
ADD ;*ADD SHOULD NOT SET AROV
JFCL 10,.+2 ;PASS IF AROV WAS RESET
SKIPA ;SKIP HALT IF ADD PASSED
STOP
;**********
;THIS TEST VERIFIES THAT ADD OF 0 TO 0 WILL NOT SET CRY0.
;FIRST, ALL FLAGS ARE RESET, THEN 0 IS ADDED TO 0 VIA ADD.
;CRY0 IS THEN CHECKED. IF CRY0 IS SET, THIS TEST FAILS.
C5300: SETZ ;RESET ARITHMETIC FLAGS
JFCL 17,.+1 ;PRELOAD AC,E WITH 0
ADD ;*ADD SHOULD NOT SET CRY0
JFCL 4,.+2 ;PASS IF CRY0 WAS RESET
SKIPA ;SKIP HALT IF ADD PASSED
STOP
;**********
;THIS TEST VERIFIES THAT ADD OF 0 TO 0 WILL NOT SET CRY1.
;FIRST, ALL FLAGS ARE RESET, THEN 0 IS ADDED TO 0 VIA ADD.
;CRY1 IS THEN CHECKED. IF CRY1 IS SET, THIS TEST FAILS.
C5400: SETZ ;RESET ARITHMETIC FLAGS
JFCL 17,.+1 ;PRELOAD AC,E WITH 0
ADD ;*ADD SHOULD NOT SET CRY1
JFCL 2,.+2 ;PASS IF CRY1 WAS RESET
SKIPA ;SKIP HALT IF ADD PASSED
STOP
;**********
;THIS TEST VERIFIES THAT THE 30X AND THE 31X INSTRUCTION GROUPS DO NOT AFFECT
;THE ARITHMETIC FLAGS. FIRST, THE FLAGS ARE CLEARED AND AC0 IS CLEARED; THEN, CAI
;AND CAM ARE EXECUTED. THE FLAGS ARE THEN CHECKED. IF ANY OF THE FLAGS ARE SET,
;THIS TEST FAILS AND CAI OR CAM IS CONSIDERED TO HAVE ERRONEOUSLY SET THE FLAGS
C5500: JFCL 17,.+1 ;CLEAR ALL FLAGS
SETZ ;CLEAR AC,0
CAI ;*CAI SHOULD NOT SET ANY ARITHMETIC FLAG
CAM [-1] ;*CAM SHOULD NOT SET ANY ARITHMETIC FLAG
JFCL 17,.+2 ;FAIL IF ANY FLAG WAS SET
SKIPA ;SKIP HALT IF TEST PASSED
STOP
;**********
;THIS TEST VERIFIES THAT THE BOOLEAN INSTRUCTION GROUPS DO NOT AFFECT
;THE ARITHMETIC FLAGS. FIRST THE FLAGS ARE CLEARED AND AC0 IS CLEARED; THEN, XOR [0]
;AND XOR [-1] ARE EXECUTED. THE FLAGS ARE THEN CHECKED. IF ANY OF THE FLAGS ARE SET,
;THIS TEST FAILS AND XOR IS CONSIDERED TO HAVE ERRONEOUSLY SET THE FLAGS
C5600: JFCL 17,.+1 ;CLEAR ALL FLAGS
SETO ;CLEAR AC,0
XOR [0] ;*XOR SHOULD NOT SET ANY ARITHMETIC FLAG
XOR [-1] ;*XOR SHOULD NOT SET ANY ARITHMETIC FLAG
JFCL 17,.+2 ;FAIL IF ANY FLAG WAS SET
SKIPA ;SKIP HALT IF TEST PASSED
STOP
;**********
;THIS TEST VERIFIES THAT THE AOBJX INSTRUCTION GROUP DOES DO NOT AFFECT
;THE ARITHMETIC FLAGS. FIRST THE FLAGS ARE CLEARED AND AC0 IS CLEARED; THEN, AOBJN
;AND AOBJP ARE EXECUTED. THE FLAGS ARE THEN CHECKED. IF ANY OF THE FLAGS ARE SET,
;THIS TEST FAILS AND AOBJN OR AOBJP IS CONSIDERED TO HAVE ERRONEOUSLY SET THE FLAGS
C5700: SETO ;CLEAR ALL FLAGS
JFCL 17,.+1 ;CLEAR AC,0
AOBJN .+1 ;*AOBJN SHOULD NOT SET ANY ARITHMETIC ARITHMETIC
AOBJP .+1 ;*AOBJP SHOULD NOT SET ANY ARITHMETIC FLAG
JFCL 17,.+2 ;FAIL IF ANY FLAG WAS SET
SKIPA ;SKIP HALT IF TST PASSED
STOP
;**********
;THIS TEST VERIFIES THAT SKIP DOES NOT AFFECT THE FLAGS.
;FIRST, THE ARITHMETIC FLAGS ARE CLEARED; THEN, SKIP IS EXECUTED.
;IF SKIP SETS AROV, CRYO, CRY1 OR FOV, THIS TEST FAILS.
C5701: JFCL 17,.+1 ;CLEAR ALL FLAGS
SKIP 0,[-1] ;*SKIP SHOULD NOT SET ANY FLAGS
JFCL 17,.+2 ;FAIL IF ANY FLAG IS SET
SKIPA ;PASS IF NO FLAG IS SET
STOP
;**********
;THIS TEST VERIFIES THAT JUMP DOES NOT AFFECT THE FLAGS.
;FIRST, THE ARITHMETIC FLAGS ARE CLEARED; THEN, JUMP IS EXECUTED.
;IF JUMP SETS AROV, CRYO, CRY1 OR FOV, THIS TEST FAILS.
C5702: JFCL 17,.+1 ;CLEAR ALL FLAGS
JUMP 0,[-1] ;*JUMP SHOULD NOT SET ANY FLAGS
JFCL 17,.+2 ;FAIL IF ANY FLAG IS SET
SKIPA ;PASS IF NO FLAG IS SET
STOP
;**********
SUBTTL TEST OF JRST INSTRUCTION AND ARITHMETIC FLAGS
;**********
;THIS TEST VERIFIES THAT 'JRST, 0' DOES NOT SET ANY FLAGS.
;FIRST THE ARITHMETIC FLAGS ARE RESET; THEN, 'JRST 0,.+1' IS EXECUTED
;THE AROV,CRY0 AND CRY1 FLAGS ARE THEN CHECKED. IF ANY
;OF THESE FLAGS ARE SET, THIS TEST FAILS
C6000: JFCL 17,.+1 ;RESET ALL FLAGS
JRST .+1 ;*JRST SHOULD NOT SET ANY FLAGS
JFCL 16,.+2 ;PASS IF NO FLAGS ARE SET
SKIPA ;SKIP HALT IF JRST PASSES
STOP
;**********
;THIS TEST VERIFIES THAT 'MOVE 2,2' DOES NOT SET ANY FLAGS.
;FIRST, THE ARITHMETIC FLAGS ARE RESET; THEN, 'MOVE 2,2' IS EXECUTED.
;THE FOV,AROV,CRY0 AND CRY1 FLAGS ARE THEN CHECKED. IF ANY
;OF THESE FLAGS ARE SET, THIS TEST FAILS
C6100: JFCL 17,.+1 ;RESET ALL FLAGS
MOVE 2,2 ;*MOVE SHOULD NOT SET ANY FLAGS
JFCL 17,.+2 ;PASS IF NO FLAGS ARE SET
SKIPA ;SKIP HALT IF MOVE PASSED
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1. IN THIS CASE, AC1 SPECIFIES THE CRY0 FLAG.
;FIRST, ALL FLAGS ARE RESET; THEN AC1 IS SET TO SPECIFY CRY0.
;NEXT, JRST 2,.+1(1) IS EXECUTED TO SET CRY0. CRY0 IS THEN CHECKED. IF
;CRY0 IS SET, THIS TEST PASSES. OTHERWISE, JRST 2,.+1 IS FAULTY
C6200: JFCL 17,.+1 ;CLEAR ALL FLAGS
SFLAG CRY0 ;SET CRY0 FLAG
JFCL 4,.+2 ;PASS IF CRY0 IS SET
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2,.+(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1. IN THIS CASE, AC1 CONTAIN 0. HENCE, JRST 2,.+1(1)
;SHOULD RESET THE ARITHMETIC FLAGS. FIRST, THE CRY0/1, FLAGS ARE SET BY ADDI;
;THEN THE FLAGS SHOULD BE CLEARED BY JRST 2,.+1. IF CRY1 WAS CLEARED, THE
;TEST PASSES. OTHERWISE, JRST 2,.+1 IS FAULTY
C6300: MOVE [-1] ;PRELOAD AC0 WITH -1,,-1
ADDI 1 ;SET CRY0/1 FLAGS
SFLAG 0 ;RESET ALL ARITHMETIC FLAGS
JFCL 2,.+2 ;PASS IF CRY1 IS RESET
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSED
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2,.+(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1. IN THIS CASE, AC1 CONTAIN 0. HENCE, JRST 2,.+1(1)
;SHOULD RESET THE ARITHMETIC FLAGS. FIRST, THE CRY0/1, FLAGS ARE SET BY ADD
;THEN THE FLAGS SHOULD BE CLEARED BY JRST 2,.+1. IF AROV WAS CLEARED, THE
;TEST PASSES. OTHERWISE, JRST 2,.+1 IS FAULTY
C6400: MOVSI 400000 ;PRELOAD AC0 WITH -1,,-1
ADD [-1] ;SET CRY0 AND AROV FLAGS
SFLAG 0 ;RESET ALL ARITHMETIC FLAGS
JFCL 10,.+2 ;PASS IF AROV IS RESET
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSED
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1. IN THIS CASE, AC1 SPECIFIES THE AROV FLAG.
;FIRST, ALL FLAGS ARE RESET; THEN AC1 SET TO SPECIFY AROV.
;NEXT, JRST 2,.+1(1) IS EXECUTED TO SET AROV. AROV IS THEN CHECKED. IF
;AROV IS SET, THIS TEST PASSES. OTHERWISE, JRST 2,.+1 IS FAULTY
C6500: SFLAG AROV ;SET AROV FLAG
JFCL 10,.+2 ;PASS IF AROV WAS SET
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1. IN THIS CASE, AC1 SPECIFIES THE CRY1 FLAG.
;FIRST, ALL FLAGS ARE RESET; THEN AC1 SET TO SPECIFY CRY1.
;NEXT, JRST 2,.+1(1) IS EXECUTED TO SET CRY1. CRY1 IS THEN CHECKED. IF
;CRY1 IS SET, THIS TEST PASSES. OTHERWISE, JRST 2,.+1 IS FAULTY
C6600: SFLAG CRY1 ;SET CRY1 FLAG
JFCL 2,.+2 ;PASS IF CRY1 WAS SET
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1. IN THIS CASE, AC1 SPECIFIES THE FOV FLAG.
;FIRST, ALL FLAGS ARE RESET; THEN AC1 SET TO SPECIFY FOV.
;NEXT, JRST 2,.+1(1) IS EXECUTED TO SET FOV. FOV IS THEN CHECKED. IF
;FOV IS SET, THIS TEST PASSES. OTHERWISE, JRST 2,.+1 IS FAULTY
C6700: SFLAG FOV ;SET FOV FLAG
JFCL 1,.+2 ;PASS IF FOV WAS SET
STOP
;**********
;THIS TEST VERIFIES THAT JFCL 0, SHOULD NEVER JUMP.
;FIRST, FOV IS SET VIA JRST2, ;THEN JFCL 0,
;IS EXECUTED. IF JFCL 0, DOES NOT SKIP, THIS TEST PASSES
C7000: SFLAG FOV ;SET FOV FLAG
JFCL ,.+2 ;*JFCL SHOULD NOT JUMP
SKIPA ;PASS IF JFCL DID NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1. IN THIS CASE, AC1 CONTAINS 0. HENCE, JRST 2,.+1(1)
;SHOULD RESET THE ARITHMETIC FLAGS. FIRST, THE CRY0, FLAG IS SET BY JRST 2,.+1(1)
;WITH C(AC1)=CRY0. THEN, THE FLAGS SHOULD BE CLEARED BY JRST 2,.+1 WITH C(AC1)=0.
;IF CRY0 WAS CLEARED, THE TEST PASSES. OTHERWISE, JRST 2,.+1 IS FAULTY
C7100: SFLAG CRY0 ;SET CRY0 FLAGS
SETZ 1, ;SETUP MASK TO CLEAR ARITHMETIC FLAGS
JRST 2,.+1(1) ;*RESET ARITHMETIC FLAGS
JFCL 4,.+2 ;PASS IF CRY0 FLAG WAS RESET
SKIPA ;SKIP HALT INSTRUCTION IF TEST PSSED
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1. IN THIS CASE, AC1 CONTAINS 0. HENCE, JRST 2,.+1(1)
;SHOULD RESET THE ARITHMETIC FLAGS. FIRST, THE FOV, FLAG IS SET BY JRST 2,.+1(1)
;WITH C(AC1)=FOV. THEN, THE FLAGS SHOULD BE CLEARED BY JRST 2,.+1 WITH C(AC1)=0.
;IF FOV WAS CLEARED, THE TEST PASSES. OTHERWISE, JRST 2,.+1 IS FAULTY
C7200: SFLAG FOV ;SET FOV FLAG
SETZ 1, ;SETUP MASK TO CLEAR ARITHMETIC FLAGS,
JRST 2,.+1(1) ;*RESET ARITHMETIC FLAGS
JFCL 1,.+2 ;PASS IF FOV FLAG WAS RESET
SKIPA ;SKIP HALT INSTRUCTION IF TEST PSSED
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1. IN THIS CASE, AC1 CONTAINS 0. HENCE, JRST 2,.+1(1)
;SHOULD RESET THE ARITHMETIC FLAGS. FIRST, THE ARITHMETIC FLAGS ARE RESET BY
;JFCL 17,.+1. THEN, THE FLAGS SHOULD BE CLEARED BY JRST 2,.+1.
;IF ALL THE ARITHMETIC FLAGS WERE CLEARED,
;THE TEST PASSES. OTHERWISE, JRST 2,.+1 IS FAULTY
C7300: JFCL 17,.+1 ;CLEAR FLAGS
SETZ 1, ;SETUP MASK TO CLEAR ARITMETIC FLAGS
JRST 2,.+1(1) ;*RESET ARITHMETIC FLAGS
JFCL 17,.+2 ;PASS IF ALL FLAGS ARE RESET
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSED
STOP
;**********
SUBTTL TEST OF JSP INSTRUCTION
;**********
;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS AND PC IN THE AC.
;IN THIS CASE, THE FLAGS ARE RESET; THEN, JSP IS EXECUTED. THE AC IS THEN
;CHECKED FOR ITS CONTENTS NON-ZERO. IF C(AC)=0, IT INDICATES
;THAT NEITHER THE FLAGS NOR THE PC WAS SAVED. HENCE, THIS TEST FAILS.
C7400: SETZB 1 ;CLEAR AC AND SETUP MASK TO RESET FLAGS
JRST 2,.+1(1) ;RESET FLAGS
JSP .+1 ;*JSP SHOULD STORE FLAGS AND PC IN THE AC
SKIPN ;PASS IF C(AC) IS NON-ZERO
STOP ;IT DID NOT STORE ANY FLAGS OR PC
;**********
;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE PC IN THE RIGHT HALF OF THE AC.
;IN THIS CASE, THE AC IS CLEARED, THEN, JSP IS EXECUTED. THE RIGHT HALF OF
;THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO. IF C(AC RIGHT HALF)
;IS NON-ZERO, IT INDICATED THAT THE PC WAS SAVED; AND THIS TEST PASSES.
C7500: SETZ ;CLEAN AC
JSP .+1 ;*JSP SHOULD STORE THE PC IN THE AC
TRNN -1 ;PASS IF C(AC) IN NON-ZERO
STOP
;**********
;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS IN THE LEFT HALF OF THE AC.
;FIST, THE AC IS CLEARED; THEN, SOME FLAGS ARE SET AND JSP IS EXECUTED.
;THE LEFT HALF OF THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO TO DETERMINE
;WHETHER THE FLAGS WERE SAVED. IF C(AC-LEFT) IS NON-ZERO, THIS TEST PASSES
C7600: SETZM 0 ;CLEAR AC
MOVSI 1,740000 ;SET UP MASK TO SET FLAGS
JRST 2,.+1(1) ;SET SOME ARITHMETIC FLAGS
JSP .+1 ;*JSP SHOULD STORE FLAGS IN THE AC
TLNN -1 ;PASS IF C(AC) IS NON-ZERO
STOP
;**********
;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS IN THE LEFT HALF OF THE AC.
;FIRST, THE AC IS CLEARED; THEN, THE AROV FLAG IS SET AND JSP IS EXECUTED.
;THEN, THE AROV FLAG BIT OF
;THE LEFT HALF OF THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO TO DETERMINE
;WHETHER THE AROV FLAG WAS SAVED. IF THE AROV FLAG BIT OF THE AC IS SET, THIS TEST PASSES
C7700: SETZM 0 ;CLEAR THE AC
SFLAG AROV ;SET AROV FLAG
JSP .+1 ;*JSP SHOULD SAVE THE FLAGS IN THE AC-LEFT
TLNN AROV ;PASS IF AROV WAS SAVED
STOP
;**********
;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS IN THE LEFT HALF OF THE AC.
;FIRST, THE AC IS CLEARED; THEN, THE CRY0 FLAG IS SET AND JSP IS EXECUTED.
;THEN, THE CRY0 FLAG BIT OF
;THE LEFT HALF OF THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO TO DETERMINE
;WHETHER THE CRY0 FLAG WAS SAVED. IF THE CRY0 FLAG BIT OF THE AC IS SET, THIS TEST PASSES
C10000: SETZM 0 ;CLEAR THE AC
SFLAG CRY0 ;SET CRY0 FLAG
JSP .+1 ;*JSP SHOULD SAVE THE FLAGS IN THE AC-LEFT
TLNN CRY0 ;PASS IF CRY0 WAS SAVED
STOP
;**********
;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS IN THE LEFT HALF OF THE AC.
;FIRST, THE AC IS CLEARED; THEN, THE CRY1 FLAG IS SET AND JSP IS EXECUTED.
;THEN, THE CRY1 FLAG BIT OF
;THE LEFT HALF OF THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO TO DETERMINE
;WHETHER THE FLAG WAS SAVED. IF THE CRY1 FLAG BIT OF THE AC IS SET, THIS TEST PASSES
C10100: SETZ ;CLEAR AC
SFLAG CRY1 ;SET CRY1 FLAG
JSP .+1 ;*JSP SHOULD SAVE THE FLAGS IN THE AC-LEFT
TLNN CRY1 ;PASS IF AROV WAS SAVED
STOP
;**********
;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS IN THE LEFT HALF OF THE AC.
;FRIST, THE AC IS CLEARED; THEN, THE FOV FLAG IS SET AND JSP IS EXECUTED.
;THEN, THE FOV FLAG BIT OF THE LEFT HALF OF THE AC IS CHECKED FOR
;ITS CONTENTS NON-ZERO TO DETERMINE WHETHER THE FOV FLAG WAS SAVED.
;IF THE FOV FLAG BIT OF THE AC IS SET, THIS TEST PASSES
C10200: SETZ ;CLEAR THE AC
SFLAG FOV ;SET FOV FLAG
JSP .+1 ;*JSP SHOULD SAVE THE FLAGS IN THE AC-LEFT
TLNN FOV ;PASS IF FOV WAS SAVED
STOP
;**********
;THIS TEST VERIFIES THAT JSP WILL STORE ONLY FLAGS THAT EXIST.
;I.E. RESET FLAGS WILL NOT BE SET IN THE AC. ONLY FLAGS THAT ARE
;CLEARABLE BY JRSTF WILL BE CHECKED HERE. FIRST ALL CLEARABLE
;FLAGS ARE RESET BY JRSTF; THEN JSP IS EXECUTED. THE AC IS THEN CHECKED.
;IF ANY CLEARABLE FLAGS ARE SET IN THE AC, THIS TEST FAILS.
C10300: SFLAG 0 ;CLEAR ALL CLEARABLE FLAGS
JSP .+1 ;*JSP SHOULD NOT STORE CLEARABLE FALGS
TLNE 761777 ;FAIL IF ANY CLEARABLE FLAG IS SET
STOP
;**********
;THIS TEST VERIFIES THAT JSP ALWAYS JUMPS.
;IN THIS TEST, JSP .+2 IS EXECUTED. IF JSP JUMPS, THE TEST PASSES;
;OTHERWISE, THIS TEST HALTS
C10400: JSP .+2 ;*JSP SHOULD ALWAYS JUMP
STOP
;**********
SUBTTL TEST JRST INSTRUCTION
;**********
;THIS TEST VERIFIES THAT JRST ALWAYS JUMPS.
;IN THIS TEST, JRST .+2 IS EXECUTED. IF JRST JUMPS, THE TEST PASSES;
;OTHERWISE, THIS TEST HALTS
C10500: JRST .+2 ;*JRST 0, SHOULD ALWAYS JUMP
STOP
;**********
SUBTTL TEST OF AOBJX INSTRUCTIONS
;**********
;THIS TEST VERIFIES THAT AOBJN ALWAYS ADDS 1 TO BOTH HALVES OF THE AC.
;FIRST, THE AC IS CLEARED; THEN, AOBJN IS EXECUTED AND THE AC IS CHECKED
;FOR 1,,1. IF C(AC)=1,,1, THIS TEST PASSES.
C11200: SETZ ;CLEAR THE AC
AOBJN .+1 ;*AOBJN SHOULD ADD 1 TO BOTH HALVES OF THE AC
CAME [XWD 1,1] ;PASS IF C(AC)=1,,1
STOP
;**********
;THIS TEST VERIFIES THAT AOBJP ALWAYS ADDS 1 TO BOTH HALVES OF THE AC.
;FIRST, THE AC IS CLEARED; THEN AOBJP IS EXECUTED AND THE AC IS CHECKED
;FOR 1,,1. IF C(AC)=1,,1, THIS TEST PASSES.
C11300: MOVE [XWD 377777,377777] ;PRELOAD AC WITH 377777,,377777
AOBJP .+1 ;*AOBJP SHOULD ADD, TO BOTH HALVES OF THE AC
CAME [XWD 400000,400000] ;PASS IF C(AC)=400000,400000
STOP
;**********
;THIS TEST VERIFIES THAT AOBJN WILL NOT JUMP WHEN C(AC) IS POSITIVE
;FIRST, THE AC IS CLEARED; AND AOBJN IS EXECUTED. AOBJN SHOULD NOT JUMP
;BECAUSE C(AC) IS POSITIVE. IF AOBJN JUMPS, THIS TEST FAILS
C11400: SETZ ;CLEAR THE AC
AOBJN .+2 ;*AOBJN SHOULD NOT JUMP WHEN C(AC) IS POSITIVE
SKIPA ;PASS IF AOBJN DOES NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT AOBJP WILL JUMP WHEN C(AC) IS POSITIVE
;FIRST, THE AC IS CLEARED; AND AOBJP IS EXECUTED. AOBJP SHOULD JUMP
;BECAUSE C(AC) IS POSITIVE. IF AOBJP DOES NOT JUMP, THIS TEST FAILS
C11500: SETZ ;CLEAR THE AC
AOBJP .+2 ;*AOBJP SHOULD JUMP BECAUSE C(AC) IS POSITIVE
STOP
;**********
;THIS TEST VERIFIES THAT AOBJN WILL JUMP WHEN C(AC) IS NEGATIVE
;FIRST, THE AC IS PRELOADED WITH 400000,,0; AND AOBJN IS EXECUTED. AOBJN SHOULD JUMP
;BECAUSE C(AC) IS NEGATIVE. IF AOBJN DOES NOT JUMP, THIS TEST FAILS
C11600: MOVE [XWD 400000,400000] ;PRELOAD AC WITH 400000,,400000
AOBJN .+2 ;*AOBJN SHOULD JUMP BECAUSE C(AC) IS NEGATIVE
STOP
;**********
;THIS TEST VERIFIES THAT AOBJP WILL NOT JUMP WHEN C(AC) IS NEGATIVE. FIRST,
;THE AC IS PRELOADED WITH 400000,,0; AND AOBJP IS EXECUTED. AOBJP SHOULD NOT JUMP
;BECAUSE C(AC) IS NEGATIVE. IF AOBJP JUMPS, THIS TEST FAILS
C11700: MOVE [XWD 400000,400000] ;PRELOAD AC WITH 400000,,400000
AOBJP .+2 ;*AOBJP SHOULD NOT JUMP BECAUSE C(AC) IS NEGATIVE
SKIPA ;PASS IF AOBJP DOES NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT THERE IS A CARRY FROM BIT 18 TO BIT 17 OF THE AC ON AOBJN.
;THE AC IS PRELOADED WITH -1,,-1; THEN AOBJN IS EXECUTED. AOBJN 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
C12000: SETO ;PRELOAD AC WITH -1,, -1
AOBJN .+1 ;*AOBJN SHOULD GENERATE A CARRY FROM BIT 18 TO 17
CAME [1,,0] ;PASS IF C(AC)=1,,0 (CARRY WAS GENERATED)
STOP
;**********
SUBTTL TEST SETTING OF ARITHMETIC FLAGS VIA MOVNX AND MOVMX
;THIS TEST VERIFIES THAT MOVNI SETS CRY0 AND CRY1 FLAGS ONLY WHEN THE DATA IS 0.
;FIRST, THE ARITHMETIC FLAGS ARE RESET; THEN, MOVNI IS EXECUTED WITH DATA OF ZEROS.
;THE ARITHMETIC FLAGS ARE CHECKED.
; CRY0/1 ARE SET AND AROV AND FOV RESET, THIS TEST PASSES.
C12100: JFCL 17,.+1 ;CLEAR FLAGS
MOVNI 0 ;* MOVNI 0 SHOULD SET CRY0/1
JCRY0 .+2 ;PASS IF CRY0 IS SET
STOP
JCRY1 .+2 ;PASS IF CRY1 IS SET
STOP
JOV .+2 ;PASS IF AROV RESET
SKIPA
STOP
JFOV .+2 ;PASS IF FOV RESET
SKIPA
STOP
;**********
;THIS TEST VERIFIES THAT MOVN WILL NOT SET ARITHMETIC FLAGS WHEN THE DATA IS -1,,-1.
;FIRST, THE FLAGS ARE RESET; THEN, MOVN [-1,,-1] IS EXECUTED.
;THE ARITHMETIC FLAGS ARE CHECKED.
;IF ANY ARITHMETIC FLAG IS SET, THIS TEST FAILS.
C12200: JFCL 17,.+1 ;CLEAR FLAGS
MOVN [-1] ;*MOVN [-1,,-1] SHOULD SET ARITHMETIC FLAGS
JFCL 17,.+2 ;FAIL IF AN ARITHMETIC FLAG IS SET
SKIPA ;SKIP HALT INSTRUCTION IF MOVN PASSED.
STOP
;**********
;THIS TEST VERIFIES THAT MOVN WILL SET THE AROV AND
;CRY1 FLAGS ONLY WHEN THE DATA IS 400000,,0
;FIRST, THE FLAGS ARE RESET; THEN, MOVN [400000,,0] IS EXECUTED.
;THE ARITHMETIC FLAGS ARE CHECKED.
;IF AROV AND CRY1 ARE SET AND CRY0 AND FOV ARE RESET, THIS TEST PASSES.
C12300: JFCL 17,.+1 ;CLEAR ARITHMETIC FLAGS
MOVN [XWD 400000,0] ;*MOVN [400000,,0] SHOULD SET AROV AND CRY1 ONLY
JOV .+2 ;PASS IF AROV IS SET
STOP
JCRY1 .+2 ;PASS IF CRY0 IS SET
STOP
JCRY0 .+2 ;PASS IF CRY0 IS RESET
SKIPA
STOP
JFOV .+2 ;PASS IF FOV IS RESET
SKIPA
STOP
;**********
;THIS TEST VERIFIES THAT MOVM WILL SET THE AROV AND
;CRY1 FLAGS ONLY WHEN THE DATA IS 400000,,0
;FIRST, THE FLAGS ARE RESET; THEN, MOVM [400000,,0] IS EXECUTED.
;THE ARITHMETIC FLAGS ARE CHECKED.
;IF AROV AND CRY1 ARE SET AND CRY0 AND FOV ARE RESET, THIS TEST PASSES.
C12301: JFCL 17,.+1 ;CLEAR ARITHMETIC FLAGS
MOVM [XWD 400000,0] ;*MOVM [400000,,0] SHOULD SET AROV AND CRY1 ONLY
JOV .+2 ;PASS IF AROV IS SET
STOP
JCRY1 .+2 ;PASS IF CRY0 IS SET
STOP
JCRY0 .+2 ;PASS IF CRY0 IS RESET
SKIPA
STOP
JFOV .+2 ;PASS IF FOV IS RESET
SKIPA
STOP
;**********
SUBTTL TEST OF AOS AND SOS INSTRUCTIONS
;**********
;THIS TEST VERIFIES THAT AOS ADDS 1 TO MEMORY AND DOES NOT SKIP.
;FIRST, E IS CLEARED; THEN, AOS IS EXECUTED. NEXT E IS CHECKED FOR 1.
;IF C(E) IS NOT 1 OR AOS SKIPPED, THIS TEST FAILS
C12600: SETZ ;CLEAR E
AOS ;*AOS SHOULD ADD 1 TO C(E) AND NOT SKIP
CAIE 1 ;PASS IF C(E)=0,,1 ANDAOS DID NOT SKIP
STOP
;**********
;THIS TEST VERIFIES THAT AOS ADDS 1 TO MEMORY AND DOES NOT SKIP.
;FIRST, E IS PRELOADED WITH -1,,-1; THEN, AOS IS EXECUTED. NEXT E IS CHECKED FOR 0.
;IF C(E) IS NOT 0 OR AOS SKIPPED, THIS TEST FAILS
C12700: SETO ;PRELOAD E WITH -1,,-1
AOS ;*AOS SHOULD ADD 1 TO C(E) AND NOT SKIP
CAIE ;PASS IF C(E)=0,,0 AND AOS DID NOT SKIP
STOP
;**********
;THIS TEST VERIFIES THAT SOS SUBTRACTS 1 FROM MEMORY AND DOES NOT SKIP.
;FIRST, E IS CLEARED; THEN, SOS IS EXECUTED. NEXT E IS CHECKED FOR -1,,-1.
;IF C(E) IS NOT -1,,-1 OR SOS SKIPPED, THIS TEST FAILS
C13100: SETZ ;CLEAR E
SOS ;*SOS SHOULD SUBTRACT 1 FROM C(E) AND NOT SKIP
CAME [-1] ;PASS IF C(E)=-1,,-1 AND SOS DID NOT SKIP
STOP
;**********
;THIS TEST VERIFIES THAT SOS SUBTRACTS 1 FROM MEMORY AND DOES NOT SKIP.
;FIRST, E IS PRELOADED WITH A; THEN, SOS IS EXECUTED. NEXT E IS CHECKED FOR 0.
;IF C(E) IS NOT 0 OR SOS SKIPPED, THIS TEST FAILS
C13200: MOVEI 1 ;PRELOAD E WITH 1
SOS ;*SOS SHOULD SUBTRACT 1 FROM C(E) AND DID NOT SKIP
CAIE 0 ;PASS IF C(E)=0 AND SOS DID NOT SKIP
STOP
;**********
;THIS TEST VERIFIES THAT SOS SETS CRY0/1 FLAGS IF C(E) IS A NON-ZERO NUMBER OTHER
;THAN 400000,,0. IN THIS CASE, C(E)=1. FIRST THE FLAGS ARE RESET; THEN
;SOS IS EXECUTED. THE FLAGS ARE CHECKED. IF CRY0 AND CRY1 ARE SET
;AND AROV AND FOV ARE RESET, THIS TEST PASSES.
C13300: JFCL 17,.+1 ;RESET ARITHMETIC FLAGS
MOVEI 1 ;PRELOAD E WITH 1
SOS ;*SOS SHOULD SET CRY0/1
JCRY0 .+2 ;PASS IF CRY0 IS SET
STOP
JCRY1 .+2 ;PASS IF CRY1 IS SET
STOP
JOV .+2 ;PASS IF AROV IS RESET
SKIPA
STOP
JFOV .+2 ;PASS IF FOV IS RESET
SKIPA
STOP
;**********
;THIS TEST VERIFIES THAT AOS SETS CRY0 AND CRY1 FLAG IF C(E) IS -1,,-1
;FIRST THE FLAGS ARE RESET; THEN
;AOS IS EXECUTED. THE FLAGS ARE CHECKED.
;IF CRY0 AND CRY1 ARE SET AND AROV AND FOV ARE RESET, THIS TEST PASSES.
C13400: JFCL 17,.+1 ;RESET ARITHMETIC FLAGS
SETO ;PRELOAD E WITH 1
AOS ;*AOS SHOULD SET CRY0 AND CRY1
JCRY0 .+2 ;PASS IF CRY0 IS SET
STOP
JCRY1 .+2 ;PASS IF CRY1 IS SET
STOP
JOV .+2 ;PASS IF AROV IS RESET
SKIPA
STOP
JFOV .+2 ;PASS IF FOV IS RESET
SKIPA
STOP
;**********
SUBTTL TEST OF INTERACTION OF JFCL, JRST, AND JSP WITH ARITHMETIC FLAGS
;**********
;THIS TEST VERIFIES THAT JFCL 1, WILL ALWAYS CLEAR FOV FLAG.
;FIRST, FOV IS SET VIA JRST 2, ;THEN JFCL 1,.+1 IS EXECUTED TO CLEAR FOV.
;IF FOV WAS CLEARED, THIS TEST PASSES.
C13600: SFLAG FOV ;SET FOV FLAG
JFCL 1,.+1 ;*JFCL SHOULD RESET FOV
JFCL 1,.+2 ;PASS IF FOV IS RESET
SKIPA ;SKIP HALT IF JFCL 1,.+1 PASSED
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2, CAN SET FXU AND JSP CAN SAVE FXU IN THE AC.
;FIRST, FXU IS SET VIA JRST 2, ;THEN, JSP IS EXECUTED. THE AC IS CHECKED
;FOR FXU. IF FXU IS SET, THIS TEST PASSES; OTHERWISE, EITHER JRST 2, OR JSP FAILED.
C13700: SFLAG FXU ;*SET FXU FLAG
JSP .+1 ;*STORE FXU FLAG IN AC
TLNN FXU ;PASS IF FXU IS SET IN THE AC
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2, CAN RESET FXU AND JSP CAN SAVE FXU IN THE AC.
;FIRST, FXU IS SET; THEN, FXU IS RESET VIA JRST 2,. NEXT, JSP IS EXECUTED; AND
;THE AC IS CHECKED FOR FXU RESET. IF FXU IS RESET IN THE AC, THIS TEST PASSES;
;OTHERWISE, JRST 2, FAILED TO CLEAR FXU OR JSP STORED FXU INCORECTLY.
C14000: SFLAG FXU ;SET FXU FLAG
SFLAG ;*RESET FXU FLAG
JSP .+1 ;*STORE FXU FLAG IN THE AC
TLNE FXU ;PASS IF FXU IS RESET IN THE AC
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2, CAN SET DCK AND JSP CAN SAVE DCK IN THE AC.
;FIRST, DCK IS SET VIA JRST 2, ;THEN JSP IS EXECUTED. THE AC IS CHECKED
;FOR DCK. IF DCK IS SET, THIS TEST PASSES, OTHERWISE JRST 2, OR JSP FAILED.
C14100: SFLAG DCK ;*SET DCK FLAG
JSP .+1 ;*STORE FXU FLAG IN AC
TLNN DCK ;PASS IF FXU IS SET IN THE AC
STOP
;**********
;THIS TEST VERIFIES THAT JRST 2, CAN RESET DCK AND JSP CAN SAVE DCK IN THE AC.
;FIRST, FXU IS SET; THEN, DCK IS RESET VIA JRST 2,. NEXT, JSP IS EXPECTED; AND
;THE AC IS CHECKED FOR DCK RESET. IF DCK IS RESET IN THE AC, THIS TEST PASSES;
;OTHERWISE, JRST 2, FAILED TO CLEAR DCK OR JSP STORED DCK INCORRECTLY.
C14200: SFLAG DCK ;SET DCK FLAG
SFLAG ;*RESET DCK FLAG
JSP .+1 ;*STORE DCK FLAG IN THE AC
TLNE DCK ;PASS IF DCK IS RESET IN THE AC
STOP
;**********
SUBTTL TEST OF JUMPX INSTRUCTIONS
;**********
;THIS TEST VERIFIES THAT JUMPL IS DATA DEPENDENT. IT WILL JUMP IF AND ONLY IF
;C(AC) IS NEGATIVE. IN THIS TEST, THE AC CONTAINS -1,,-1. HENCE,
;JUMPL SHOULD JUMP. IF JUMPL JUMPS, THIS TEST PASSES.
C14500: SETO ;PRELOAD AC WITH -1,,-1
JUMPL .+2 ;*JUMPL SHOULD JUMP BECAUSE C(AC) IS NEGATIVE
STOP
;**********
;THIS TEST VERIFIES THAT JUMPL IS DATA DEPENDENT. IT WILL JUMP IF AND ONLY IF
;C(AC) IS NEGATIVE. IN THIS TEST, THE AC CONTAINS 0. HENCE,
;JUMPL SHOULD NOT JUMP. IF JUMPL DOES NOT JUMP, THIS TEST PASSES.
C14600: SETZ ;PRELOAD AC WITH 0
JUMPL .+2 ;*JUMPL SHOULD NOT JUMP
SKIPA ;PASS IF JUMPL DOES NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT JUMPE IS DATA DEPENDENT. IT WILL JUMP IF AND ONLY IF
;C(AC)=0. IN THIS TEST, THE AC CONTAINS 0. HENCE,
;JUMPE SHOULD JUMP. IF JUMPE JUMPS, THIS TEST PASSES.
C14700: SETZ ;PRELOAD AC WITH 0
JUMPE .+2 ;*JUMPE SHOULD JUMP
STOP
;**********
;THIS TEST VERIFIES THAT JUMPN IS DATA DEPENDENT. IT WILL JUMP IF AND ONLY IF
;C(AC) IS NON-ZERO. IN THIS TEST, THE AC CONTAINS 1. HENCE,
;JUMPN SHOULD JUMP. IF JUMPN JUMPS, THIS TEST PASSES.
C15000: MOVEI 1 ;PRELOAD AC WITH 1
JUMPN .+2 ;*JUMPN SHOULD JUMP
STOP
;**********
;THIS TEST VERIFIES THAT JUMPE IS DATA DEPENDENT. IT WILL JUMP IF AND ONLY IF
;C(AC)=0. IN THIS TEST, THE AC CONTAINS 2. HENCE,
;JUMPL SHOULD NOT JUMP. IF JUMPE DOES NOT JUMP, THIS TEST PASSES.
C15100: MOVEI 2 ;PRELOAD AC WITH 2
JUMPE .+2 ;*JUMPE SHOULD NOT JUMP
SKIPA ;PASS IF JUMPE DID NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT JUMPN IS DATA DEPENDENT. IT WILL JUMP IF AND ONLY IF
;C(AC) IS NON-ZERO. IN THIS TEST, THE AC CONTAINS 0. HENCE,
;JUMPN SHOULD NOT JUMP. IF JUMPN DOES NOT JUMP, THIS TEST PASSES.
C15200: SETZ ;PRELOAD AC WITH 0
JUMPN .+2 ;*JUMPN SHOULD NOT JUMP
SKIPA ;PASS IF JUMPN DID NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT JUMPG IS DATA DEPENDENT. IT WILL JUMP IF AND ONLY IF
;C(AC) IS GREATER THAN 0. IN THIS TEST, THE AC CONTAINS 1. HENCE,
;JUMPG SHOULD JUMP. IF JUMPG JUMPS, THIS TEST PASSES.
C15300: MOVEI 1 ;PRELOAD AC WITH 1
JUMPG .+2 ;*JUMPG SHOULD JUMP
STOP
;**********
;THIS TEST VERIFIES THAT JUMPG IS DATA DEPENDENT. IT WILL JUMP IF AND ONLY IF
;C(AC) IS GREATER THAN 0. IN THIS TEST, THE AC CONTAINS -1,,0. HENCE,
;JUMPG SHOULD NOT JUMP. IF JUMPG DOES NOT JUMP, THIS TEST PASSES.
C15400: MOVSI -1 ;PRELOAD AC WITH -1,,0
JUMPG .+2 ;*JUMPG SHOULD NOT JUMP
SKIPA ;PASS IF JUMPG DID NOT JUMP
STOP
;**********
SUBTTL TEST OF AOJ AND SOJ INSTRUCTIONS
;**********
;THIS TEST VERIFIES THAT AOJ ADDS 1 TO THE AC AND DOES NOT JUMP.
;FIRST, THE AC IS PRELOADED WITH 0; THEN, AOJ IS EXECUTED. NEXT, THE
;AC IS CHECKED FOR 1. IF C(AC) IS NOT 1 OR AOJ SKIPPED, THIS TEST FAILS.
C15500: SETZ ;PRELOAD AC WITH 0
AOJ .+2 ;*AOJ SHOULD ADD 1 TO THE AC AND NOT JUMP
CAIE 1 ;PASS IF C(AC)=1 AND AOJ DID NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT AOJ ADDS 1 TO THE AC AND DOES NOT JUMP.
;FIRST, THE AC IS PRELOADED WITH -1,,-1; THEN, AOJ IS EXECUTED. NEXT, THE
;AC IS CHECKED FOR 0. IF C(AC) IS NOT 0 OR AOJ SKIPPED, THIS TEST FAILS.
C15600: SETO ;PRELOAD AC WITH 0
AOJ .+2 ;*AOJ SHOULD ADD 1 TO THE AC AND NOT JUMP
CAIE 0 ;PASS IF C(AC)=1 AND AOJ DID NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT SOJ SUBTRACTS 1 FROM THE AC AND DOES NOT JUMP.
;FIRST, THE AC IS PRELOADED WITH 0; THEN, SOJ IS EXECUTED. NEXT, THE
;AC IS CHECKED FOR -1,,-1. IF C(AC) IS NOT -1,,-1 OR SOJ SKIPPED, THIS TEST FAILS.
C15700: SETZ ;PRELOAD AC WITH 0
SOJ .+2 ;*SOJ SHOULD SUBTRACT 1 FROM THE AC AND NOT JUMP
CAME [-1] ;PASS IF C(AC)=-1,,-1 AND SOJ DID NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT SOJ SUBTRACTS 1 FROM THE AC AND DOES NOT JUMP.
;FIRST, THE AC IS PRELOADED WITH -1,,-1; THEN, SOJ IS EXECUTED. NEXT, THE
;AC IS CHECKED FOR -1,,-2. IF C(AC) IS NOT -1,,-2 OR SOJ SKIPPED, THIS TEST FAILS.
C16000: SETO ;PRELOAD AC WITH -1,,-1
SOJ .+2 ;*SOJ SHOULD SUBTRACT 1 FROM THE AC AND NOT JUMP
CAME [-2] ;PASS IF C(AC)=-1,,-2 AND SOJ DID NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT SOJ SUBTRACTS 1 FROM THE AC AND DOES NOT JUMP.
;FIRST, THE AC IS PRELOADED WITH 0,,1; THEN, SOJ IS EXECUTED. NEXT, THE
;AC IS CHECKED FOR 0. IF C(AC) IS NOT 0 OR SOJ SKIPPED, THIS TEST FAILS.
C16100: MOVEI 1 ;PRELOAD AC WITH 1
SOJ .+2 ;*SOJ SHOULD SUBTRACT 1 FROM THE AC AND NOT JUMP
CAIE 0 ;PASS IF C(AC)=0 AND SOJ DID NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT SOJ AC, FOLLOWED BY AOJ AC, HAS NO NET EFFECT ON C(AC).
;IN THIS CASE, THE AC IS PRELOADED WITH 0; THEN, SOJ AC, FOLLOWED BY AOJ.
;AC, IS REPEATED 7 TIMES. THE AC IS THEN CHECKED FOR ITS ORIGINAL CONTENTS, 0.
;IF C(AC)=0, THIS TEST PASSES; OTHERWISE AOJ OR SOJ FAILED.
C16200: AC=17
SETZ AC, ;PRELOAD AC WITH 0
REPEAT ^D10,<
SOJ AC,. ;*SOJ SHOULD SUBTRACT 1 FROM THE AC
AOJ AC,. ;*AOJ SHOULD ADD 1 TO THE AC>
SKIPE AC ;PASS IF C(AC) IS UNCHANGED. I.E. C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT SOJ SETS CRY0/1 FLAGS IF C(E) IS A NON-ZERO NUMBER OTHER
;THAN 400000,,0. IN THIS CASE, C(E)=1. FIRST THE FLAGS ARE RESET; THEN
;SOJ IS EXECUTED. THE FLAGS ARE CHECKED. IF CRY0 AND CRY1 ARE SET
;AND AROV AND FOV ARE RESET, THIS TEST PASSES.
C16201: JFCL 17,.+1 ;RESET ARITHMETIC FLAGS
MOVEI 1 ;PRELOAD E WITH 1
SOJ ;*SOJ SHOULD SET CRY0/1
JCRY0 .+2 ;PASS IF CRY0 IS SET
STOP
JCRY1 .+2 ;PASS IF CRY1 IS SET
STOP
JOV .+2 ;PASS IF AROV IS RESET
SKIPA
STOP
JFOV .+2 ;PASS IF FOV IS RESET
SKIPA
STOP
;**********
;THIS TEST VERIFIES THAT AOJ SETS CRY0 AND CRY1 FLAG IF C(E) IS -1,,-1
;FIRST THE FLAGS ARE RESET; THEN
;AOJ IS EXECUTED. THE FLAGS ARE CHECKED.
;IF CRY0 AND CRY1 ARE SET AND AROV AND FOV ARE RESET, THIS TEST PASSES.
C16202: JFCL 17,.+1 ;RESET ARITHMETIC FLAGS
SETO ;PRELOAD E WITH 1
AOJ ;*AOJ SHOULD SET CRY0 AND CRY1
JCRY0 .+2 ;PASS IF CRY0 IS SET
STOP
JCRY1 .+2 ;PASS IF CRY1 IS SET
STOP
JOV .+2 ;PASS IF AROV IS RESET
SKIPA
STOP
JFOV .+2 ;PASS IF FOV IS RESET
SKIPA
STOP
;**********
SUBTTL TEST OF MEMORY, BOTH AND SELF MODE INSTRUCTIONS
;**********
;THIS TEST VERIFIES THAT ADDM DOES NOT MODIFY C(AC)
;BOTH AC AND E ARE PRELOADED WITH -1,,-1. THEN ADDM IS EXECUTED.
;THIS TEST PASSES IF C(AC) ARE UNCHANGED
C16400: SETOB 1 ;PRELOAD AC, E WITH -1,,-1
ADDM 1 ;*ADDM SHOULD NOT AFFECT C(AC)
CAME [-1] ;PASS IF C(AC) IS UNMODIFIED BY ADDM
STOP
;**********
;THIS TEST VERIFIES THAT HRREM DOES NOT MODIFY C(AC)
;THE AC IS PRELOADED WITH 0,,-1. THEN HRRM IS EXECUTED.
;THIS TEST PASSES IF C(AC) ARE UNCHANGED
C16500: MOVEI -1 ;PRELOAD AC WITH 0,,-1
HRREM 1 ;*HRRM SHOULD NOT AFFECT C(AC)
CAIE -1 ;PASS IF C(AC) IS UNMODIFIED BY HRRM
STOP
;**********
;THIS TEST VERIFIES THAT MOVSM DOES NOT MODIFY C(AC)
;THE AC IS PRELOADED WITH 0,,-1. THEN MOVSM IS EXECUTED.
;THIS TEST PASSES IF C(AC) ARE UNCHANGED
C16600: MOVEI -1 ;PRELOAD AC WITH 0,,-1
MOVSM 1 ;*MOVSM SHOULD NOT AFFECT C(AC)
CAIE -1 ;PASS IF C(AC) IS UNMODIFIED BY MOVSM
STOP
;**********
;THIS TEST VERIFIES THAT XORM DOES NOT MODIFY C(AC)
;BOTH AC AND E ARE PRELOADED WITH -1,,-1. THEN XORM IS EXECUTED.
;THIS TEST PASSES IF C(AC) ARE UNCHANGED
C16700: SETOB 1 ;PRELOAD AC, E WITH -1,,-1
XORM 1 ;*XORM SHOULD NOT AFFECT C(AC)
CAME [-1] ;PASS IF C(AC) IS UNMODIFIED BY XORM
STOP
;**********
;THIS TEST VERIFIES THAT ADDB ADDS C(AC) TO C(E) AND PLACES THE
;RESULT IN BOTH AC AND E. IN THIS TEST, BOTH AC AND E ARE PRELOADED
;WITH -1,,-1, THEN, ADDB IS EXECUTED. C(AC) IS THEN COMPARED TO C(E);
;AND C(AC) IS THEN COMPARED TO -2. IF BOTH OF THESE COMPARISONS SUCCEED, THIS
;TEST PASSES; OTHERWISE, ADDB FAILED
C17000: SETOB 1 ;PRELOAD AC, E WITH -1,,-1
ADDB 1 ;*ADDB SHOULD ADD C(AC) TO C(E) AND PLACE RESULT
;INTO BOTH AC AND E
CAME 1 ;PASS IF C(AC)=C(E)
STOP
CAME [-2] ;PASS IF C(AC)=-2
STOP
;**********
;THIS TEST VERIFIES THAT ADDM ADDS C(AC) TO C(E) AND PLACES THE RESULT IN E
;IN THIS CASE, AC, E ARE BOTH PRELOADED WITH -1; THEN, ADDM IS EXECUTED.
;E IS THEN CHECKED FOR -2. IF C(E)=-2, THIS TEST PASSES; OTHERWISE, ADDM FAILED
C17100: SETOB 1 ;PRELOAD AC, E WITH -1,,-1
ADDM 1 ;*ADDM SHOULD ADD C(AC) TO C(E)
CAME 1,[-2] ;PASS IF C(E)=-2
STOP
;**********
;THIS TEST VERIFIES THAT HLLOS PLACES ONES ON THE RIGHT HALF OF E
;BUT DOES NOT AFFECT THE LEFT HALF OF E. IN THIS CASE,
;E IS PRELOADED WITH 0; THE, HLLOS IS EXECUTED. THE RESULT
;IN E SHOULD BE 0,,-1. IF C(E)=0,,-1, THIS TEST PASSES
C17200: SETZM 1 ;PRELOAD E WITH 0
HLLOS 1 ;*HLLOS SHOULD PLACE 0,,-1 INTO E
CAIE 1,-1 ;PASS IF C(E)=0,,-1
STOP
;**********
;THIS TEST VERIFIES THAT MOVSS SWAPS BOTHS HALVES OF E AND
;PLACES THE RESULT IN E. IN THIS CASE, E IS PRELOADED WITH
;-1,,0; THEN, MOVSS IS EXECUTED. THE RESULT IN E SHOULD BE 0,,-1.
;IF C(E)=0,,-1, THIS TEST PASSES
C17300: MOVSI 1,-1 ;PRELOAD E WITH -1,,0
MOVSS 1 ;*MOVSS SHOULD PLACE 0,,-1 INTO E
CAIE 1,-1 ;PASS IF C(E)=0,,-1
STOP
;**********
;THIS TEST VERIFIES THAT AOS ADDS ONE TO MEMORY BUT DOES NOT SKIP
;FIRST, E IS PRELOADED WITH -1,-1; THEN, AOS IS EXECUTED. NEXT, E IS CHECKED FOR 0.
;IF C(E) IS NOT 0 OR AOS SKIPPED, THIS TEST FAILS
C17400: SETOB 1 ;PRELOAD E WITH -1,,-1
AOS 1 ;*AOS SHOULD ADD TO C(E) AND NOT SKIP
CAIE 1,0 ;PASS IF C(E)=0,,0 AND AOS DID NOT SKIP
STOP
;**********
;THIS TEST VERIFIES THAT HRLM PLACES C(AC-RIGHT) INTO E-LEFT AND DOES
;NOT MODIFY E-RIGHT. IN THIS CASE, AC IS PRELOADED WITH 0 AND E IS PRELOADED
;WITH -1,,-1. THEN, HRLM IS EXECUTED. E IS THEN CHECKED FOR 0,,-1. IF
;C(E)=0,,-1, THIS TEST PASSES
C17500: SETZ ;PRELOAD AC WITH 0
SETO 1, ;PRELOAD E WITH -1,,-1
HRLM 1 ;*HRLM SHOULD PLACE 0,,-1 INTO E
CAIE 1,-1 ;PASS IF C(E)=0,,-1
STOP
;**********
;THIS TEST VERIFIES THAT HRRS DOES NOT MODIFY E
;E IS PRELOADED WITH 0 AND AC IS PRELOADED WITH -1,,-1.
;HRRS IS EXECUTED; THEN E IS CHECKED. IF C(E) DOES
;NOT CHANGE, THIS TEST PASSES
C17600: SETO ;PRELOAD AC WITH -1,,-1
SETZ 1, ;PRELOAD E WITH 0,,0
HRRS 1 ;*HRRS SHOULD PLACE 0,,0 INTO E
SKIPE 1
STOP
;**********
;THIS TEST VERIFIES THAT HRRZM PLACES C(AC-RIGHT) INTO E-RIGHT AND PLACES
;ZEROS INTO E-LEFT. IN THIS CASE, AC=E=AC1 AND C(AC)=C(E)=-1,,0. HRRZM
;IS EXECUTED AND AC1 IS CHECKED FOR 0. IF AC1=0, THIS TEST PASSES.
C17700: SETO ;PRELOAD AC0 WITH -1,,-1
MOVSI 1,-1 ;PRELOAD AC1 WITH -1,,0
HRRZM 1,1 ;*HRRZM SHOULD PLACE 0 INTO AC1
SKIPE 1 ;PASS IF C(AC1)=0
STOP
;**********
;THIS TEST VERIFIES THAT JFCL 17,.+1 NEVER JUMPS AND DOES NOT MODIFY C(AC0).
;FIRST, AC0 IS PRELOADED; THEN, JFCL IS EXECUTED. IF AC0 IS MODIFIED
;OR JFCL SKIPS, THIS TEST FAILS
C20000: SETZ ;CLEAR AC0
JFCL 17,.+1 ;*JFCL SHOULD NOT JUMP OR MODIFY C(AC0).
SKIPE ;PASS IF C(AC0)=0 AND JFCL DID NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT XORM PERFORMS THE LOGICAL EXCLUSIVE OR FUNCTION
;BETWEEN C(AC) AND C(E) AND PLACES THE RESULT INTO E
;IN THIS CASE, AC AND E ARE PRELOADED WITH -1,,-1; THEN, XORM IS
;EXECUTED. IF THE RESULT IN E IS 0, THE TEST PASSES
C20100: SETOB 1 ;PRELOAD AC,E WITH -1,,-1
XORM 1 ;*XORM SHOULD PLACE 0 INTO E
CAIE 1,0 ;PASS IF C(E)=0
STOP
;**********
;THIS TEST VERIFIES THAT SETZB PLACES ZEROS INTO BOTH AC AND E.
;AFTER SETZB IS EXECUTED, BOTH AC AND E ARE CHECKED
;FOR 0. IF EITHER AC OR E CONTAINS ANY ONES, THIS TEST FAILS
C20200: SETZB 1 ;*SETZB SHOULD PLACE ZEROES IN BOTH AC AND E
CAMN [0] ;FAIL IF C(AC) IS NON-ZERO
CAME 1 ;FAIL IF C(E) IS NON-ZERO
STOP
;**********
;THIS TEST VERIFIES THAT SETAB PLACES C(AC) INTO BOTH AC AND E.
;FIRST, AC IS PRELOADED WITH -1,,-1 AND E IS PRELOADED WITH 0;
;THEN, SETAB IS EXECUTED. BOTH AC AND E ARE CHECKED FOR -1,,-1
;IF EITHER AC OR E CONTAIN ANY ZEROS, THIS TEST FAILS.
C20300: SETZ 1, ;PRELOAD E WITH 0
SETO ;PRELOAD AC WITH -1,,-1
SETAB 1 ;*SETAB SHOULD PLACE -1,,-1 INTO BOTH AC AND E
CAMN [-1] ;FAIL IF C(AC) IS NOT -1,-1
CAME 1 ;FAIL IF C(E) IS NOT -1,,-1
STOP
;**********
SUBTTL XCT INSTRUCTION - BASIC TESTS
;**********
;THIS TEST VERIFIES THAT XCT WILL EXECUTE THE INSTRUCTION SPECIFIED BY C(E)
;IN THIS CASE, C(E) SPECIFIES A MOVEI INSTRUCTION
;AFTER EXECUTING MOVEI, CONTROL SHOULD RETURN TO
;THE NEXT SEQUENTIAL INSTRUCTION FOLLOWING XCT.
;THIS TEST PASSES IF CONTROL RETURNS TO THE NEXT SEQUENTIAL INSTRUCTION FOLLOWING XCT
C20400: SETZB 1 ;CLEAR AC0 AND AC1
XCT [MOVEI 1,.+2] ;*XCT SHOULD RETURN CONTROL TO NEXT INSTRUCTION
SKIPA
STOP
;**********
;THIS TEST VERIFIES THAT XCT WILL EXECUTE THE INSTRUCTION SPECIFIED BY C(E)
;IN THIS CASE, C(E) SPECIFIES A MOVEI INSTRUCTION.
;AFTER EXECUTING MOVEI, THE AC SPECIFIED BY MOVEI IS CHECKED FOR
;0,,1 (THE EXPECTED RESULT). IF C(AC)=0,,1, THIS TEST PASSES
C20500: SETZB 1 ;CLEAR AC
XCT [MOVEI 1,1] ;*XCT OF MOVEI SHOULD PLACE 1 IN THE AC
CAIE 1,1 ;PASS IF C(AC)=1
STOP
;**********
;THIS TEST VERIFIES THAT A NEST OF XCT INSTRUCTIONS WILL EXECUTE
;THE INSTRUCTION SPECIFIED BY THE MOST NESTED XCT AND RETURN CONTROL TO
;THE NEXT SEQUENTIAL INSTRUCTION FOLLOWING THE FIRST XCT.
;IN THIS CASE, THE EXECUTED INSTRUCTION IS MOVEI. AFTER EXECUTING THE MOVEI,
;C(AC) IS CHECKED FOR 0,,-1 (THE EXPECTED RESULT). IF C(AC)=0,,-1, THIS TEST PASSES
C20600: SETZB 1 ;CLEAR AC
XCT [XCT[XCT[XCT[XCT[MOVEI 1,-1]]]]] ;*NESTED XCT OF MOVEI
;SHOULD PLACE 0,,-1 INTO AC
CAIE 1,-1 ;PASS IF C(AC)=0,,-1
STOP
;**********
;THIS TEST VERIFIES THAT XCT WILL NOT MODIFY AN AC WHICH IS NOT SPECIFIED BY THE
;EXECUTED INSTRUCTION. IN THIS CASE, AC0 IS CLEARED AND THEN CHECKED FOR ZERO AFTER
;THE XCT INSTRUCTION IS EXECUTED. AC0 SHOULD NOT BE MODIFIED.
C20700: SETZB 1 ;CLEAR AC0,AC1
XCT [MOVE 1,[-1]] ;*XCT SHOULD NOT MODIFY AC0
SKIPE ;PASS IF AC0 WAS NOT MODIFIED
STOP
;**********
;THIS TEST VERIFIES THAT XCT OF SKIPA SHOULD RETURN CONTROL TO THE
;SECOND SEQUENTIAL INSTRUCTION FOLLOWING XCT
C21000: XCT [SKIPA] ;XCT OF SKIPA SHOULD RETURN CONTROL TO .+2
STOP
;**********
SUBTTL INDIRECT ADDRESSING - BASIC TESTS
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN BOTH E AND @E
;ARE WITHIN THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A MOVE.
;AFTER MOVE IS EXECUTED, C(AC) IS CHECKED FOR 0,
;THE INITIAL CONTENTS OF THE INDIRECT ADDRESS
C21100: SETOM 1 ;PRELOAD AC WITH -1,,-1
MOVEI 7,3 ;SETUP DIRECT ADDRESS WITH INDIRECT ADDRESS
SETZM 3 ;PRELOAD INDIRECT ADDRESS WITH 0
MOVE 1,@7 ;*FWT FROM INDIRECT ADDRESSS SHOULD
;PLACE 0 INTO THE AC
SKIPE 1 ;PASS IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN BOTH E AND @E
;ARE WITHIN THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A MOVE.
;AFTER MOVE IS EXECUTED, C(AC) IS CHECKED FOR -1,,-1,
;THE INITIAL CONTENTS OF THE INDIRECT ADDRESS
C21200: SETZM 1 ;PRELOAD AC WITH -1,,-1
MOVEI 7,3 ;SETUP DIRECT ADDRESS WITH INDIRECT ADDRESS
SETOM 3 ;PRELOAD INDIRECT ADDRESS WITH -1,,-1
MOVE 1,@7 ;*FWT FROM INDIRECT ADDRESS SHOULD
;PLACE -1,,-1 INTO THE AC
CAME 1,[-1,,-1] ;PASS IF C(AC)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN BOTH E AND @E
;ARE WITHIN THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A MOVE.
;AFTER MOVE IS EXECUTED, C(AC) IS CHECKED FOR 707070,,707070,
;THE INITIAL CONTENTS OF THE INDIRECT ADDRESS
C21300: SETZM 1 ;PRELOAD AC WITH 0
MOVEI 7,3 ;SETUP DIRECT ADDRESS WITH INDIRECT ADDRESS
MOVE 3,[707070,,707070] ;PRELOAD INDIRECT ADDRESS WITH 707070,,707070
MOVE 1,@7 ;*FWT FROM INDIRECT ADDRESS SHOULD
;PLACE 707070,,707070 INTO THE AC
CAME 1,[707070,,707070] ;PASS IF C(AC)=707070,,707070
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN E IS WITHIN THE AC RANGE
;AND @E IS BEYOND THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A MOVE.
;AFTER MOVE IS EXECUTED, C(AC) IS CHECKED FOR 707070,,707070,
;THE INITIAL CONTENTS OF THE INDIRECT ADDRESS
C21400: JRST .+2
XWD 707070,707070 ;INDIRECT ADDRESS AND ITS DATA
SETZM 1 ;PRELOAD AC WITH 0
MOVEI 7,C21400+1 ;SETUP DIRECT ADDRESS WITH INDIRECT ADDRESS
MOVE 1,@7 ;*FWT FROM INDIRECT ADDRESS SHOULD
;PLACE 707070,,707070 INTO AC
CAME 1,C21400+1 ;PASS IF C(AC)=707070,,707070
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN BOTH E AND @E
;ARE BEYOND THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A MOVE.
;AFTER MOVE IS EXECUTED, C(AC) IS CHECKED FOR 202020,,202020,
;THE INITIAL CONTENTS OF THE INDIRECT ADDRESS
C21500: JRST .+3
.+1 ;DIRECT ADDRESS AND ITS DATA
XWD 202020,202020 ;INDIRECT ADDRESS AND ITS DATA
SETZM 1 ;PRELOAD AC WITH 0
MOVE 1,@C21500+1 ;*FWT FROM INDIRECT ADDRESS SHOULD
;PLACE 202020,,202020 INTO AC
CAME 1,C21500+2 ;PASS IF C(AC)=202020,,202020
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN BOTH E AND @E
;ARE BEYOND THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A CAME.
C21600: JRST .+3
.+1 ;DIRECT ADDRESS AND ITS DATA
XWD 272727,272727 ;INDIRECT ADDRESS AND ITS DATA
MOVE 1,C21600+2 ;PRELOAD AC
CAME 1,@C21600+1 ;*CAME OF DATA FROM INDIRECT ADDRESS - NON-AC RANGE
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN E IS WITHIN THE AC RANGE
;AND @E IS BEYOND THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A CAME.
C21700: JRST .+2
XWD 252525,252525 ;INDIRECT ADDRESS AND ITS DATA
MOVEI 7,C21700+1 ;SETUP DIRECT ADDRESS WITH INDIRECT ADDRESS
MOVE 1,C21700+1 ;SETUP AC
CAME 1,@7 ;*CAME IF DATA FROM INDIRECT ADDRESS - AC RANGE
STOP
;**********
SUBTTL TEST INDIRECT ADDRESSING WITH INDEXING
;SETUP INDEX REGISTERS
MOVEI 1,-4
MOVEI 3,2
MOVEI 4,10
MOVEI 5,1
MOVEI 6,5
MOVEI 7,7
MOVEI 10,4
MOVEI 11,-6
MOVEI 12,5
MOVEI 13,2
JRST C22000 ;RESUME TEST
;INDIRECT ADDRESSING/INDEXING TEST TABLE
;;;;;;;;;;; ;;;;;;;;;; ;;;;;;;;;;
;DO NOT MODIFY THIS TABLE OR TESTS C21700 THRU C22600 INDEPENDENTLY !
;;;;;;;;;; ;;;;;;;;;; ;;;;;;;;;;
E217: E217A(3)
E220: @E220A
E220B: 220220,,220220
E217A: @E221A ;E221-4
E221B: 221221,,221221
E222A: 217217,,217217 ;E217A+2
E220A: E220B
E221: E221
E221A: E221B
E222: E221
E223A: 223223,,223223
E224A: E224A(4) ;E223-6
222222,,222222 ;E222A+7
E225: E225
E222A(7) ;E222+5
@E225A ;E225+2
E225B: 225225,,225225
E223: E223
E225A: E225B
224224,,224224 ;E224A+10
E226B: 226226,,226226
E223A ;E223+4
E226A: @E226A(5) ;E223+5
E226B ;E226A+1
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E217 IS TESTED WHERE C(E217)=E217A(3) AND C(3)=0,,2.
;HENCE, THE RESULT IN THE AC SHOULD BE C(E217A+2)=217217,,217217
C22000: SETOM 2 ;INITIALIZE AC
MOVE 2,@E217 ;TEST INDIRECT ADDRESSING WITH INDEXING
CAME 2,E217A+2 ;PASS IF C(AC)=217217,,217217
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E220 IS TESTED WHERE C(E220)=@E220A AND C(E220A)=E220B.
;HENCE, THE RESULT IN THE AC SHOULD BE C(E220B)=220220,,220220
C22100: SETZM 2 ;INITIALIZE AC
MOVE 2,@E220 ;TEST INDIRECT ADDRESSING WITH INDEXING
CAME 2,E220B ;PASS IF C(AC)=220220,,220220
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE,E221(1) 2,@E217 IS TESTED WHERE C(1)=-4 AND E221-4=E217A
;HENCE, THE RESULT IN THE AC SHOULD BE C(E217A)=@E221A=20,,E221A
C22200: SETOM 2 ;INITIALIZE AC
MOVE 2,E221(1) ;TEST INDIRECT ADDRESSING WITH INDEXING
CAME 2,E217A ;PASS IF C(AC)=@E221A=20,,E221A
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,E222(6) IS TESTED WHERE C(6)=5
;HENCE, THE RESULT IN THE AC SHOULD BE C(E222+5)=E222A(7)=7,,E222A
C22300: SETZM 2 ;INITIALIZE AC
MOVE 2,E222(6) ;TEST INDIRECT ADDRESSING WITH INDEXING
CAME 2,E222+5 ;PASS IF C(AC)=E222A(7)=7,,E222A
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E223(10) IS TESTED WHERE C(10)=4 AND C(E223+4)=E223A
;HENCE, THE RESULT IN THE AC SHOULD BE C(E223A)=223223,,223223
C22400: SETOM 2 ;INITIALIZE AC
MOVE 2,@E223(10) ;TEST INDIRECT ADDRESSING WITH INDEXING
CAME 2,E223A ;PASS IF C(AC)=223223,,223223
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E223(11) IS TESTED WHERE C(11)=-6, C(E223-6)=E224A(4) AND C(4)=10
;HENCE, THE RESULT IN THE AC SHOULD BE C(E224A+10)=224224,,224224
C22500: SETZM 2 ;INITIALIZE AC
MOVE 2,@E223(11) ;TEST INDIRECT ADDRESSING WITH INDEXING
CAME 2,E224A+10 ;PASS IF C(AC)=224224,,224224
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E225(13) IS TESTED WHERE C(13)=2, C(E225+2)=@E225A
;AND C(E225A)=E225B
;HENCE, THE RESULT IN THE AC SHOULD BE C(E225B)=225225,,225225
C22600: SETOM 2 ;INITIALIZE AC
MOVE 2,@E225(13) ;TEST INDIRECT ADDRESSING WITH INDEXING
CAME 2,E225B ;PASS IF C(AC)=225225,,225225
STOP
;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E223(12) IS TESTED WHERE C(12)=5, C(E223+5)=@E226A(5),
;C(5)=1 AND C(E226A+1)=E226B
;HENCE, THE RESULT IN THE AC SHOULD BE C(E226B)=226226,,226226
C22700: SETZM 2 ;INITIALIZE AC
MOVE 2,@E223(12) ;TEST INDIRECT ADDRESSING WITH INDEXING
CAME 2,E226B ;PASS IF C(AC)=226226,,226226
STOP
;**********
JRST BEGEND