ER[DG1]; TARGET[ILC]; %DG1, NORMALLY ASSEMBLED WITH DG0, TESTS THE MEMORIES ON BASIC PATTERNS, THE F-REGISTER, AND FUNCTIONS DEPENDENT ON MEMORIES OR F-REGISTER. IT MUST BE ASSEMBLED BEFORE DG2A FOR MAXC1 OR DG2B FOR MAXC2. % *TEST ADDRESSING FROM X AND DATA STORAGE OF BOTH LB AND RB LRXT: Q←A1, CALL[Q5], P←NULL; Y←Q, Q←P+1; *Y HOLDS 37 DURING THE REMAINDER OF THE *RB AND LB TESTS *FIRST TEST THE REGISTERS ON THE 36 PATTERNS WHICH CONTAIN A SINGLE 1 *WITH 35 ZEROES. THE PATTERN IS LCY'ED 1 IN PASSING FROM REGISTER TO REGISTER X←Y, CALL[LRBT1]; *RETURN FROM LRBT1 WITH ORIGINAL Q RCY 1 GOTO[.-1,Q EVEN]; *NOW TEST 36 PATTERNS OF A SINGLE 0 WITH 35 1'S Q←NOT Q; X←Y, CALL[LRBT1]; *RETURN FROM LRBT1 WITH ORIGINAL Q RCY 1 GOTO[.-1,Q ODD]; *NOW TEST LB SPECIAL KLUDGES LINDX AND LACS Q←A1, X←NULL; LX←A1, AC←NULL; Q←LINDX, CALL[QZT]; *LINDX DIDN'T READ 0 ON [X]=0 Q←LACS, CALL[QZT]; *LACS DIDN'T READ 0 LINDX←A0; Q←LX, CALL[NQZT]; *LINDX←A0 SUCCEEDED ON [X]=0 LACS←A0, INCAC; Q←LX, CALL[NQZT], INCX; *LACS←A0 SUCCEEDED ON [AC]=0 LBTL: LAC←A1; Q←LACS, CALL[NQZT]; *LACS FAILED ON [AC]#0 Q←LINDX, CALL[NQZT]; *LINDX FAILED ON [X]#0 LINDX←A0; Q←LX, CALL[QZT]; *LINDX← FAILED ON [X]#0 LACS←A1, INCAC; Q←LX, CALL[NQZT], INCX; *LACS← FAILED ON [AC]#0 P←AC; P; GOTO[LBTL,ALU#0]; LX←A1; Q←LINDX, CALL[QZT]; ***IT WOULD BE BETTER IF THIS TEST WERE ON ***FIVE BITS. LINDX←A0; Q←LX, CALL[NQZT]; *LINDX FAILED ON [X]=20 *[X]>17 IS REALLY A DON'T CARE FOR LINDX GOTO[SMTEST]; LRBT1: RX←Q, Q LCY 1, DECX; GOTO[.-1,X>=0]; X←Y; LX←Q, Q LCY 1, DECX; GOTO[.-1,X>=0]; *AT THIS POINT THE ORIGINAL VALUE IN Q HAS BEEN LCY'ED AFTER EACH OF 64 *LOADS SO IT CAN BE RESTORED TO THE ORIGINAL VALUE BY LCYING 8 MORE TIMES. Q LCY 1, CALL[QLCY7], X←Y; LRBTA: P←B, B←Q, Q←RX, DECX, CALL[PQCOMP]; *RB[X-1] FAILED ON [P] Q←P; Q LCY 1, GOTO[.-2,X>=0]; X←Y; LRBTB: P←B, B←Q, Q←LX, DECX, CALL[PQCOMP]; *LB[X-1] FAILED ON [P] Q←P; Q LCY 1, GOTO[.-2,X>=0], P←AC←Y; *NOW CHECK OUT ADDRESSING LB AND RB FROM AC LRBT2: P; GOTO[.-1,ALU>0], LAC←RAC←Q, DECAC, P←AC, Q LCY 1; CALL[QLCY23], Q LCY 1; LRBT4: P←B, B←Q, Q←LAC, CALL[PQCOMP]; Q←RAC, CALL[PQCOMP]; Q←P, P←AC, DECAC; P, Q LCY 1; GOTO[LRBT4,ALU>0]; *ORIGINAL Q HAS NOW BEEN CYCLED 80 TIMES SET[TT,4]; LRBT5: REPEAT[33,ILC[(LA[TT]RA[TT] LB←RB←Q, Q LCY 1, SET[TT,ADD[TT,1]])]]; CALL[QLCY10], Q LCY 1; SET[TT,4]; LRBT6: REPEAT[33,ILC[(P←B, B←Q, Q←LB, CALL[PQCOMP], LA[TT], SET[TT,ADD[TT,1]])] ILC[(Q←RB, RA[TT], CALL[CPQCOMP])]]; RETURN; *ORIGINAL Q CYCLED 107 TIMES = RCY 1 CPQCOMP: CALL[PQCOMP]; *GET PROBLEM ADDRESS FROM STACK Q←P; Q LCY 1, RETURN; *TEST OF SM INCPCOMP: P←B, B←P+1, GOTO[PQCOMP]; *SUBROUTINE "SMTC" INITIALIZES ALL THE SM AND DM REGISTERS TO VALUES BEGINNING *WITH [R7] AND [Q] AND THEN CYCLED BY 1 FOR EACH SUCCESSIVE WORD. AFTER *INITIALIZING ALL 1024 REGISTERS IT READS THEM BACK AND CHECKS FOR ERRORS. *DM[I] IS ALWAYS SET TO NOT[SM[I]]. SMTC: SY←Q, Q←NOT Q; D←Q, Q←NOT Q, INCY; Q LCY 1, GOTO[.-2,Y>=0]; SY←Q, Q←NOT Q; D←Q, Q←NOT Q, INCY; Q LCY 1, GOTO[.-2,Y<0]; SMTC0: Q←R7, P←SY, CALL[PQCOMP]; *SY←B OR B←SY FAILED SMTC1: Q←NOT Q, P←D, CALL[PQCOMP], INCY; *D←B OR B←D FAILED Q←NOT Q, DGOTO[.-1,Y>=0]; SMTC2: Q LCY 1, P←SY, CALL[PQCOMP]; *SY←B OR B←SY FAILED SMTC3: Q←NOT Q, P←D, CALL[PQCOMP], INCY; *D←B OR B←D FAILED Q←NOT Q, DGOTO[.-1,Y<0]; SMTC4: Q LCY 1, P←SY, CALL[PQCOMP,Y<0]; *SY←B OR B←SY FAILED Q←R7, RETURN; *TEST OF SM AND DM ADDRESSED FROM Y SMTEST: Y←P←NULL, DGOTO[SMT0]; R7←Q←P+1, CALL[SMTC]; GOTO[SMT1,ALU<=0], R7←Q, Y←NULL; CALL[SMTC]; SMT0: GOTO[.-2], Q RCY 1, AQ; SMT1: P←B, B←A1; R7←Q←2P, CALL[SMTC]; AQ, Q LCY 1; DGOTO[.-1,ALU<0]; CALL[SMTC], R7←Q, Y←NULL; *TEST Y U SA FOR SA FROM 0 TO 17 FOR Y FROM 0 BY 20 TO 760 *WRITE ADDRESS INTO EACH SM LOCATION SMT2: Y←P←Q←NULL; SY←Q, INCY; P←Q←B, B←P+1, GOTO[.-1,Y>=0]; SY←Q, INCY; P←Q←B, B←P+1, GOTO[.-1,Y<0]; *TEST BELOW FAILS WITH EXPECTED VALUE IN P, ACTUAL VALUE READ FROM SM IN Q. *INTENDED TO CATCH ADDRESSING FAILURES FOR SM, FAILURES MIGHT ALSO *BE THE LOW FOUR BITS OF RETURN ADDRESS. SMT3: P←B, B←A1; Y←NULL; SMTX: SET[TEMP,0]; REPEAT[20,ILC[(Q←$,SET[TEMP,ADD[TEMP,1]],SA[TEMP], CALL[INCPCOMP])]]; Q←A1, CALL[Q10]; P-Q; GOTO[SMTX,ALU<0], Y←P+1; *TEST READ ADDRESSING FROM SA FOR SA = 20 TO 377 SMT4: Q←A1, CALL[Q4]; P←B, B←Q; SET[TEMP,17]; REPEAT[360,(ILC[(Q←$, SA[TEMP], CALL[INCPCOMP], SET[TEMP,ADD[TEMP,1]])] )]; *TEST F1 = READS AND F2 = READS TREADS: STEMP←Q←NULL; P←(Q) U (AQ) U (STEMP), CALL[PZT]; *F2=READS FAILED ON BITS IN Q Q←NULL; P←(Q) U (STEMP), INHINT, CALL[PZT]; *F1=READS FAILED ON BITS IN Q Q←A1; STEMP←Q, Q←A0; P←(Q) U (AQ) U (STEMP), CALL[NPZT]; *F2=READS FAILED ON BITS IN Q P←(Q) U (STEMP), INHINT, CALL[NPZT]; *F1=READS FAILED ON BITS IN Q *TEST F1=LOADS AND F2=LOADS TLOADS: Q←A1; STEMP←Q; STEMP←X←NULL; P←STEMP, Q←A0, CALL[PQCOMP]; *F2=LOADS FAILED ON 1'S IN P STEMP←NULL, Q←A1; STEMP←X←Q; P←STEMP, CALL[PQCOMP]; *F2=LOADS FAILED ON 0'S IN P STEMP←Q; STEMP←X←NULL, INHINT; P←STEMP, Q←A0, CALL[PQCOMP]; *F1=LOADS FAILED ON 1'S IN P STEMP←NULL, Q←A1; STEMP←X←Q, INHINT; P←STEMP, CALL[PQCOMP]; *F1=LOADS FAILED ON 0'S IN P *TEST Q-REGISTER RCYQQ, RCYNOTLUQ, RCY0Q (=NO ACTION) ON * Q RSH 1 AND Q LSH 1. F2=RCYQQ HAS ALREADY BEEN TESTED ON Q RSH 1 AND *Q LSH 1 SO ONLY F1 = RCYQQ NEED BE TESTED *! MAXC1 ONLY M[RCYNOTLUQ,Z[47]]; *LANG HAS NO WAY TO INVOKE THIS F1 WITHOUT CLOBBERING P ALSO *! *~ MAXC2 ONLY M[RCYNOTLUQ,Z[7]]; *LANG2 HAS NO WAY TO INVOKE THIS F1 WITHOUT CLOBBERING P ALSO *~ TQCYC: Q←A1; Q RCY 1, INHINT, CALL[NQZT]; *F1=RCYQQ FAILED ON Q RSH 1, Q=-1 Q←A1; TQC0: Q RSH 1, RCYNOTLUQ, CALL[NQZT]; *F1=RCYNOTLUQ FAILED ON -1 Q←A1; Q RSH 1, RCY0Q; P←B, B←Q; TQC1: Q←2P+1, CALL[NQZT]; *F2=RCY0Q SCRAMBLED Q RSH 1 Q←A1; Q RSH 1, RCY0Q, INHINT; P←B, B←Q; TQC2: Q←2P+1, CALL[NQZT]; *F1=RCY0Q SCRAMBLED Q RSH 1 P←Q←B, B←A1; TQC3: Q LCY 1, INHINT, CALL[NQZT]; *F1=RCYQQ FAILED ON Q LSH 1, Q=-1 Q←A1; TQC4: Q LSH 1, RCYNOTLUQ, CALL[NQZT]; *F1=RCYNOTLUQ FAILED ON Q LSH 1, Q=-1 Q←A0; TQC5: Q RCY 1, INHINT, CALL[QZT]; *F1=RCYQQ FAILED ON Q=0, Q RSH 1 Q←A0; TQC6: Q RSH 1, RCYNOTLUQ, CALL[QZT]; *F1=RCYNOTLUQ FAILED ON Q=0,Q RSH 1 Q←A0; TQC7: Q LCY 1, INHINT, CALL[QZT]; *F1=RCYQQ FAILED ON Q=0, Q LSH 1 Q←A0; TQC8: Q LSH 1, RCYNOTLUQ, CALL[QZT]; *F1=RCYNOTLUQ FAILED ON Q=0, Q LSH 1 P←Q←NULL; TQC9: Q RSH 1, ASHOVF, CALL[PQCOMP]; *ASHOVF FAILED ON Q RSH 1 *0 IN P, 0 IN Q P←B, B←P+1; Q RSH 1, ASHOVF; TQC10: Q LCY 1, CALL[PQCOMP]; *ASHOVF FAILED ON Q RSH 1, 1 IN P, 0 IN Q Q←NULL; P←B, B←NOT P; TQC11: Q RSH 1, ASHOVF, CALL[QZT]; *ASHOVF FAILED ON Q=0, P=-2 P←B, B←A1; Q←NULL; Q RSH 1, ASHOVF; P←NULL; TQC12: Q LCY 1, P←B, B←P+1, CALL[PQCOMP]; *ASHOVF FAILED ON Q=0, P=-1 *TEST Q←RB RSH 1 FOR THE CASES PS=ALU RSH 1, F1 OR F2=RCYQQ, OR F1= *RCYNOTLUQ, OR NOT THESE TQRB: Q←R7←A1, CALL[QRB1]; Q←R7←A0, CALL[QRB1]; GOTO[FTEST]; QRB1: P←B, B←Q, Q←A0; Q←(R7) RCY 1, CALL[PQCOMP]; *RB RSH 1, F2=RCYQQ FAILED Q←(R7) RCY 1, INHINT, CALL[PQCOMP]; *RB RSH 1, F1=RCYQQ FAILED Q←(R7) RSH 1, RCYNOTLUQ, CALL[PQCOMP]; *RB RSH 1, F1=RCYNOTLUQ FAILED Q←P; Q RSH 1; QRB2: P←B, B←Q, Q←(R7) RSH 1, CALL[PQCOMP]; *RB RSH 1 FAILED L7←P; P←(A0) ARSHC 1, Q←(R7) RSH 1; *RB ARSHC 1 FAILED ON 0 THROUGH ALU QRB3: P←B, B←Q, Q←L7, CALL[PQCOMP]; P←(A1) ARSHC 1, Q←(R7) RSH 1; AQ; QRB4: CALL[CBRK,ALU>=0], P←NULL; *RB ARSHC 1 FAILED ON -1 THROUGH ALU P←B, L7←B←P+1; P←(P) ARSHC 1, Q←(R7) RSH 1; AQ, Q←L7; QRB5: CALL[CBRK,ALU>=0], P←B, B←Q; *RB ARSHC 1 FAILED ON 1 THROUGH ALU P←(NOT P) ARSHC 1, Q←(R7) RSH 1; AQ; RETURN[ALU>=0]; QRB6: BREAK; *RB ARSHC 1 FAILED ON -2 THROUGH ALU *TEST FLAG REGISTER FTEST: Q←A1; -1S←Q; SETF[-1S], CALL[NFZT]; *SETF OR NOT F (OR F) FAILED (WRONG BITS IN Q) CLEARF[-1S], CALL[FZT]; *CLEARF OR NOT F (OR F) FAILED (WRONG BITS IN Q) SETFC[-1S,NEVER], CALL[FZT,NEVER]; *SETFC TOOK ON BC=NEVER (WRONG BITS IN Q) SETFC[-1S,A], CALL[NFZT]; *SETFC FAILED TO TAKE ON BC=ALWAYS (WRONG BITS IN Q) CLEARFC[-1S,NEVER], CALL[NFZT,NEVER]; *CLEARFC FAILED ON BC=NEVER (WRONG BITS IN Q) CLEARFC[-1S,A], CALL[FZT]; *CLEARFC FAILED ON BC=ALWAYS (WRONG BITS IN Q) SETFB[-1S,A], CALL[NFZT]; *SETFB FAILED ON BC=ALWAYS (WRONG BITS IN Q) SETFB[-1S,NEVER], CALL[FZT,NEVER]; *SETFB FAILED ON BC=NEVER (WRONG BITS IN Q) *TEST SETF ON EVERY COMBINATION OF A SINGLE 1 WITH 35 0'S WITH F ORIGINALLY *0 AND WITH F ORIGINALLY THE COMPLEMENT OF THE WORD CONTAINING THE SINGLE 1. *PERFORM THE ANALOGOUS TESTS ON CLEARF. PERFORM THE COMPLEMENT TESTS. FT1: P←NULL; R7←Q←P+1; STEMP←Q, Q←NOT Q; STEMP1←Q, CALL[FTX]; *Q=STEMP1=NOT[STEMP] Q LCY 1, DGOTO[TSETSF]; GOTO[.-3,Q EVEN], R7←Q; FTX: CLEARF[-1S]; SETF[STEMP], CALL[FQNEQ]; *SETF FAILED ON [Q] CLEARF[STEMP1], CALL[FQNEQ]; *CLEARF FAILED ON NOT[Q] CLEARF[STEMP], CALL[FZT]; *CLEARF FAILED ON [Q] SETF[STEMP1], Q←R7, CALL[FQNEQ]; *SETF FAILED ON NOT[Q] Q←R7, RETURN; *NOW TEST SETSF. TSETSF: P←NULL; Q←P+1; G←Q, Q LSH 1; H←Q, Q LSH 1; J←Q, Q LSH 1; K←Q, Q LSH 1; STEMP1←Q, GOTO[.+3]; SFT1: Q LCY 1; GOTO[GBCT,Q ODD], STEMP1←Q; CALL[SETSFT]; GOTO[SFT1], Q←STEMP1; SETSFT: P←G, CALL[SFT2]; P←H, CALL[SFT2]; P←J, CALL[SFT2]; P←K, GOTO[SFT2]; *"SFT2" CALLED WITH G, H, J, OR K COMBINATION IN P AND BIT TO *BE TESTED IN Q SFT2: STEMP2←P←B, B←Q, Q←P; *STEMP2←P←BIT, Q←FLAG STEMP3←Q, Q←P OR Q; *STEMP3←G, H, J, OR K STEMP4←Q; *STEMP4←BOTH BIT AND G, H, J, OR K CLEARF[-1S]; *CLEAR ALL FLAGS SETF[STEMP2], Q←$, CALL[FQEQ]; *SETF FAILED ON NOT[Q] SETSF[STEMP4], Q←$, CALL[FQEQ]; *SETSF FAILED TO SET FLAG = 1 CLEARF[STEMP3]; Q←STEMP2, CALL[FQEQ]; *CLEARF FAILED ON BIT IN STEMP3 *NOW TEST FOR ALL 37 CASES WHEN SETSF DOES NOT SET THE SELECTED FLAGS TO 1 SFT3: Q←STEMP2, GOTO[SFT5]; SFT3X: P←STEMP2; P#Q, STEMP5←Q; GOTO[SFT4,ALU=0], P←B, B←NOT P; Q←(Q) U (STEMP3); STEMP4←Q; SETSF[STEMP4], CALL[FPEQ]; *SETSF SET SOME FLAG TO 1 IT SHOULDN'T HAVE. Q←STEMP5; SFT5: Q LCY 1, DGOTO[SFT3X]; CALL[QLCY4,Q ODD]; SFT4: Q←STEMP1, RETURN; *NOW TEST G, H, J, AND K BRANCH CONDITIONS GBCT: CLEARF[-1S]; SETF[G]; GOTO[.+2,G=1]; BREAK; *G=1 BC FAILED ON TRUE CALL[CBRK,G=0], SETF[-1S]; *G=0 BC FAILED ON FALSE CLEARF[G]; GOTO[.+2,G=0]; BREAK; *G=0 BC FAILED ON TRUE CALL[CBRK,G=1]; *G=1 BC FAILED ON FALSE HBCT: CLEARF[-1S]; SETF[H]; GOTO[.+2,H=1]; BREAK; *H=1 FAILED ON TRUE CALL[CBRK,H=0], SETF[-1S]; *H=0 FAILED ON FALSE CLEARF[H]; GOTO[.+2,H=0]; BREAK; *H=0 FAILED ON TRUE CALL[CBRK,H=1]; *H=1 FAILED ON FALSE JBCT: CLEARF[-1S]; SETF[J]; GOTO[.+2,J=1]; BREAK; *J=1 FAILED ON TRUE CALL[CBRK,J=0], SETF[-1S]; *J=0 FAILED ON FALSE CLEARF[J]; GOTO[.+2,J=0]; BREAK; *J=0 FAILED ON TRUE CALL[CBRK,J=1]; *J=1 FAILED ON FALSE KBCT: CLEARF[-1S]; SETF[K]; GOTO[.+2,K=1]; BREAK; *K=1 FAILED ON TRUE CALL[CBRK,K=0], SETF[-1S]; *K=0 FAILED ON FALSE CLEARF[K]; GOTO[.+2,K=0]; BREAK; *K=0 FAILED ON TRUE CALL[CBRK,K=1]; *K=1 FAILED ON FALSE *TEST Q35ALUG (Q35←ALU0[PREVIOUS INSTRUCTION] # G) IF Q LSH 1 TQ35AG: P←Q←NULL, CALL[TQ35X]; Q←A1, CALL[Q43]; P←B, B←Q, Q←A0, CALL[TQ35X]; GOTO[MPTEST]; TQ35X: CLEARF[G], P; Q LSH 1, Q35ALUG; CALL[CBRK,Q ODD], NOT P; *Q35ALUG FAILED ON G=0, ALU0=0, Q35=0 Q LSH 1, Q35ALUG, CALL[CBRK,Q ODD]; *Q35ALUG FAILED ON G=0, ALU0=0,Q35=0 CALL[CBRK,Q EVEN], NOT P; *Q35ALUG FAILED ON G=0, ALU0=1, Q35=0 Q LSH 1, Q35ALUG, CALL[CBRK,Q EVEN]; *Q35ALUG FAILED ON G=0,ALU0=1,Q35=0 CALL[CBRK,Q EVEN], SETF[G], P; *Q35ALUG FAILED ON G=0, ALU0=1, Q35=1 Q LSH 1, Q35ALUG, CALL[CBRK,Q EVEN]; *Q35ALUG FAILED ON G=0,ALU0=1,Q35=1 CALL[CBRK,Q EVEN], NOT P; *Q35ALUG FAILED ON G=1, ALU0=0,Q35=1 Q LSH 1, Q35ALUG, CALL[CBRK,Q EVEN]; *Q35ALUG FAILED ON G=1,ALU0=0,Q35=1 CALL[CBRK,Q ODD]; *Q35ALUG FAILED ON G=1,ALU0=1,Q35=1 RETURN[Q EVEN]; BREAK; *Q35ALUG FAILED ON G=1, ALU0=1 *SUBROUTINES TO FILL 1024 MAP ENTRIES WITH Q, Q LCY 1, Q LCY 2, ETC. *AND THEN READ BACK AND CHECK THE RESULTS. ORIGINAL Q IS *RETURNED IN Q. [Y]=0, CUM=0, [P]=777777 AT CALL. MPTCX: Q←P AND Q, P←B, B←Q; MAP←Q, Q←P, INCY; Q LCY 1, GOTO[.-2,Y>=0], P←777777S; Q←P AND Q, P←B, B←Q; MAP←Q, Q←P, INCY, DGOTO[.-1]; Q LCY 1, P←777777S, RETURN[Y>=0]; MPTCY: R11←L7←P AND Q, Q LCY 1; P←MAP, INCY, R10←Q, Q←L7, CALL[PQCOMP]; *[MAP] AT Y-1 WRONG Q←R10, P←777777S, GOTO[.-2,Y>=0]; R11←L7←P AND Q, Q LCY 1, P←MAP, INCY; R10←Q, Q←L7, CALL[PQCOMP]; *[MAP] AT Y-1 WRONG Q←R10, P←777777S, GOTO[.-2,Y<0]; RETURN; *HERE WITH [Y]=0, 777777 IN P, AND NUMBER BASE IN R7 MPTC: CLEARF[CUM], CALL[MPTCX]; *MON. MAP WRITES SETF[CUM], CALL[MPTCX]; *USER MAP WRITES CLEARF[CUM], Q←R7, CALL[MPTCY]; *MON. MAP READS SETF[CUM], GOTO[MPTCY]; *USER MAP READS MPTEST: Y←P←NULL, CLEARF[-1S]; Q←P+1, CALL[QLCY10]; CUM←Q, Q←A1, CALL[Q22]; *TEST 18 PATTERNS OF A SINGLE 1 WITH 17 ZEROES AND 18 PATTERNS OF ALL ZEROES 777777S←Q, DGOTO[MPT0]; R7←Q←P+1, CALL[MPTC], P←777777S; MPT2: GOTO[MPT1,ALU<=0], R7←Q, Y←NULL; CALL[MPTC], P←777777S; MPT0: Q LCY 1, AQ, GOTO[MPT2]; *TEST 18 PATTERNS OF A SINGLE 0 WITH 17 1'S AND 18 PATTERNS OF 777777 MPT1: P←B, B←A1, DGOTO[MPT3]; R7←Q←2P, CALL[MPTC], P←777777S; MPT4: GOTO[M4TEST,ALU>=0], R7←Q, Y←NULL; CALL[MPTC], P←777777S; MPT3: Q LCY 1, AQ, GOTO[MPT4]; *M4CHK CALLED WITH Y, CUM, AND Q LOADED WITH SOME VALUES. IT PERFORMS *MAP4← AND CHECKS IT. LH[Q] MUST BE 0 M4CHK: P←Y; MAP4←Q, R7←Q; REPEAT[4,ILC[(DECY)]]; Q←Y, CALL[PQCOMP]; *MAP4← FAILED TO INCREMENT Y BY 4 *CORRECT VALUE IN P, WRONG VALUE IN Q P←MAP, INCY, Q←R7, CALL[PQCOMP]; *MAP4← FAILED ON 0TH WORD P←MAP, INCY, Q←R7, CALL[PQCOMP]; *MAP4← FAILED ON 1ST WORD P←MAP, INCY, Q←R7, CALL[PQCOMP]; *MAP4← FAILED ON 2ND WORD P←MAP, INCY, Q←R7, GOTO[PQCOMP]; *MAP4← FAILED ON 3RD WORD *RETURN WITH Y INCREMENTED BY 4, Q UNCHANGED M4TX: Q←Y←NULL, CALL[M4CHK]; Q←NULL, CALL[M4CHK]; GOTO[.-1, Y>=0]; Q←NULL, CALL[M4CHK]; GOTO[.-1,Y<0], Q←777777S; Y←NULL, CALL[M4CHK]; Q←777777S, CALL[M4CHK]; GOTO[.-1,Y>=0]; Q←777777S, CALL[M4CHK]; GOTO[.-1,Y<0]; RETURN; M4TEST: CLEARF[CUM], CALL[M4TX]; SETF[CUM], CALL[M4TX]; *XSPLIT← PUTS B[0,8] INTO Y, B[9,12] INTO AC, B[14,17] INTO X, AND NOT *B[13] INTO G AND H TXSPLIT: Q←A1, Y←NULL, CALL[Q11]; CALL[QLCY33], P←B, B←Q; XSPLIT←Q; Q←Y, CALL[PQCOMP]; *XSPLIT← FAILED TO LOAD Y FROM 777 Q←NOT P, CALL[QLCY33]; XSPLIT←Q; Q←Y, CALL[QZT]; *XSPLIT← FAILED TO LOAD Y FROM 0 Q←A1, CALL[Q4], X←NULL; CALL[QLCY22], P←B, B←Q; XSPLIT←Q; Q←X, CALL[PQCOMP]; *XSPLIT← FAILED TO LOAD X FROM 17 Q←NOT P, CALL[QLCY22]; XSPLIT←Q; Q←X, CALL[QZT]; *XSPLIT← FAILED TO LOAD X FROM 0 Q←A1, CALL[Q4], AC←NULL; CALL[QLCY27], P←B, B←Q; XSPLIT←Q; Q←AC, CALL[PQCOMP]; *XSPLIT← FAILED TO LOAD AC FROM 17 Q←NOT P, CALL[QLCY27]; XSPLIT←Q; Q←AC, CALL[QZT]; *XSPLIT← FAILED TO LOAD AC FROM 0 P←NULL, SETF[-1S]; B←Q←P+1, CALL[QLCY26], P←B; XSPLIT←Q, Q←2P+1, CALL[FQNEQ]; *P SHOULD HAVE 3 (777777 777774) CLEARF[-1S], P←NULL; B←Q←P+1, P←B, CALL[QLCY26]; XSPLIT←Q←NOT Q; Q←2P+1, CALL[FQEQ]; *P SHOULD HAVE NOT 3 (3) (XSPLIT← FAILED TO *SET G=H=1 ON B[13]=0 *ISPLIT SHOULD LOAD X FROM B[14,17] AND G←NOT B[13]. ** ASSUME THAT ROUGHLY SAME LOGIC AS FOR XSPLIT IS USED SO WORRY **ABOUT CLOBBERING OTHER REGISTERS TISPLIT: XSPLIT←NULL; CLEARF[-1S]; ISPLIT←A1; P←AC, CALL[PZT]; *ISPLIT← CLOBBERED AC P←Y, CALL[PZT]; *ISPLIT← CLOBBERED Y P←X, Q←A1, CALL[Q4]; *Q←17 CALL[PQCOMP]; *ISPLIT← FAILED TO LOAD X FROM 17 CALL[FZT]; *ISPLIT← CLOBBERED F (SHOULD HAVE 0 IN Q) ISPLIT←NULL; Q←X, CALL[QZT]; *ISPLIT← FAILED TO LOAD X FROM 0 CALL[F1T]; *ISPLIT← FAILED TO LOAD G FROM 1 *FSPLIT← LOADS Y FROM B[0,8] TFSPLIT: XSPLIT←NULL, SETF[-1S]; *CLEAR ALL FSPLIT←Q←A1, CALL[Q11]; P←Y, CALL[PQCOMP]; *FSPLIT← FAILED TO LOAD Y FROM 777 CALL[NFZT]; *FSPLIT← CLOBBERED F Q←X, CALL[QZT]; *FSPLIT← CLOBBERED AC FSPLIT←NULL; Q←Y, CALL[QZT]; *FSPLIT← DIDN'T LOAD Y FROM 0 *BSPLIT← LOADS Y FROM B[0,5] AND X FROM B[6,11] TBSPLIT: XSPLIT←NULL; CLEARF[-1S], Q←A1, CALL[Q6]; CALL[QLCY36], R7←Q; BSPLIT←Q, Q←R7; P←Y, CALL[PQCOMP]; *BSPLIT← FAILED TO LOAD Y FROM 77. Q←X, CALL[QZT]; *BSPLIT← FAILED TO LOAD X FROM 0 Q←R7, CALL[QLCY30]; BSPLIT←Q; Q←Y, CALL[QZT]; *BSPLIT← FAILED TO LOAD Y FROM 0 P←X, CALL[PQCOMP], Q←R7; *BSPLIT← FAILED TO LOAD X FROM 77 *TEST STACK← FOR ITS AFFECT ON G. PREVIOUSLY TESTED ONLY DATA PUSHING *AND POPPING. G←G OR (B[0]=0) IS SUPPOSED TO OCCUR. TSTACKG: CLEARF[-1S], Q←A1, CALL[Q43]; STACK←NULL; CALL[CBRK,G=0]; *G WRONG AFTER STACK←NULL (SHOULD CHANGE 0 TO 1) STACK←A1; CALL[CBRK,G=0]; *G WRONG AFTER STACK←A1 (SHOULD REMAIN 1) CLEARF[-1S]; STACK←A1; CALL[CBRK,G=1]; *G WRONG AFTER STACK←A1 (SHOULD REMAIN 0) STACK←Q; CALL[CBRK,G=0]; *G WRONG AFTER STACK←377777 777777 (G SHOULD GO 0 TO 1) STACK←NOT Q; CALL[CBRK,G=0]; *G WRONG AFTER STACK←400000 000000 (SHOULD REMAIN 1) *THIS COMPLETES TEST OF ALL SOURCES AND DESTINATIONS APART FROM THOSE *RELATED TO THE DISK UNITS OR INTERRUPT SYSTEM, TO THE INSTRUCTION *MEMORY, AND TO THE MEMORY INTERFACES. GOTO[TOVPC01]; %"OPC01T" ACCEPTS ARGUMENTS FOR P+Q AND P-Q-1 IN P AND Q, PROPER VALUE FOR F AFTER P+Q IN STEMP1, PROPER VALUE FOR F AFTER P-Q-1 IN STEMP2. SETOVPC01 IS CHECKED FOR P+Q AND P-Q-1 WITH F ORIGINALLY 0 AND ORIGINALLY -1. CJ&SJC IS ALSO CHECKED FOR BOTH INITIAL VALUES OF J FOR THE ARGU- MENTS IN P AND IN Q. SETHOVF IS ALSO CHECKED. % OPC01T: CLEARF[-1S], L7←Q; P+Q, SETOVPC01; OPCT0: Q←STEMP1, R7←P, CALL[FQEQ]; *SETOVPC01 FAILED ON P+Q, F=0 CALL[TCJ]; Q←R7; P←B, B←Q, Q←L7, SETF[-1S]; OPCT1: P+Q, SETOVPC01, CALL[NFZT]; *SETOVPC01 ZEROED OVF, PC0, OR PC1 Q←R7, CLEARF[-1S]; P←B, B←Q, Q←L7; OPCT2: P-Q-1, SETOVPC01, Q←STEMP2, CALL[FQEQ]; *SETOVPC01 FAILED ON P-Q-1, F=0 CALL[TCNJ]; Q←R7; P←B, B←Q, Q←L7, SETF[-1S]; OPCT3: P-Q-1, SETOVPC01, CALL[NFZT]; *SETOVPC01 ZEROED OVF, PC0, OR PC1 RETURN, P←Q←NULL; TCJ: Q←R7; P←B, B←Q, Q←L7, CLEARF[400000 000000S]; R10←P+Q+J, GOTO[TCJ1,J=1]; P+Q, SETHOVF; P←B, B←P+Q, Q←R10, CALL[PQCOMP], SETOVPC01; *P+Q+J # P+Q FOR J=0; P+Q IS IN P, *P+Q+J IN Q, ORIGINAL P IN R7, ORIGINAL Q IN L7 TCNJ2: SETSF[PC0&G], GOTO[.+3,J=0]; GOTO[THO,G=1]; BREAK; *J AFTER CJ&SJC # PC0 (PC0 WAS 0) CALL[CBRK,G=1]; *J AFTER CJ&SJC # PC0 (PC0 WAS 1) THO: Q←R7; P←B, B←Q, Q←L7, SETSF[OVF&G]; GOTO[.+3,G=0]; RETURN[H=1]; BREAK; *H=0 AFTER SETHOVF WHEN OVF=1 RETURN[H=0]; BREAK; *H=1 AFTER SETHOVF WHEN OVF=0 TCJ1: P+Q+1, SETHOVF; P←B, B←P+Q+1, Q←R10, CALL[PQCOMP], SETOVPC01; *P+Q+J # P+Q+1 FOR J=1, (SEE EARLIER COMMENT) TCNJ: Q←R7; P←B, B←Q, Q←L7, CLEARF[400000 000000S]; R10←P-Q-NJ, GOTO[TCNJ1,J=0]; P-Q, SETHOVF; P←B, B←P-Q, Q←R10, SETOVPC01, CALL[PQCOMP]; *P-Q-NJ # P-Q FOR J=1 GOTO[TCNJ2]; TCNJ1: P-Q-1, SETHOVF; P←B, B←P-Q-1, Q←R10, SETOVPC01, CALL[PQCOMP]; *P-Q-NJ # P-Q-1 FOR J=0 GOTO[TCNJ2]; *TEST OF OVF, PC0, AND PC1 BEGINS HERE AND USES THE SUBROUTINES ABOVE TOVPC01: P←NULL; Q←P←B, B←P+1, CALL[QLCY42]; Q←P OR Q; PC0&G←Q, Q←P, CALL[QLCY43]; Q←P OR Q; OVF&G←Q; Q←A1, CALL[Q43]; Q←NOT Q; 400000 000000S←Q; STEMP1←P←Q←NULL; TOP01: STEMP2←NULL, CALL[OPC01T]; *00,00 = 000,000 Q←P+1, CALL[QLCY41]; P←B, B←R11←Q, Q LCY 1; *R11←100000 000000 R12←Q; *R12←200000 000000 R15←P OR Q, Q LCY 1; *R15←300000 000000 B←R13←Q, P←B; *R13←400000 000000 Q←R12; R14←P OR Q; *R14←600000 000000 *THE NUMBERS IN THE COMMENTS BELOW REFER TO THE 2 LEADING BITS OF P AND *OF Q AND TO THE RESULTING OVF, PC0, AND PC1 RESULTS FOR P+Q AND P-Q, *RESPECTIVELY TOP02: P←NULL, Q←R12, CALL[OPC01T]; *00,01 = 000,000 TOP03: P←NULL, Q←R13, CALL[OPC01T]; *00,10 = 000,000 TOP04: Q←R14, P←NULL, CALL[OPC01T]; *00,11=000,000 Q←R12; Q←R15, P←B, B←Q; TOP05: STEMP2←Q, Q←A0, CALL[OPC01T]; *01,00=000,011 Q←R14; TOP06: P←B, B←Q, Q←A0, CALL[OPC01T]; *11,00=000,011 Q←R13; P←B, B←Q, Q←R14; TOP07: STEMP2←Q, Q←A0, CALL[OPC01T]; *10,00=000,110 Q←R13; TOP10: P←B, B←Q, Q←R12, CALL[OPC01T]; *10,01=000,110 Q←R13; P←B, B←Q, Q←R11; R16←Q←P OR Q; *R16←500000 000000 STEMP2←Q, Q←R12; TOP11: P←B, B←Q, Q←R13, CALL[OPC01T]; *01,10=000,101 STEMP2←NULL, Q←R13; P←B, B←Q, Q←R14; TOP12: STEMP1←Q, CALL[OPC01T]; *10,11=110,000 Q←R13; TOP13: P←B, B←Q, CALL[OPC01T]; *10,10=011,000 Q←R16; STEMP1←Q, Q←R12; TOP14: P←B, B←Q, CALL[OPC01T]; *01,01=101,000 Q←R15; STEMP1←Q, Q←R14; TOP15: P←B, B←Q, CALL[OPC01T]; *11,11=011,000 Q←R12; TOP16: P←B, B←Q, Q←R14, CALL[OPC01T]; *01,11=011,000 Q←R14; TOP17: STEMP2←Q, P←B, Q←R12, CALL[OPC01T]; *11,01=011,110 P←Q←STEMP2; STEMP1←Q, Q←R15; TOP20: STEMP2←Q, Q←R13, CALL[OPC01T]; *11,10=110,011 ***DG2A.MC (MAXC1) OR DG2B.MC (MAXC2) MUST BE ASSEMBLED AFTER THIS***