PCjs Machines
Home of the original IBM PC emulator for browsers.
DEC PDP-10 KA10 Basic Instruction Diagnostic #4
The PDP-10 KA10 Basic Instruction Diagnostic #4 (MAINDEC-10-DAKAD) test code has been extracted from DAKADM.MAC [original] for use with the PDP-10 Test Machine with Debugger below.
This diagnostic “TESTS REGISTER ADDRESSING, JFCL, AR FLAGS, AOS, SOS, JRST, AOBJX, JSP, XCT, INDIRECT AND INDEXED ADDRESSING.”
Resources for this diagnostic include:
[PCjs Machine "testka10"]
Waiting for machine "testka10" to load....
The Debugger’s assemble (“a”) command can be used to test the new built-in MACRO-10 Mini-Assembler, which supports a subset of the MACRO-10 assembly language.
This command:
a 30724 DAKAD.MAC
will automatically read the DAKAD.MAC source file (a slightly modified copy of DAKADM.MAC),
assemble it, and then load the binary output at the specified address. Use the command db 30724 to dump the first few words
of binary data:
030724: 254000 030741 053 000 000 061 160 +..1p
030725: 064252 042240 015 012 120 104 120 ..PDP
030726: 265426 020226 055 061 060 040 113 -10 K
030727: 405426 020204 101 061 060 040 102 A10 B
030730: 406471 141500 101 123 111 103 040 ASIC
030731: 446352 352244 111 116 123 124 122 INSTR
030732: 526072 444636 125 103 124 111 117 UCTIO
030733: 471010 444602 116 040 104 111 101 N DIA
030734: 436351 751650 107 116 117 123 124 GNOST
030735: 446064 024150 111 103 040 050 064 IC (4
030736: 245013 342202 051 040 133 104 101 ) [DA
030737: 456030 456432 113 101 104 135 015 KAD].
DAKAD.TXT
MAINDEC-10-DAKAD.TXT
IDENTIFICATION
--------------
PRODUCT CODE: MAINDEC-10-DAKAD-B-D
PRODUCT NAME: DECSYSTEM10 PDP-10 KA10 BASIC
INSTRUCTION DIAGNOSTIC (4)
FUNCTION: REGISTER ADDRESSING, PC CHANGE, XCT
VERSION: 0.2
DATE RELEASED: JANUARY 1977
MAINTAINED BY: DIAGNOSTIC ENGINEERING GROUP
AUTHOR: JOHN R. KIRCHOFF
COPYRIGHT(C) 1976,1977
DIGITAL EQUIPMENT CORPORATION
MARLBORO, MASS. 01752
THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY
ON A SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH
THE INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE,
OR ANY OTHER COPIES THEREOF, MAY NOT BE PROVIDED OR OTHERWISE
MADE AVAILABLE TO ANY OTHER PERSON EXECPT FOR USE ON SUCH SYSTEM
AND TO ONE WHO AGREES TO THESE LICENSE TERMS. TITLE TO AND
OWNERSHIP OF THE SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC.
THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE WITHOUT
NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL
EQUIPMENT CORPORATION.
DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS
SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC.
MAINDEC-10-DAKAD.TXT
PAGE 2
TABLE OF CONTENTS
-----------------
1.0 ABSTRACT
2.0 REQUIREMENTS
2.1 EQUIPMENT
2.2 STORAGE
2.3 PRELIMINARY PROGRAMS
3.0 PROGRAM PROCEDURES
3.1 LOADING PROCEDURE
3.2 STARTING PROCEDURE
3.3 OPERATING PROCEDURE
4.0 ERRORS
5.0 ITERATION COUNTER
6.0 CYCLE TIME
7.0 OPERATIONAL VARIATIONS
8.0 MISCELLANEOUS
9.0 LISTING
MAINDEC-10-DAKAD.TXT
PAGE 3
1.0 ABSTRACT
THIS PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC IS THE
FOURTH IN A SERIES OF PDP-10 KA10 PROCESSOR DIAGNOSTICS.
THE DIAGNOSTIC TESTS REGISTER ADDRESSING, JFCL, AR FLAGS,
AOS, SOS, JRST, AOBJX, JSP, XCT, INDIRECT AND
INDEXED ADDRESSING.
2.0 REQUIREMENTS
2.1 EQUIPMENT
A PDP-10 KA10 WITH A MINIMUM OF 32K OF MEMORY
PAPER-TAPE READER
DECTAPE (OPTIONAL)
CONSOLE TELETYPE
2.2 STORAGE
THE PROGRAM RUNS WITHIN 32K OF MEMORY.
2.3 PRELIMINARY PROGRAMS
CONSOLE FUNCTIONS WORKING PROPERLY
PAPER-TAPE OR DECTAPE READ-IN WORKING PROPERLY
PREVIOUS PROCESSOR DIAGNOSTICS
MAINDEC-10-DAKAD.TXT
PAGE 4
3.0 PROGRAM PROCEDURES
3.1 LOADING PROCEDURE
PAPER TAPE - HARDWARE READ-IN (READER DEVICE CODE 104)
DECTAPE - LOAD WITH DIAMON (DECTAPE DEVICE CODE 320)
3.2 STARTING PROCEDURE
STAND-ALONE STARTING ADDRESS IS 30000.
IF THE DIAGNOSTIC FAILS TO START CORRECTLY TRY STARTING AT THE
FIRST TEST INSTEAD OF AT THE BEGINNING OF THE CONTROL SEQUENCE.
(SEE LISTING).
3.3 OPERATING PROCEDURE
ONCE STARTED THE PROGRAM WILL CYCLE CONTINUALLY UNTIL STOPPED
OR AN ERROR OCCURS.
4.0 ERRORS
ERRORS ARE IN THE FORM OF HALT INSTRUCTIONS. THE LISTING
SHOULD BE CONSULTED TO DETERMINE THE CAUSE OF THE ERROR. A
NO OPERATION (JUMP) INSTRUCTION FOLLOWS EACH HALT. THIS
MAY BE USEFUL IN CONSTRUCTING A SCOPE LOOP TO CYCLE ON THE
FAILING INSTRUCTION.
5.0 ITERATION COUNTER
THE ITERATION COUNT OF THE PROGRAM IS DISPLAYED IN THE MEM-
ORY INDICATORS (MI). THIS COUNT IS A DECREMENTING COUNT AND
INITIALLY STARTS AT -1 IN STAND-ALONE OPERATION.
6.0 CYCLE TIME
THE CYCLE TIME OF THE PROGRAM IS IN THE MILLISECOND RANGE AND
IS THEREFORE SUITABLE FOR TAKING MARGINS, VIBRATION TESTS, ETC.
MAINDEC-10-DAKAD.TXT
PAGE 5
7.0 OPERATIONAL VARIATIONS
A. DIAGNOSTIC MONITOR
THE PROGRAM IS USABLE WITH THE DIAGNOSTIC MONITOR TO PRO-
VIDE RELIABILITY TESTS, ACCEPTANCE TESTS, AND/OR TO PRO-
VIDE A QUICK METHOD OF ISOLATION OF A FAULT TO A PARTICULAR
AREA OF THE PROCESSOR. CERTAIN PROCEDURES ARE USED WHEN
THE PROGRAM IS USED IN THIS MANNER. THEY ARE:
1. THE DIAGNOSTIC MONITOR TRANSFERS CONTROL TO THE PRO-
GRAM AND STARTS IT AT LOCATION 30002.
2. MONCTL - LOCATION 30043 IS USED AS THE DIAGNOSTIC MON-
ITOR CONTROL FLAG WORD.
B. USER MODE
THE PROGRAM WILL OPERATE IN USER MODE AND AS SUCH PROVIDES
ASSURANCE THAT THE PROCESSOR IS PERFORMING ALL FUNCTIONS
CORRECTLY. USER MODE STARTING ADDRESS IS 30000.
C. SYSTEM EXERCISER
STARTING ADDRESS IS 30003. NO DATA SWITCHES ARE USED BY
THIS PROGRAM.
8.0 MISCELLANEOUS
NONE
9.0 LISTING
DAKAD.HST
THIS IS A HISTORY OF THE DEVELOPMENT OF MAINDEC-10-DAKAD
************************************************************************
PRODUCT CODE: MAINDEC-10-DAKAD
PRODUCT NAME: BASIC INSTRUCTION DIAGNOSTIC #4
DATE RELEASED: JANUARY 1977
VERSION: 0.2
UPDATE AUTHOR: JOHN R. KIRCHOFF
CHANGES MADE:
1. UPGRADE TO ALLOW COMPATABILITY WITH THE SUBROUTINE PACKAGE.
************************************************************************
ORIGINAL VERSION: 0.1
ORIGINAL AUTHOR: RICHARD MALISKA
ORIGINAL RELEASE: 16-MAR-72
************************************************************************
DAKAD.MAC
[Download]
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