PCjs Machines
Home of the original IBM PC emulator for browsers.
DEC PDP-10 KA10 Basic Instruction Diagnostic #1
The PDP-10 KA10 Basic Instruction Diagnostic #1 (MAINDEC-10-DAKAA) test code has been extracted from DAKAAM.MAC [original] for use with the PDP-10 Test Machine with Debugger below.
This diagnostic “IS THE FIRST IN A SERIES OF PDP-10 KA10 PROCESSOR DIAGNOSTICS. IT IS THE MOST BASIC OF THE PROCESSOR DIAGNOSTICS. THIS DIAGNOSTIC ASSUMES THE HALT INSTRUCTION AND THE COMPUTER CONSOLE TO BE OPERATIVE. IT MAKES NO FURTHER ASSUMPTIONS EXCEPT THAT IT IS LOADED INTO MEMORY CORRECTLY.”
Resources for this test 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 DAKAA.MAC
will automatically read the DAKAA.MAC source file (a slightly modified copy of DAKAAM.MAC), assemble it, and then load the binary output at the specified address.
DAKAA.TXT
MAINDEC-10-DAKAA
IDENTIFICATION
--------------
PRODUCT CODE: MAINDEC-10-DAKAA-B-D
PRODUCT NAME: DECSYSTEM10 PDP-10 KA10 BASIC
INSTRUCTION DIAGNOSTIC (1)
FUNCTION: BASIC INSTRUCTIONS
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-DAKAA.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-DAKAA.TXT
PAGE 3
1.0 ABSTRACT
THIS PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC IS THE FIRST IN A
SERIES OF PDP-10 KA10 PROCESSOR DIAGNOSTICS. IT IS THE MOST
BASIC OF THE PROCESSOR DIAGNOSTICS. THIS DIAGNOSTIC
ASSUMES THE HALT INSTRUCTION AND THE COMPUTER CONSOLE
TO BE OPERATIVE. IT MAKES NO FURTHER ASSUMPTIONS EXCEPT
THAT IT IS LOADED INTO MEMORY CORRECTLY.
THE DIAGNOSTIC TESTS SOME OF THE MOVE AND SKIP INSTRUCTIONS.
IT ALSO TESTS THE ADDERS AND OTHER LOGIC WITH AND, XOR, EQV,
AND ALL BOOLE INSTRUCTIONS.
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
MAINDEC-10-DAKAA.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-DAKAA.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
DAKAA.HST
THIS IS A HISTORY OF THE DEVELOPMENT OF MAINDEC-10-DAKAA
************************************************************************
PRODUCT CODE: MAINDEC-10-DAKAA
PRODUCT NAME: BASIC INSTRUCTION DIAGNOSTIC #1
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
************************************************************************
DAKAA.MAC
[Download]
;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>
SUBTTL DIAGNOSTIC SECTION
START: ;SETZM USER# ;CLEAR USER CONTROL WORD
;JSP 0,.+1 ;GET FLAGS
;TLNE USERF ;IN USER MODE?
;SETOM USER ;YES, SET USER CONTROL WORD
;SKIPN MONFLG ;SPECIAL USER MODE?
;SETZM USER ;YES, CLEAR USER CONTROL WORD
;SKIPN USER
;JRST STARTA
;SKIPL MONCTL
;TTCALL 3,PGMNAM ;MENTION OUR NAME
JRST STARTA
PGMNAM: ASCIZ/
PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) [DAKAA]
/
;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
SUBTTL TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS
;NOTE: AN "*" IN THE COMMENT FIELD OF AN INSTRUCTION INDICATES THAT IT IS THE TESTED
;INSTRUCTION.
;**********
;THIS TEST VERIFIES THAT SKIPA ALWAYS SKIPS THE NEXT INSTRUCTION
A00=.
A12500: SKIPA ;*SKIPA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION
HALT ;IF PROGRAM HALTS, SKIPA DID NOT SKIP
;IF PROGRAM HANGS UP ON SKIPA INSTRUCTION, CHECK AB PC EN [ABC], AB PC F/F [ABC],
;AB PC B [ABC OR AB], AB PC (FETCH) EN [ABC], IR SKIPS [IR3], IR SKIPX [IR1],
;IR 3XX [IR1], IR BITS 00 - 08 [IR1], F CYC ACT EN C [FI], FT6 F/F [F2],
;PC CLOCK EN [PCC], ET2 J F/F [E], PC CLK (ET2) EN [PCC], ADZ COND P [ADZ] AND
;ADZ COND R [ADZ], PC CLOCK A [PCC], PC CLOCK B [PCC]
;IF PROGRAM HALTED ON HALT INSTRUCTION, CHECK ST1 COND [ST2]
;**********
;THIS TEST VERIFIES THAT JUMP NEVER JUMPS
A15000: JUMP .+1 ;*JUMP SHOULD NEVER JUMP
SKIPA ;SKIP HALT INSTRUCTION IF JUMP IS SUCCESSFUL
HALT ;HALT IF JUMP FAILS
;IF PROGRAM HANGS UP ON JUMP .+1 INSTRUCTION, THE JUMP INSTRUCTION
;MAY HAVE FAILED. CHECK ST1 COND [ST2], ST INST FET ST1 EN [ST2], ET2 D F/F [E],
;IR JUMPS [IR1], IR JUMPX [IR1]
;**********
;THIS TEST VERIFIES THAT JUMP NEVER JUMPS
A15100: JUMP .+2 ;*JUMP SHOULD NEVER JUMP
SKIPA ;SKIP HALT INSTRUCTION IF JUMP IS SUCCESSFUL
HALT ;HALT IF JUMP FAILS
;AB PC EN [ABC]
;**********
;THIS TEST VERIFIES THAT JUMPA .+1 ALWAYS JUMPS TO THE NEXT INSTRUCTION
A12700: JUMPA .+1 ;*JUMPA .+1 SHOULD NEVER JUMP
SKIPA ;SKIP HALT INSTRUCTION IF JUMPA IS SUCCESSFUL
HALT ;HALT IF JUMPA .+1 FAILED
;**********
;THIS TEST VERIFIES THAT JUMPA JUMPS TO THE LOCATION SPECIFIED BY E WHEN E=.+2
A12600: JUMPA .+2 ;*JUMPA .+2 SHOULD ALWAYS SKIP THE NEXT INSTRUCTION
HALT ;PROGRAM HALTS HERE IF JUMPA .+2 FAILS
;ST1 COND [ST2]
;**********
;THIS TEST VERIFIES THAT SKIPA IS DATA INDEPENDENT. HENCE, IT ALWAYS SKIPS THE NEXT
;INSTRUCTION.
;THE MOVE [0] INSTRUCTION IS USED TO TEST THE DATA INDEPENDENCE OF SKIPA.
A100: MOVE [0] ;PRESET LOCATION 0 TO ALL ZEROS
SKIPA ;*SKIPA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST INSURES THAT SKIPA IS DATA INDEPENDENT. HENCE, IT ALWAYS SKIPS THE NEXT
;INSTRUCTION.
;THE MOVE [-1] INSTRUCTION IS USED TO TEST THE DATA INDEPENDENCE OF SKIPA.
A200: MOVE [-1] ;PRESET LOCATION 0 TO ALL ONES
SKIPA ;*SKIPA SKOULD ALWAYS SKIP THE NEXT INSTRUCTION
STOP
;COND P [ADZ]
;**********
;THIS TEST VERIFIES THAT SKIPGE SKIPS THE NEXT INSTRUCTION WHEN C(E)
;IS ALL ZEROS. THE MOVE INSTRUCTION IS USED TO LOAD E WITH ALL ZEROS.
A300: MOVE [0] ;PRESET E TO ALL ZEROS
SKIPGE ;*SKIPGE SHOULD SKIP THE NEXT INSTRUCTION
STOP
;COND R [ADZ], AD00 S-A-1, AD AR + EN [ADAP], AD LT AR + EN [ADAP],
;AD RT AR + EN [ADAP], AD AR + EN C [ADAP], F CYC ACT EN A [F1]
;**********
;THIS TEST VERIFIES THAT SKIP IS DATA INDEPENDENT. HENCE, SKIP NEVER SKIPS. IT ALWAYS
;CONTINUES ON TO THE NEXT INSTRUCTION.
A400: MOVE [-1] ;PRESET E TO ALL ONES
SKIP ;*SKIP SHOULD NEVER SKIP THE NEXT INSTRUCTION
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES
STOP
;PC CHANGE [PCC], PC CHANGE A [PCC], SEE MEMORY CONTROL DWGS [MC1-4]
;**********
;THIS TEST VERIFIES THAT SKIPGE WILL NOT SKIP THE NEXT INSTRUCTION WHEN C(E) IS
;NEGATIVE. THE MOVE INSTRUCTION LOADS E WITH -1, A NEGATIVE NUMBER.
A500: MOVE [-1] ;PRESET E WITH ALL ONES, A NEGATIVE NUMBER
SKIPGE ;*SKIPGE SHOULD NOT SKIP THE NEXT INSTRUCTION
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES
STOP
;IF MOVE INSTRUCTION FAILED, CHECK MOVX-: FCE [F1], -IR XXXI [IR1], -IR XXXM [IR1],
;IR HWTFWT [IR3], IR FWT [IR2], IR2XX [IR1]
;IF SKIPGE FAILED, CHECK SKIPX: FCE [F1]
;**********
;THIS TEST VERIFIES THAT SKIPN WILL NOT SKIP THE NEXT INSTRUCTION WHEN
;C(E) IS ZERO. THE MOVE INSTRUCTION LOADS E WITH ALL ZEROS.
A600: MOVE [0] ;PRESET E WITH ALL ZEROS
SKIPN ;*SKIPN SHOULD NOT SKIP THE NEXT INSTRUCTION
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES
STOP
;**********
;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT SHOULD SKIP
;THE NEXT INSTRUCTION WHEN C(E) IS NON-ZERO. THE MOVE INSTRUCTION LOADS
;E WITH -1, A NON-ZERO NUMBER.
A700: MOVE [-1] ;PRESET E WITH ALL ONES, A NON-ZERO NUMBER
SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST VERIFIES THAT SKIPE IS DATA DEPENDENT. HENCE, IT SHOULD NOT
;SKIP THE NEXT INSTRUCTION WHEN C(E) IS NON-ZERO. THE MOVE INSTRUCTION LOADS E
;WITH -1, A NON-ZERO NUMBER.
A1000: MOVE [-1] ;PRESET E WITH ALL ONES, A NON-ZERO NUMBER
SKIPE ;*SKIPE SHOULD NOT SKIP THE NEXT INSTRUCTION
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES
STOP
;**********
;THIS TEST VERIFIES THAT SKIPE IS DATA DEPENDENT. HENCE, IT SHOULD SKIP
;THE NEXT INSTRUCTION WHEN C(E) IS ZERO. THE MOVE INSTRUCTION LOADS ALL
;ZEROS INTO E.
A1100: MOVE [0] ;PRESET E TO ALL ZEROS
SKIPE ;*SKIPE SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST VERIFIES THAT SKIP IS DATA INDEPENDENT. HENCE, IT NEVER SKIPS. IT ALWAYS
;CONTINUES ON TO THE NEXT INSTRUCTION.
A1200: MOVE [0] ;PRESET E TO ALL ZEROS
SKIP ;*SKIP SHOULD NEVER SKIP THE NEXT INSTRUCTION
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES
STOP
;**********
;THIS TEST VERIFIES THAT SKIPL IS DATA DEPENDENT. HENCE, IT WILL NOT SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS NOT NEGATIVE. THE MOVE INSTRUCTION IS USED TO LOAD
;E WITH ALL ZEROS, A NON-NEGATIVE NUMBER.
A1300: MOVE [0] ;PRESET E T0 ZERO, A NON-NEGATIVE NUMBER
SKIPL ;*SKIPL SHOULD NOT SKIP THE NEXT INSTRUCTION
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES
STOP
;**********
;THIS TEST VERIFIES THAT SKIPL IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS NEGATIVE. THE MOVE INSTRUCTION IS USED TO LOAD E WITH -1,
;A NEGATIVE NUMBER.
A1400: MOVE [-1] ;PRESET E TO -1, A NEGATIVE NUMBER
SKIPL ;*SKIPL SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST VERIFIES THAT SKIPG IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS GREATER THAN ZERO. THE MOVE INSTRUCTION IS USED TO LOAD
;E WITH A NON-ZERO POSITIVE NUMBER.
A1500: MOVE [XWD 377777,-1] ;PRESET E TO 377777777777, A NON-ZERO POSITIVE NUMBER
SKIPG ;*SKIPG SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST VERIFIES THAT SKIPG IS DATA DEPENDENT. HENCE, IT WILL NOT SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS NOT GREATER THAN ZERO. THE MOVE INSTRUCTION IS USED TO
;LOAD E WITH -1, A NUMBER NOT GREATER THAN ZERO.
A1600: MOVE [-1] ;PRESET E TO -1, A NEGATIVE NUMBER
SKIPG ;*SKIPG SHOULD NOT SKIP THE NEXT INSTRUCTION
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES
STOP
;**********
;THIS TEST VERIFIES THAT SKIPL IS DATA DEPENDENT. HENCE, IT WILL NOT SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS NON-NEGATIVE. THE MOVE INSTRUCTION IS USED TO LOAD E WITH
;377777777777, A NON-NEGATIVE NUMBER.
A1700: MOVE [XWD 377777,-1] ;PRESET E TO 377777777777, A NON-NEGATIVE NUMBER
SKIPL ;*SKIPL SHOULD NOT SKIP THE NEXT INSTRUCTION
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES
STOP
;**********
;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS ZERO. THE MOVE INSTRUCTION LOADS E WITH ALL ZEROS.
A2000: MOVE [0] ;PRESET E TO ALL ZEROS
SKIPLE ;*SKIPLE SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NEGATIVE NUMBER. THE MOVE INSTRUCTION IS USED TO LOAD
;E WITH 400000000000, A NEGATIVE NUMBER.
A2100: MOVE [XWD 400000,0] ;PRESET E TO 400000000000, A NEGATIVE NUMBER.
SKIPLE ;*SKIPLE SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT. HENCE, IT WILL NOT SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A POSITIVE NUMBER. THE MOVE INSTRUCTION LOADS
;E WITH 377777777777, A POSITIVE NUMBER.
A2200: MOVE [XWD 377777,-1] ;PRESET E TO 377777777777, A POSITIVE NUMBER
SKIPLE ;*SKIPLE SHOULD NOT SKIP THE NEXT INSTRUCTION
SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES
STOP
;*********
;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION ;WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO
;LOAD 777000000000, A NON-ZERO NUMBER INTO E.
A2300: MOVE [XWD 777000,0] ;PRESET E WITH 777000000000, A NON-ZERO NUMBER
SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO
;LOAD A NON-ZERO NUMBER, 377000000 INTO E.
A2400: MOVE [XWD 377,0] ;PRESET E TO 377000000, A NON ZERO NUMBER
SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO
;LOAD E WITH A NON-ZERO NUMBER, 177000.
A2500: MOVE [177000] ;PRESET E WITH 177000, A NON ZERO NUMBER
SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO
;LOAD 777, A NON-ZERO NUMBER INTO E.
A2600: MOVE [777] ;PRESET E WITH 777, A NON-ZERO NUMBER
SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO
;LOAD E WITH 600000, A NON-ZERO NUMBER.
A2700: MOVE [600000] ;PRESET E WITK 600000, A NON-ZERO NUMBER
SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO
;LOAD E WITH 400000000, A NON-ZERO NUMBER.
A3000: MOVE [XWD 400,000] ;PRESET E WITH 400000000, A NON-ZERO NUMBER
SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
SN=3100
ZZ=0
A3100: REPEAT ^D36,
<;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST
;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO
;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E).
;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
STOP
;**********
>
SUBTTL TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS
;THIS TEST VERIFIES THAT MOVEI LOADS E INTO THE AC. SKIPG IS USED TO CHECK THAT
;THE AC WAS INDEED MODIFIED BY MOVEI.
A3200: MOVEI [-1] ;*MOVEI SHOULD LOAD A POSITIVE NUMBER INTO AC0
SKIPG ;SKIP HALT INSTRUCTION IF MOVEI LOADED AC CORRECTLY
STOP
;IF PROGRAM HANGS UP ON MOVEI INSTRUCTION, CHECK AD FM +EN [ADFP], AD FM + EN A [ADFP],
;AD FM + F/F [ADFP], F CYC ACT EN C [F1]
;**********
;THIS TEST VERIFIES THAT SKIPL IS SENSITIVE TO THE DATA IN E AND NOT SENSITIVE TO
;THE DATA IN THE AC. HENCE, SKIPL WILL SKIP THE NEXT INSTRUCTION ONLY IF
;C(E) IS LESS THAN ZERO. E IS SET TO -1, A NEGATIVE NUMBER; AND
;THE AC IS SET TO 0 IN THIS TEST. THEREFORE SKIPL SHOULD SKIP.
A3300: MOVE [0] ;SET THE AC TO ALL ZEROS
SKIPL [-1] ;*SKIPL SHOULD SKIP BECAUSE C(E) IS NEGATIVE
STOP
;**********
;THIS TEST VERIFIES THAT SKIPL IS SENSITIVE TO THE SIGN BIT IN E. SKIPL SHOULD
;SKIP THE NEXT INSTRUCTION WHEN AND ONLY WHEN THE SIGN BIT IS SET. IN THIS
;TEST, C(AC) IS PRESET TO ALL ZEROS, THEN SKIPL IS EXECUTED WITH C(E)=400000,,0.
;A FAILURE UCCURS IF SKIPL DOES NOT SKIP.
A13100: MOVE [0] ;SET THE AC TO ALL ZEROS
SKIPL [400000,,0] ;*SKIPL SHOULD SKIP BECAUSE C(E) IS NEGATIVE
STOP
;**********
;THIS TEST VERIFIES THAT THE CAM INSTRUCTION DOES NOT MODIFY C(AC). THE AC IS
;INITIALLY LOADED WITH ALL ZEROS; THEN CAM IS EXECUTED WITH C(E) NON-ZERO.
;THE AC IS THEN CHECKED FOR ALL ZEROS. THIS TEST FAILS IF THE AC WAS MODIFIED BY CAM.
A3400: MOVE [0] ;PRESET THE AC TO ALL ZEROS
CAM [1234] ;*CAM SHOULD NOT MODIFY THE AC
MOVE ;MOVE C(0) INTO 0 (THIS INSTRUCTION SERVES AS A NO-OP.
;IT IS A PROGRAM FILLER IN CASE CAM SKIPS.)
SKIPE ;SKIP HALT INSTRUCTION IF AC WAS NOT MODIFIED BY CAM
STOP
;IF TEST HANGS ON CAM INSTRUCTION, AB PC EN [ABC], AB PC (FETCH) EN [ABC],
;IR CAXX [IR3]
;IF TEST LOOPS ON CAM INSTRUCTION, MC INSTR FETCH EN [MC1], MC INST FET ET2 EN [MC1],
;ET2 J F/F [E], IR CAXX [IR3]
;IF TEST HALTS AT HALT INSTRUCTION, SAC INH [ST2], IR CAXX [IR3], IR CAMX [IR1]
;**********
;THIS TEST VERIFIES THAT THE CAI INSTRUCTION DOES NOT MODIFY C(AC). THE AC IS
;INITIALLY LOADED WITH ALL ZEROS; THEN CAI IS EXECUTED WITH E NON-ZERO. THE AC IS
;THEN CHECKED FOR ALL ZEROS. THIS TEST FAILS IF THE AC WAS MODIFIED BY CAM.
A3500: MOVE [0] ;PRESET THE AC TO ALL ZEROS
CAI [1234] ;*CAI SHOULD NOT MODIFY THE AC
MOVE ;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A PROGRAM FILLER
;IN CASE CAI MODIFIES THE AC. IT SERVES AS A NO-OP)
SKIPE ;SKIP HALT INSTRUCTION IF CAI DID NOT MODIFY THE AC
STOP
;**********
;THIS TEST VERIFIES THAT CAI DOES NOT MODIFY C(AC0) WHEN AN AC OTHER THAN AC0 IS
;SPECIFIED BY THE CAI INSTRUCTION.
;THIS IS THE FIRST TEST THAT USES AN AC OTHER THAN AC0.
;FIRST, AC0 IS LOADED WITH ALL ZEROS; THEN, THE CAI INSTRUCTION IS EXECUTED WITH
;A NON-ZERO E. AC 0 IS THEN TESTED F0R ALL ZEROS.
A3600: MOVE [0] ;LOAD AC0 WITH ALL ZEROS
CAI 17,[1234] ;*CAI SHOULD NOT MODIFY AC0
MOVE ;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE
;CAI SKIPS THE NEXT INSTRUCTION. IT ACTS AS A NO-OP)
SKIPE ;SKIP HALT INSTRUCTION IF C(AC0) WAS NOT MODIFIED
STOP
;**********
;THIS TEST VERIFIES THAT CAM DOES NOT MODIFY C(AC0) WHEN AN AC OTHER THAN AC0 IS
;SPECIFIED BY THE CAM INSTRUCTION.
;FIRST, AC0 IS LOADED WITH ALL ZEROS; THEN, THE CAM INSTRUCTION IS EXECUTED WITH
;A NON-ZERO E. AC 0 IS THEN TESTED F0R ALL ZEROS.
A3700: MOVE [0] ;PRESET C(AC0) TO ALL ZEROS
CAM 17,[1234] ;*CAM SHOULD NOT MODIFY AC0
MOVE ;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE
;CAM SKIPS THE NEXT INSTRUCTION. IT SERVES AS A NO-OP)
SKIPE ;SKIP HALT INSTRUCTION IF AC0 WAS NOT MODIFIED BY CAM
STOP
;**********
;THIS TEST VERIFIES THAT MOVE WILL PLACE C(E) INTO THE AC. AC, E AND C(E) ARE NON-ZERO
;IN THIS TEST. THIS TEST PASSES IF FINAL C(AC) OF THE MOVE INSTRUCTION IS NON-ZERO.
A4500: MOVE 1,[0] ;LOAD THE AC WITH ALL ZEROS
MOVE 1,[-1] ;*MOVE SHOULD PLACE ALL ONES IN THE AC
SKIPN 1 ;SKIP HALT INSTRUCTION IF MOVE MODIFIED THE AC
STOP
;**********
;THIS TEST VERIFIES THAT THE MOVE INSTRUCTION WILL PLACE C(E) INTO THE AC.
;AC, E ARE NON-ZERO AND C(E)=0.
;THIS TEST FAILS IF THE FINAL C(AC) IS NOT EQUAL TO ZERO, THE ORIGINAL C(E)
A4600: MOVE 1,[0] ;*PLACE ALL ZEROS INTO THE AC
SKIPE 1 ;SKIP HALT INSTRUCTION IF MOVE PLACED ALL ZEROS INTO AC
STOP
;IF JUMP .+1 OF PREVIOUS TEST FAILED, CHECK JUMPS: AD FM + EN [ADFP], IR JUMPS [IR1],
;IR JUMPX [IR1], AR AD EN [ARMA], AR AD EN A [ARMA], AR LT AD EN A [ARMA],
;AR LT ADD EN B [ARMA], AR RT AD EN A [ARMA],
;AR RT AD EN B [ARMA], AR A CLK INPUT [ARMA],
;ET2 C F/F [E], AR AD ET2 EN [ARMA], AR AD BR (ET2) B [ARMA]
;**********
;THIS TEST VERIFIES THAT SOS DOES NOT MODIFY C(AC) WHEN THE AC IS AC0.
;FIRST, AC0 IS LOADED WITH ALL ZEROS AND E IS LOADED WITH A POSITIVE NUMBER;
;THEN, SOS IS EXECUTED. SOS SHOULD SUBTRACT ONE FROM C((E)
;AND EXECUTE THE NEXT INSTRUCTION. IT SHOULD NOT MODIFY AC0.
;THE TEST PASSES IF AC0 WAS NOT MODIFIED.
A4000: MOVE [0] ;PRESET AC0 TO ALL ZEROS
MOVE 7,[1234] ;PRESET E WITH A POSITIVE NUMBER
SOS 7 ;*SOS SHOULD NOT MODIFY C(AC0)
MOVE ;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE
;SOS SKIPS THE NEXT INSTRUCTION. IT SERVES AS A NO-OP)
SKIPE ;SKIP THE HALT INSTRUCTION IF C(AC0) WAS NOT MODIFIED
STOP
;**********
SN=4100
AC=0
A4100: REPEAT 4,
<;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC
;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10.
;FIRST, THE AC IS LOADED WITH ALL ZEROS; THEN, THE SKIP INSTRUCTION IS EXECUTED
;WITH AC1, AC2, AC4 OR AC10. C(E) IS EQUAL TO -1. THE SKIP INSTRUCTION SHOULD CAUSE
;THE AC TO CONTAIN -1. THE AC IS THEN CHECKED FOR
;NON-ZERO CONTENTS. THE TEST FAILS IF C(AC)=0.
;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0.
SN=SN+1
AC=AC+AC
IFE AC,<AC=1>
MOVE 0,[0] ;PRESET AC0 TO ALL ZEROS
MOVE AC,[0] ;PRESET THE AC TO ALL ZEROS
SKIP AC,[-1] ;*SKIP SHOULD PLACE -1 INTO THE AC
SKIPN AC ;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO
STOP
SKIPE 0 ;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP
STOP
;**********
>
SUBTTL TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS
;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL NOT MODIFY THE CONTENTS OF AC0.
;FIRST, AC0 IS LOADED WITH ALL ZEROS; THEN,
;THE SKIP INSTRUCTION IS EXECUTED WITH C(E)=-1 AND AC0. AC0 IS THEN TESTED FOR ALL
;ZEROS. THE TEST FAILS IF AC0 WAS MODIFIED BY THE SKIP INSTRUCTION.
A4200: MOVE [0] ;PRESET AC0 TO ALL ZEROS
SKIP [-1] ;*SKIP SHOULD NOT MODIFY AC0
SKIPE ;SKIP HALT INSTRUCTION IF AC0 WAS NOT MODIFIED BY SKIP
STOP
;AC=0: SAC INH, IR BIT 9, 10, 11 OR 12 S-A-1
;**********
;THIS TEST VERIFIES THAT MOVSS DOES NOT MODIFY C(AC0) WHEN AC0 IS SPECIFIED AS THE AC.
;FIRST, E IS LOADED WITH ALL ONES AND THE AC (AC0)
;IS LOADED WITH ALL ZEROS; THEN, MOVSS IS EXECUTED. MOVSS SHOULD NOT MODIFY AC0.
;AC0 IS THEN CHECKED TO INSURE THAT IT WAS NOT MODIFIED BY MOVSS.
A4300: MOVE 7,[-1] ;LOAD E OF THE MOVSS INSTRUCTION WITH ALL ONES
MOVE [0] ;PRESET AC0 TO ALL ZEROS
MOVSS 7 ;*MOVSS SHOULD NOT MODIFY AC0
SKIPE ;SKIP HALT INSTRUCTION IF AC0 WAS INTACT
STOP
;MOVX & AC=0: SAC INH [ST2], IR XXXS [IR1]
;**********
;THIS TEST VERIFIES THAT HRRS DOES NOT MODIFY C(AC0) WHEN AC0 IS THE SPECIFIED AC.
;FIRST, E IS LOADED WITH ALL ONES AND AC0 IS LOADED WITH ALL ZEROS;
;THEN, HRRS IS EXECUTED WITH AC=AC0. AC0 IS THEN CHECKED FOR ALL ZEROS.
;IF AC0 WAS MODIFIED BY THE HRRS INSTRUCTION, THE TEST FAIL.
A4400: MOVE 7,[-1] ;PRESET E OF THE HRRS INSTRUCTION TO ALL ONES
MOVE [0] ;PRESET AC0 TO ALL ZEROS
HRRS 7 ;*HRRS SHOULD NOT MODIFY THE AC WHEN THE AC IS AC0
SKIPE ;SKIP THE HALT INSTRUCTION IF AC0 WAS INTACT
STOP
;(HXXXS&AC=0): SAC INH [ST2], IR HWTFWT [IR3], IR XXXS [IR1], IR HWT [IR1],
;IR BITS S-A-1
;**********
;THIS TEST VERIFIES THAT THE JUMP INSTRUCTION DOES NOT MODIFY C(AC).
;THE AC IS FIRST LOADED WITH ALL ZEROS;
;THEN JUMP .+1 IS EXECUTED. THE AC IS THEN CHECKED TO INSURE THAT IT WAS NOT MODIFIED
;BY JUMP. THE TEST FAILS IF THE AC WAS MODIFIED
A4700: MOVE [0] ; PRESET THE AC TO ALL ZEROS
JUMP .+1 ;*JUMP SHOULD NOT MODIFY THE AC
SKIPE ;SKIP HALT INSTRUCTION IF AC WAS INTACT
STOP
;**********
;THIS TEST VERIFIES THAT MOVS WILL NOT PICK UP ANY ONES WHEN SWAPPING A WORD
;OF ALL ZEROS. FIRST, E IS LOADED WITH A WORD OF ALL ZEROS;
;THEN, MOVS IS EXECUTED. THE AC IS THEN CHECKED TO INSURE THAT THE RESULT DOES NOT
;CONTAIN ANY ONES.
A5000: MOVE [0] ;PRESET E WITH ALL ZEROS
MOVS ;*MOVS SHOULD RESULT WITH AN AC 0F ALL ZEROS
SKIPE ;SKIP HALT INSTRUCTION IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT A MOVS EXECUTED ON AN E CONTAINING A NON-ZERO NUMBER
;RESULTS IN A NON-ZERO NUMBER IN THE AC. FIRST A NON-ZERO WORD
;IS LOADED INTO E; THEN, MOVS IS EXECUTED. THE AC IS CHECKED FOR A NON-ZERO RESULT.
;IF C(AC)=0, THE TEST FAILS.
A5100: MOVE [XWD 0,-1] ;LOAD E WITH A NON-ZERO VALUE
MOVS ;*MOVS SHOULD RESULT IN C(AC) NON-ZERO
SKIPN ;SKIP HALT INSTRUCTION IF C(AC) OF MOVS IS NON-ZERO
STOP
;**********
;THIS TEST VERIFIES THAT A MOVS EXECUTED ON AN E CONTAINING A NON-ZERO NUMBER
;RESULTS IN A NON-ZERO NUMBER IN THE AC. FIRST A NON-ZERO WORD
;IS LOADED INTO E; THEN, MOVS IS EXECUTED. THE AC IS CHECKED FOR A NON-ZERO
;RESULT. IF C(AC)=0, THE TEST FAILS.
A5200: MOVE [XWD -1,0] ;LOAD E OF MOVS WITH A NON-ZERO NUMBER
MOVS ;*MOVS SHOULD RESULT WITH C(AC) NON-ZERO
SKIPN ;SKIP HALT INSTRUCTION IF C(AC) OF MOVS IS NON-ZERO
STOP
;**********
;THIS TEST VERIFIES THAT THE MOVS INSTRUCTION SWAPS BITS 0 AND 188 OF E
;AND STORES THEM IN THE AC UNLESS AR BIT 0 IS S-A-0. FIRST, A WORD
;WITH BIT 0 SET TO A ONE AND BIT 18 CLEARED IS LOADED INTO E. THEN, MOVS
;IS EXECUTED. THE AC IS THEN CHECKED FOR A 0 IN BIT 0, WHICH IS THE
;CORRECT RESULT.
A5300: MOVE [XWD -1,0] ;LOAD E OF MOVS WITH 777777000000
MOVS ;*MOVS SHOULD RESULT WITH AC BIT 0 EQUAL TO 0
SKIPG ;SKIP HALT INSTRUCTION IF BIT 0 OF AC IS 0
STOP
;MOVSX: AR SWAP [ARMB], AR LT AR RT A [ARMB], AR LT AR RT B [ARMB],
;AR RT AR LT A [ARMB], AR RT AR LT B [ARMB], ET2 A F/F [E], IR MOVSX [IR1],
;IR MOV(E,S)X [IR1]
;**********
;THIS TEST VERIFIES THAT THE MOVS INSTRUCTION SWAPS BITS 0 AND 18 OF E AND
;STORES THEM IN THE AC UNLESS AR BIT 0 IS S-A-1. FIRST, A WORD WITH BIT 0
;SET TO A ONE AND BIT 18 CLEARED IS LOADED INTO E. THEN, MOVS IS EXECUTED.
;THE AC IS CHECKED FOR A ZERO IN BIT ZERO, WHICH IS THE CORRECT RESULT.
A5400: MOVE [XWD 0,-1] ;LOAD E OF MOVS WITH 777777
MOVS ;*MOVS SHOULD RESULT WITH BIT 0 OF THE AC SET
SKIPL ;PASS IF AC BIT 0 IS SET
STOP
;**********
SN=5500
ZZ=0
A5500: REPEAT ^D18,
<;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S,
;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES
;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [0] ;CLEAR AC
MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
STOP
;**********
>
SN=5600
A5600: REPEAT ^D18,
<;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL
;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS
;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS
;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
;HALF OF THE AC IS TESTED WITH A 1.
SN=SN+1
ZZ=ZZ+ZZ
MOVE [0] ;CLEAR AC
MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
STOP
;**********
>
SUBTTL TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)
;THIS TEST VERIFIES THAT SETM LOADS AC FROM E. THE AC IS FIRST SET
;TO ZERO; THEN, SETM IS EXECUTED WITH ALL ONES IN E. BIT 0 OF THE AC
;IS THEN CHECKED FOR A 1.
A5700: MOVE [0] ;PRELOAD AC WITH ALL ZEROS
SETM [-1] ;*SETM SHOULD LOAD AC WITH ALL ONES
SKIPL ;PASS TEST IF AC BIT 0 IS A ONE
STOP
;FCE [F1], IR BOOLE [IR1], IRXX(0,5,12,17) [IR2]
;**********
;THIS TEST VERIFIES THAT SETM LOADS AC FROM E. THE AC IS FIRST SET TO
;ALL ONES; THEN, SETM IS EXECUTED WITH ALL ZEROS IN E. THE AC IS CHECKED
;FOR ALL ZEROS
A6000: MOVE [-1] ;PRESET AC TO ALL ONES
SETM [0] ;*SETM SHOULD LOAD AC WITH ALL ONES
SKIPE ;PASSES TEST IF C(AC) = 0
STOP
;AD AR + EN [ADAP], AD AR + EN C[ADAP],
;F CYC ACT EN A[F1], IR BOOLE AD A +F[IR2],
;IR BOOLE [IR1], IRXX(1-3,6,11,15,16) [IR2]
;**********
;THIS TEST VERIFIES THAT SETZ LOADS TH AC WITH ALL ZEROS. FIRST, A WORD
;OF ALL ZEROS IS LOADED INTO THE AC VIA A MOVE INSTC. THEN, SETZ IS
;EXECUTED. THE AC IS CHECKED FOR ALL ZEROS.
;IF ANY BITS IN THE AC ARE SET, THE TEST FAILS.
A6100: MOVE [0] ;RESET AC TO ALL ZEROS
SETZ ;*SETZ SHOULD CLEAR THE AC
SKIPE ;PASS TEST IF C(AC) = 0
STOP
;AD MASK GEN EN [ADC1], AD MASK GEN F/F'S [ADC1]
;AD MASK EN B; F CYC ACT EN B[F1]; IRXX00 [IR1];
;IR BOOLE [IR1]
;**********
;THIS TEST VERIFIES THAT SETZ LOADS THE AC WITH ALL ZEROS. FIRST,
;THE AC IS SET TO ALL ONES; THEN, SETZ IS EXECUTED. THE AC IS THEN
;CHECKED FOR ALL ZEROS. IF ANY BITS IN THE AC ARE SET, THE TEST FAILS.
A6200: MOVE [-1] ;PRESET AC TO ALL ONES
SETZ . ;*SETZ SHOULD CLEAR THE AC
SKIPE ;PASS TEST IF C(AC) = 0
STOP
;AR AD EN [ARMA], AR AD ET2 EN [ARMA], IR BOOLE [IR]
;**********
;THIS TEST VERIFIES THAT THE AND INSTRUCTION OPERATING ON AN AC
;CONTAINING ALL ZEROS AND AN E CONTAINING ALL ZEROS RESULTS IN AN AC
;OF ALL ZEROS. THE AC AND E ARE THE SAME IN THIS TEST.
;AC, E ARE LOADED WITH ZEROS; THEN, AND IS EXECUTED. THE AC IS THEN
;CHECKED FOR ALL ZEROS. IF ANY BITS IN THE AC ARE SET BY THE AND INSTRUCTION,
;THE TEST FAILS.
A6300: MOVE [0] ;PRESET AC, E TO ALL ZEROS
AND ;*AND SHOULD RESULT IN C(AC) = 0
SKIPE ;PASS TEST IF C(AC) = 0
STOP
;**********
SN=6400
ZZ=0
A6400: REPEAT ^D36,
<;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH
;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS.
;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO,
;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS
;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
SETZ ;PRESET E TO ALL ZEROS
MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
;WHERE X VARIES FROM 0 THRU 35
AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0
SKIPE 1 ;FAIL IF C(AC) NON-ZERO
STOP
SKIPE 0 ;FAIL IF C(0) IS NON-ZERO
STOP
;**********
>
SN=6500
ZZ=0
A6500: REPEAT ^D36,
<;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS
;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED
;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT
;POSITION WITH ITSELF SHOULD RESULT WITH
;C(AC) NONZERO
SKIPN ;PASS TEST IF C(AC) NONZERO
STOP
;**********
>
;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE
;C(AC)=0 AND C(E)=0 AND E OUTSIDE OF THE AC RANGE IS ALL ZEROS IN THE AC.
;FIRST, THE AC IS CLEARED; THEN, THE C(AC) IS ANDED WITH C(E) WHEN
;E GREATER THAN 20 AND C(E)=0. THE RESULT SHOULD BE C(AC)=0.
;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.
A6600: MOVE [0] ;PRESET AC TO ALL ZEROS
AND [0] ;*AND OF TWO WORDS OF ALL ZEROS
;SHOULD RESULT IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(AC)=0
;AND C(E) IS ALL ONES IS AN AC CONTAINING ALL ZEROS. FIRST, THE AC IS
;CLEARED; THEN THE C(AC) IS ANDED WITH AN E CONTAINING ALL ONES, WHERE
;E IS BEYOND THE AC RANGE. THE RESULT SHOULD BE C(AC)=0.
;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.
A6700: MOVE [0] ;PRESET AC TO ALL ZEROS
AND [-1] ;*AND OF TWO WORDS WHERE C(AC)=0 SHOULD RESULT IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;AD FM+EN [ADFP],AD FM+EN A [ADFP],
;F CYC ACT EN C [F1],IR BOOLE AD FM+F [IR2],
;IR BOOLE [IR1],IRXX(1,4,5,11,13,16) [IR2]
;**********
;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(E)=0
;AND C(AC) IS ALL ONES IS AN AC CONTAINING ALL ZEROS. FIRST, THE
;AC IS SET TO ALL ONES; THEN, THE AC IS ANDED WITH AN E CONTAINING ALL
;ZEROS, WHERE E IS BEYOND THE AC RANGE. THE RESULT SHOULD BE C(AC)=0.
;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.
A7000: MOVE [-1] ;PRESET AC TO ALL ONES
AND [0] ;*AND OF TWO WORDS WHERE C(E)=0 SHOULD RESULT IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(E) IS
;ALL ONES AND C(AC) IS ALL ONES IS AN AC CONTAINING ALL ONES. FIRST, THE
;AC IS SET TO ALL ONES; THEN, C(AC) IS ANDED WITH AN E CONTAINING ALL
;ONES. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
;IF C(AC) IS ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.
A7100: MOVE [-1] ;PRELOAD AC WITH ALL ONES
AND [-1] ;*AND OF TWO WORDS OF ALL ONES SHOULD
;RESULT IN C(AC)=ALL ONES
SKIPN ;PASS TEST IF C(AC) IS NON ZERO
STOP
;**********
;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHERE CONTENTS IS NON-ZERO.
;FIRST, THE AC IS CLEARED, THEN, XOR IS EXECUTED WHERE C(E) IS NON-ZERO.
;THE AC IS THEN CHECKED FOR NON-ZERO CONTENTS.
A7200: MOVE [0] ;CLEAR AC
XOR [707070707070] ;*XOR WITH C(AC)=0 AND C(E)=7070707070 SHOULD
;RESTULT IN C(AC)=707070707070
SKIPN ;PASS TEST IF C(AC) NON-ZERO
STOP
;**********
SN=7300
ZZ=0
A7300: REPEAT ^D36,
<;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [0] ;CLEAR AC
XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
;RESULT IN C(AC) NONZERO
SKIPN ;PASS TEST IF C(AC) NON-ZERO
STOP
;**********
>
SN=7400
ZZ=0
A7400: REPEAT ^D36,
<;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET
XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
;RESULT IN C(AC) NON-ZERO
SKIPN ;PASS TEST IF C(AC) NON-ZERO
STOP
;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
;**********
>
SN=7500
ZZ=0
A7500: REPEAT ^D36,
<;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST,
;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST
;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
;INDICATE AN ILLEGAL CARRY GENERATION.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET
XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
>
;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION WHERE
;C(AC)=C(E)=0 IS AN AC CONTAINING ALL ZEROS; FIRST THE AC IS CLEARED; THEN
;XOR IS EXECUTED WITH C(E)=0. THE RESULT IN THE AC IS CHECKED FOR ALL ZEROS
A7600: MOVE [0] ;INITIALIZE AC TO ALL ZEROS
XOR [0] ;*XOR WITH C(AC)=C(E)=0 SHOULD RESULT INC(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
;C(AC)=0 AND C(E) ALL ONES IS AN AC CONTAINING ALL ZEROS SINCE
;THE EQUIVALENCE FUNCTION SHOULD SET ONLY LIKE BITS. FIRST, THE AC
;SHOULD BE CLEARED; THEN, EQV IS EXECUTED WITH E CONTAINING ALL ONES.
;THE AC IS THEN CHECKED FOR ALL ZEROS
A7700: MOVE [0] ;CLEAR THE AC
EQV [-1] ;*EQV WITH C(AC)=0 AND C(E) ALL ONES SHOULD
;RESULT IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
SN=10000
ZZ=0
A10000: REPEAT ^D18,
<;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS
;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE
;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
SN=SN+1
ZZ=ZZ+ZZ+1
IFE <ZZ-1>,<ZZ=-2>
MOVE [0] ;PRESET AC TO ALL ZEROS
EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
;RESULT IN C(AC) NON-ZERO
SKIPN ;PASS TEST IF C(AC) NON-ZERO
STOP
;**********
>
SN=10100
ZZ=0
A10100: REPEAT ^D18,
<;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS
;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE
;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
SN=SN+1
ZZ=ZZ+ZZ+1
IFE <ZZ-1>,<ZZ=-2>
MOVE [0] ;PRESET AC TO ALL ZEROS
EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
;RESULT IN C(AC) NON-ZERO
SKIPN ;PASS TEST IF C(AC) NON-ZERO
STOP
;**********
>
;THIS TEST VERIFIES THAT THE RESULT OF AN AC CONTAINING ALL ZEROS
;EQUIVALENCED WITH AN E CONTAINING ALL ZEROS IS AN AC CONTAINING ALL
;ONES; AND FUTHERMORE, IF THIS AC CONTAINING ALL ONES IS EQUIVALANCED
;WITH AN E CONTAINING ALL ZEROS, THE FINAL RESULT IN THE AC
;SHOULD BE ALL ZEROS. FIRST, THE AC IS INITIALIZED TO ALL ZEROS, THEN,
;THIS AC IS EQUIVALENCED TWICE WITH AN E CONTAINING ALL ZEROS. THE AC IS
;THEN CHECKED FOR ALL ZEROS
A10200: MOVE [0] ;CLEAR THE AC
EQV [0] ;*EQV SHOULD RESULT IN C(AC)=ALL ONES
EQV [0] ;*EQV SHOULD RESULT IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT THE RESULT OF AN AC CONTAINING ALL ONES
;EQUIVALENCED WITH AN E CONTAINING ALL ONES IS AN AC CONTAINING ALL ONES;
;AND FUTHERMORE, IF THIS AC CONTAINING ALL ONES ISEQUIVALENCED WITH AN E
;CONTAINING ALL ZEROS, THE FINAL RESULT IN THE AC SHOULD BE ALL ZEROS.
;FIRST, THE AC IS INITIALIZED TO ALL ONES; THEN, THIS AC IS
;EQUIVALENCED WITH AN E OF ALL ONES. NEXT, THIS SAME AC IS EQUIVALENCED
;WITH AN E OF ALL ZEROS. THE AC IS THEN CHECKED FOR ALL ZEROS.
A10300: MOVE [-1] ;SET C(AC) TO ALL ONES
EQV [-1] ;*EQV SHOULD RESULT IN C(AC) OF ALL ONES
EQV [0] ;*EQV SHOULD RESULT IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
SN=13000
ZZ=0
A13000: REPEAT ^D36,
<;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD
;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS.
;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO
;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT
AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES
EQV [0] ;RESULTS IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
>
ENDXX:
;JRST BEGEND ;LOOP PROGRAM