PCjs Machines
Home of the original IBM PC emulator for browsers.
DEC PDP-10 KA10 Basic Instruction Diagnostic #7
The PDP-10 KA10 Basic Instruction Diagnostic #7 (MAINDEC-10-DAKAG) test code has been extracted from DAKAGM.MAC [original] for use with the PDP-10 Test Machine with Debugger below.
This diagnostic “TESTS THE PUSH, POP, XCT AND BASIC SHIFT ROTATE INSTRUCTIONS.”
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 DAKAG.MAC
will automatically read the DAKAG.MAC source file (a slightly modified copy of DAKAGM.MAC), assemble it, and then load the binary output at the specified address.
DAKAG.TXT
MAINDEC-10-DAKAG.TXT
IDENTIFICATION
--------------
PRODUCT CODE: MAINDEC-10-DAKAG-B-D
PRODUCT NAME: DECSYSTEM10 PDP-10 KA10 BASIC
INSTRUCTION DIAGNOSTIC (7)
FUNCTION: PUSH, POP, XCT, BASIC SHIFT/ROTATE
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-DAKAG.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-DAKAG.TXT
PAGE 3
1.0 ABSTRACT
THIS PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC IS THE
SEVENTH IN A SERIES OF PDP-10 KA10 PROCESSOR DIAGNOSTICS.
THE DIAGNOSTIC TESTS THE PUSH, POP, XCT AND BASIC
SHIFT ROTATE 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
PREVIOUS PROCESSOR DIAGNOSTICS
MAINDEC-10-DAKAG.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-DAKAG.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
DAKAG.HST
THIS IS A HISTORY OF THE DEVELOPMENT OF MAINDEC-10-DAKAG
************************************************************************
PRODUCT CODE: MAINDEC-10-DAKAG
PRODUCT NAME: BASIC INSTRUCTION DIAGNOSTIC #7
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
************************************************************************
DAKAG.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 STARTA
;SKIPL MONCTL
;TTCALL 3,PGMNAM ;MENTION OUR NAME
JRST STARTA
PGMNAM: ASCIZ/
PDP-10 KI10 BASIC INSTRUCTION DIAGNOSTIC (7) [DAKAG]
/
STARTA: JRST .+1
SUBTTL TEST OF PUSH INSTRUCTION
;**********
;THIS TEST VERIFIES THAT PUSH DECODES CORRECTLY.
;IF PUSH DECODES AS PUSHJ, THIS TEST FAILS.
C27200: SETZ 2, ;CLEAR AC
PUSH 2,.+2 ;*PUSH SHOULD NOT JUMP
SKIPA ;PASS IF PUSH DID NOT JUMP
STOP
;**********
;THIS TEST VERIFIES THAT PUSH DOES NOT MODIFY C(E).
;CLEAR E AND AC; THEN, EXECUTE PUSH.
;CHECK E FOR ORIGINAL CONTENTS ,0.
;PASS IF C(E)=0.
C27300: SETZB 2 ;CLEAR AC,E
PUSH 2, ;*PUSH SHOULD NOT ALTER C(E)
SKIPE ;PASS IF C(E)=0,,0
STOP
;**********
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC.
;FIRST THE AC IS CLEARED; THEN PUSH IS EXECUTED.
;THE AC IS CHECKED FOR 1,,1. IF C(AC)=1,,1, THIS TEST PASSES.
C27400: SETZ 2, ;CLEAR AC
PUSH 2,.+1 ;*PUSH SHOULD ADD 1,,1 TO C(AC)
CAME 2,[XWD 1,1] ;PASS IF C(AC)=1,,1
STOP
;**********
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC BEFORE MODIFYING C(C(AC-RIGHT)).
;FIRST, THE AC AND AC0 ARE ZEROED; THEN PUSH IS EXECUTED.
;C(C(AC-RIGHT)) [BEFORE AC UPDATING] (AC0) IS CHECKED FOR THE INITIAL VALUE, 0.
;IF C(AC0)=0, THIS TEST PASSES
C27500: SETZB 2 ;CLEAR AC AND AC0
PUSH 2,[16541320] ;*PUSH SHOULD NOT MODIFY C(AC0)
SKIPE ;PASS IF C(AC0)=0
STOP
;**********
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC BEFORE MODIFYING C(C(AC-RIGHT)).
;FIRST, THE AC AND AC0 ARE ZEROED; THEN PUSH IS EXECUTED.
;C(C(AC-RIGHT)) [BEFORE AC UPDATING] (AC0) IS CHECKED FOR
;IF C(AC0)IS NOT EQUAL TO E, THIS TEST PASSES
C27600: SETZB 1,2 ;CLEAR AC AND AC0
PUSH 2,.+1 ;*PUSH SHOULD NOT MODIFY C(AC0)
CAIN . ;FAIL IF C(AC0)=E
STOP
;**********
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC; THEN, MOVES C(E) INTO
;THE LOCATION SPECIFIED BY C(AC-RIGHT). IN THIS CASE, AC AND THE LOCATION SPECIFIED
;BY UPDATING C(AC-RIGHT) ARE CLEARED; THEN, PUSH IS EXECUTED WITH C(E)=-1,,-1.
;THE LOCATION SPECIFIED BY C(AC-RIGHT) IS THEN CHECKED FOR -1,,-1, THE
;ORIGINAL C(E). IF C(C(AC-RIGHT))=-1,,-1, THIS TEST PASSES.
C27700: SETZB 1,2 ;CLEAR AC, C(AC-RIGHT)
PUSH 2,[-1] ;*PUSH SHOULD PLACE -1,,-1 INTO AC1
CAME 1,[-1] ;PASS IF C(1)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC; THEN, MOVES C(E) INTO
;THE LOCATION SPECIFIED BY C(AC-RIGHT). IN THIS CASE, AC
;IS CLEARED; THEN, PUSH IS EXECUTED WITH C(E)=0.
;THE LOCATION SPECIFIED BY C(AC-RIGHT) IS THEN CHECKED FOR 0, THE
;ORIGINAL C(E). IF C(C(AC-RIGHT))=0, THIS TEST PASSES.
C30000: SETZM 2 ;CLEAR AC
PUSH 2,[0] ;*PUSH SHOULD PLACE 0 INTO AC1
SKIPE 1 ;PASS IF C(1)=0
STOP
;**********
;THIS TEST VERIFIES THAT PUSH ADDS 1,,1 TO THE AC; THEN, MOVES C(E) INTO
;THE LOCATION SPECIFIED BY C(AC-RIGHT). IN THIS CASE,
;AC IS PRELOADED WITH 0,,-1, AND THE LOCATION SPECIFIED
;BY UPDATING C(AC-RIGHT) IS CLEARED; THEN, PUSH IS EXECUTED WITH C(E)=-1,,-1.
;THE LOCATION SPECIFIED BY C(AC-RIGHT) IS THEN CHECKED FOR -1,,-1, THE
;ORIGINAL C(E). IF C(C(AC-RIGHT))=-1,,-1, THIS TEST PASSES.
C30100: MOVEI 2,-1 ;PRELOAD AC WITH 0,,-1
SETZ ;CLEAR AC, C(AC-RIGHT)
PUSH 2,[-1] ;*PUSH SHOULD PLACE -1,,-1 INTO AC0
CAME [-1] ;PASS IF C(0)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT THERE IS A CARRY FROM AC BIT 18 TO BIT 17 OF THE AC ON PUSH.
;THE AC IS PRELOADED WITH 0,,-1; THEN PUSH IS EXECUTED. PUSH SHOULD ADD ONE TO BOTH
;HALVES OF THE AC, GENERATING A CARRY FROM BIT 18 TO BIT 17. IF A CARRY WAS GENERATED,
;THIS TEST PASSES.
C30101: MOVEI 2,-1 ;PRELOAD AC WITH 0,,-1
PUSH 2,0 ;*PUSH SHOULD GENERATE A CARRY FROM BIT 18 TO BIT 17
CAME 2,[2,,0] ;PASS IF C(AC)=2,,0 (CARRY WAS GENERATED)
STOP
;*************
SUBTTL TEST OF PUSHJ INSTRUCTION
;**********
;THIS TEST VERIFIES THAT PUSHJ TRANSFERS CONTROL TO THE LOCATION ADDRESSED BY E.
;IF PUSHJ DOES NOT JUMP, THIS TEST FAILS
C30200: SFLAG CRY0 ;SETS CRY0 FLAG
SETZ ;CLEAR AC
PUSHJ .+2 ;*PUSHJ SHOULD JUMP TO LOCATION E
STOP
;**********
;THIS TEST VERIFIES THAT PUSHJ DOES NOT MODIFY C(PC) WHERE PC IS ONE GREATER
;THAN THE LOCATION OF THE PUSHJ INSTRUCTION.
;IF PUSHJ MODIFIES C(PC), THIS TEST FAILS
C30300: SFLAG CRY0 ;SET CRY0
SETZB 1,.+2 ;CLEAR C(AC-RIGHT) AND C(PC)
PUSHJ .+3 ;*PUSHJ SHOULD NOT MODIFY C(PC)
0 ;THIS LOCATION SHOULD NOT BE MODIFIED BY PUSHJ
CAM ;PUSHJ SHOULD JUMP OVER THIS LOCATION
SKIPE .-2 ;PASS IF PUSHJ DID NOT MODIFY C(PC)
STOP
;**********
;THIS TEST VERIFIES THAT PUSHJ DOES NOT STORE IN E
;IF PUSHJ STORED IN E, THIS TEST FAILS
C30400: SFLAG CRY0 ;SET CRY0
SETZB 1 ;CLEAR AC AND C(AC-RIGHT
PUSHJ .+1 ;*PUSHJ SHOULD NOT STORE IN E
MOVE 2,. ;SAVE C(E)
CAME 2,.-1 ;FAIL IF PUSHJ STORED IN E
STOP
;**********
;THIS TEST VERIFIES THAT PUSHJ DOES NOT STORE IN LOC 0
;PUSHJ SHOULD STORE PC IN C(AC-RIGHT) - LOCATION 2.
;IF PUSHJ STORES IN LOCATION 0, THIS TEST FAILS
C30500: MOVEI 2,1 ;PRELOAD AC WITH 0,,1
SETZ 0 ;CLEAR 0
PUSHJ 2,.+1 ;*PUSHJ SHOULD NOT STORE IN LOCATION 0
SKIPE ;FAIL IF PUSHJ STORED IN LOCATION 0
STOP
;**********
;THIS TEST VERIFIES THAT PUSHJ STORES THE PC IN THE LOCATION SPECIFIED
;BY C(AC-RIGHT) AFTER INCREMENTING AC.
;IN THIS TEST, AC AND C(AC-RIGHT) ARE CLEARED; THEN, PUSHJ IS EXECUTED.
;C(C(AC-RIGHT))IS THEN COMPARED TO ZERO. IF C(C(AC-RIGHT)) IS NON-ZERO,
;A PC WAS STORED AND THIS TEST PASSES.
C30600: SETZB 1 ;CLEAR AC, C(AC-RIGHT)
PUSHJ .+2 ;*PUSHJ SHOULD STORE PC IN RIGHT HALF OF C(AC-RIGHT)
HALT . ;PUSHJ SHOULD JUMP OVER THIS INSTRUCTION
ANDI 1,-1 ;SAVE C(C(AC-RIGHT))
CAIN 1,.-1 ;FAIL IF PC WAS NOT STORED IN C(AC-RIGHT)
STOP
;**********
;THIS TEST VERIFIES THAT PUSHJ ADDS 1,,1 TO THE AC
;THE AC IS CLEARED AND PUSHJ IS EXECUTED
;AC IS CHECKED FOR 1,,1 IF C(AC)=1,,1, THIS TEST PASSES
C31000: SETZ ;CLEAR AC
PUSHJ .+1 ;*PUSHJ SHOULD PLACE 1,,1 INTO THE AC
CAME [1,,1] ;PASS IF C(AC)=1,,1
STOP
;**********
;THIS TEST VERIFIES THAT PUSHJ STORES THE FLAGS IN LEFT HALF OF C(AC-RIGHT)
;FIRST, CRY0 IS SET AND AC AND C(AC-RIGHT) ARE CLEARED; THEN, PUSHJ IS EXECUTED.
;C(C(AC-RIGHT)) IS THEN CHECKED FOR CRY0. IF CRY0 IS SET, THIS TEST PASSES.
C31100: SFLAG CRY0 ;SET CRY0
SETZB 1 ;CLEAR AC AND C(AC-RIGHT)
PUSHJ .+1 ;*PUSHJ SHOULD STORE FLAGS IN LEFT HALF OF C(AC-RIGHT)
TLNN 1,CRY0 ;PASS IF CRY0 STORED CORRECTLY
STOP
;**********
;THIS TEST VERIFIES THAT PUSHJ ADDS 1,,1 TO THE AC
;THE AC IS PRELOADED WITH 0,,1 AND PUSHJ IS EXECUTED
;AC IS CHECKED FOR 1,,2 IF C(AC)=1,,2, THIS TEST PASSES
C31400: MOVEI 1,1 ;PRELOAD AC WITH 0,,1
PUSHJ 1,.+2 ;*PUSHJ SHOULD PLACE 1,,2 INTO THE AC
HALT ;PUSHJ SHOULD JUMP OVER THIS INSTRUCTION
CAME 1,[XWD 1,2] ;PASS IF AC WAS INCREMENTED CORRECTLY
STOP
;**********
;THIS TEST VERIFIES THAT PUSHJ STORES THE PC IN RIGHT HALF OF C(AC-RIGHT)
;THIS TEST PASSES IF THE PC WAS STORED CORRECTLY.
C31500: MOVEI 1,1 ;PLACE 0,,1 INTO AC
PUSHJ 1,.+2 ;*PUSHJ SHOULD STORE .+1 INTO RIGHT HALF OF C(AC-RIGHT)
HALT ;PUSHJ SHOULD JUMP OVER THIS PC
ANDI 2,-1 ;SAVE RIGHT HALF OF C(AC-RIGHT)
CAIE 2,.-2 ;PASS IF PC STORED CORRECTLY
STOP
;**********
;THIS TEST VERIFIES THAT PUSHJ ALWAYS RESETS BIS.
;FIRST BIS IS SET; THEN PUSHJ IS EXECUTED. THE FLAGS ARE
;THEN SAVED AND CHECKED. IF BIS WAS RESET VIA PUSHJ, THIS TEST PASSES.
C31501: SFLAG BIS ;SET BIS
SETZ ;CLEAR AC
PUSHJ .+1 ;*PUSHJ SHOULD RESET BIS
JSP .+1 ;SAVE FLAGS
TLNE BIS ;PASS IF BIS FLAG IS RESET
STOP
;**********
;THIS TEST VERIFIES THAT THERE IS A CARRY FROM BIT18 TO BIT17 OF THE AC ON PUSHJ.
;THE AC IS PRELOADED WITH 0,,-1; THEN PUSHJ IS EXECUTED. PUSHJ SHOULD ADD ONE TO
;BOTH HALVES OF THE AC, GENERATING A CARRY FROM BIT18 TO BIT17. IF A
;CARRY WAS GENERATED, THE TEST PASSES.
C31502: MOVEI 2,-1 ;PRELOAD AC WITH 0,,-1
PUSHJ 2,.+1 ;*PUSHJ SHOULD GENERATE A CARRY FROM BIT18 TO BIT17
CAME 2,[2,,0] ;PASS IF C(AC)=2,,0 (CARRY WAS GENERATED)
STOP
;****************
SUBTTL TEST OF POP INSTRUCTION
;**********
;THIS TEST VERIFIES THAT POP SUBTRACTS 1,,1 FROM THE AC
;THE AC IS PRELOADED WITH 1,,1; THEN, POP IS EXECUTED.
;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES.
C31600: MOVE [XWD 1,1] ;PRELOAD AC WITH 1,,1
POP 1 ;*POP SHOULD SUBTRACT 1,,1 FROM THE AC
SKIPE ;PASS IF AC WAS DECREMENTED CORRECTLY
STOP
;**********
;THIS TEST VERIFIES THAT POP SUBTRACTS 1,,1 FROM THE AC
;THE AC IS PRELOADED WITH 2,,2; THEN, POP IS EXECUTED.
;THE AC IS CHECKED FOR 1,,1. IF C(AC)=1,,1, THIS TEST PASSES.
C31700: MOVE [XWD 2,2] ;PRELOAD AC WITH E,,E WHERE E=2
MOVEI 2,5 ;PRELOAD 2 WITH 0,,5
POP 2 ;*POP SHOULD SUBTRACT 1,,1 FROM THE AC
CAME [1,,1] ;PASS IF AC WAS DECREMENTED CORRECTLY
STOP
;**********
;THIS TEST VERIFIES THAT POP STORES C(C(AC-RIGHT)) INTO E
;IN THIS CASE, AC=0 AND AC IS PRELOADED WITH 2,,2; E=2 AND IS PRELOADED WITH 0.
;POP IS THEN EXECUTED. POP SHOULD PLACE 0 INTO E. IF C(E)=0, THIS TEST PASSES.
C32300: MOVE [XWD 2,2] ;PRELOAD AC WITH 2,,2
SETZM 2 ;CLEAR E AND C(AC-RIGHT)
POP 2 ;*POP SHOULD PLACE 0 INTO E
SKIPE 2 ;PASS IF C(E)=0
STOP
;**********
;THIS TEST VERIFIES THAT POP DOES NOT MODIFY C(C(AC-RIGHT)-1).
;THIS TEST FAILS IF C(C(AC-RIGHT)-1) IS MODIFIED BY POP.
C32400: MOVE [XWD 2,2] ;PRELOAD AC WITH 2,,2
MOVEI 2,17 ;PRELOAD 2 WITH 0,,17
SETZM 1 ;CLEAR C(C(AC-RIGHT)-1)
POP 2 ;*POP SHOULD NOT MODIFY C(C(AC-RIGHT)-1)
SKIPE 1 ;PASS IF C(C(AC-RIGHT)-1) WAS UNALTERED
STOP
;**********
;THIS TEST VERIFIES THAT POP STORES C(C(AC-RIGHT)) INTO E.
;IN THIS CASE, AC IS PRELOADED WITH 2,,2 AND AC2 [C(AC-RIGHT)] IS PRELOADED WITH 0,,3.
;E IS CLEARED AND POP IS EXECUTED. E IS THEN CHECKED FOR 0,,3 [C(C(AC-RIGHT))] .
;IF C(E)=0,,3, THIS TEST PASSES.
C32500: MOVE [XWD 2,2] ;PRELOAD AC WITH 2,,2
MOVEI 2,3 ;PRELOAD C(AC-RIGHT) WITH 0,,3
SETZM 3 ;CLEAR E
POP 3 ;*POP SHOULD PLACE 0,,3 INTO E
CAIE 3,3 ;PASS IF C(E)=0,,3
STOP
;**********
;THIS TEST VERIFIES THAT POP STORES C(C(AC-RIGHT)) INTO E. IN THIS CASE,
;AC IS PRELOADED WITH 2,,2 AND AC2 [C(AC-RIGHT)] IS PRELOADED WITH 0,,17.
;E IS CLEARED AND POP IS EXECUTED. E IS THEN CHECKED FOR 0,,17 [C(C(AC-RIGHT))] .
;IF C(E)=0,,17, THIS TEST PASSES.
C32600: SETZM 2 ;CLEAR E
MOVE [XWD 2,2] ;PRELOAD AC WITH 2,,2
MOVEI 2,17 ;PRELOAD C(AC-RIGHT) WITH 0,,17
POP 2 ;*POP SHOULD PLACE 0,,17 INTO E
CAIE 2,17 ;PASS IF C(E)=0,,17
STOP
;**********
;THIS TEST VERIFIES THAT POP STORES C(C(AC-RIGHT)) INTO E. IN THIS CASE,
;AC IS PRELOADED WITH 2,,2 AND AC2 [C(AC-RIGHT)] IS PRELOADED WITH -1,,-1.
;E IS CLEARED AND POP IS EXECUTED. E IS THEN CHECKED FOR -1,,-1 [C(C(AC-RIGHT))] .
;IF C(E)=0,,3, THIS TEST PASSES.
C33100: MOVE [XWD 2,2] ;PRELOAD AC WITH 2,,2
SETOM 2 ;PRELOAD C(AC-RIGHT) WITH -1,,-1
SETZM 3 ;CLEAR E
POP 3 ;*POP SHOULD PLACE -1,,-1 INTO E
CAME 3,[-1] ;PASS IF C(E)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT POP PLACES C(C(AC-RIGHT)) INTO E AND ADDS 1,,1 TO AC.
;IN THIS CASE, THE AC IS PRELOADED WITH 1,,17; E=1 AND E IS PRELOADED WITH 0;
;C(AC-RIGHT) IS PRELOADED WITH -1,,-1; AND POP IS EXECUTED. POP SHOULD PLACE -1,,-1
;INTO E AND 0,,16 INTO AC. IF AC AND E ARE UPDATED CORRECTLY, THIS TEST PASSES.
C33300: MOVE [XWD 1,17] ;PRELOAD AC WITH 1,,17
SETZM 1 ;PRELOAD E WITH 0
SETOM 17 ;PRELOAD C(AC-RIGHT) WITH 1,,1
POP 1 ;*POP SHOULD PLACE -1,,-1 INTO E AND 0,,16 INTO AC
CAME 1,[-1] ;PASS IF C(E)=-1,,-1
STOP
C33310: CAIE 16 ;PASS IF C(AC)=0,,16
STOP
;**********
;THIS TEST VERIFIES THAT POP PLACES C(C(AC-RIGHT)) INTO E AND ADDS 1,,1 TO AC
;IN THIS CASE, THE AC IS PRELOADED WITH -1,,0; E=17
;C(AC-RIGHT) IS PRELOADED WITH 0; AND POP IS EXECUTED. POP SHOULD PLACE 0
;INTO E. IF AC IS UPDATED CORRECTLY, THIS TEST PASSES.
C33400: MOVSI 1,-1 ;PRELOAD AC WITH -1,,0
SETZ ;CLEAR C(AC-RIGHT)
POP 1,17 ;*POP SHOULD PLACE 0 INTO E
SKIPE 17 ;PASS IF C(E)=0
STOP
;**********
;THIS TEST VERIFIES THAT THERE IS A CARRY FROM BIT18 TO BIT17 OF THE AC ON POP.
;THE AC IS PRELOADED WITH 2,,0; THEN POP IS EXECUTED. POP SHOULD SUBTRACT ONE FROM
;BOTH HALVES OF THE AC, GENERATING A CARRY FROM BIT18 TO BIT17.
;IF A CARRY WAS GENERATED, THIS TEST PASSES.
C33401: HRLZI 2,2 ;PRELOAD AC WITH 2,,0
POP 2,0 ;*POP SHOULD GENERATE A CARRY FROM BIT18 TO BIT17
CAIE 2,-1 ;PASS IF C(AC) = 0,,-1 (CARRY WAS GENERATED)
STOP
;************
SUBTTL TEST OF POPJ INSTRUCTION
;**********
;THIS TEST VERIFIES THAT POPJ JUMPS TO THE LOCATION ADDRESSED BY RIGHT HALF OF
;C(C(AC-RIGHT)) BEFORE POPJ DECREMENTED THE AC.
;THIS TEST PASSES IF POPJ JUMPS CORRECTLY.
C33500: MOVE [XWD 1,1] ;PRELOAD AC WITH 1,,1
MOVEI 1,.+3 ;PRELOAD C(AC-RIGHT) WITH .+3
POPJ .+2 ;*POPJ SHOULD JUMP TO LOCATION
;ADDRESSED BY C(C(AC-RIGHT))
STOP
;**********
;THIS TEST VERIFIES THAT POPJ SUBTRACTS 1,,1 FROM THE AC
;THIS AC IS PRELOADED WITH 1,,1; THEN,POPJ IS EXECUTED.
;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES.
C33600: MOVE [XWD 1,1] ;PRELOAD AC WITH 1,,1
MOVEI 1,.+2 ;PRELOAD C(AC-NIGHT)WITH .+2
POPJ .+1 ;*POPJ SHOULD SUBTRACT 1,,1 FROM AC
CAME [0] ;PASS IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT POPJ JUMPS TO THE LOCATION ADDRESSED BY RIGHT HALF OF
;C(C(AC-RIGHT)) BEFORE POPJ DECREMENTED THE AC.
;THIS TEST PASSES IF POPJ JUMPS CORRECTLY.
C33700: MOVE [XWD 1,1] ;PRELOAD AC WITH 1,,1
MOVEI 1,.+2 ;PRELOAD C(AC-RIGHT) WITH C33700+3
POPJ .+2 ;*POPJ SHOULD JUMP TO C33700+3
SKIPA ;PASS IF POPJ JUMPED CORRECTLY
STOP
;**********
;THIS TEST VERIFIES THAT THERE IS A CARRY FROM BIT18 TO BIT17 OF THE AC ON POPJ.
;THE AC IS PRELOADED WITH 2,,0; THEN POPJ IS EXECUTED POPJ SHOULD SUBTRACT ONE FROM
;BOTH HALVES OF THE AC, GENERATING A CARRY FROM BIT18 TO BIT17.
;IF A CARRY WAS GENERATED, THIS TEST PASSES.
C33701: HRLZI 2,2 ;PRELOAD AC WITH 2,,0
MOVEI 0,.+2 ;PRELOAD RH(AC) WITH C33701: +3
POPJ 2,0 ;*POPJ SHOULD GENERATE A CARRY FROM BIT18 TO BIT17
CAIE 2,-1 ;PASS IF C(AC)=0,,-1 (CARRY WAS GENERATED)
STOP
;*************
SUBTTL XCT INSTRUCTION - ADDITIONAL TESTS
;**********
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A SKIP INSTRUCTION, THE SKIP IS RELATIVE
;TO THE LOCATION OF THE XCT.
C34000: SETOB 1
XCT [CAME 0,1] ;*CAME SHOULD SKIP TO C34000+3
STOP
;**********
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A SKIP INSTRUCTION, THE SKIP IS RELATIVE
;TO THE LOCATION OF THE XCT.
C34100: SETOB 1
XCT [XCT[XCT[CAME 0,1]]] ;*CAME SHOULD SKIP TO C34100+3
STOP
;**********
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A JUMP, PROGRAM FLOW IS ALTERED AS
;SPECIFIED BY THE JUMP.
C34200: XCT [JRST .+4] ;*JRST SHOULD JUMP TO C34200+4
HALT ;JRST SHOULD JUMP OVER THIS LOCATION
HALT ;JRST SHOULD JUMP OVER THIS LOCATION
STOP
;**********
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A JUMP, PROGRAM FLOW IS ALTERED AS
;SPECIFIED BY THE JUMP AND THAT WHEN THE PC IS SAVED IT CONTAINS AN
;ADDRESS ONE GREATER THAN THE LOCATION OF FIRST XCT OF THE CHAIN.
C34300: SETZM 3 ;CLEAR AC OF JSP
XCT [XCT[XCT[JSP 3,.+3]]] ;*JSP SHOULD JUMP TO C34300+4 AND
HALT ;THE SAVED PC SHOULD BE C 34300+2
HALT ;PASS IF JSP JUMPED CORRECTLY
TRZ 3,.-2 ;AND SAVED PC=C34300+2
TRNE 3,-1
STOP
;**********
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A SKIP INSTRUCTION, THE SKIP IS RELATIVE
;TO THE LOCATION OF THE XCT.
;IN THIS CASE, NO SKIP SHOULD OCCUR ;HENCE, THE INSTRUCTION
;FOLLOWING XCT SHOULD BE EXECUTED AFTER 'CAME' IS EXECUTED.
C34400: SETZB 0 ;SET-UP AC,E SO THAT
SETOM 1 ;CAME WILL NOT SKIP
XCT [CAME 0,1] ;*CAME SHOULD CAUSE EXECUTION
;OF INSTRUCTION FOLLOWING XCT
JRST .+2 ;PASS IF THIS INSTRUCTION IS EXECUTED
STOP
;**********
;THIS TEST VERIFIES INDEXING FOR XCT OF AN ADD INSTRUCTION
;C(4)=10, AND C(6)=3, SO THE RESULT IN 6 (THE AC) SHOULD BE 16
;C(11)=13
C34500: MOVEI 4,10 ;PRELOAD INDEX REG WITH 10
MOVEI 11,13 ;PRELOAD EFFECTIVE ADDRESS WITH 13
MOVEI 6,3 ;PRELOAD AC WITH 3
XCT [ADD 6,1(4)] ;*ADD SHOULD PLACE 16 IN AC
CAIE 6,16 ;PASS IF C(AC)=16
STOP
;**********
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A SKIP INSTRUCTION, THE SKIP IS RELATIVE
;TO THE LOCATION OF THE XCT
;IN THIS CASE, NO SKIP SHOULD OCCUR ;HENCE, THE INSTRUCTION
;FOLLOWING XCT SHOULD BE EXECUTED AFTER CAME IS EXECUTED.
C34600: SETZM 2 ;SETUP E SO THAT SKIPL WILL NOT SKIP
XCT [SKIPL 1,2] ;*SKIPL SHOULD CAUSE INSTRUCTION
;OF FOLLOWING INSTRUCTION
JRST .+2 ;PASS IF THIS INSTRUCTION IS EXECUTED.
STOP
C34610: SKIPE 1 ;*SKIPE SHOULD SKIP BECAUSE XCT OF SKIPL
;PLACED 0 INTO AC1
STOP
;**********
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A SKIP INSTRUCTION, THE SKIP IS RELATIVE
;TO THE LOCATION OF THE XCT.
C34700: SETOM 6 ;SETUP E SO THAT SKIPL WILL SKIP
XCT [SKIPL 3,6] ;*SKIPL SHOULD SKIP TO C34700+3
STOP
C34710: SKIPL 3 ;*SKIPE SHOULD SKIP BECAUSE XCT OF SKIPL
;PLACED 0 INTO AC1
STOP
;**********
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A JUMP, PROGRAM FLOW IS ALTERED AS
;SPECIFIED BY THE JUMP.
;THIS TEST ALSO VERIFIES CORRECT UPDATING OF THE AC FOR AOBJN
C35000: MOVE 3,[-2,,5] ;SETUP AC SO THAT AOBJN WILL JUMP
XCT [AOBJN 3,.+3] ;*JUMP SHOULD BE TO C35000+4
HALT ;JUMP OVER THIS INSTRUCTION
HALT ;JUMP OVER THIS INSTRUCTION
CAME 3,[-1,,6] ;PASS IF C(AC)=-1,,6 AND AOBJN JUMPED
STOP
;**********
;THIS TEST VERIFIES THAT IF AN XCT EXECUTES A JUMP, PROGRAM FLOW IS ALTERED AS
;SPECIFIED BY THE JUMP.
;THIS TEST ALSO VERIFIES CORRECT UPDATING OF THE AC FOR AOBJN
C35100: MOVE 3,[-1,,6] ;SETUP AC SO THAT AOBJN WILL NOT JUMP
XCT [AOBJN 3,.+2] ;*AOBJN SHOULD NOT JUMP
CAME 3,[0,,7] ;PASS IF AOBJN DID NOT JUMP AND C(AC)=0,,7
STOP
;**********
SUBTTL TEST XCT INSTRUCTION WITH INDIRECT ADDRESSING AND INDEXING
;**********
;THIS TEST VERIFIES THAT XCT WILL EXECUTE AN INSTRUCTION
;FROM AN INDIRECTLY ADDRESSED LOCATION
C35200: SETZB 2
JRST .+3
.+1
SETOM 2 ;THIS INSTRUCTION SHOULD BE EXECUTED
XCT @.-2
CAME 2,[-1,,-1] ;PASS IF 'SETOM 2' WAS EXECUTED
STOP
;**********
;THIS TEST VERIFIES THAT XCT WILL EXECUTE AN INSTRUCTION
;FROM AN INDEXED LOCATION
C35300: MOVEI 4,.+1
JRST .+2
CAIE 4,.-1 ;THIS INSTRUCTION SHOULD BE EXECUTED
XCT 1(4)
STOP ;PASS IF 'CAIE 4,,-1' WAS EXECUTED
;**********
;THIS TEST VERIFIES THAT XCT WILL EXECUTE AN INSTRUCTION
;FROM AN INDIRECTLY ADDRESSED AND INDEXED LOCATION
C35400: SETZM 5
MOVEI 3,.+3
JRST .+2
MOVEI 5,.+3
XCT @-1(3)
JRST .+2
SETOM 5 ;THIS INSTRUCTION SHOULD BE EXECUTED
CAME 5,[-1,,-1] ;PASS IF 'SETOM 5' WAS EXECUTED
STOP
;**********
;THIS TEST VERIFIES THAT XCT WILL EXECUTE AN INDIRECTLY ADDRESSED
;AND INDEXED INSTRUCTION
C35500: SETZM 3
MOVEI 10,3
JRST .+5
HALT
HALT
MOVE 3,@.-2(10) ;THIS INSTRUCTION SHOULD BE EXECUTED
HALT [0,,707070]
XCT .-2
CAIE 3,707070 ;PASS IF 'MOVE 3,@.-2(10)' WAS EXECUTED
STOP
;**********
SUBTTL TEST OF SHIFT/ROTATE INSTRUCTIONS USED IN THE ERROR HANDLER
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 0,,0 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=0,,0.
;C(AC+1) SHOULD NOT BE AFFECTED.
C35600: MOVE 0,[0,,0] ;PRELOAD AC WITH 0,,0
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 0,-3 ;*ROT SHOULD ROTATE 0,,0 RIGHT 3 BIT POSITIONS
CAME 0,[0,,0] ;PASS IF C(AC)=0,,0
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, -1,,-1 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=-1,,-1.
;C(AC+1) SHOULD NOT BE AFFECTED.
C35700: MOVE 0,[-1,,-1] ;PRELOAD AC WITH 0,,0
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 0,-3 ;*ROT SHOULD ROTATE -1,,-1 RIGHT 3 BIT POSITIONS
CAME 0,[-1,,-1] ;PASS IF C(AC)=-1,,-1
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 252525,,252525 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=525252,,525252.
;C(AC+1) SHOULD NOT BE AFFECTED.
C36000: MOVE 0,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 0,-3 ;*ROT SHOULD ROTATE 252525,,252525
;RIGHT 3 BIT POSITIONS
CAME 0,[525252,,525252] ;PASS IF C(AC)=525252,,525252
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 525252,,525252 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=252525,,252525.
;C(AC+1) SHOULD NOT BE AFFECTED.
C36100: MOVE 0,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 0,-3 ;*ROT SHOULD ROTATE 525252,,525252
;RIGHT 3 BIT POSITIONS
CAME 0,[252525,,252525] ;PASS IF C(AC)=252525,,252525
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 230703,,603700 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=023070,,360370.
;C(AC+1) SHOULD NOT BE AFFECTED.
C36200: MOVE 0,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 0,-3 ;*ROT SHOULD ROTATE 230703,,603700
;RIGHT 3 BIT POSITIONS
CAME 0,[023070,,360370] ;PASS IF C(AC)=023070,,360370
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 007603,,607062 SHOULD BE ROTATED RIGHT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=200760,,360706.
;C(AC+1) SHOULD NOT BE AFFECTED.
C36300: MOVE 0,[007603,,607062] ;PRELOAD AC WITH 007603,,607062
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 0,-3 ;*ROT SHOULD ROTATE 007603,,607062
;RIGHT 3 BIT POSITIONS
CAME 0,[200760,,360706] ;PASS IF C(AC)=200760,,360706
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 0,,0 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
;SO THAT FINAL C(AC)=0,,0.
;C(AC+1) SHOULD NOT BE AFFECTED.
C36400: MOVE 2,[0,,0] ;PRELOAD AC WITH 0,,0
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 2,15 ;*ROT SHOULD ROTATE 0,,0 LEFT 15 BIT POSITIONS
CAME 2,[0,,0] ;PASS IF C(AC)=0,,0
STOP
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, -1,,-1 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
;SO THAT FINAL C(AC)=-1,,-1.
;C(AC+1) SHOULD NOT BE AFFECTED.
C36500: MOVE 2,[-1,,-1] ;PRELOAD AC WITH -1,,-1
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 2,15 ;*ROT SHOULD ROTATE -1,,-1 LEFT 15 BIT POSITIONS
CAME 2,[-1,,-1] ;PASS IF C(AC)=-1,,-1
STOP
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 252525,,252525 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
;SO THAT FINAL C(AC)=525252,,525252.
;C(AC+1) SHOULD NOT BE AFFECTED.
C36600: MOVE 2,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 2,15 ;*ROT SHOULD ROTATE 252525,,252525
;LEFT 15 BIT POSITIONS
CAME 2,[525252,,525252] ;PASS IF C(AC)=525252,,525252
STOP
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 525252,,525252 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
;SO THAT FINAL C(AC)=252525,,252525.
;C(AC+1) SHOULD NOT BE AFFECTED.
C36700: MOVE 2,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 2,15 ;*ROT SHOULD ROTATE 525252,,525252
;LEFT 15 BIT POSITIONS
CAME 2,[252525,,252525] ;PASS IF C(AC)=252525,,252525
STOP
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 230703,,603700 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
;SO THAT FINAL C(AC)074076,,004616.
;C(AC+1) SHOULD NOT BE AFFECTED.
C37000: MOVE 2,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 2,15 ;*ROT SHOULD ROTATE 230703,,603700
;LEFT 15 BIT POSITIONS
CAME 2,[074076,,004616] ;PASS IF C(AC)074076,,004616
STOP
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROT INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 007603,,607062 SHOULD BE ROTATED LEFT 15 BIT POSITIONS
;SO THAT FINAL C(AC)074161,,440174.
;C(AC+1) SHOULD NOT BE AFFECTED.
C37100: MOVE 2,[007603,,607062] ;PRELOAD AC WITH 007603,,607062
MOVE 3,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
ROT 2,15 ;*ROT SHOULD ROTATE 007603,,607062
;LEFT 15 BIT POSITIONS
CAME 2,[074161,,440174] ;PASS IF C(AC)074161,,440174
STOP
CAME 3,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 0,,0 0,,0 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=0,,0 AND FINAL C(AC+1)=0,,0
C37200: MOVE 0,[0,,0] ;PRELOAD AC WITH 0,,0
MOVE 1,[0,,0] ;PRELOAD AC+1 WITH 0,,0
ROTC 0,3 ;*ROTC SHOULD ROTATE 0,,0 0,,0 LEFT 3 BIT POSITIONS
CAME 0,[0,,0] ;PASS IF C(AC)=0,,0
STOP
CAME 1,[0,,0] ;PASS IF C(AC+1)=0,,0
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, -1,,-1 -1,,-1 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=-1,,-1 AND FINAL C(AC+1)=-1,,-1
C37300: MOVE 0,[-1,,-1] ;PRELOAD AC WITH -1,,-1
MOVE 1,[-1,,-1] ;PRELOAD AC+1 WITH -1,,-1
ROTC 0,3 ;*ROTC SHOULD ROTATE -1,,-1
;-1,,-1 LEFT 3 BIT POSITIONS
CAME 0,[-1,,-1] ;PASS IF C(AC)=-1,,-1
STOP
CAME 0,[-1,,-1] ;PASS IF C(AC+1)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 252525,,252525 252525,,252525 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=525252,,525252 AND FINAL C(AC+1)=525252,,525252
C37400: MOVE 0,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
MOVE 1,[252525,,252525] ;PRELOAD AC+1 WITH 252525,,252525
ROTC 0,3 ;*ROTC SHOULD ROTATE 252525,,252525
;252525,,252525 LEFT 3 BIT POSITIONS
CAME 0,[525252,,525252] ;PASS IF C(AC)=525252,,525252
STOP
CAME 1,[525252,,525252] ;PASS IF C(AC+1)=525252,,525252
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 525252,,525252 525252,,525252 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=252525,,252525 AND FINAL C(AC+1)=252525,,252525
C37500: MOVE 0,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
MOVE 1,[525252,,525252] ;PRELOAD AC+1 WITH 525252,,525252
ROTC 0,3 ;*ROTC SHOULD ROTATE 525252,,525252
;525252,,525252 LEFT 3 BIT POSITIONS
CAME 0,[252525,,252525] ;PASS IF C(AC)=252525,,252525
STOP
CAME 1,[252525,,252525] ;PASS IF C(AC+1)=252525,,252525
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 230703,,603700 770037,,600377 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=307036,,37007 AND FINAL C(AC+1)=700376,,003772
C37600: MOVE 0,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
MOVE 1,[770037,,600377] ;PRELOAD AC+1 WITH 770037,,600377
ROTC 0,3 ;*ROTC SHOULD ROTATE 230703,,603700
;770037,,600377 LEFT 3 BIT POSITIONS
CAME 0,[307036,,037007] ;PASS IF C(AC)=307036,,37007
STOP
CAME 1,[700376,,003772] ;PASS IF C(AC+1)=700376,,003772
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 776003,,760077 007603,,607062 SHOULD BE ROTATED LEFT 3 BIT POSITIONS
;SO THAT FINAL C(AC)=760037,,600770 AND FINAL C(AC+1)=076036,,070627
C37700: MOVE 0,[776003,,760077] ;PRELOAD AC WITH 776003,,760077
MOVE 1,[007603,,607062] ;PRELOAD AC+1 WITH 007603,,607062
ROTC 0,3 ;*ROTC SHOULD ROTATE 776003,,760077
;007603,,607062 LEFT 3 BIT POSITIONS
CAME 0,[760037,,600770] ;PASS IF C(AC)=076036,,070627
STOP
CAME 1,[076036,,070627] ;PASS IF C(AC+1)=760037,,600770
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 0,,0 0,,0 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
;SO THAT FINAL C(AC)=0,,0 AND FINAL C(AC+1)=0,,0
C40000: MOVE 0,[0,,0] ;PRELOAD AC WITH 0,,0
MOVE 1,[0,,0] ;PRELOAD AC+1 WITH 0,,0
ROTC 0,7 ;*ROTC SHOULD ROTATE 0,,0 0,,0 LEFT 7 BIT POSITIONS
CAME 0,[0,,0] ;PASS IF C(AC)=0,,0
STOP
CAME 1,[0,,0] ;PASS IF C(AC+1)=0,,0
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, -1,,-1 -1,,-1 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
;SO THAT FINAL C(AC)=-1,,-1 AND FINAL C(AC+1)=-1,,-1
C40100: MOVE 0,[-1,,-1] ;PRELOAD AC WITH -1,,-1
MOVE 1,[-1,,-1] ;PRELOAD AC+1 WITH -1,,-1
ROTC 0,7 ;*ROTC SHOULD ROTATE -1,,-1
;-1,,-1 LEFT 7 BIT POSITIONS
CAME 0,[-1,,-1] ;PASS IF C(AC)=-1,,-1
STOP
CAME 1,[-1,,-1] ;PASS IF C(AC+1)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 252525,,252525 252525,,252525 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
;SO THAT FINAL C(AC)=525252,,525252 AND FINAL C(AC+1)=525252,,525252
C40200: MOVE 0,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
MOVE 1,[252525,,252525] ;PRELOAD AC+1 WITH 252525,,252525
ROTC 0,7 ;*ROTC SHOULD ROTATE 252525,,252525
;252525,,252525 LEFT 7 BIT POSITIONS
CAME 0,[525252,,525252] ;PASS IF C(AC)=525252,,525252
STOP
CAME 1,[525252,,525252] ;PASS IF C(AC+1)=525252,,525252
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 525252,,525252 525252,,525252 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
;SO THAT FINAL C(AC)=252525,,252525 AND FINAL C(AC+1)=252525,,252525
C40300: MOVE 0,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
MOVE 1,[525252,,525252] ;PRELOAD AC+1 WITH 525252,,525252
ROTC 0,7 ;*ROTC SHOULD ROTATE 525252,,525252
;525252,,525252 LEFT 7 BIT POSITIONS
CAME 0,[252525,,252525] ;PASS IF C(AC)=252525,,252525
STOP
CAME 1,[252525,,252525] ;PASS IF C(AC+1)=252525,,252525
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 230703,,603700 770037,,600377 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
;SO THAT FINAL C(AC)=160740,,760176 AND FINAL C(AC+1)=007740,,077646
C40400: MOVE 0,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
MOVE 1,[770037,,600377] ;PRELOAD AC+1 WITH 770037,,600377
ROTC 0,7 ;*ROTC SHOULD ROTATE 230703,,603700
;770037,,600377 LEFT 7 BIT POSITIONS
CAME 0,[160740,,760176] ;PASS IF C(AC)=160740,,760176
STOP
CAME 1,[007740,,077646] ;PASS IF C(AC+1)=007740,,077646
STOP
;**********
;THIS TEST VERIFIES THAT A ROTC INSTRUCTION FUNCTIONS CORRECTLY.
;IN THIS CASE, 776003,,760077 007603,,607063 SHOULD BE ROTATED LEFT 7 BIT POSITIONS
;SO THAT FINAL C(AC)=400774,,017610 AND FINAL C(AC+1)=740741,,614577
C40500: MOVE 0,[776003,,760077] ;PRELOAD AC WITH 776003,,760077
MOVE 1,[007603,,607062] ;PRELOAD AC+1 WITH 007603,,607062
ROTC 0,7 ;*ROTC SHOULD ROTATE 776003,,760077
;007603,,607062 LEFT 7 BIT POSITIONS
CAME 0,[400774,,017601] ;PASS IF C(AC)=400774,,017601
STOP
CAME 1,[740741,,614577] ;PASS IF C(AC+1)=740741,,614577
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 0,,0 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,0.
;C(AC+1) SHOULD NOT BE AFFECTED
C40600: MOVE 0,[0,,0] ;PRELOAD AC WITH 0,,0
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT 0,,0
;RIGHT 33 OCTAL BIT POSITIONS
CAME 0,[0,,0] ;PASS IF C(AC)=0,,0
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN -1,,-1 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,777.
;C(AC+1) SHOULD NOT BE AFFECTED
C40700: MOVE 0,[-1,,-1] ;PRELOAD AC WITH -1,,-1
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT -1,,-1
;RIGHT 33 OCTAL BIT POSITIONS
CAME 0,[0,777] ;PASS IF C(AC)=0,,777
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN 252525,,252525 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,252.
;C(AC+1) SHOULD NOT BE AFFECTED
C41000: MOVE 0,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT 252525,,252525
;RIGHT 33 OCTAL BIT POSITIONS
CAME 0,[0,,252] ;PASS IF C(AC)=0,,252
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 525252,,525252 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,525.
;C(AC+1) SHOULD NOT BE AFFECTED
C41100: MOVE 0,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT 525252,,525252
;RIGHT 33 OCTAL BIT POSITIONS
CAME 0,[0,,525] ;PASS IF C(AC)=0,,525
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 230703,,603700 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,230.
;C(AC+1) SHOULD NOT BE AFFECTED
C41200: MOVE 0,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT 230703,,603700
;RIGHT 33 OCTAL BIT POSITIONS
CAME 0,[0,,230] ;PASS IF C(AC)=230703,,603700
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 007603,,607062 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,7.
;C(AC+1) SHOULD NOT BE AFFECTED
C41300: MOVE 0,[007603,,607062] ;PRELOAD AC WITH 007603,,607062
MOVE 1,[172737,,405060] ;PRELOAD AC+1 WITH 172737,,405060
LSH 0,-33 ;*LSH SHOULD LOGICALLY SHIFT 007603,,6070062
;RIGHT 33 OCTAL BIT POSITIONS
CAME 0,[0,,7] ;PASS IF C(AC)=0,,7
STOP
CAME 1,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 0,,0 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,0.
;C(AC+1) SHOULD NOT BE AFFECTED
C41400: MOVE 1,[0,,0] ;PRELOAD AC WITH 0,,0
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT 0,,0
;RIGHT 27 OCTAL BIT POSITIONS
CAME 1,[0,,0] ;PASS IF C(AC)=0,,0
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, -1,,-1 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,17777.
;C(AC+1) SHOULD NOT BE AFFECTED
C41500: MOVE 1,[-1,,-1] ;PRELOAD AC WITH -1,,-1
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT -1,,-1
;RIGHT 27 OCTAL BIT POSITIONS
CAME 1,[0,,17777] ;PASS IF C(AC)=0,17777
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 252525,,252525 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,5252.
;C(AC+1) SHOULD NOT BE AFFECTED
C41600: MOVE 1,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT 252525,,252525
;RIGHT 27 OCTAL BIT POSITIONS
CAME 1,[0,,5252] ;PASS IF C(AC)=0,,5252
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 525252,,525252 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,12525.
;C(AC+1) SHOULD NOT BE AFFECTED
C41700: MOVE 1,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT 525252,,525252
;RIGHT 27 OCTAL BIT POSITIONS
CAME 1,[0,,12525] ;PASS IF C(AC)=0,,12525
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 230703,602700 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,4616.
;C(AC+1) SHOULD NOT BE AFFECTED
C42000: MOVE 1,[230703,,603700] ;PRELOAD AC WITH 230703,603700
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT 230703,,603700
;RIGHT 27 OCTAL BIT POSITIONS
CAME 1,[0,,4616] ;PASS IF C(AC)=0,,4616
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 007603,,607062 SHOULD BE LOGICALLY SHIFTED RIGHT 27 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,174.
;C(AC+1) SHOULD NOT BE AFFECTED
C42100: MOVE 1,[007603,,607062] ;PRELOAD AC WITH 007603,,607062
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-27 ;*LSH SHOULD LOGICALLY SHIFT 007603,,607062
;RIGHT 27 OCTAL BIT POSITIONS
CAME 1,[0,,174] ;PASS IF C(AC)=0,,174
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 0,,0 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,0.
;C(AC+1) SHOULD NOT BE AFFECTED
C42200: MOVE 1,[0,0] ;PRELOAD AC WITH 0,,0
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT 0,,0
;RIGHT 33 OCTAL BIT POSITIONS
CAME 1,[0,,0] ;PASS IF C(AC)=0,,0
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, -1,,-1 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,777.
;C(AC+1) SHOULD NOT BE AFFECTED
C42300: MOVE 1,[-1,,-1] ;PRELOAD AC WITH -1,,-1
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT -1,,-1
;RIGHT 33 OCTAL BIT POSITIONS
CAME 1,[0,,777] ;PASS IF C(AC)=0,,777
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 252525,,252525 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,252.
;C(AC+1) SHOULD NOT BE AFFECTED
C42400: MOVE 1,[252525,,252525] ;PRELOAD AC WITH 252525,,252525
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT 252525,,252525
;RIGHT 33 OCTAL BIT POSITIONS
CAME 1,[0,,252] ;PASS IF C(AC)=0,,252
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 525252,,525252 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,525.
;C(AC+1) SHOULD NOT BE AFFECTED
C42500: MOVE 1,[525252,,525252] ;PRELOAD AC WITH 525252,,525252
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT 525252,,525252
;RIGHT 33 OCTAL BIT POSITIONS
CAME 1,[0,,525] ;PASS IF C(AC)=0,525
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 230703,,603700 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,230.
;C(AC+1) SHOULD NOT BE AFFECTED
C42600: MOVE 1,[230703,,603700] ;PRELOAD AC WITH 230703,,603700
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT 230703,,603700
;RIGHT 33 OCTAL BIT POSITIONS
CAME 1,[0,,230] ;PASS IF C(AC)=0,,230
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;**********
;THIS TEST VERIFIES THAT THE LSH INSTRUCTION FUNCTIONS CORRECTLY
;IN THIS CASE, 007603,,607062 SHOULD BE LOGICALLY SHIFTED RIGHT 33 OCTAL BIT POSITIONS
;SO THAT FINAL C(AC)=0,,7.
;C(AC+1) SHOULD NOT BE AFFECTED
C42700: MOVE 1,[007603,,607062] ;PRELOAD AC WITH 007603,,607062
MOVE 2,[172737,,405060] ;PRELOAD C(AC+1) WITH 172737,,405060
LSH 1,-33 ;*LSH SHOULD LOGICALLY SHIFT 007603,,607062
;RIGHT 33 OCTAL BIT POSITIONS
CAME 1,[0,,7] ;PASS IF C(AC)=0,,7
STOP
CAME 2,[172737,,405060] ;PASS IF C(AC+1) NOT AFFECTED
STOP
;JRST BEGEND ;REPEAT TEST