Trailing-Edge
-
PDP-10 Archives
-
klad_sources
-
klad.sources/dbkabm.mac
There are no other files named dbkabm.mac in the archive.
SUBTTL DIAGNOSTIC PARAMETERS
SUBTTL DIAGNOSTIC SECTION
LALL
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 B00
SKIPL MONCTL
TTCALL 3,PGMNAM ;MENTION OUR NAME
JRST STARTA ; GO START
PGMNAM: ASCIZ/
PDP-10 KI10 BASIC INSTRUCTION DIAGNOSTIC (2) [DBKAB]
/
;BASIC INSTRUCTION TEST (2)
;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF
;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES
;IN THE FIELD
STARTA: JRST .+1
B00:
SUBTTL TEST OF THE ADD INSTRUCTION
;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED
;TO ADD A NON-ZERO NUMBER CONTAINED IN E TO AN AC CONTAINING ALL ZEROS,
;THE RESULT IS A NON-ZERO NUMBER IN THE AC. FIRST, THE AC IS CLEARED;
;THEN, ANON-ZERO POSITIVE NUMBER IS ADDED TO THE AC USING THE ADD
;INSTRUCTION. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
A10400: MOVE [0] ;PRESET AC TO ALL ZEROS
ADD [123456765432] ;*ADD OF A NON-ZERO NUMBER TO AN AC OF ALL
;ZEROS SHOULD RESULT
;IN AN AC CONTAINING A NON-ZERO NUMBER
SKIPN ;PASS TEST IF C(AC) IS NON-ZERO
STOP
;AD ADD [ADC1], AD ADD EN [ADC1],
;F CYC ACT EN A [F1], AD FM + FETCH EN A [ADFP],
;F CYC ACT EN C[F1], IR ADSUB [IR1], IRXX [IR1]
;**********
;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE
;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS
;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS
; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
A10500: MOVE [123456765432] ;PRESET AC WITH A NON-ZERO NUMBER
ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC
;CONTAINING A NON-ZERO NUMBER
;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
SKIPN ;PASS TEST IF C(AC) IS NON-ZERO
STOP
;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F [E],
;AR AD ET2 EN [ARMA], IR ADSUB [IR1]
;**********
;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE
;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS
;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS
; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
A10600: MOVE [XWD 123456,0] ;PRESET AC WITH A NON-ZERO NUMBER
ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING
;A NON-ZERO NUMBER SHOULD RESULT IN AN AC
;CONTAINING A NON-ZERO NUMBER
SKIPN ;PASS TEST IF C(AC) IS NON-ZERO
STOP
;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F[E],
;AR AD ET2 EN [ARMA], IR AD SUB [IR1]
;*********
;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE
;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS
;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS
; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
A10700: MOVE [123456] ;PRESET AC WITH A NON-ZERO NUMBER
ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING
;A NON-ZERO NUMBER
;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
SKIPN ;PASS TEST IS C(AC) IS NON-ZERO
STOP
;**********
;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE
;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS
;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER
;IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
A13300: MOVE [0] ;PRESET AC WITH ALL ZEROS
ADD [123456,,0] ;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS
;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
SKIPN ;PASS TEST IF C(AC) IS NON-ZERO
STOP
;**********
;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE
;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS
;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER
;IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
A13400: MOVE [0] ;PRESET AC WITH ALL ZEROS
ADD [123456] ;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS
;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
SKIPN ;PASS TEST IF C(AC) IS NON-ZERO
STOP
;**********
;ADD ZERO TO A RIPPLED ONE
SN=11000
ZZ=0
A11000: REPEAT ^D36,
<;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
;A WORD OF ALL ZEROS IS ADDED TO AN
;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD
;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
;EVERY BIT OF THE AC.
;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE
ADD [0] ;*ADD OF ZERO TO FLOATING ONE
EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES
EQV [0] ;RESULTS IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
;IR ADDX [IR1], IR ADSUB [IR1]
;**********
PAGE
>
;THIS TEST VERIFIES THAT THE ADDITION OF A WORD OF
;ALL ZEROS TO AN AC OF ALL ZEROS RESULTS IN
;C(AC)=0. FIRST THE AC IS CLEARED; THEN, A WORD
;OF ALL ZEROS IS ADDED TO THE AC. THE RESULT IN
;THE AC IS THEN CHECKED TO INSURE THAT C(AC)=0
A11100: MOVE [0] ;PRESET AC TO ZERO
ADD [0] ;*ADD OF ZERO TO ZERO SHOULD RESULT IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;FCE[F1], IR AD SUB [IR1]
;AD FM + EN [ADFP], AD FM + EN A [ADFP],
;F CYC ACT EN C[F1], IR ADSUB [IR1]
;**********
;ADD ZERO TO A RIPPLED ONE
SN=13200
ZZ=0
A13200: REPEAT ^D36,
<;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
;TO AN AC OF ALL ZEROS IS ADDED A
;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD
;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
;EVERY BIT OF THE AC.
;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [0] ;LOAD AC WITH ALL ZEROS
ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO
EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES
EQV [0] ;RESULTS IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
>
PAGE
;ADD A RIPPLED ONE TO A RIPPLED ONE
SN=11200
ZZ=0
A11200: REPEAT ^D35,
<;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
;RESULT IN THE AC WILL BE ZERO AND THE TEST
;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
;SO THAT A ONE WILL BE FLOATED THROUGH
;BITS 1 THRU 35 OF BOTH AC AND E
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE
ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES
EQV [0] ;RESULTS IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
>
SN=11300
ZZ=0
YY=0
A11300: REPEAT ^D18,
<;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
;FORMER VALUE PLUS THE CURRENT C(AC)
SN=SN+1
YY=YY/2
ZZ=ZZ+YY
IFE YY,<YY=400000>
IFE ZZ,<ZZ=400000>
MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
;POWER SHOULD RESULT IN C(AC)=0.
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
>
PAGE
SN=11400
ZZ=0
YY=0
A11400: REPEAT ^D18,
<;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
;FORMER VALUE PLUS THE CURRENT C(AC)
SN=SN+1
YY=YY/2
ZZ=ZZ+YY
IFE YY,<YY=400000>
IFE ZZ,<ZZ=400000> ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
;POWER SHOULD RESULT IN C(AC)=0.
ADD [YY] ;PASS TEST IF C(AC)=0
SKIPE
STOP
;**********
>
SUBTTL SPECIAL KI10 FOUR BIT ADDER TEST
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 33 TO BIT 32.
A13500: MOVE [-1,,-5] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 33
ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 33 TO BIT 32
EQV [-1,,-4] ;RESULT IN AC=ALL ONES
EQV [0] ;RESULT IN AC=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 29 TO BIT 28.
A13600: MOVE [-1,,-101] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 29
ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 29 TO BIT 28
EQV [-1,,-100] ;RESULT IN AC=ALL ONES
EQV [0] ;RESULT IN AC=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 25 TO BIT 24.
A13700: MOVE [-1,,-2001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 25
ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 25 TO BIT 24
EQV [-1,,-2000] ;RESULT IN AC=ALL ONES
EQV [0] ;RESULT IN AC=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 21 TO BIT 20.
A14000: MOVE [-1,,-40001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 21
ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 21 TO BIT 20
EQV [-1,,-40000] ;RESULT IN AC=ALL ONES
EQV [0] ;RESULT IN AC=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 18 TO BIT 17.
A14100: MOVE [-1,,-400001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 18
ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 18 TO BIT 17
EQV [-1,,400000] ;RESULT IN AC=ALL ONES
EQV [0] ;RESULT IN AC=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 14 TO BIT 13.
A14200: MOVE [-11,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 14
ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 14 TO BIT 13
EQV [-10,,0] ;RESULT IN AC=ALL ONES
EQV [0] ;RESULT IN AC=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 10 TO BIT 9.
A14300: MOVE [-201,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 10
ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 10 TO BIT 9
EQV [-200,,0] ;RESULT IN AC=ALL ONES
EQV [0] ;RESULT IN AC=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 6 TO BIT 5.
A14400: MOVE [-4001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 6
ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 6 TO BIT 5
EQV [-4000,,0] ;RESULT IN AC=ALL ONES
EQV [0] ;RESULT IN AC=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 2 TO BIT 1.
A14500: MOVE [-100001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 2
ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 2 TO BIT 1
EQV [-100000,,0] ;RESULT IN AC=ALL ONES
EQV [0] ;RESULT IN AC=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 1 TO BIT 0.
A14600: MOVE [-200001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 1
ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 1 TO BIT 0
EQV [600000,,0] ;RESULT IN AC=ALL ONES
EQV [0] ;RESULT IN AC=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT -1TO BIT 35.
A14700: MOVE [-1,,-1] ;PRESET AC WITH ALL ONES
ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT -1 TO BIT 35
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
SUBTTL TEST OF SUB AND COMPARE INSTRUCTIONS
;THIS TEST VERIFIES THAT IF A NON ZERO POSITIVE NUMBER IN E IS
;SUBTRACTED FROM THE AC WHEN C(AC)=0, THE RESULT IN THE AC
;IS NEGATIVE
A11500: MOVE [0] ;PRESET AC TO ZERO
SUB [XWD 0,-1] ;*SUB OF POSITIVE NONZERO NUMBER FROM AC OF ALL ZEROS
;SHOULD RESULT IN C(AC) NEGATIVE
SKIPL ;PASS TEST IF C(AC) IS NEGATIVE
STOP
;AD AR- EN D [ADAM], F CYC ACT ENB [F1],
;IR SUBX[IR1], IR ADSUB[IR1]
;**********
;THIS TEST VERIFIES THAT IF A WORD OF ALL ZEROS IS
;SUBTRACTED FROM AN AC OF ALL ZEROS, THE RESULT
;IS AN AC OF ZEROS.
A11600: MOVE [0] ;PRESET AC TO ZERO
SUB [0] ;*SUB OF 0 FROM 0 SHOULD RESULT IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;AD CRY 36[ADCR], F CYC ACT EN D[F1], IF SUBX [IR1]
;**********
PAGE
SN=11700
ZZ=0
A11700: REPEAT ^D36,
<;THIS TEST VERIFIES THAT IF A RIPPLED ONE
;IS SUBTRACTED FROM ITSELF, THE RESULT IS
;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
;TIMES IN ORDER TO TEST ALL 36 BITS.
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE
SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
>
PAGE
;THIS TEST VERIFIES THAT IF A WORD OF ALL
;ONES IS SUBTRACTED FROM ITSELF, THE RESULT
;IN THE AC IS ZERO.
A12000: MOVE [-1] ;PRESET AC TO ALL ONES
SUB [-1] ;*SUB OF -1 FROM ITSELF SHOULD RESULT IN C(AC)=0
SKIPE ;PASS TEST IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT CAMA ALWAYS SKIPS THE
;NEXT INSTRUCTION INDEPENDENT OF THE DATA WITH AC
;AND E. THIS TEST FAILS IF CAMA DOES NOT SKIP ALWAYS.
A12100: MOVE [0] ;PRESET AC, E TO ZERO
CAMA ;*CAMA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION,
;OTHERWISE THIS TEST FAILS
STOP
;ET0 [E], ET0 EN[E], IR CAXX[IR3], AD CRY 3C[ADCR],
;FCYC ACT EN D [ADCR], AD CRY 36 F/F'S [ADCR],
;PC CLOCK EN [PCC], ET0 C F/F[E], IR CAXX[IR3],
;ADZ COND P[ADZ] AND ADZ COND Z[ADZ]
;**********
;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE.
;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY
;IF C(AC)=C(E). IN THIS TEST AC=E=0 AND
;C(AC)=C(E)=0. HENCE, CAME MUST
;SKIP THE NEXT INSTRUCTION
;IN THIS TEST
A12200: MOVE [0] ;PRESET AC, E TO ZERO
CAME ;*CAME SHOULD SKIP SINCE E=AC
STOP
;AD FM + EN [ADFP], F CXC ACT ENC[F1], IRCAXX[IR3]
;**********
;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE
;IT SKIPS THE NEXT INSTRUCTION OF AND ONLY IF
;C(AC)=C(E). IN THIS TEST C(AC)=C(E)=0;
;BUT, E IS NOT WITHIN THE AC RANGE.
;HENCE, CAME MUST SKIP
;THE NEXT INSTRUCTION IN THIS TEST.
A12300: MOVE [0] ;*CAME SHOULD SKIP WHEN C(AC)=C(E)=0
CAME [0]
STOP
;CAMX: FCE[F1], IR CAMX[IR1]
;**********
;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE.
;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY IF
;C(AC)=C(E). IN THIS TEST C(AC)=0 AND
;C(E)=-1. HENCE, CAME SHOULD NOT
;SKIP THE NEXT INSTRUCTION IN THIS TEST.
A12400: MOVE [0] ;PRESET AC TO ZERO
CAME [-1] ;*CAME SHOULD NOT SKIP BECAUSE C(AC)=0 ANDC(E)=-
SKIPA ;SKIP HALT INSTRUCTION IF CAME PASSES TEST
STOP
;AD AR- EN [ADAM], IR CAXX [IR3], F CYC ACT EN B [F1],
;AD AR- F/F'S [ADAM], AD ADD [ADC1], AD FM + FETCH EN A [ADFP],
;F CYC ACT EN A [F1], AD ADD EN C [ADC1], AD ADD F/F'S [ADC1]
;**********
SUBTTL TEST OF COMPARE (CAMX) INSTRUCTIONS
;**********
;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS TEST, C(AC)=-1 AND C(E)=0; HENCE, CAML SHOULD SKIP. OTHERWISE,THE
;PROGRAM HALTS.
B100: MOVE [-1] ;PRELOAD AC WITH -1
CAML [0] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E)
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; FC: AB PC EN
; ET0: COND Q: PC CLK EN
;**********
;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=-1; HENCE, CAML SHOULD NOT SKIP. OTHERWISE,
;THE PROGRAM HALTS.
B200: MOVE [0] ;PRELOAD AC WITH 0
CAML [-1] ;*CAML SHOULD NOT SKIP BECAUSE
;C(AC) IS GREATER THAN C(E)
SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; SW: FCE
; FC: PC CHANGE
;**********
;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=400000,,0 (THE MOST
;NEGATIVE NUMBER) AND C(E)=377777,,-1
;(THE MOST POSITIVE NUMBER); HENCE,
;CAML SHOULD SKIP. OTHERWISE, THE
;PROGRAM HALTS
B300: MOVE [XWD 400000,0] ;PRELOAD AC WITH 400000,,0
CAML [XWD 377777,-1] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E)
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; FC: AD ADD
;**********
;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=377777,,-1 (THE MOST POSITIVE NUMBER) AND C(E)=400000,,0 (THE MOST NEGATIVE NUMBER)
;HENCE, CAML SHOULD NOT SKIP. OTHERWISE, THE PROGRAM HALTS.
B400: MOVE [XWD 377777,-1] ;PRELOAD AC WITH 377777,,-1
CAML [XWD 400000,0] ;*CAML SHOULD NOT SKIP BECAUSE
;C(AC) IS GREATER THAN C(E)
SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES
STOP
;**********
;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=400000,,0 (THE MOST NEGTIVE NUMBER) AND C(E)=-1;
;HENCE, CAML SHOULD SKIP. OTHERWISE, THE PROGRAM HALTS
B500: MOVE [XWD 400000,0] ;PRELOAD AC WITH 400000,,0
CAML [-1] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E)
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; FC: AD FM + EN
;**********
;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=-1 ;HENCE, CAML SHOULD NOT SKIP. OTHERWISE,
;THE PROGRAM HALTS.
B600: SETZ ;PRELOAD AC WITH 0
CAML [-1] ;*CAML SHOULD NOT SKIP BECAUSE
;C(AC) IS GREATER THAN C(E)
SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES.
STOP
;**********
;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=0 ;HENCE, CAML SHOULD NOT SKIP. OTHERWISE,
;THE PROGRAM HALTS.
B700: SETZ ;PRELOAD AS WITH 0
CAML [0] ;*CAML SHOULD NOT SKIP BECAUSE C(AC)=C(E)
SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; FC: AD CRY 36
;**********
;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=400000,,O (THE MOST NEGATIVE NUMBER);
;HENCE CAML SHOULD NOT SKIP. OTHERWISE, THE PROGRAM HALTS.
B1000: SETZ ;PRELOAD AC WITH 0
CAML [XWD 400000,0] ;*CAML SHOULD NOT SKIP BECAUSE
;C(AC) IS GREATER THAN C(E)
SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES
STOP
;**********
;THIS TEST VERIFIES THAT CAM IS DATA INDEPENDENT. IT NEVER SKIPS
;THE NEXT SEQUENTIAL INSTRUCTION
;IN THIS CASE, C(AC)=-1 AND C(E)=0
;IF IT DOES SKIP THE NEXT INSTRUCTION, THE PROGRAM HALTS
B1100: MOVE [-1] ;PRELOAD AC WITH -1
CAM [0] ;*CAM SHOULD NEVER SKIP
SKIPA ;SKIP HALT INSTRUCTION IF CAM PASSES
STOP
;**********
;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E).
;IN THIS CASE, C(AC)=-1 AND C(E)=0; HENCE, CAMGE SHOULD NOT SKIP.
;OTHERWISE, THE PROGRAM HALTS.
B1200: MOVE [-1] ;PRELOAD AC WITH-1
CAMGE [0] ;*CAMGE SHOULD NOT SKIP BECAUSE C(AC) IS LESS THAN C(E)
SKIPA ;SKIP HALT INSTRUCTION IF CAMGE PASSES.
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; FC: PC CHANGE
; FC: AB PC EN
;**********
;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E)
;IN THIS CASE, C(AC)=0 AND C(E)=-1; HENCE CAMGE SHOULD SKIP.
;OTHEWISE, THE PROGRAM HALTS.
B1300: SETZ ;PRELOAD AC WITH 0
CAMGE [-1] ;*CAMGE SHOULD SKIP BECAUSE C(AC) IS GREATER THAN C(E)
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; SW: FCE
; ET0: COND Q: PC CLK EN
;**********
;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS NOT EQUAL TO C(E)
;IN THIS CASE C(AC)=0 AND C(E)=-1; HENCE CAMN SHOULD SKIP.
;OTHERWISE, THE PROGRAM HALTS
B1400: SETZ ;PRELOAD AC WITH 0
CAMN [-1] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; FC:AD FM + EN
; FC: AD AR - EN
; FC: AD CRY 36
; FC: AD ADD
; FC: AB PC EN
; ET0: PC CLK EN
;**********
;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS NOT EQUAL TO C(E)
;IN THIS CASE, C(AC)=0 AND C(E)=0; HENCE CAMN SHOULD NOT SKIP.
;OTHERWISE, THE PROGRAM HALTS
B1500: SETZ ;PRELOAD AC WITH 0
CAMN [0] ;*CAMN SHOULD NOT SKIP BECAUSE C(AC)=C(E).
SKIPA ;SKIP HALT INSTRUCTION IF CAMN PASSES
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; SW: FCE
; FC: PC CHANGE
;**********
SN=1600
ZZ=0
B1600: REPEAT ^D18,<
;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME
;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E)
;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1
CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)
CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; ET0: COND P
;**********
>
ZZ=0
REPEAT ^D18,<
;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME
;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E)
;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1
CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)
CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)
STOP
;**********
>
SN=1700
ZZ=0
B1700: REPEAT ^D36,<
;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE,
;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
SETZ ;PRELOAD AC WITH 0
CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)
STOP
;**********
>
SN=2000
ZZ=0
B2000: REPEAT ^D36,<
;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE,
;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1
CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)
STOP
;**********
>
SUBTTL TEST OF MOVS INSTRUCTION
;**********
SN=2100
ZZ=0
B2100: REPEAT ^D18,<
;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED.
;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
SN=SN+1
ZZ=ZZ+ZZ
IFE ZZ,<ZZ=1>
MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E)
;AND MOVE RESULT INTO AC
CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
STOP
;**********
>
SN=2200
ZZ=0
B2200: REPEAT ^D18,<
;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES
;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED.
;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF
SN=SN+1
ZZ=ZZ+ZZ+1
IFE <ZZ-1>,<ZZ=-2>
MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E)
;AND MOVE RESULT INTO AC
CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ
STOP
;**********
>
SN=2300
ZZ=0
YY=0
B2300: REPEAT ^D18,<
;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E
;AND A 0 IS RIPPLED THRU THE RIGHT HALF
;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0].
;THEN, C(AC) IS CHECKED.
;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF
;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E
SN=SN+1
ZZ=ZZ+ZZ
YY=YY+YY+1
IFE ZZ,<ZZ=1>
IFE <YY-1>,<YY=-2>
MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E)
;AND MOVE RESULT INTO AC
CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ
STOP
;**********
>
SN=2400
ZZ=0
YY=0
B2400: REPEAT ^D18,<
;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E
;AND A 1 IS RIPPLED THRU THE RIGHT HALF
;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0].
;THEN, C(AC) IS CHECKED.
;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF
;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E
SN=SN+1
ZZ=ZZ+ZZ
YY=YY+YY+1
IFE ZZ,<ZZ=1>
IFE <YY-1>,<YY=-2>
MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E)
;AND MOVE RESULT INTO AC
CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY
STOP
;**********
>
SUBTTL TEST OF COMPARE (CAXX) INSTRUCTIONS
;**********
;THIS TEST VERIFIES THAT CAIE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN C(AC)=E
;IN THIS CASE C(AC)=E=0; HENCE, CAIE SHOULD SKIP
;OTHERWISE THE PROGRAM HALTS
B2500: SETZ ;PRELOAD AC TO 0
CAIE ;*CAIE SHOULD SKIP BECAUSE C(AC)=E
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; SW: PC CHANGE
; FC: AD FM ; EN
; FC: AD CRY 36
; FC: AB PC EN
; ET0: COND P: PC CLK EN
;**********
;THIS TEST VERIFIES THAT CAIE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN C(AC)=E
;IN THIS CASE C(AC)=E=1. HENCE, CAIE SHOULD SKIP
;OTHERWISE THE PROGRAM HALTS
B2600: MOVE [1] ;PRELOAD AC TO 1
CAIE 1 ;*CAIE SHOULD SKIP BECAUSE C(AC)=E
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
; FC: AD AR - EN
;**********
;THIS TEST VERIFIES THAT CAME SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN C(AC)=C(E)
;IN THIS CASE C(AC)=C(E)=1; HENCE, CAME SHOULD SKIP
;OTHERWISE THE PROGRAM HALTS
B2700: MOVEI 1 ;PRELOAD AC TO 1
CAME [1] ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)
STOP
;**********
SUBTTL TEST OF BOOLEAN INSTRUCTIONS
;**********
;THIS TEST VERIFIES THAT SETCA IGNORES THE ADDRESS FIELD OF THE INSTUCTION WORD.
;IN THIS CASE C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0
;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES.
B3000: MOVEI -1 ;PRELOAD AC TO 0,,-1
SETCA [-1] ;*SETCA SHOULD PUT -1,,0 INTO THE AC
CAME [-1,,0] ;PASS TEST IF C(AC)=-1,,0
STOP
;**********
;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE
;RESULT IN THE AC.
;IN THIS CASE C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0
;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES
B3100: MOVEI -1 ;PRELOAD AC TO 0,,-1
SETCA ;*SETCA SHOULD PUT -1,,0 INTO THE AC
CAME [-1,,0] ;PASS TEST IF C(AC) =-1,,0
STOP
;**********
;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE
;RESULT IN THE AC,
;IN THIS CASE C(AC)=0,,0 HENCE, THE RESULT IN THE AC SHOULD BE,-1
;IF THE RESULT IN THE AC IS -1,,-1, THE TEST PASSES
B3200: MOVEI 0 ;PRELOAD AC TO 0,,0
SETCA ;*SETCA SHOULD PUT -1,,-1 INTO THE AC
CAME [-1] ;PASS TEST IF C(AC) =-1,,-1
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;0 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE
;RESULT IN THE AC,
;IN THIS CASE C(AC)=-1,,-1; HENCE, THE RESULT IN THE AC SHOULD BE 0,,0
;IF THE RESULT IN THE AC IS ZERO, THE TEST PASSES
B3300: MOVE [-1] ;PRELOAD AC TO -1,,-1
SETCA ;*SETCA SHOULD PUT 0,,0 INTO THE AC
CAME [0] ;PASS TEST IF C(AC) IS ZERO
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;-1,,-1 FC: AD FM - EN
;**********
;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE
;RESULT IN THE AC.
;IN THIS CASE AC=E AND C(E)=C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0
;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES
B3500: MOVEI -1 ;PRELOAD AC TO 0,,-1
SETCM ;*SETCM SHOULD PUT -1,,0 INTO THE AC
CAME [-1,,0] ;PASS TEST IF C(AC) =-1,,0
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;-1,,-1 SW: FCE
;-1,,-1 FC: AD AR - EN
;0,,-1 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE
;RESULT IN THE AC.
;IN THIS CASE C(E)=-1,,-1; HENCE, THE RESULT IN THE AC SHOULD BE 0,,0
;IF THE RESULT IN THE AC IS ZERO,THE TEST PASSES
B3600: SETCM [-1] ;*SETCM SHOULD PUT 0 INTO THE AC
SKIPE ;PASS TEST IF C(AC0)=0
STOP
;**********
;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE
;RESULT IN THE AC.
;IN THIS CASE C(E)=0,,0; HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1
;IF THE RESULT IN THE AC IS -1,,-1,THE TEST PASSES
B3700: SETCM [0] ;*SETCM SHOULD PUT -1,,-1 INTO THE AC
CAME [-1] ;PASS TEST IF C(AC)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT SETO SETS C(AC) TO -1,,-1. SETO IGNORES
;THE ADDRESS FIELD OF THE INSTRUCTION WORD.
;FIRST C(AC) IS SET TO 0,,0; THEN SETO IS EXECUTED.
;THE AC IS THEN CHECKED FOR ALL ONES. IF C(AC) IS ALL ONES,
;THE TEST PASSES
B4300: MOVEI 0 ;PRELOAD AC WITH 0,,0
SETO ;*SETO SHOULD LOAD THE AC WITH -1,,-1
CAME [-1] ;PASS TEST IF C(AC)=-1,,-1
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;0 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=0.
;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES.
;THE AC IS CHECKED FOR ITS FINAL CONTENTS NON-ZERO.
;IF C(AC) IS NOT=0, THE TEST PASSES
B4400: MOVEI 0 ;PRELOAD AC,E WITH 0
ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0
SKIPN ;PASS IF C(AC) IS NON-ZERO
STOP
;**********
;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY).
;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=0
;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES.
;THE AC IS CHECKED FOR ITS FINAL CONTENTS EQUAL TO -1,,-1
;IF C(AC0)=-1,,-1, THE TEST PASSES
B4500: MOVEI 0 ;PRELOAD AC,E WITH 0
ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0
CAME [-1] ;PASS IF C(AC)=-1,,-1
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;0 SW: ET0
;0 FC: AD AR + EN
;0 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY).
;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=-1,,-1
;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES.
;THE AC IS CHECKED FOR ITS FINAL CONTENTS EQUAL TO -1,,-1
;IF C(AC0)=-1,,-1, THE TEST PASSES
B4600: MOVE [-1] ;PRELOAD AC,E WITH -1,,-1
ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0
CAME [-1] ;PASS IF C(AC)=-1,,-1
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;0 FC: AD FM - EN
;0 ET0: AR AD EN
;**********
;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1; HENCE, THE RESULT
;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR ITS INAL CONTENTS=0.
;IF C(AC)=0, THE TEST PASSES
B4700: MOVEI 0 ;PRELOAD AC WITH 0
ORCM [-1] ;*ORCM SHOULD PLACE ALL ZEROS INTO THE AC
SKIPE ;PASS IF C(AC)=0,,0
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;-E SW: FCE
;**********
;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH C(E).
;IN THIS CASE AC=E AND C(AC)=C(E)=0,,0. HENCE THE
;RESULT IN THE AC SHOULD BE 0,,0.
;THE AC IS CHECKED FOR 0,,0. IF C(AC)=0,,0, THIS TEST PASSES
B5000: MOVEI 0 ;PRELOAD AC,E WITH 0,,0
IOR ;*IOR SHOULD PUT 0 INTO AC
SKIPE ;PASS TEST IF C(AC)=0,,0
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;-1,,-1 SW: ET0
;-1,,-1 ET0: AR AD EN
;-1,,-1 ET0: AD AR - EN
;-1,,-1 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH C(E).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE
;RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED FOR -1,,-1
;IF C(AC) =-1,,-1 THE TEST PASSES.
B5100: MOVEI 0 ;PRELOAD AC WITH 0
IOR [-1] ;*IOR SHOULD PUT -1,,-1 INTO AC
CAME [-1] ;PASS TEST IF C(AC) =-1,,-1
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;E SW: FCE
;0 FC: AD AR - EN
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;0 FC: AD FM - EN
NB5300:;**********
;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH C(E).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE
;RESULT IN THE AC SHOULD BE -1,,-1
;THE AC IS CHECKED FOR ITS CONTENTS = ALL ONES
;IF C(AC)=-1, THE TEST PASSES
B5200: SETO ;PRELOAD AC WITH -1,,-1
IOR [-1] ;*IOR SHOULD PUT -1,,-1 INTO AC
CAME [-1] ;PASS TEST IF C(AC)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH C(E).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE
;RESULT IN THE AC SHOULD BE -1,,-1
;THE AC IS CHECKED FOR ITS CONTENTS = ALL ONES
;IF C(AC)=-1,,-1, THE TEST PASSES
B5300: SETO ;PRELOAD AC WITH -1,,-1
IOR [0] ;*IOR SHOULD PUT -1,,-1 INTO AC
CAME [-1] ;PASS TEST IF C(AC)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND
;OF C(AC) AND THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT
;IN THE AC SHOULD BE 0,,-1
;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THE TEST PASSES
B5500: SETO ;PRELOAD AC WITH ALL ONES
ANDCM [XWD -1,0] ;*ANDCM SHOULD PLACE 0,,-1 IN THE AC
CAME [0,,-1] ;IF C(AC)=0,,-1, THE TEST PASSES
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;-E SW: FCE
;-1,,-1 FC: AD AR - EN
;-1,,0 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND
;OF C(AC) AND THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=0. HENCE,
;THE RESULT IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0.
;IF C(AC)=0, THE TEST PASSES.
B5600: SETO ;PRELOAD AC WITH ALL ONES
ANDCM ;*ANDCM SHOULD PLACE 0 IN THE AC
SKIPE ;IF C(AC)=0, THE TEST PASSES.
STOP
;**********
;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND
;OF C(AC) AND THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE C(AC)=-1,,-1, AND C(E)=0. HENCE, THE RESULT IN THE AC
;SHOULD BE ALL ONES. THE AC IS CHECKED FOR -1,,-1.
;IF C(AC)=-1,,-1, THE TEST PASSES
B5700: SETO ;PRELOAD AC WITH 0
ANDCM [0] ;*ANDCM SHOULD PLACE -1,,-1 IN THE AC
CAME [-1] ;IF C(AC)=-1,,-1, THE TEST PASSES
STOP
;**********
;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND
;OF C(AC) AND THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC
;SHOULD BE 0. THE AC IS CHECKED FOR 0.
;IF C(AC)=0, THE TEST PASSES
B6000: MOVEI 0 ;PRELOAD AC WITH 0
ANDCM ;*ANDCM SHOULD PLACE 0 IN THE AC
SKIPE ;IF C(AC)=0, THE TEST PASSES.
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;-1,,-1 FC: AD FM + EN
;**********
;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND
;OF C(AC) AND THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC
;SHOULD BE 0. THE AC IS CHECKED FOR 0.
;IF C(AC)=0, THE TEST PASSES
B6100: SETZ ;PRELOAD AC WITH 0
ANDCM [-1] ;*ANDCM SHOULD PLACE 0 IN THE AC
SKIPE ;IF C(AC)=0, THE TEST PASSES
STOP
;**********
;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC
;SHOULD BE 0. THE AC IS CHECKED FOR ZERO. IF C(AC) IS
;EQUAL TO ZERO, THE TEST PASSES.
B6200: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0
ANDCA [0] ;*ANDCA SHOULD PLACE 0 IN THE AC
SKIPE ;IF C(AC)=0, THE TEST PASSES.
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;E SW: FCE
;0,,-1 FC: AD AR + EN
;**********
;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE, THE
;RESULT IN THE AC SHOULD BE 0,,707070. THE AC IS CHECKED
;FOR 0,,707070. IF C(AC)=0,,707070, THE TEST PASSES.
B6300: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0
ANDCA [707070707070] ;*ANDCA SHOULD PLACE 0,,707070 IN THE AC
CAME [XWD 0,707070] ;IF C(AC)=0,,707070, THE TEST PASSES
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;707070,,707070 FC: AD FM - EN
;707070,,707070 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=0. HENCE, THE RESULT
;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC=0,
;THE TEST PASSES.
B6400: SETZ ;CLEAR THE AC AND E
ANDCA ;*ANDCA SHOULD PLACE 0 IN THE AC
SKIPE ;IF C(AC)=0, THE TEST PASSES
STOP
;**********
;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1. THE AC IS CHECKED FOR ALL ONES.
;IF C(AC)=-1,,-1, THE TEST PASSES.
B6500: SETZ ;CLEAR THE AC
ANDCA [-1] ;*ANDCA SHOULD PLACE ALL ONES IN THE AC
CAME [-1] ;IF C(AC)=ALL ONES, THE TEST PASSES.
STOP
;**********
;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT
;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0,
;THE TEST PASSES.
B6600: SETO ;PRESET AC TO ALL ONES
ANDCA ;*ANDCA SHOULD PLACE 0 IN THE AC
SKIPE ;IF C(AC)=0, THE TEST PASSES
STOP
;**********
;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC
;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0,
;THE TEST PASSES.
B6700: SETO ;PRESET AC TO ALL ONES
ANDCA [0] ;*ANDCA SHOULD PLACE 0 IN THE AC
SKIPE ;IF C(AC)=0, THE TEST PASSES.
STOP
;**********
;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE C(AC)=-1,,0 AND C(E)=0; HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1,
;THIS TEST PASSES.
B7000: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0
ANDCB [0] ;*ANDCB SHOULD PLACE 0,,-1 IN THE AC
CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;0,,-E SW: FCE
;-1,,-1 FC: AD FM - EN
;0 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,-1; HENCE, THE RESULT IN THE AC
;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0,
;THIS TEST PASSES.
B7100: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0
ANDCB [-1] ;*ANDCB SHOULD PLACE 0 IN AC
SKIPE ;PASS IF C(AC)=0
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;0,,-1 FC: AD AR - EN
;**********
;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC
;SHOULD BE ALL ONES. THE AC IS CHECKED FOR ALL ONES. IF C(AC)=-1,,-1,
;THE TEST PASSES.
B7200: SETZ ;PRELOAD AC,E WITH ZEROES
ANDCB ;*ANDCB SHOULD PLACE ALL ONES IN THE AC
CAME [-1] ;PASS IF C(AC) IS ALL ONES
STOP
;**********
;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1. HENCE THE RESULT IN THE AC
;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES.
B7300: SETO ;PRELOAD AC,E WITH ONES
ANDCB ;*ANDCB SHOULD PLACE ALL ZEROS IN THE AC
SKIPE ;PASS IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC
;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES.
B7400: SETZ ;PRELOAD AC WITH 0
ANDCB [-1] ;*ANDCB SHOULD PLACE 0 IN THE AC
CAIE ;PASS IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC
;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES.
B7500: SETO ;PRELOAD AC WITH -1,,-1
ANDCB [0] ;*ANDCB SHOULD PLACE 0 IN THE AC
CAIE ;PASS IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1,
;THIS TEST FAILS.
B7600: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0
ORCA [0] ;*ORCA SHOULD PLACE 0,,-1 IN THE AC
CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;-1,,0 SW: ET0
;-1,,0 FC: AD AR - EN
;0 FC: AD FM + EN
;-1,,-1 ET0: AR AD EN
;-1,,-1 ET0: AD AR - EN
;-1,,0 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE, THE RESULT IN THE AC
;SHOULD BE 707070,,-1. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0,
;THIS TEST FAILS.
B10000: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0
ORCA [707070707070] ;*ORCA SHOULD PLACE 707070,,-1 IN THE AC
CAME [XWD 707070,-1] ;PASS IF C(AC)=707070,,-1
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;0,,-1 SW: FCE
;**********
;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES.
B10100: SETZ ;PRELOAD AC,E WITH 0
ORCA ;*ORCA SHOULD PLACE -1,,-1 IN THE AC
CAME [-1] ;PASS IF C(AC)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OF FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES.
B10200: SETO ;PRELOAD AC,E WITH 0
ORCA ;*ORCA SHOULD PLACE -1,,-1 IN THE AC
CAME [-1] ;PASS IF C(AC)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESUTL IN THE AC
;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES.
B10300: SETZ ;PRELOAD AC WITH 0
ORCA [-1] ;*ORCA SHOULD PLACE -1,,-1 IN THE AC
CAME [-1] ;PASS IF C(AC)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC
;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES.
B10400: SETO ;PRELOAD AC WITH -1,,-1
ORCA [0] ;*ORCA SHOULD PLACE 0 IN THE AC
CAIE ;PASS IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E)
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE THE RESULT
;IN THE AC 070707,,-1. THE AC IS CHECKED FOR 070707,,-1. IF C(AC)=070707,,-1,
;THIS TEST PASSES
B10500: MOVE [XWD -1,0] ;PRELOAD THE AC WITH -1,,0
ORCB [707070707070] ;*ORCB SHOULD PLACE 070707,,-1 IN THE AC
CAME [XWD 070707,-1] ;PASS IF C(AC)=070707,,-1
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;-1,,-1 SW: FCE
;707070,,0 SW: ET0
;0,,-1 FC: AD AR + EN
;070707,,070707 FC: AD FM + EN
;070707,,070707 ET0: AR AD EN
;-1,,-1 ET0: AD AR - EN
;707070,,0 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E)
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE THE RESULT
;IN THE AC -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0,
;THIS TEST PASSES
B10700: MOVE [XWD 0,-1] ;PRELOAD THE AC WITH 0,,-1
ORCB [-1] ;*ORCB SHOULD PLACE -1,,0 IN THE AC
CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0
STOP
;**********
;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)-1,,-1, THE TEST PASSES
B11000: SETZ ;PRELOAD AC WITH 0
ORCB [0] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC
CAME [-1] ;PASS IF C(AC)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC
;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES
B11100: SETO ;PRELOAD AC WITH -1,,-1
ORCB [-1] ;*ORCB SHOULD PLACE 0 IN THE AC
CAIE ;PASS IF C(AC)=0
STOP
;**********
;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E)
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES
B11200: SETZ ;PRELOAD AC WITH 0
ORCB [-1] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC
CAME [-1] ;PASS IF C(AC)=-1,,-1
STOP
;**********
;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES
B11300: SETO ;PRELOAD AC WITH -1,,-1
ORCB [0] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC
CAME [-1] ;PASS IF C(AC)=-1,,-1
STOP
;**********
SUBTTL TEST OF MOVN INSTRUCTION
;**********
;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC
;IN THIS CASE C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0, THE NEGATIVE OF 0. IF C(AC)=0, THIS TEST PASSES
B11500: SETO ;PRELOAD AC WITH -1,,-1
MOVN [0] ;*MOVN SHOULD PLACE 0 INTO THE AC
SKIPE ;PASS IF C(AC)=0
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;E SW: FCE
;-1,,-1 FC: AD FM + EN
;-1,,-1 FC: AD CRY 36
;**********
;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC.
;IN THIS CASE C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE 1,,0
;THE AC IS CHECKED FOR 1,,0. IF C(AC)=1,,0, THE TEST PASSES
B11600: MOVE [XWD -1,0] ;PRELOAD AC,E WITH -1,,0
MOVN ;*MOVN SHOULD PLACE 1,,0 INTO THE AC
CAME [XWD 1,0] ;PASS IF C(AC)=1,,0
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;0 FC: AD ADD
;0 FC: AD FM - EN
;0 FC: AD AR - EN
;-1,,0 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC.
;IN THIS CASE C(E) =707070,,707070. HENCE, THE RESULT IN THE AC SHOULD BE
;070707,,070710. THE AC IS CHECKED FOR 070707,,070710. IF C(AC)=
;070707,,070710, THE TEST PASSES
B11700: SETZ ;PRELOAD AC WITH 0
MOVN [707070707070] ;*MOVN SHOULD PLACE 070707,,070710 INTO THE AC
CAME [070707070710] ;PASS IF C(AC) 070707,,070710
STOP
;**********
;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC
;IN THIS CASE C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0,,1.
;THE AC IS CHECKED FOR 0,,1, THE NEGATIVE OF -1,,-1. IF C(AC)=1, THIS TEST PASSES
B12100: MOVN [-1] ;*MOVN SHOULD PLACE 0,,1 INTO THE AC
CAIE 1 ;PASS OF C(AC)=0,,1
STOP
;**********
SUBTTL TEST OF MOVM INSTRUCTION
;**********
;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC.
;IN THIS CASE, C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES
B12200: SETO ;PRELOAD AC WITH -1,,-1
MOVM [0] ;*MOVM SHOULD PLACE 0 INTO THE AC
SKIPE ;PASS IF C(AC)=0
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;E SW: FCE
;**********
;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC
;IN THIS CASE, C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0,,1.
;THE AC IS CHECKED FOR 0,,1. IF C(AC)=0,,1, THIS TEST PASSES
B12300: SETZ ;PRELOAD AC WITH 0
MOVM [-1] ;*MOVM SHOULD PLACE 0,,1 INTO THE AC
CAIE 1 ;PASS IF C(AC)=0,,1
STOP
;***** FAILURE ANALYSIS *****
;C(AC0) C(AC1) FAILING SIGNAL
;0 FC: AD FM + EN
;0 FC: AD ADD
;0 FC: AD CRY 36
;0 FC: AD AR - EN
;-1,,-1 ET2: AR AD EN
;**********
;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC
;IN THIS CASE, C(E)=400000,,0. HENCE, THE RESULT IN THE AC SHOULD BE
;400000,,0. THE AC IS CHECKED FOR 400000,,0.
;IF C(AC)=400000,,0, THIS TEST PASSES.
B12400: SETZ
MOVM [XWD 400000,0] ;*MOVM SHOULD PLACE 400000,,0 INTO THE AC
CAME [XWD 400000,0] ;PASS IF C(AC)=400000,,0
STOP
;**********
;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC
;IN THIS CASE, C(E)=377777,,-1. HENCE, THE RESULT IN THE AC SHOULD BE
;377777,,-1. THE AC IS CHECKED FOR 377777,,-1.
;IF C(AC)=377777,,-1, THIS TEST PASSES.
B12500: SETZ ;PRELOAD AC WITH 0
MOVM [XWD 377777,-1] ;*MOVM SHOULD PLACE 377777,,-1 INTO THE AC
CAME [XWD 377777,-1] ;PASS IF C(AC)=377777,,-1
STOP
;**********
JRST BEGEND