ER[DGREG];

%TO ASSEMBLE:	@MI@ DGREG
TO RUN:		MIDAS DGREG
		START;G

THIS DIAGNOSTIC TESTS ASSORTED REGISTERS WITH RANDOM NUMBERS.  DGBASIC AND
DGP MUST WORK BEFORE THIS IS TRIED.  PROBABLY DGRL, DGALU, DGIMH, AND DGIML
SHOULD BE TESTED FIRST, BUT NOT NECESSARILY.

THE DIAGNOSTIC PERMITS INDIVIDUAL REGISTERS TO BE TESTED IN A LOOP BY
MANUALLY LOADING Y WITH 777 AND STARTING AT THE APPROPRIATE PLACE.
%

SM[SLC,0]; RM[RLC,0]; LM[LLC,10];

TARGET[SLC];

400000 000000V;	200000 000000V;	100000 000000V;
 40000 000000V;	 20000 000000V;	 10000 000000V;
  4000 000000V;	  2000 000000V;	  1000 000000V;
   400 000000V;	   200 000000V;	   100 000000V;
    40 000000V;	    20 000000V;	    10 000000V;
     4 000000V;	     2 000000V;	     1 000000V;
400000V;		200000V;		100000V;
 40000V;		 20000V;		 10000V;
  4000V;		  2000V;		  1000V;
   400V;		   200V;		   100V;
    40V;		    20V;		    10V;
     4V;		     2V;		     1V;
-1S: 777777 777777V;

RV[X0,7654321];
RV[X1,76543210];
RV[X2,765432100];
RV[X3,7654321000];
RV[X4,76543210000];
RV[X5,765432100000];
RV[X6,654321000007];
RV[X7,543210000076];

LVN[RAN]; LVN[RRAN]; LVN[XRAN]; LVN[COUNT];

LVN[TEMP]; RVN[RTEMP]; RVN[ICOUNT];

LVN[LDATA]; RV[LMASK,777777 777777]; LVN[LBASE];
RVN[RDATA]; LV[RMASK,777777 777777]; RVN[RBASE];
RV[WLOOK,0]; RV[RLOOK,0];
SVN[ADDR]; SVN[STEMP]; SVN[STEMP1]; RV[AINC,1];

IM[ILC,0]; TARGET[ILC];

REPEAT[20,ILC[BRKP[1]]];

MCYCLE:	BRKP[1], COUNT_P+1, GOTO[LOOP];
START:	ARM_NULL, INHINT;
	IRET, INHINT, COUNT_A0, GOTO[LOOP];

PQCOMP:	P#Q;
	RETURN[ALU=0];
CBRK:	BRKP[1], RETURN;

*RETURN RANDOM NO. IN Q AND RAN
*(USES X WHICH MUST NOT BE CLOBBERED), CLOBBERS P
RGEN:	P_RAN, Q_RX, GOTO[RGEN1,X>=0];
	Q_X7, DGOTO[6];
	X_NPC, RAN_X7_Q_P+Q, RETURN;

RGEN1:	RX_RAN_Q_P+Q, DECX, RETURN;

*SAVE RANDOM NO. GEN. STATE IN LM FOR RESTORATION LATER.  RETURN RANDOM NO. IN Q.
RMARK:	P_X, DGOTO[7], Q_RAN;
	X_NPC, RRAN_Q, GOTO[.+1];
	Q_RX, XRAN_P, GOTO[.+2,X<0];
	LX_Q, DECX, GOTO[.-1];
PXRET:	X_P, Q_RAN, GOTO[RGEN];

*RESTORE RANDOM NO. GEN FROM LM
RREST:	P_RRAN, DGOTO[7];
	X_NPC, RAN_P, GOTO[.+1];
	Q_LX, GOTO[PXRET,X<0];
	RX_Q, P_XRAN, DECX, GOTO[.-1];

*START HERE--USE Y<0 TO INDICATE REPEATED ITERATIONS.  SET Y > 0 TO
*CAUSE REPEATED ITERATION OF ONE TEST
LOOP:	Y_NULL;
*~ MAXC2 ONLY
	CALL[EREGSM];
	CALL[EREGQ];
	CALL[EREGALU];
*~
	CALL[FPTEST];
	CALL[FQTEST];
	CALL[SETSFF];
	CALL[SETSFT];
	P_COUNT, GOTO[MCYCLE];

*~ MAXC2 ONLY
*READ AND WRITE EREG FROM SM USING RANDOM DATA
EREGSM:	CALL[RGEN];
	STEMP_Q;
	B_NOT Q;
	B_STEMP, SIGNOVA, DGOTO[EREGSM,Y<0];
	P_EREG, CALL[PQCOMP];
	RETURN;

*READ AND WRITE EREG FROM Q USING RANDOM DATA
EREGQ:	CALL[RGEN];
	B_NOT Q;
	B_Q, SIGNOVA, DGOTO[EREGQ,Y<0];
	P_EREG, CALL[PQCOMP];
	RETURN;

*READ AND WRITE EREG FROM ALU USING RANDOM DATA
EREGALU: CALL[RGEN];
	B_Q_NOT Q, SIGNOVA, DGOTO[EREGALU,Y<0];
	P_EREG, CALL[PQCOMP];
	RETURN;

*SET AND CLEAR F FROM STEMP USING RANDOM DATA
*(READS F INTO P WHICH HAS AN EARLY -K1 LOADING CLOCK)
FPTEST:	CALL[RGEN];
	STEMP_Q;
	CLEARF[STEMP], MDR_P_FLAGS;
	Q_P AND NOT Q, KMDR_P_FLAGS, CALL[PQCOMP];	*CLEARF FAILED
	CALL[RGEN];
	STEMP_Q;
	SETF[STEMP], MDR_P_FLAGS;
	Q_P OR Q, KMDR_P_FLAGS, CALL[PQCOMP];		*SETF FAILED
	Q_37 777777L, P_FLAGS, DGOTO[FPTEST,Y<0];
	Q_P AND NOT Q, P_TENF, CALL[PQCOMP];		*TENF FAILED
	RETURN;

*SET AND CLEAR F FROM STEMP USING RANDOM DATA
*(READS F INTO Q WHICH HAS A LATE -K1 LOADING CLOCK)
FQTEST:	CALL[RGEN];
	STEMP_Q;
	CLEARF[STEMP], MDR_Q_FLAGS, P_Q;
	P_NOT P AND Q, KMDR_Q_FLAGS, CALL[PQCOMP];	*CLEARF FAILED
	CALL[RGEN];
	STEMP_Q;
	SETF[STEMP], P_Q, MDR_Q_FLAGS;
	P_P OR Q, KMDR_Q_FLAGS, CALL[PQCOMP];		*SETF FAILED
	P_A1, SAMASK[27], DGOTO[FPTEST,Y<0];
	P_NOT P AND Q, Q_TENF, CALL[PQCOMP];		*TENF FAILED
	RETURN;
*~
*! MAXC1 ONLY
FPTEST:	CALL[RGEN];
	STEMP_Q;
	CLEARF[STEMP], MDR_P_NOT F;
	Q_P OR Q, KMDR_P_NOT F, CALL[PQCOMP];		*CLEARF FAILED
	CALL[RGEN];
	STEMP_Q;
	SETF[STEMP], MDR_P_NOT F, DGOTO[FPTEST,Y<0];
	Q_P AND NOT Q, KMDR_P_NOT F, CALL[PQCOMP];	*SETF FAILED
	RETURN;

FQTEST:	CALL[RGEN];
	STEMP_Q;
	CLEARF[STEMP], MDR_Q_NOT F, P_Q;
	P_P OR Q, KMDR_Q_NOT F, CALL[PQCOMP];		*CLEARF FAILED
	CALL[RGEN];
	STEMP_Q;
	SETF[STEMP], P_Q, MDR_Q_NOT F, DGOTO[FQTEST,Y<0];
	P_NOT P AND Q, KMDR_Q_NOT F, CALL[PQCOMP];	*SETF FAILED
	RETURN;
*!

*TEST SETSF WITH RANDOM NUMBERS--TEST ALWAYS FALSE
SETSFF:	CLEARF[-1S], CALL[RGEN];
	STEMP_Q;
	SETF[STEMP], Q_NOT Q;
	STEMP_Q;
*~ MAXC2 ONLY
	Q_FLAGS, P_Q, AMASK[4], SETSF[STEMP], DGOTO[SETSFF,Y<0];
	Q_NOT P AND Q, P_FLAGS, CALL[PQCOMP];
*~
*! MAXC1 ONLY
	Q_NOT F, P_Q, AMASK[4], SETSF[STEMP], DGOTO[SETSFF,Y<0];
	Q_P OR Q, P_NOT F, CALL[PQCOMP];
*!
	RETURN;

*CYCLE THROUGH THE VARIOUS BITS IN F TESTING SETSF ON THAT BIT WITH
*RANDOM VALUES FOR G, H, J, AND K
SETSFT:	MDR_Y;		*PRESERVE Y DURING TEST
SETST1:	Y_NULL, CALL[SETSFY];		*ADDRESS TABLE OF 2^N IN SM
	INCY, DGOTO[.];
	P_40R, Q_Y, CALL[.+1];
	P-Q;
	GOTO[SETSFY,ALU>0];		*RETURNS TO .-3
	Y_MDR, POP, DGOTO[SETST1];
	RETURN[Y>=0];

*TEST SETSF WITH RANDOM NUMBERS--TEST ALWAYS TRUE ON BIT SY ONLY
*RANDOM BITS IN G, H, J, AND K
SETSFY:	CLEARF[-1S], CALL[RGEN];
	Q_(Q) U (SY);
	STEMP_Q;
	SETF[STEMP], CALL[RGEN];
	P_Q, BAMASK[4], Q_SY;
	Q_P OR Q;
	STEMP_Q;
*~ MAXC2 ONLY
	SETSF[STEMP], Q_FLAGS;
	P_P OR Q, Q_FLAGS, GOTO[PQCOMP];
*~
*! MAXC1 ONLY
	SETSF[STEMP], Q_NOT F;
	P_NOT P AND Q, Q_NOT F, GOTO[PQCOMP];
*!