DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 1 DAKAET MAC 21-Dec-78 14:28 *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, AUG 1,1977 SEQ 0007 1 ;DAKAE 2 3 4 5 000003 DECVER==3 6 000000 MCNVER==0 7 8 XLIST 9 LIST 10 LALL 11 NAME \MCNVER,\DECVER^ 12 13 TITLE DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 14 ^ 15 16 ;TEST DESIGNED FOR INITIAL DEBUGGING OF PROCESSOR HARDWARE 17 ;AND TO DETECT (SOLID) FAILURES IN THE FIELD. 18 19 ;COPYRIGHT 1972,1977,1978 20 ;DIGITAL EQUIPMENT CORPORATION 21 ;MARLBORO, MASS. 01752 22 23 ;DICK MALISKA 24 ;JOHN R. KIRCHOFF 25 ;BILL SCORZELLI 26 27 000137 LOC 137 28 000137 000000 000003 MCNVER,,DECVER 29 30 NOSYM DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 2 DAKAET MAC 21-Dec-78 14:28 DIAGNOSTIC PARAMETERS SEQ 0008 31 SUBTTL DIAGNOSTIC PARAMETERS 32 33 ;PARAMETER DEFINITIONS 34 000001 EXCASB==1 35 000001 USRASB==1 36 000001 PGMEND==1 37 000100 DEBUG==100 38 39 ;FLAG DEFINITIONS 40 010000 USERF=10000 ;USER MODE FLAG 41 42 43 ;MACROS 44 45 ;SPECIAL FEATURE PARAMETERS 46 47 030674 SADR1=START 48 030674 SADR2=START 49 030674 SADR3=START 50 030674 SADR4=START 51 254000 030674 SADR5=JRST START 52 254000 030674 SADR6=JRST START 53 254000 030674 SADR7=JRST START 54 254000 030674 SADR8=JRST START 55 254000 030674 SADR9=JRST START 56 254000 030674 SADR10=JRST START 57 254000 030674 SADR11=JRST START 58 59 000000 PAREA0=0 60 000000 PAREA1=0 61 000000 PAREA2=0 62 444153 414500 PAREA3=SIXBIT/DAKAE/ 63 645560 000000 PAREA4=SIXBIT/TMP/ 64 000000 PAREA5=0 65 000000 PAREA6=0 66 001000 ITERAT==1000 67 000001 PGMEND==1 DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 3 DAKAET MAC 21-Dec-78 14:28 DIAGNOSTIC PARAMETERS SEQ 0009 68 SUBTTL DIAGNOSTIC PARAMETERS 69 70 ;ACCUMULATOR ASSIGNMENTS 71 72 ;CONTROL WORDS 73 74 400000 AROV=400000 ;ARITHMETIC OVERFLOW 75 200000 CRY0=200000 ;CARRY 0 76 100000 CRY1=100000 ;CARRY 1 77 040000 FOV=40000 ;FLOATING OVERFLOW 78 020000 BIS=20000 ;BYTE INTERRUPT 79 010000 USERF=10000 ;USER MODE FLAG 80 004000 EXIOT=4000 ;USER PRIV I/O FLAG 81 000100 FXU=100 ;FLOATING UNDERFLOW 82 000040 DCK=40 ;DIVIDE CHECK 83 84 85 ;MACROS 86 87 ; STOP - USED FOR SCOPE LOOP, IF INSTRUCTION FAILS, CHANGE (JUMPA .+1) 88 ; TO A (JUMPA X) TO CYCLE ON FAILING INSTRUCTION 89 90 DEFINE STOP (A)< 91 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 92 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 93 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 94 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 95 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1> 96 97 ; SFLAG - USED TO CLEAR ALL FLAGS THEN TO SET REQUESTED FLAG 98 99 DEFINE SFLAG (A)< 100 MOVSI 1,A 101 JFCL 17,.+1 ;RESET ALL FLAGS 102 JRST 2,.+1(1) ;SET A FLAG> DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 1 PARAM KLM 1-Aug-77 08:33 *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, AUG 1,1977 SEQ 0010 103 SUBTTL *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, AUG 1,1977 104 105 DEFINE S,<;*********************************************************************> 106 107 S^;*********************************************************************^ 108 ;*DATA SWITCHES (READ FROM CONSOLE IN EXEC MODE OR TYPED IN IN USER MODE) 109 ;*LEFT HALF SWITCHES ARE PRE-ASSIGNED FOR SUBROUTINE PACKAGE USE 110 ;*AND CONTROL LOOPING, PRINTING (TTY OR OTHER DEVICE) AND MISC. FUNCTIONS 111 S^;*********************************************************************^ 112 113 400000 ABORT== 400000 ;ABORT PROGRAM ON PASS COMPLETION 114 200000 RSTART==200000 ;RESTART TEST, PRINT TOTALS 115 100000 TOTALS==100000 ;PRINT TOTALS, CONTINUE 116 117 040000 NOPNT== 040000 ;INHIBIT ALL PRINT/TYPE OUT (EXCEPT FORCED) 118 020000 PNTLPT==020000 ;PRINT ALL DATA ON LPT (LOGICAL DEVICE, USER MODE) 119 010000 DING== 010000 ;RING BELL ON ERROR 120 121 004000 LOOPER==004000 ;ENTER EXERCISE/CHECK LOOP ON ERROR 122 002000 ERSTOP==002000 ;HALT ON TEST ERROR 123 001000 PALERS==001000 ;PRINT ALL ERRORS 124 125 000400 RELIAB==000400 ;RELIABILITY MODE 126 000200 TXTINH==000200 ;INHIBIT ERROR TEXT 127 000100 INHPAG==000100 ;INHIBIT PAGING 128 129 000040 MODDVC==000040 ;MODIFY DEVICE CODE 130 000020 INHCSH==000020 ;INHIBIT CACHE 131 000010 OPRSEL==000010 ;OPERATOR SELECTION 132 133 000004 CHAIN== 000004 ;CHAIN CONTROL SWITCH 134 135 000002 KAHZ50==000002 ;KA10 50 HERTZ POWER 136 137 ;SWITCH 17 RESERVED !!! DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 2 PARAM KLM 1-Aug-77 08:33 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 SEQ 0011 138 SUBTTL *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 139 140 S^;*********************************************************************^ 141 ;*SPECIAL SUBPROGRAM LINKAGES 142 S^;*********************************************************************^ 143 144 027772 FSELNK= 27772 ;FILE SELECT LINK 145 027773 FRDLNK= 27773 ;FILE READ LINK 146 027774 LDLNK= 27774 ;LOAD LINKAGE ADDRESS 147 027775 DDTLNK= 27775 ;DDT LINKAGE ADDRESS 148 027776 MODLNK= 27776 ;OPERATIONAL MODE CHECK LINKAGE ADDRESS 149 027777 SUBLNK= 27777 ;SUBROUTINE LINKAGE ADDRESS 150 151 S^;*********************************************************************^ 152 ;*SPECIAL SUBROUTINE FATAL HALTS 153 ;*USED TO REPORT ERRORS THAT CAUSE THE SUBROUTINES TO BE UNUSABLE 154 S^;*********************************************************************^ 155 156 ;ADDRESS TAG REASON 157 ;--------------------- 158 159 ; 1010 NOEXEC ;PROGRAM NOT CODED FOR EXEC MODE OPERATION 160 ; 1011 PLERR ;FATAL PUSH LIST POINTER ERROR 161 ; 1012 PLERR1 ;INITIAL PUSH LIST POINTER ERROR 162 ; 1013 MUOERR ;MUUO WITH LUUO HANDLER WIPED OUT 163 ; 1014 DTEBER ;DTE20 INTERRUPT WITHOUT DOORBELL 164 ; 1015 DTECER ;DTE20 CLOCK INTERRUPT WITHOUT FLAG SET 165 ; 1016 CPIERR ;CPU INITIALIZATION ERROR 166 ; 1017 EOPERR ;END OF PROGRAM ERROR 167 ; 1020 LUOERR ;INTERRUPT WITH LUUO HANDLER WIPED OUT 168 169 S^;*********************************************************************^ DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 3 PARAM KLM 1-Aug-77 08:33 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 SEQ 0012 170 S^;*********************************************************************^ 171 ;OPERATOR DEFINITIONS (NON-UUO'S) 172 S^;*********************************************************************^ 173 174 260740 000000 OPDEF GO [PUSHJ P,] ;SUBROUTINE CALL 175 263740 000000 OPDEF RTN [POPJ P,] ;SUBROUTINE RETURN 176 261740 000000 OPDEF PUT [PUSH P,] ;PUT DATA ON PUSH LIST 177 262740 000000 OPDEF GET [POP P,] ;GET DATA FROM PUSH LIST 178 254000 000000 OPDEF PJRST [JRST ] ;JRST TO ROUTINE THAT RTN'S 179 254200 000000 OPDEF HALT [JRST 4,] ;DEFINITION FOR DDT 180 254100 000000 OPDEF JRSTF [JRST 2,] ;DEFINITION FOR DDT 181 254500 000000 OPDEF JEN [JRST 12,] ;DEFINITION FOR DDT 182 183 S^;*********************************************************************^ 184 ;*SUBROUTINE INITIALIZATION CALL 185 S^;*********************************************************************^ 186 187 265000 030011 OPDEF PGMINT [JSP 0,SBINIT] ;SUBROUTINE INITIALIZATION 188 189 S^;*********************************************************************^ 190 ;*HALTING UUO'S (A MORE GRACEFUL HALT THAN SIMPLY USING THE HALT INSTRUCTION). 191 S^;*********************************************************************^ 192 193 037640 000004 OPDEF FATAL [37B8!15B12!4] ;FATAL PROGRAMMING HALT 194 037600 000004 OPDEF ERRHLT [37B8!14B12!4] ;PROGRAM ERROR HALT 195 196 S^;*********************************************************************^ 197 ;*TERMINAL INPUT UUO'S 198 ;*ALWAYS COME FROM THE CONSOLE TERMINAL IN EXEC MODE OR THE 199 ;*CONTROLLING TERMINAL (REAL TERMINAL OR PTY) IN USER MODE. 200 S^;*********************************************************************^ 201 202 037000 000003 OPDEF TTICHR [37B8!0B12!3] ;TTY, INPUT ANY CHARACTER 203 037040 000003 OPDEF TTIYES [37B8!1B12!3] ;TTY, NORMAL RETURN Y 204 037100 000003 OPDEF TTINO [37B8!2B12!3] ;TTY, NORMAL RETURN N 205 037140 000003 OPDEF TTIOCT [37B8!3B12!3] ;TTY, INPUT OCTAL WORD 206 037200 000003 OPDEF TTIDEC [37B8!4B12!3] ;TTY, INPUT DECIMAL WORD 207 037240 000003 OPDEF TTICNV [37B8!5B12!3] ;TTY, INPUT CONVERTABLE WORD 208 037300 000003 OPDEF TTLOOK [37B8!6B12!3] ;TTY, KEYBOARD CHECK 209 037340 000003 OPDEF TTALTM [37B8!7B12!3] ;TTY, ALT-MODE CHECK 210 037400 000003 OPDEF TTSIXB [37B8!10B12!3] ;TTY, INPUT SIXBIT WORD 211 037440 000003 OPDEF TTYINP [37B8!11B12!3] ;TTY, IMAGE MODE INPUT 212 037500 000003 OPDEF TTICLR [37B8!12B12!3] ;TTY, CLEAR INPUT DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 4 PARAM KLM 1-Aug-77 08:33 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 SEQ 0013 213 ;*TERMINAL OUTPUT UUO'S. 214 215 037000 000000 OPDEF PNTA [37B8!0B12!0] ;PRINT ASCII WORD 216 037000 000001 OPDEF PNTAF [37B8!0B12!1] ;PRINT ASCII WORD FORCED 217 037740 000000 OPDEF PNTAL [37B8!17B12!0] ;PRINT ASCIZ LINE 218 037740 000001 OPDEF PNTALF [37B8!17B12!1] ;PRINT ASCIZ LINE FORCED 219 037600 000003 OPDEF PSIXL [37B8!14B12!3] ;PRINT SIXBIT'Z LINE 220 037640 000003 OPDEF PSIXLF [37B8!15B12!3] ;PRINT SIXBIT'Z LINE FORCED 221 037000 000000 OPDEF PNTMSG [37B8!0B12!0] ;PRINT MESSAGE IMMEDIATE 222 037040 000000 OPDEF PNTMSF [37B8!1B12!0] ;PRINT MESSAGE IMMEDIATE FORCED 223 037100 000000 OPDEF PSIXM [37B8!2B12!0] ;PRINT SIXBIT'Z MSG IMMEDIATE 224 037200 000000 OPDEF PSIXMF [37B8!4B12!0] ;PRINT SIXBIT'Z MSG IMM FORCED 225 037000 000000 OPDEF PNTCI [37B8!0B12!0] ;PRINT CHARACTER IMMEDIATE 226 037040 000000 OPDEF PNTCIF [37B8!1B12!0] ;PRINT CHARACTER IMMEDIATE FORCED 227 037500 000000 OPDEF PNTCHR [37B8!12B12!0] ;PRINT CHARACTER 228 037500 000001 OPDEF PNTCHF [37B8!12B12!1] ;PRINT CHARACTER FORCED 229 037040 000000 OPDEF PNT1 [37B8!1B12!0] ;PRINT ONE OCTAL DIGIT 230 037040 000001 OPDEF PNT1F [37B8!1B12!1] ;PRINT 1 OCTAL DIGIT FORCED 231 037100 000000 OPDEF PNT2 [37B8!2B12!0] ;PRINT TWO OCTAL DIGITS 232 037100 000001 OPDEF PNT2F [37B8!2B12!1] ;PRINT 2 OCTAL DIGITS FORCED 233 037140 000000 OPDEF PNT3 [37B8!3B12!0] ;PRINT THREE OCTAL DIGITS 234 037140 000001 OPDEF PNT3F [37B8!3B12!1] ;PRINT THREE OCTAL DIGITS FORCED 235 037200 000000 OPDEF PNT4 [37B8!4B12!0] ;PRINT FOUR OCTAL DIGITS 236 037200 000001 OPDEF PNT4F [37B8!4B12!1] ;PRINT FOUR OCTAL DIGITS FORCED 237 037240 000000 OPDEF PNT5 [37B8!5B12!0] ;PRINT FIVE OCTAL DIGITS 238 037240 000001 OPDEF PNT5F [37B8!5B12!1] ;PRINT FIVE OCTAL DIGITS FORCED 239 037300 000000 OPDEF PNT6 [37B8!6B12!0] ;PRINT SIX OCTAL DIGITS 240 037300 000001 OPDEF PNT6F [37B8!6B12!1] ;PRINT SIX OCTAL DIGITS FORCED 241 037340 000000 OPDEF PNT7 [37B8!7B12!0] ;PRINT 7 OCTAL DIGITS 242 037340 000001 OPDEF PNT7F [37B8!7B12!1] ;PRINT 7 OCTAL DIGITS FORCED 243 037440 000000 OPDEF PNT11 [37B8!11B12!0] ;PRINT 11 OCTAL DIGITS 244 037440 000001 OPDEF PNT11F [37B8!11B12!1] ;PRINT 11 OCTAL DIGITS FORCED. 245 037400 000000 OPDEF PNTADR [37B8!10B12!0] ;PRINT PHYSICAL ADDRESS 246 037400 000001 OPDEF PNTADF [37B8!10B12!1] ;PRINT PHYSICAL ADDRESS FORCED 247 037600 000000 OPDEF PNTOCT [37B8!14B12!0] ;PRINT FULL WORD OCTAL 248 037600 000001 OPDEF PNTOTF [37B8!14B12!1] ;PRINT FULL WORD OCTAL FORCED 249 037540 000000 OPDEF PNTHW [37B8!13B12!0] ;PRINT OCTAL HALF WORDS, 6 SP 6 250 037540 000001 OPDEF PNTHWF [37B8!13B12!1] ;PRINT OCTAL HALF WORDS, 6 SP 6 FORCED 251 037700 000003 OPDEF PNTOCS [37B8!16B12!3] ;PRINT OCTAL, SUPPRESS LEADING 0'S 252 037740 000003 OPDEF PNTOCF [37B8!17B12!3] ;PRINT OCTAL, SUPPRESS LEADING 0'S FORCED 253 037640 000000 OPDEF PNTDEC [37B8!15B12!0] ;PRINT DECIMAL, SUPRESS LEADING 0'S 254 037640 000001 OPDEF PNTDCF [37B8!15B12!1] ;PRINT DECIMAL, SUPRESS LEADING 0'S FORCED 255 037700 000000 OPDEF PNTDS [37B8!16B12!0] ;PRINT DECIMAL, SPACES FOR LD 0'S 256 037700 000001 OPDEF PNTDSF [37B8!16B12!1] ;PRINT DECIMAL, SPACES FOR LD 0'S FORCED DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 5 PARAM KLM 1-Aug-77 08:33 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 SEQ 0014 257 037200 000002 OPDEF PNTNM [37B8!4B12!2] ;PRINT PROGRAM NAME 258 037000 000002 OPDEF PNTSIX [37B8!0B12!2] ;PRINT SIXBIT WORD 259 037040 000002 OPDEF PNTSXF [37B8!1B12!2] ;PRINT SIXBIT WORD FORCED 260 037240 000002 OPDEF DROPDV [37B8!5B12!2] ;CLOSE LOGICAL FILE, USER MODE 261 037100 000002 OPDEF PNTCW [37B8!2B12!2] ;PRINT DF10 CONTROL WORD 262 037140 000002 OPDEF PNTCWF [37B8!3B12!2] ;PRINT DF10 CONTROL WORD FORCED 263 037000 030242 OPDEF PCRL [37B8!0B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED 264 037040 030242 OPDEF PCRLF [37B8!1B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED FORCED 265 037000 000040 OPDEF PSP [37B8!0B12!40] ;PRINT SPACE 266 037040 000040 OPDEF PSPF [37B8!1B12!40] ;PRINT SPACE FORCED 267 037000 030243 OPDEF PCRL2 [37B8!0B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE) 268 037040 030243 OPDEF PCRL2F [37B8!1B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE) FORCED 269 037040 000007 OPDEF PBELL [37B8!1B12!7] ;PRINT TTY BELL 270 271 037040 000026 OPDEF PFORCE [37B8!1B12!26] ;PRINT FORCE, CONTROL O OVERRIDE 272 273 DEFINE PMSG (ARG),< 274 PSIXM [SIXBIT\ARG'_\]> 275 276 DEFINE PMSGF (ARG),< 277 PSIXMF [SIXBIT\ARG'_\]> 278 279 ;*SIXBTZ -- MACRO TO GENERATE SIXBIT DATA FOR PRINTING 280 ;* CONSERVES CORE OVER ASCIZ 281 282 DEFINE SIXBTZ (ARG),< [SIXBIT\ARG'_\]> 283 284 ;*CONSOLE SWITCH INPUT UUO. 285 ;*READS CONSOLE SWITCHES IF IN EXEC MODE OR ASKS FOR THEM IF 286 ;* USER MODE. 287 288 037400 000002 OPDEF SWITCH [37B8!10B12!2] ;INPUT CONSOLE SWITCHES 289 290 ;*CLOCK INITIALIZATION UUO - TO SET DESIRED CLOCK OPERATION 291 ;*EITHER IGNORE CLOCK, ONLY LET IT TICK OR CAUSE INTERRUPT TO OCCUR. 292 293 037540 000004 OPDEF CLOKOP [37B8!13B12!4] ;CLOCK OPERATION UUO - PDP-11 CLOCK 294 037200 000004 OPDEF MTROP [37B8!4B12!4] ;CLOCK OPERATION UUO - DK20 METER 295 296 ;*KL10 ONLY CACHE OPERATION UUO'S 297 298 037040 000004 OPDEF CINVAL [37B8!1B12!4] ;CACHE INVALIDATE 299 037100 000004 OPDEF CFLUSH [37B8!2B12!4] ;CACHE FLUSH 300 037140 000004 OPDEF CWRTBI [37B8!3B12!4] ;CACHE WRITE-BACK & INVALIDATE DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 6 PARAM KLM 1-Aug-77 08:33 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 SEQ 0015 301 ;*END OF PASS/PROGRAM UUOS 302 303 ;PERFORMS THE END OF PASS FUNCTIONS. INCREMENT PASS COUNT, 304 ;*DECREMENT ITERATION COUNT, CHECK IF FINISHED WITH THIS PROGRAM ETC. 305 306 037500 000004 OPDEF ENDUUO [37B8!12B12!4] ;UUO TO DISPLAY LIGHTS 307 037700 000004 OPDEF EOPUUO [37B8!16B12!4] ;END OF PROGRAM UUO 308 309 ;*MEMORY MANAGEMENT UUO'S 310 ;*UUO'S TO PERFORM VARIOUS MEMORY FUNCTIONS. MAPPING, ZEROING, PAGING, 311 ;*ADDRESS CONVERSION, ETC... 312 313 037000 000004 OPDEF MAPMEM [37B8!0B12!4] ;MAP MEMORY 314 037500 000002 OPDEF MEMZRO [37B8!12B12!2] ;ZERO MEMORY 315 037440 000002 OPDEF MEMSEG [37B8!11B12!2] ;SETUP MEMORY SEGMENT 316 037540 000002 OPDEF MAPADR [37B8!13B12!2] ;VIRTUAL TO PHYSICAL ADR CONVERT 317 037640 000002 OPDEF MAPCNK [37B8!15B12!2] ;MAP MEMORY CHUNK 318 037600 000002 OPDEF MAPSET [37B8!14B12!2] ;SET KI10 EXEC PAGE MAP 319 037740 000002 OPDEF MAPPNT [37B8!17B12!2] ;PRINT MEMORY MAP 320 321 ;*DEVICE CODE MODIFICATION UUO 322 ;*ALLOWS THE MODIFICATION OF IOT'S TO ONE DEVICE TO BE CHANGED TO 323 ;*IOT'S TO A DIFFERENT DEVICE CODE. 324 325 037340 000002 OPDEF MODPCU [37B8!7B12!2] ;MODIFY PERHIPERAL CODE, USER 326 037300 000002 OPDEF MODPCP [37B8!6B12!2] ;MODIFY PERHIPERAL CODE, PROGRAM 327 328 030000 IFNDEF MODDVL, 329 030000 IFNDEF MODDVU, 330 331 ;*"DIAMON" FILE SELECTION AND READ UUOS 332 333 037240 000004 OPDEF FSELECT [37B8!5B12!4] ;FILE SELECTION 334 037300 000004 OPDEF FREAD [37B8!6B12!4] ;FILE READ - ASCII DATA 335 037340 000004 OPDEF FRD36 [37B8!7B12!4] ;FILE READ - 36 BIT DATA 336 037400 000004 OPDEF FRD8 [37B8!10B12!4] ;FILE READ - 8 BIT DATA 337 338 ;*KI10 ONLY UUO FOR PRINTING MARGIN VALUES 339 340 037700 000002 OPDEF PNTMGN [37B8!16B12!2] ;PRINT MARGIN VALUE 341 342 XLIST 343 IFNDEF KLOLD, 368 369 ;*A MACRO TO REPORT AN ERROR AND NOT LOOP 370 371 DEFINE ERROR1 (FORMAT,CORECT,ACTUAL,F,D,ERR)< 372 SALL 373 ERUUO FORMAT,[T,,[SIXBIT\F'_\] 374 CORECT,,ACTUAL 375 [SIXBIT\D'_\],,ERR] 376 XALL> 377 378 >;END OF KLOLD CONDITIONAL 379 380 XLIST 381 LIST DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 1 FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0017 382 SUBTTL *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 383 384 030000 LOC 30000 385 386 S^;*********************************************************************^ 387 ;*PROGRAM STARTING ADDRESSES 388 ;*THESE ADDRESSES CALL VARIOUS SPECIAL START ROUTINES AND OR OPTIONS 389 ;*NORMAL START ADDRESS IS 30000 ALL OTHERS ARE SPECIAL. INVOKED BECAUSE 390 ;*OF END OF PASS, POWER FAILURE, DDT START, RE-ENTERING(TYPICALLY USER 391 ;*MODE), OR ANY NUMBER OF SPECIAL FEATURE TESTS. 392 S^;*********************************************************************^ 393 394 030000 254 00 1 00 027776 BEGIN: JRST @MODLNK ;STAND-ALONE START 395 030001 254 00 0 00 030674 $START: JRST START ;MODE CHECK STARTING ADDRESS 396 397 030002 254 00 1 00 027774 DIAGMN: JRST @LDLNK ;DIAGNOSTIC MONITOR START 398 399 030003 254 00 1 00 027774 SYSEXR: JRST @LDLNK ;SYSTEM EXERCISER START 400 401 030004 254 00 0 00 030674 SFSTRT: JRST SADR1 ;SPECIAL FEATURE START 402 403 030005 254 00 0 00 030674 PFSTRT: JRST SADR2 ;POWER FAIL RESTART 404 405 030006 254 00 0 00 030674 REENTR: JRST SADR3 ;REENTER START(USUALLY USER MODE ONLY) 406 407 030007 SRTDDT: ;COMMONLY MISTAKEN NAME FOR "DDTSRT" 408 030007 254 00 1 00 027775 DDTSRT: JRST @DDTLNK ;DDT START 409 410 030010 254 00 0 00 030723 BEGIN1: JRST STARTA ;LOOP START(END OF PASS COMES HERE) 411 030011 254 00 1 00 027777 SBINIT: JRST @SUBLNK ;PMGINT LINKAGE 412 030012 000000 000000 RETURN: 0 ;RETURN ADDRESS STORAGE 413 414 030013 254000 030674 START1: SADR7 ;OPTIONAL STARTING ADR/INSTRUCTIONS 415 030014 254000 030674 START2: SADR8 ; " 416 030015 254000 030674 START3: SADR9 ; " 417 030016 254000 030674 START4: SADR10 ; " 418 030017 254000 030674 START5: SADR11 ; " DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 2 FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0018 419 S^;*********************************************************************^ 420 ;*PROGRAM FIXED PARAMETER AREA 421 S^;*********************************************************************^ 422 423 030020 444153 414500 PNTNAM: PAREA3 ;SIXBIT PROGRAM NAME 424 030021 645560 000000 PNTEXT: PAREA4 ;SIXBIT PROGRAM EXTENSION 425 030022 000000 000000 RANDBS: PAREA1 ;RANDOM BASE NUMBER 426 030023 000000 000000 SWTEXR: PAREA2 ;SYSTEM EXERCISER SWITCHES 427 030024 000000 001000 ITRCNT: ITERAT ;PROGRAM ITERATIONS 428 030025 000000 030707 $PNAME: PGMNAM ;POINTER TO PROGRAMS NAME 429 030026 000000 000003 $PVER: MCNVER,,DECVER ;MCN & DEC VERSION LEVEL 430 030027 000000 030000 $MODVL: MODDVL ;DEVICE CODE CHANGE LOWER LIMIT 431 030030 000000 030000 $MODVU: MODDVU ;DEVICE CODE CHANGE UPPER LIMIT 432 030031 777777 777777 $EMODE: IFNDEF EXCASB,<0> IFDEF EXCASB,<-1> ;EXEC ALLOWED 433 030032 777777 777777 $UMODE: IFNDEF USRASB,<0> IFDEF USRASB,<-1> ;USER ALLOWED 434 030033 000000 000000 $DSKUP: IFNDEF DSKUPD,<0> IFDEF DSKUPD,<-1> ;DISK UPDATE MODE 435 030034 000000 000000 $MMAP: IFNDEF MEMMAP,<0> IFDEF MEMMAP,<-1> ;ALLOW MEMORY RTNS 436 030035 000000 000000 PAREA7: PAREA5 ;OPTIONAL PARAMETER 437 030036 000000 000000 PAREA8: PAREA6 ;OPTIONAL PARAMETER 438 439 S^;*********************************************************************^ 440 ;*PROGRAM VARIABLE PARAMETER AREA 441 S^;*********************************************************************^ 442 443 030037 000000 000000 USER: 0 ; 0 = EXEC, -1 = USER MODE FLAG 444 030040 000000 000000 KAIFLG: 0 ;PROCESSOR TYPE, 0 = KA10, -1 = KI10 445 030041 000000 000000 KLFLG: 0 ;PROCESSOR TYPE, 0 = KA/KI, -1 = KL10 446 030042 777777 777777 MONFLG: -1 ;DIAG MONITOR SPECIAL USER FLAG 447 030043 000000 000000 MONCTL: 0 ;DIAG MON/SYS EXR FLAG 448 030044 000000 000000 MONTEN: 0 ;-1= LOADED BY 10 449 030045 000000 000000 CLOCKF: 0 ;CLOCK TICKED FLAG 450 030046 000000 000000 CONSW: 0 ;CONSOLE SWITCH SETTINGS 451 030047 000000 000000 PASCNT: 0 ;PROGRAM PASS COUNT 452 030050 000000 000000 RUNFLG: 0 ;PROGRAM RUN FLAG 453 030051 000000 000000 TESTPC: 0 ;SUBTEST PC 454 030052 000000 000000 ERRPC: 0 ;ERROR PC 455 030053 000000 000000 ERRTLS: 0 ;ERROR TOTALS 456 030054 000000 000000 TICKS: 0 ;PROGRAM RUNNING TIME 457 030055 000000 000000 MARGIN: 0 ;KI10 MARGIN WORD VALUE 458 030056 000000 000000 $ONETM: 0 ;SUBROUTINE INITIALIZATION FLAG DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 3 FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0019 459 S^;*********************************************************************^ 460 ;*SPECIAL PROGRAM DISPATCH ADDRESSES 461 S^;*********************************************************************^ 462 463 030057 037 12 0 00 000004 BEGEND: ENDUUO ;END OF PASS 464 030060 254 00 0 00 030010 $BEND1: JRST BEGIN1 ;KEEP RUNNING PROGRAM 465 030061 037 16 0 00 000004 $BEND2: EOPUUO ;END OF PROGRAM - NO RETURN 466 030062 254000 030674 CNTLC: SADR5 ;CONTROL C XFER ADDRESS 467 030063 254000 030674 ALTMGO: SADR6 ;ALTMODE XFER ADDRESS 468 030064 CPOPJ1: ;SKIP RETURN 469 030064 350 00 0 17 000000 UUOSKP: AOS (P) ;SKIP RETURN FROM UUO 470 030065 CPOPJ: ;NON-SKIP REGULAR RETURN 471 030065 263 17 0 00 000000 UUOEXT: RTN ;UUO RETURN 472 030066 255 00 0 00 000000 UUORTN: JFCL ;ADDITIONAL USERS UUO ROUTINE 473 030067 255 00 0 00 000000 $UORTX: JFCL ;ADDITIONAL UUO LINKAGE 474 030070 255 00 0 00 000000 $UUOER: JFCL ;INITED AS (JRST $UOERX) 475 030071 255 00 0 00 000000 $ITRHL: JFCL ;ADDITIONAL INTERRUPT LINKAGE 476 030072 255 00 0 00 000000 $ITRX1: JFCL ; " 477 030073 255 00 0 00 000000 $USRHL: JFCL ; " 478 030074 255 00 0 00 000000 $RSRTX: JFCL ;ADDITIONAL POWER FAIL LINKAGE 479 030075 255 00 0 00 000000 $RSRTY: JFCL ; " 480 030076 255 00 0 00 000000 RESRT1: JFCL ; INITED AS (JRST RESRTX) 481 030077 255 00 0 00 000000 RESRT2: JFCL ; " 482 030100 255 00 0 00 000000 $PARER: JFCL ;ADDITIONAL PARITY ERROR LINKAGE 483 030101 255 00 0 00 000000 ERMORE: JFCL ;ADDITIONAL ERROR HANDLER LINKAGE 484 030102 254 04 0 00 030102 HALT . ;IMPROPER TRANSFER HALT 485 486 030103 000000 000000 $PSHER: 0 ;INITED AS (JRST PSHERR) 487 030104 000000 000000 ITRCH1: 0 ;PC & FLAGS OF CURRENT INTERRUPT 488 030105 000000 000000 0 ;INITED AS (JRST $ITRC1) 489 490 S^;*********************************************************************^ 491 ;*PROCESSOR CONTROL STORAGE 492 S^;*********************************************************************^ 493 494 030106 000000 000000 $ACC0: 0 ;INTERRUPT SAVED AC0 495 030107 000000 000000 $SVPI: 0 ;INTERRUPT SAVED PI 496 030110 000000 000000 $SVAPR: 0 ;INTERRUPT SAVED APR 497 030111 000000 000000 $SVPAG: 0 ;INTERRUPT SAVED PAG (DATAI) 498 030112 000000 000000 $SPAG1: 0 ;INTERRUPT SAVED PAG (CONI) 499 500 030113 000000 000000 $SVUUO: 0 ;CURRENT USERS UUO 501 030114 000000 000000 $SVUPC: 0 ;PC OF CURRENT USERS UUO 502 503 030115 000000 000000 REPTU: 0 ;REPEAT UUO ITERATIONS 504 030116 000000 000000 SCOPE: 0 ;ERROR HANDLER SCOPE LOOP FLAG 505 030117 000000 000000 %CORFLG:0 ; " CORRECT FLAG 506 030120 000000 000000 %COREC: 0 ; " CORRECT DATA 507 030121 000000 000000 %ACTFL: 0 ; " ACTUAL FLAG 508 030122 000000 000000 %ACTUL: 0 ; " ACTUAL DATA 509 030123 000000 000000 %DISCR: 0 ; " DISCREPENCY DATA DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 4 FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0020 510 S^;*********************************************************************^ 511 ;*UUO DISPATCH TABLE 512 S^;*********************************************************************^ 513 XLIST 514 LIST 515 030124 030070 030070 UUODIS: LUUO1,,$UUOER 516 030125 030070 030070 LUUO3,,LUUO2 517 030126 030070 030070 LUUO5,,LUUO4 518 030127 030070 030070 LUUO7,,LUUO6 519 030130 030070 030070 LUUO11,,LUUO10 520 030131 030070 030070 LUUO13,,LUUO12 521 030132 030070 030070 LUUO15,,LUUO14 522 030133 030070 030070 LUUO17,,LUUO16 523 030134 030070 030070 LUUO21,,LUUO20 524 030135 030070 030070 LUUO23,,LUUO22 525 030136 030070 030070 LUUO25,,LUUO24 526 030137 030070 030070 LUUO27,,LUUO26 527 030140 030070 030070 LUUO31,,LUUO30 528 030141 030070 030070 LUUO33,,LUUO32 529 530 S^;*********************************************************************^ 531 ;*MEMORY MANAGMENT STORAGE 532 S^;*********************************************************************^ 533 534 030142 000000 000000 DF22F: 0 ;DF10 CONTROL FLAG, 0 = 18, -1 = 22 BIT 535 030143 000000 000000 MAPNEW: 0 ;MEMORY MAPPING CONTROL FLAG, -1 = 4096K MAPPING 536 030144 000000 000000 MEMTOT: 0 ;TOTAL MEMORY SIZE IN K (1024.) 537 030145 000000 000000 MEMLOW: 0 ;LOWEST USABLE MEMORY 538 030146 MEMSIZ: BLOCK ^D41 ;MEMORY SEGMENT POINTER TABLE 539 540 S^;*********************************************************************^ 541 ;*PRINT CONTROL STORAGE 542 S^;*********************************************************************^ 543 544 030217 000000 000000 PNTFLG: 0 ;PRINT FLAG, -1 WHILE IN PRINT ROUTINE 545 030220 000000 000000 PNTENB: 0 ;PRINT ENABLE 546 030221 000000 000000 PDISF: 0 ;PRINT DISABLED FLAG 547 030222 000000 000000 PNTINH: 0 ;INHIBIT PRINT INPUT CHECKS 548 030223 000000 000000 PNTSPC: 0 ;PRINT SPACE CONTROL 549 030224 000000 000000 OPTIME: 0 ;TYPE-IN WAIT TIME 550 030225 000000 000000 $TWCNT: 0 ;TIME WAITED 551 030226 000000 000000 $DVOFF: 0 ;LOGICAL DEVICE INITED FLAG 552 030227 000000 000000 TTYFIL: 0 ;TTY EXEC FILLERS FLAG 553 030230 000000 000000 TTYSPD: 0 ;TTY EXEC BAUD RATE 554 030231 000000 000000 $TTCHR: 0 ;ACTUAL TYPED IN CHAR 555 030232 000000 000000 $CHRIN: 0 ;UPPER CASED & PARITY STRIPPED CHAR 556 030233 000000 000000 $TYPNB: 0 ;TYPED IN NUMBER 557 030234 000000 000000 $CRLF: 0 ;FREE CR/LF FLAG 558 030235 000000 000000 $TABF: 0 ;TAB CONVERSION FLAG 559 030236 000000 000000 $FFF: 0 ;FORM FEED CONVERSION FLAG 560 030237 000000 000000 $VTF: 0 ;VERTICAL TAB CONVERSION FLAG 561 030240 000000 000000 USRLFF: 0 ;USER LF FILLERS 562 030241 000000 000000 USRCRF: 0 ;USER CR FILLERS DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 5 FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0021 563 S^;*********************************************************************^ 564 ;*THE FOLLOWING MISCELLANEOUS PRINT CHARACTERS ARE INCLUDED 565 ;*TO FACILITATE PRINTING AND ARE CALLED AS FOLLOWS: 566 ;* MOVEI NAME 567 ;* PNTA ;OR PNTAF 568 S^;*********************************************************************^ 569 570 030242 CRLF: ASCII/ 571 030242 015 012 000 000 000 / 572 030243 CRLF2: ASCII/ 573 574 030243 015 012 015 012 000 / 575 030244 054 000 000 000 000 COMMA: ASCII/,/ 576 030245 056 000 000 000 000 PERIOD: ASCII/./ 577 030246 040 000 000 000 000 SPACE: ASCII/ / 578 030247 011 000 000 000 000 TAB: ASCII/ / 579 030250 MINUS: 580 030250 055 000 000 000 000 HYPEN: ASCII/-/ 581 030251 053 000 000 000 000 PLUS: ASCII/+/ 582 030252 052 000 000 000 000 AST: ASCII/*/ 583 030253 100 000 000 000 000 ATSIN: ASCII/@/ 584 030254 050 000 000 000 000 LFP: ASCII/(/ 585 030255 051 000 000 000 000 RTP: ASCII/)/ 586 030256 007 0000000000 BELL: BYTE (7) 007 587 030257 077 000 000 000 000 QUEST: ASCII/?/ 588 030260 057 000 000 000 000 SLASH: ASCII!/! 589 030261 044 000 000 000 000 DOLLAR: ASCII/$/ 590 030262 000000 000012 RADIX: ^D10 ;DECIMAL PRINT RADIX 591 030263 000000 000040 RADLSP: 40 ;DECIMAL PRINT LEADING CHAR 592 030264 000000 000012 RADLSC: ^D10 ;DECIMAL PRINT LEADING CHAR COUNT 593 594 S^;*********************************************************************^ 595 ;*USER MODE OUTPUT FILE INFORMATION 596 S^;*********************************************************************^ 597 598 030265 $OBUF: BLOCK 3 ;LOGICAL FILE OUTPUT BUFFER HEADER 599 030270 60 62 51 56 64 00 $OUTNM: SIXBIT /PRINT/ ;FILE NAME 600 030271 60 56 64 00 00 00 $OUTEX: SIXBIT /PNT/ ;FILE NAME EXTENSION 601 030272 BLOCK 2 602 603 S^;*********************************************************************^ 604 ;*DISK UPDATE MODE FILE INFORMATION 605 S^;*********************************************************************^ 606 607 030274 $IBUF: BLOCK 3 608 030277 60 62 51 56 64 00 $INNM: SIXBIT /PRINT/ 609 030300 60 56 64 00 00 00 $INEXT: SIXBIT /PNT/ 610 030301 BLOCK 2 DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 6 FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0022 611 S^;*********************************************************************^ 612 ;*PUSHDOWN LIST CONTROL INFORMATION 613 S^;*********************************************************************^ 614 615 030303 777577 030303 PLIST: PLIST-PLISTE,,PLIST 616 030304 PLISTS: BLOCK 200 617 030504 000000 000000 PLISTE: 0 ;END OF PUSHDOWN LIST 618 619 S^;*********************************************************************^ 620 ;*POWER LINE CLOCK FREQUENCY FLAG 621 S^;*********************************************************************^ 622 623 030505 000000 000000 CYCL60: 0 ;0 = 60, -1 = 50 CYCLE 624 625 S^;*********************************************************************^ 626 ;*KL10 CACHE CONTROL FLAGS 627 S^;*********************************************************************^ 628 629 030506 000000 000000 CSHFLG: 0 ;ALLOW CACHE IF 0 630 030507 000000 000000 CSHMEM: 0 ;CACHE MEMORY SEGMENTS IF 0 631 632 S^;*********************************************************************^ 633 ;*NUMBER INPUT DIGIT FLAG 634 S^;*********************************************************************^ 635 636 030510 000000 000000 TTNBRF: 0 ;-1 IF ANY DIGIT TYPED 637 638 S^;*********************************************************************^ 639 ;*KL10 & KI10 "INHPAG" SWITCH PAGING PREVENTION 640 S^;*********************************************************************^ 641 642 030511 000000 000000 PVPAGI: 0 ;IF NON-ZERO, OVERRIDE "INHPAG" SWITCH ACTION 643 644 S^;*********************************************************************^ 645 ;*ERROR REPORTING ROUTINE ADDITIONAL USERS CONTROL INSTRUCTIONS 646 S^;*********************************************************************^ 647 648 030512 000000 000000 %ERHI1: 0 ;IF NON-ZERO, XCT'D AT START OF %ERUUO 649 030513 000000 000000 %ERHI2: 0 ;IF NON-ZERO, XCT'D AT END OF %ERUUO 650 030514 000000 000000 %ERHI3: 0 ;IF NON-ZERO, XCT'D AFTER "PC" OF %ERUUO 651 652 S^;*********************************************************************^ 653 ;*SPECIAL USERS UUO INTERCEPT INSTRUCTION 654 S^;*********************************************************************^ 655 656 030515 000000 000000 $$UUO: 0 ;IF NON-ZERO, XCT'D AT START OF $UORTN DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 7 FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0023 657 S^;*********************************************************************^ 658 ;*USER MODE MONITOR TYPE FLAG 659 S^;*********************************************************************^ 660 661 030516 000000 000000 MONTYP: 0 ;0 = TOPS10, -1 = TOPS20 662 663 S^;*********************************************************************^ 664 ;*SPECIAL USERS MUUO INTERCEPT INSTRUCTION 665 S^;*********************************************************************^ 666 667 030517 000000 000000 $$MUUO: 0 ;IF NON-ZERO, XCT'D AT START OF MUUOER 668 669 S^;*********************************************************************^ 670 ;*SPECIAL USERS USER MODE OUTPUT ERROR INTERCEPT INSTUCTION 671 S^;*********************************************************************^ 672 673 030520 000000 000000 $$OUTER:0 ;IF NON-ZERO, XCT'D AT END OF USER MODE ERROR 674 675 S^;*********************************************************************^ 676 ;*"SWITCH" CALL USAGE CONTROL 677 S^;*********************************************************************^ 678 679 030521 000000 000000 $$TOGGLE:0 ;IF NON-ZERO, USE C(CONSW) FOR SWITCHES 680 681 S^;*********************************************************************^ 682 ;*SPECIAL USERS ALTMODE SWITCH CALL INTERCEPT INSTRUCTIONS 683 S^;*********************************************************************^ 684 685 030522 000000 000000 $$TAX1: 0 ;IF NON-ZERO, XCT'D AT START OF ALTMODE SWITCH CALL 686 030523 000000 000000 $$TAX2: 0 ;IF NON-ZERO, XCT'D AT END OF ALTMODE SWITCH CALL 687 688 S^;*********************************************************************^ 689 ;*SM10 (KS-10) PROCESSOR TYPE FLAG 690 S^;*********************************************************************^ 691 692 030524 000000 000000 SM10: 0 ;IF -1 THIS IS A KS-10 693 694 S^;*********************************************************************^ 695 ;*RIGHT HALF SWITCHES PROMPT TABLE ADDRESS 696 S^;*********************************************************************^ 697 698 030525 000000 000000 SWPTAB: 0 ;0 = NO PROMPT, ADR = ADR OF SIXBIT PROMPT TABLE 699 700 S^;*********************************************************************^ 701 ;*SPECIAL FUTURE EXPANSION ROOM 702 S^;*********************************************************************^ 703 704 S^;*********************************************************************^ 705 ;*END OF FIXED STORAGE 706 S^;*********************************************************************^ 707 708 030577 LOC 30577 709 030577 000000 000000 ENDFIX: 0 ;END OF FIXED STORAGE DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 1 SPCCPU KLM 24-Oct-78 08:57 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0024 710 SUBTTL *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 711 712 ;NEW DEFINITIONS USED BY THE KL10 SUBROUTINE PACKAGE 713 714 000000 AC0= 0 715 030000 DIAGNOS=30000 ;PDP-10 DIAGNOSTIC START ADDRESS 716 010000 DDT= 10000 ;PDP-10 DDT START ADDRESS 717 020000 DIAMON= 20000 ;PDP-10 DIAMON LOADER START ADDRESS 718 020000 DONG11= 1B22 ;11 DOORBELL (FROM THE 10) 719 720 ;DTE20 DEVICE CODES 721 722 000200 DTE== 200 ;DTE0 723 000204 DTE0== 204 724 000204 DTE1== 204 725 000210 DTE2== 210 726 000214 DTE3== 214 727 728 ;KL10 EPT COMMUNICATION AREA 729 730 000440 $STD= 440 ;PDP-10 DIAGNOSTIC START ADDRESS 731 000441 $DDT= 441 ;PDP-10 DDT START ADDRESS 732 000442 $STL= 442 ;PDP-10 LOADER START ADDRESS 733 000443 $STM= 443 ;PDP-10 MONITOR START ADDRESS 734 735 000444 $DTFLG= 444 ;DTE20 OPERATION COMPLETE FLAG 736 000445 $DTCLK= 445 ;DTE20 CLOCK INTERRUPT FLAG 737 000446 $DTCI= 446 ;DTE20 CLOCK INTERRUPT INSTRUCTION 738 000447 $DTT11= 447 ;DTE20 10 TO 11 ARGUMENT 739 000450 $DTF11= 450 ;DTE20 11 TO 10 ARGUMENT 740 000451 $DTCMD= 451 ;DTE20 TO 11 COMMAND WORD 741 000452 $DTSEQ= 452 ;DTE20 OPERATION SEQUENCE NUMBER 742 000453 $DTOPR= 453 ;DTE20 OPERATIONAL DTE # 743 000454 $DTCHR= 454 ;DTE20 LAST TYPED CHARACTER 744 000455 $DTMTD= 455 ;DTE20 MONITOR TTY OUTPUT COMPLETE FLAG 745 000456 $DTMTI= 456 ;DTE20 MONITOR TTY INPUT FLAG 746 747 000457 $DTSWR= 457 ;DTE20 CONSOLE SWITCH REGISTER DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 2 SPCCPU KLM 24-Oct-78 08:57 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0025 748 ;SPECIAL "FIXED" REASSIGNMENTS 749 750 030600 $$LOC=. ;SAVE CURRENT LOCATION 751 752 030000 LOC 30000 753 030000 254 00 0 00 030600 $$BEGIN:JRST $$START ;SETUP SPECIAL START 754 030001 254 00 0 00 030600 JRST $$START ;"DIAMON" CHAIN START ADDRESS 755 756 000440 LOC 440 757 000440 254 00 0 00 030000 $STD: JRST BEGIN ;SETUP FOR "STD" 758 000443 LOC 443 759 000443 254 00 0 00 030626 $STM: JRST $SPEC ;SIMPLE RUN CONTROL 760 761 030057 LOC 30057 762 030057 254 00 0 00 030631 $BEGEND:JRST $SPBEND ;SETUP SPECIAL "BEGEND" 763 764 ;SPECIAL MUUO, TRAP & PAGE FAIL SETUP 765 766 000420 LOC 420 767 000420 254 04 0 00 000420 $$420: HALT . ;KI10 PAGE FAIL 768 000421 255 00 0 00 000000 $$421: JFCL ;OVERFLOW 769 000422 254 04 0 00 000422 $$422: HALT . ;PUSHDOWN OVERFLOW 770 000423 254 04 0 00 000423 $$423: HALT . ;TRAP 3 771 000424 000000 000000 $$424: 0 ;MMUO 772 000425 000000 000000 $$425: 0 ;MMUO PC 773 000426 000000 000000 $$426: 0 ;KI10-PAGE FAIL, KL10-PROCESS CONTEXT 774 000427 254 04 0 00 000427 $$427: HALT . 775 000430 000000 000427 $$430: 427 ;MMUO NEW PC'S 776 000431 000000 000427 $$431: 427 777 000432 000000 000427 $$432: 427 778 000433 000000 000427 $$433: 427 779 000434 000000 000427 $$434: 427 780 000435 000000 000427 $$435: 427 781 000436 000000 000427 $$436: 427 782 000437 000000 000427 $$437: 427 783 784 000500 LOC 500 785 000500 000000 000000 $$500: 0 ;KL10 PAGE FAIL WORD 786 000501 000000 000000 $$501: 0 ;KL10 PAGE FAIL PC 787 000502 000000 000503 $$502: 503 ;KL10 PAGE FAIL NEW PC 788 000503 254 04 0 00 000503 $$503: HALT . DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 3 SPCCPU KLM 24-Oct-78 08:57 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0026 789 030600 LOC $$LOC ;RESET CURRENT LOCATION 790 791 ;SPECIAL STARTUP SEQUENCE 792 793 030600 402 00 0 00 030037 $$START:SETZM USER 794 030601 265 00 0 00 030602 JSP 0,.+1 ;IN USER MODE ? 795 030602 603 00 0 00 010000 TLNE 0,USERF 796 030603 476 00 0 00 030037 SETOM USER ;YES, SET CONTROL WORD 797 030604 336 00 0 00 030042 SKIPN MONFLG ;SPECIAL USER MODE ? 798 030605 402 00 0 00 030037 SETZM USER ;YES, RUN AS EXEC 799 030606 332 00 0 00 030037 SKIPE USER 800 030607 254 00 0 00 030674 JRST START ;USER MODE, DON'T NEED CPU TYPE 801 802 030610 336 00 0 00 030044 $STKIL: SKIPN MONTEN ;LOADED BY "DIAMON" ? 803 030611 476 00 0 00 030024 SETOM ITRCNT ;NO, RUN FOREVER 804 030612 402 00 0 00 030041 SETZM KLFLG ;ASSUME KI10 805 030613 200 01 0 00 033460 MOVE 1,[1,,1] 806 030614 251 01 0 00 000001 BLT 1,1 ;HOPE THIS WORKS 807 030615 316 01 0 00 033460 CAMN 1,[1,,1] ;IF AC NE 1,,1 AFTER BLT, KL10 808 030616 254 00 0 00 030674 JRST START ;KI10, NO ADDITIONAL SETUP 809 810 030617 402 00 0 00 000444 $STKL: SETZM $DTFLG 811 030620 402 00 0 00 000445 SETZM $DTCLK 812 030621 200 00 0 00 000453 MOVE $DTOPR ;GET DTE # 813 030622 436 00 0 00 030657 ORM $$DTE0 ;INSERT IN DTE I/O INSTS 814 030623 436 00 0 00 030670 ORM $$DTE2 815 030624 476 00 0 00 030041 SETOM KLFLG ;SET KL10 CONTROL FLAG 816 030625 254 00 0 00 030674 JRST START 817 818 030626 200 00 0 00 033461 $SPEC: MOVE [JRST STARTA] ;SIMPLE RUN CONTROL 819 030627 202 00 0 00 030633 MOVEM $SPB1 820 030630 254 00 0 00 030674 JRST START DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 4 SPCCPU KLM 24-Oct-78 08:57 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0027 821 ;SPECIAL "BEGEND" ROUTINE 822 823 030631 350 00 0 00 030047 $SPBEND:AOS PASCNT ;INCREMENT PASS COUNT 824 030632 370 00 0 00 030024 SOS ITRCNT ;DECREMENT ITERATION COUNT 825 030633 336 00 0 00 030037 $SPB1: SKIPN USER 826 030634 254 00 0 00 030642 JRST $SPBEX ;EXEC MODE 827 828 030635 332 00 0 00 030024 $SPBUS: SKIPE ITRCNT ;USER MODE, COMPLETED ? 829 030636 254 00 0 00 030723 JRST STARTA ;NO, KEEP RUNNING 830 030637 336 00 0 00 030044 SKIPN MONTEN ;DONE, LOADED BY "DIAMON" ? 831 030640 047 00 0 00 000012 EXIT ;NO, RETURN TO MONITOR 832 030641 254 00 1 00 030012 JRST @RETURN ;YES, RETURN TO "DIAMON" 833 834 030642 332 00 0 00 030041 $SPBEX: SKIPE KLFLG 835 030643 254 00 0 00 030650 JRST $SPBKL ;KL10 & EXEC 836 030644 7 004 14 0 00 030024 DATAO PI,ITRCNT ;KI10 & EXEC, DISPLAY ITER COUNT 837 030645 332 00 0 00 030024 SKIPE ITRCNT 838 030646 254 00 0 00 030723 JRST STARTA ;NOT COMPLETED YET 839 030647 254 00 1 00 030012 JRST @RETURN ;DONE 840 841 030650 336 00 0 00 030024 $SPBKL: SKIPN ITRCNT 842 030651 254 00 0 00 030663 JRST $SPKLD ;KL10, EXEC & COMPLETED 843 844 030652 335 00 0 00 030043 SKIPGE MONCTL 845 030653 254 00 0 00 030723 JRST STARTA ;"DIAMON" CONTROL 846 030654 201 00 0 00 000404 MOVEI 0,404 ;NOTIFY PDP-11 OF END OF PASS 847 030655 202 00 0 00 000451 MOVEM 0,$DTCMD 848 030656 402 00 0 00 000444 SETZM $DTFLG 849 030657 7 200 20 0 00 020000 $$DTE0: CONO DTE,DONG11 850 030660 336 00 0 00 000444 SKIPN $DTFLG ;WAIT TILL 11 RESPONDS 851 030661 254 00 0 00 030660 JRST .-1 852 030662 254 00 0 00 030723 JRST STARTA ;KEEP RUNNING 853 854 ;SPECIAL KL10 COMPLETED ROUTINE 855 856 030663 332 00 0 00 030044 $SPKLD: SKIPE MONTEN 857 030664 254 00 1 00 030012 JRST @RETURN ;LOADED BY "DIAMON" 858 859 030665 201 00 0 00 000403 MOVEI 0,403 ;NOTIFY PDP-11 OF COMPLETION 860 030666 202 00 0 00 000451 MOVEM 0,$DTCMD 861 030667 402 00 0 00 000444 SETZM $DTFLG 862 030670 7 200 20 0 00 020000 $$DTE2: CONO DTE,DONG11 863 030671 336 00 0 00 000444 SKIPN $DTFLG ;SHOULD NEVER HAPPEN 864 030672 254 00 0 00 030671 JRST .-1 ;11 NEVER RETURNS ON END OF PROGRAM 865 030673 254 04 0 00 030000 HALT BEGIN ;IF IT DOES, HALT. DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 1 DAKAEM MAC 28-Dec-78 13:35 DIAGNOSTIC SECTION SEQ 0028 866 SUBTTL DIAGNOSTIC SECTION 867 868 030674 402 00 0 00 030037 START: SETZM USER# ;CLEAR USER CONTROL WORD 869 030675 265 00 0 00 030676 JSP 0,.+1 ;GET FLAGS 870 030676 603 00 0 00 010000 TLNE USERF ;IN USER MODE? 871 030677 476 00 0 00 030037 SETOM USER ;YES, SET USER CONTROL WORD 872 030700 336 00 0 00 030042 SKIPN MONFLG ;SPECIAL USER MODE? 873 030701 402 00 0 00 030037 SETZM USER ;YES, CLEAR USER CONTROL WORD 874 030702 336 00 0 00 030037 SKIPN USER 875 030703 254 00 0 00 030723 JRST STARTA 876 030704 331 00 0 00 030043 SKIPL MONCTL 877 030705 051 03 0 00 030707 TTCALL 3,PGMNAM ;MENTION OUR NAME 878 030706 254 00 0 00 030723 JRST STARTA 879 880 030707 PGMNAM: ASCIZ/ 881 030707 015 012 120 104 120 PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) [DAKAE] 882 030710 055 061 060 040 113 883 030711 101 061 060 040 102 884 030712 101 123 111 103 040 885 030713 111 116 123 124 122 886 030714 125 103 124 111 117 887 030715 116 040 104 111 101 888 030716 107 116 117 123 124 889 030717 111 103 040 050 065 890 030720 051 040 133 104 101 891 030721 113 101 105 135 015 892 030722 012 000 000 000 000 / 893 894 895 ;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF 896 ;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES 897 ;IN THE FIELD. 898 899 030723 254 00 0 00 030724 STARTA: JRST .+1 DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 2 DAKAEM MAC 28-Dec-78 13:35 TEST OF JSR INSTRUCTION SEQ 0029 900 SUBTTL TEST OF JSR INSTRUCTION 901 902 ;********** 903 904 ;THIS TEST VERIFIES THAT JSR STORES THE FLAGS AND PC IN LOCATION E. 905 ;IN THIS CASE, E IS CLEARED, CRY0 IS SET AND JSR IS EXECUTED. 906 ;NEXT, E IS CHECKED FOR ITS CONTENTS NON-ZERO. IF C(E) IS NON-ZERO, 907 ;THIS TEST PASSES. 908 909 030724 C23000: SFLAG CRY0 ^;SET CRY0 FLAG 910 911 030724 205 01 0 00 200000 MOVSI 1,CRY0 912 030725 255 17 0 00 030726 JFCL 17,.+1 ;RESET ALL FLAGS 913 030726 254 02 0 01 030727 JRST 2,.+1(1) ;SET CRY0 FLAG 914 030727 402 00 0 00 030731 SETZM .+2 ;PRELOAD E WITH 0 915 030730 264 00 0 00 030731 JSR .+1 ;*JSR SHOULD PLACE FLAGS AND PC INTO AC 916 030731 000000 000000 0 ;E: PRESET TO 0, SHOULD RECEIVE FLAGS AND PC FROM JSR 917 030732 336 00 0 00 030731 SKIPN .-1 ;PASS IF C(E) IS NON-ZERO. 918 STOP^ 919 030733 254 04 0 00 030734 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 920 030734 324 00 0 00 030735 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 921 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 922 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 923 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 924 925 ;********** 926 927 ;THIS TEST VERIFIES THAT JSR IGNORES THE AC FIELD; 928 ;HENCE, IT DOES NOT MODIFY THE SPECIFIED AC. 929 ;IN THIS CASE, CRY0 IS SET. THE AC IS PRELOADED WITH -1,,-1 AND JSR IS EXECUTED. 930 ;THE AC IS THEN CHECKED. IF C(AC)=-1,,-1, THIS TEST PASSES. 931 932 030735 C23100: SFLAG CRY0 ^;SET CRY0 933 934 030735 205 01 0 00 200000 MOVSI 1,CRY0 935 030736 255 17 0 00 030737 JFCL 17,.+1 ;RESET ALL FLAGS 936 030737 254 02 0 01 030740 JRST 2,.+1(1) ;SET CRY0 FLAG 937 030740 474 01 0 00 000000 SETO 1, ;PRELOAD AC WITH -1,,-1 938 030741 264 01 0 00 030742 JSR 1,.+1 ;*JSR SHOULD NOT MODIFY THE AC 939 030742 000000 000000 0 ;STORE PC + FLAGS HERE 940 030743 312 01 0 00 033462 CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 941 STOP^ 942 030744 254 04 0 00 030745 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 943 030745 324 00 0 00 030746 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 944 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 945 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 946 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 947 948 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 3 DAKAEM MAC 28-Dec-78 13:35 TEST OF JSR INSTRUCTION SEQ 0030 949 ;THIS TEST VERIFIES THAT JSR STORES THE FLAGS IN E-LEFT HALF. 950 ;IN THIS TEST, CRY0 IS SET, E IS CLEARED AND JSR IS EXECUTED. 951 ;NEXT, C(E-LEFT) ARE PLACED INTO AC0 AND AC0 IS CHECKED FOR ITS CONTENTS NON-ZERO. 952 ;IF C(AC0) ARE NON-ZERO, THIS TEST PASSES. 953 954 030746 C23200: SFLAG CRY0 ^;SET CRY0 955 956 030746 205 01 0 00 200000 MOVSI 1,CRY0 957 030747 255 17 0 00 030750 JFCL 17,.+1 ;RESET ALL FLAGS 958 030750 254 02 0 01 030751 JRST 2,.+1(1) ;SET CRY0 FLAG 959 030751 402 00 0 00 030753 SETZM .+2 ;CLEAR E 960 030752 264 00 0 00 030753 JSR .+1 ;*JSR SHOULD STORE FLAGS IN E 961 030753 000000 000000 0 ;STORE FLAGS HERE (CRY0 MAKES THIS A MOVE INST) 962 030754 510 00 0 00 030753 HLLZ .-1 ;PUT FLAGS INTO AC0 963 030755 336 00 0 00 000000 SKIPN ;PASS IF C(AC0) NON-ZERO 964 STOP^ 965 030756 254 04 0 00 030757 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 966 030757 324 00 0 00 030760 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 967 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 968 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 969 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 970 971 ;********** 972 973 ;THIS TEST VERIFIES THAT JSR TRANSFERS CONTROL TO E+1. 974 ;IN THIS CASE, CRY0 IS SET AND E AND AC0 CLEARED; THEN, JSR IS EXECUTED. 975 ;IF JSR RESUMES CONTROL AT E INSTEAD OF E+1, AC0 WILL BE MODIFIED; 976 ;HENCE, THE TEST WILL FAIL WHEN AC0 IS CHECKED FOR 0 BECAUSE 977 ;C(E) IS DECODED AS A MOVE INSTRUCTION. 978 979 030760 C23300: SFLAG CRY0 ^;SET CRY0 980 981 030760 205 01 0 00 200000 MOVSI 1,CRY0 982 030761 255 17 0 00 030762 JFCL 17,.+1 ;RESET ALL FLAGS 983 030762 254 02 0 01 030763 JRST 2,.+1(1) ;SET CRY0 FLAG 984 030763 403 00 0 00 030765 SETZB .+2 ;CLEAR AC0 AND E 985 030764 264 00 0 00 030765 JSR .+1 ;*JSR SHOULD RESUME CONTROL AT E+1 986 030765 000000 000000 0 ;STORE FLAGS HERE (CRY0 MAKES THIS A MOVE INST) 987 030766 332 00 0 00 000000 SKIPE 0 ;PASS IF C(AC0)=0 988 STOP^ 989 030767 254 04 0 00 030770 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 990 030770 324 00 0 00 030771 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 991 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 992 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 993 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 994 995 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 4 DAKAEM MAC 28-Dec-78 13:35 TEST OF JSR INSTRUCTION SEQ 0031 996 ;THIS TEST VERIFIES THAT JSR JUMPS TO E+1 997 ;IN THIS CASE, AC0 IS CLEARED AND CRY0 IS SET; THEN, JSR .+2 IS EXECUTED. 998 ;IF JSR DID NOT JUMP, ONES ARE LOADED WITH AC0; AND THE TEST FAILS. 999 ;OTHERWISE, AC0 REMAINS CLEAR AND THE TEST PASSES 1000 1001 030771 C23400: SFLAG CRY0 ^;SET CRY0 1002 1003 030771 205 01 0 00 200000 MOVSI 1,CRY0 1004 030772 255 17 0 00 030773 JFCL 17,.+1 ;RESET ALL FLAGS 1005 030773 254 02 0 01 030774 JRST 2,.+1(1) ;SET CRY0 FLAG 1006 030774 400 00 0 00 000000 SETZ ;CLEAR AC0 1007 030775 264 00 0 00 030777 JSR .+2 ;*JSR SHOULD JUMP 1008 030776 474 00 0 00 000000 SETO ;LOAD AC0 WITH ONES IF JSR FAILED TO JUMP 1009 030777 000000 000000 0 ;STORE FLAGS HERE 1010 031000 332 00 0 00 000000 SKIPE ;PASS IF JSR JUMPED CORRECTLY 1011 STOP^ 1012 031001 254 04 0 00 031002 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1013 031002 324 00 0 00 031003 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1014 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1015 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1016 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1017 1018 ;********** 1019 1020 ;THIS TEST VERIFIES THAT JSR STORES THE PC IN E - RIGHT HALF. THE PC 1021 ;IS ONE GREATER THAN THE LOCATION OF THE JSR INSTRUCTION. 1022 ;THIS TEST WILL FAIL IF JSR STORES E INSTEAD OF PC IN E - RIGHT HALF. 1023 ;IN CASE OF FAILURE, AR PC EN AT ET2 WAS FAULTY. 1024 1025 031003 C23500: SFLAG 0 ^;CLEAR ALL FLAGS 1026 1027 031003 205 01 0 00 000000 MOVSI 1,0 1028 031004 255 17 0 00 031005 JFCL 17,.+1 ;RESET ALL FLAGS 1029 031005 254 02 0 01 031006 JRST 2,.+1(1) ;SET 0 FLAG 1030 031006 264 00 0 00 031010 JSR .+2 ;*JSR SHOULD STORE PC+1 IN E - RIGHT 1031 031007 254 04 0 00 031007 HALT . ;JSR SHOULD SKIP OVER THIS HALT 1032 031010 000000 000000 0 ;STORE FLAGS AND PC HERE 1033 031011 550 00 0 00 031010 HRRZ .-1 ;PUT STORED CONTENTS OF E - RIGHT INTO AC0 1034 031012 306 00 0 00 031010 CAIN .-2 ;FAIL IF C(AC0)=E 1035 STOP^ 1036 031013 254 04 0 00 031014 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1037 031014 324 00 0 00 031015 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1038 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1039 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1040 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1041 1042 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 5 DAKAEM MAC 28-Dec-78 13:35 TEST OF JSR INSTRUCTION SEQ 0032 1043 ;THIS TEST VERIFIES THAT JSR STORES THE PC IN E - RIGHT HALF. THE PC 1044 ;IS ONE GREATER THAN THE LOCATION OF THE JSR INSTRUCTION. 1045 ;THIS TEST WILL PASS IF JSR STORES PC IN E - RIGHT HALF. 1046 1047 031015 264 00 0 00 031017 C23600: JSR .+2 ;*JSR SHOULD STORE PC+1 IN E - RIGHT 1048 031016 254 04 0 00 031016 HALT . ;JSR SHOULD SKIP OVER THIS HALT 1049 031017 000000 000000 0 ;STORE FLAGS AND PC HERE 1050 031020 550 00 0 00 031017 HRRZ .-1 ;PUT STORED CONTENTS OF E - RIGHT INTO AC0 1051 031021 302 00 0 00 031016 CAIE C23600+1 ;PASS IF C(AC0)=C23600+1 [PC] 1052 STOP^ 1053 031022 254 04 0 00 031023 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1054 031023 324 00 0 00 031024 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1055 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1056 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1057 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1058 1059 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 6 DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0033 1060 SUBTTL TEST OF JSA INSTRUCTION 1061 1062 ;********** 1063 1064 ;THIS TEST VERIFIES THAT JSA JUMPS TO LOCATION E+1. 1065 ;IN THIS TEST, AC1 IS CLEARED AND A CAM 0,0 IS LOADED 1066 ;INTO THE AC OF THE JSA INSTRUCTION. 1067 ;IF JSA DOES NOT JUMP, AC1 WILL BE LOADED WITH ONES. AC1 IS CHECKED FOR ZEROS. 1068 ;IF C(AC1)=0, THE TEST PASSES; OTHERWISE, THIS TEST FAILS BECAUSE JSA DID NOT JUMP. 1069 1070 031024 400 01 0 00 000000 C23700: SETZ 1, ;CLEAR AC1 1071 031025 200 00 0 00 033463 MOVE [CAM] ;LOAD CAM INTO AC0 1072 031026 266 00 0 00 031030 JSA .+2 ;*JSA SHOULD JUMP TO E+1 1073 031027 474 00 0 00 000001 SETO 1 ;JSA SHOULD JUMP OVER THIS INSTRUCTION 1074 031030 000000 000000 0 ;PASS IF JSA JUMPED 1075 031031 332 00 0 00 000001 SKIPE 1 1076 STOP^ 1077 031032 254 04 0 00 031033 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1078 031033 324 00 0 00 031034 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1079 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1080 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1081 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1082 1083 ;********** 1084 1085 ;THIS TEST VERIFIES THAT JSA JUMPS TO LOCATION E+1. 1086 ;IN THIS TEST, AC1 IS CLEARED AND A MOVEI 1,1234 IS LOADED 1087 ;INTO THE AC OF THE JSA INSTRUCTION. 1088 ;IF JSA DOES NOT JUMP, AC1 WILL BE LOADED WITH 0,,1234. AC1 IS CHECKED FOR ZEROS. 1089 ;IF C(AC1)=0, THE TEST PASSES; OTHERWISE, THIS TEST FAILS BECAUSE JSA DID NOT JUMP. 1090 1091 031034 400 01 0 00 000000 C24000: SETZ 1, ;CLEAR AC1 1092 031035 200 00 0 00 033464 MOVE [MOVEI 1,1234] ;LOAD MOVEI 1,1234 INTO AC 1093 031036 266 00 0 00 031037 JSA .+1 ;*JSA SHOULD JUMP TO E+1 1094 031037 000000 000000 0 ;JSA SHOULD JUMP OVER THIS LOCATION 1095 031040 306 01 0 00 001234 CAIN 1,1234 ;FAIL IF JSA DID NOT JUMP OVER PREVIOUS INSTRUCTION 1096 STOP^ 1097 031041 254 04 0 00 031042 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1098 031042 324 00 0 00 031043 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1099 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1100 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1101 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1102 1103 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 7 DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0034 1104 ;THIS TEST VERIFIES THAT JSA LOADS PC OF LOC OF JSA+1 INTO AC RIGHT. 1105 ;THIS TEST WILL FAIL IF JSA LOADS E INTO AC RIGHT INSTEAD OF PC. 1106 1107 031043 266 00 0 00 031045 C24100: JSA .+2 ;*JSA SHOULD LOAD PC INTO AC RIGHT 1108 031044 254 04 0 00 031044 HALT . ;JSA SHOULD JUMP OVER THIS LOCATION 1109 031045 000000 000000 0 ;JSA SHOULD JUMP OVER THIS LOCATION 1110 031046 552 00 0 00 000001 HRRZM 1 ;PUT C(AC-RIGHT) INTO AC1 1111 031047 306 01 0 00 031045 CAIN 1,.-2 ;FAIL IF E WAS LOADED INTO AC-RIGHT INSTEAD OF PC 1112 STOP^ 1113 031050 254 04 0 00 031051 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1114 031051 324 00 0 00 031052 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1115 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1116 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1117 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1118 1119 ;********** 1120 1121 ;THIS TEST VERIFIES THAT JSA PLACES C(AC) INTO E 1122 ;THIS TEST WILL FAIL IF EITHER 0,,E OR 0,,PC IS LOADED 1123 ;INTO E INSTEAD OF C(AC) 1124 1125 031052 403 00 0 00 031054 C24200: SETZB .+2 ;CLEAR AC,E 1126 031053 266 00 0 00 031054 JSA .+1 ;*JSA SHOULD LOAD C(AC) [ZEROS] INTO E 1127 031054 000000 000000 0 ;JSA SHOULD PLACE ZEROS HERE 1128 031055 200 01 0 00 031054 MOVE 1,.-1 ;SAVE C(AC) 1129 031056 306 01 0 00 031054 CAIN 1,.-2 ;FAIL IF JSA LOADED 0,,E OR 0,,PC INTO E 1130 STOP^ 1131 031057 254 04 0 00 031060 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1132 031060 324 00 0 00 031061 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1133 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1134 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1135 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1136 1137 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 8 DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0035 1138 ;THIS TEST VERIFIES THAT JSA PLACES PC INTO AC-RIGHT 1139 ;THIS TEST WILL FAIL IF PC IS NOT LOADED INTO AC-RIGHT 1140 1141 031061 201 00 0 00 777777 C24300: MOVEI -1 ;PRELOAD AC WITH 0,,-1 1142 031062 266 00 0 00 031063 JSA .+1 ;*JSA SHOULD PLACE E,,PC INTO THE AC 1143 031063 000000 000000 0 ;JSA SHOULD PLACE C(AC) HERE 1144 031064 606 00 0 00 777777 TRNN -1 ;FAIL IF AR LT AR RT EN FAILED 1145 STOP^ 1146 031065 254 04 0 00 031066 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1147 031066 324 00 0 00 031067 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1148 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1149 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1150 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1151 1152 ;********** 1153 1154 ;THIS TEST VERIFIES THAT JSA PLACES THE PC OF THE LOCATION OF JSA+1 IN AC-RIGHT 1155 ;THIS TEST FAILS IF A PC WAS NOT LOADED INTO AC RIGHT 1156 1157 031067 400 00 0 00 000000 C24400: SETZ ;CLEAR AC 1158 031070 266 00 0 00 031071 JSA .+1 ;*JSA SHOULD LOAD PC INTO AC - RIGHT 1159 031071 000000 000000 0 ;JSA SHOULD PLACE C(AC) HERE 1160 031072 606 00 0 00 777777 TRNN -1 ;PASS IF AC - RIGHT IS NON-ZERO 1161 STOP^ 1162 031073 254 04 0 00 031074 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1163 031074 324 00 0 00 031075 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1164 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1165 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1166 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1167 1168 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 9 DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0036 1169 ;THIS TEST VERIFIES THAT JSA PLACES IN AC-LEFT 1170 ;THIS TEST FAILS IF JSA LOADS PC INSTEAD OF E INTO AC-LEFT 1171 1172 031075 266 00 0 00 031077 C24500: JSA .+2 ;*JSA SHOULD LOAD E INTO AC-LEFT 1173 031076 254 04 0 00 031076 HALT . ;JSA SHOULD JUMP OVER THIS INSTRUCTION 1174 031077 000000 000000 0 ;E: 1175 031100 556 00 0 00 000001 HLRZM 1 ;SAVE C(AC - LEFT) 1176 031101 306 01 0 00 031076 CAIN 1,.-3 ;FAIL IF JSA LOADED PC INSTEAD OF E INTO AC-LEFT 1177 STOP^ 1178 031102 254 04 0 00 031103 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1179 031103 324 00 0 00 031104 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1180 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1181 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1182 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1183 1184 ;********** 1185 1186 ;THIS TEST VERIFIES THAT JSA LOADS E,,PC INTO THE AC 1187 ;FIRST, THE AC IS PRELOADED WITH -1,,-1; THEN, JSA IS EXECUTED. 1188 ;THE AC IS CHECKED FOR E,,PC. IF C(AC)=E,,PC, THIS TEST PASSES 1189 1190 031104 474 00 0 00 000000 C24600: SETO ;PRELOAD AC WITH -1,,-1 1191 031105 266 00 0 00 031107 JSA .+2 ;*JSA SHOULD PLACE E,,PC INTO THE AC 1192 031106 254 04 0 00 031106 HALT . ;JSA SHOULD JUMP OVER HERE, PC: 1193 031107 000000 000000 0 ;JSA SHOULD STORE C(AC) HERE, E: 1194 031110 312 00 0 00 033465 CAME [XWD .-1,.-2] ;PASS IF C(AC)=E,,PC 1195 STOP^ 1196 031111 254 04 0 00 031112 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1197 031112 324 00 0 00 031113 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1198 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1199 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1200 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1201 1202 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 10 DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0037 1203 ;THIS TEST VERIFIES THAT JSA LOADS E,,PC INTO THE AC 1204 ;FIRST, THE AC IS PRELOADED WITH 0 JSA IS EXECUTED. 1205 ;THE AC IS CHECKED FOR E,,PC. IF C(AC)=E,,PC, THIS TEST PASSES 1206 1207 031113 400 00 0 00 000000 C24700: SETZ ;PRELOAD AC WITH 0 1208 031114 266 00 0 00 031116 JSA .+2 ;*JSA SHOULD PLACE E,,PC INTO THE AC 1209 031115 254 04 0 00 031115 HALT . ;JSA SHOULD JUMP OVER HERE, PC: 1210 031116 000000 000000 0 ;JSA SHOULD STORE C(AC) HERE, E: 1211 031117 312 00 0 00 033466 CAME [XWD .-1,.-2] ;PASS IF C(AC)=E,,PC 1212 STOP^ 1213 031120 254 04 0 00 031121 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1214 031121 324 00 0 00 031122 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1215 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1216 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1217 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1218 1219 ;********** 1220 1221 ;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. 1222 ;AC IS FIRST CLEARED AND E IS PRELOADED WITH ONES; 1223 ;THEN JSA IS EXECUTED. E IS CHECKED FOR ZEROS. IF C(E)=0, 1224 ;THIS TEST PASSES. 1225 1226 031122 400 00 0 00 000000 C25000: SETZ ;CLEAR AC 1227 031123 476 00 0 00 031125 SETOM .+2 ;PRELOAD E WITH -1,,-1 1228 031124 266 00 0 00 031125 JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E 1229 031125 000000 000000 0 ;E: SHOULD GET C(AC) FROM JSA 1230 031126 332 00 0 00 031125 SKIPE .-1 ;PASS IF C(E)=0 1231 STOP^ 1232 031127 254 04 0 00 031130 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1233 031130 324 00 0 00 031131 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1234 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1235 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1236 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1237 1238 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 11 DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0038 1239 ;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. 1240 ;AC IS FIRST PRELOADED WITH -1,,-1 AND E IS CLEARED; 1241 ;THEN, JSA IS EXECUTED. E IS CHECKED FOR -1,,-1. IF C(E)=-1,,-1, 1242 ;THIS TEST PASSES. 1243 1244 031131 477 00 0 00 000001 C25100: SETOB 1 ;PRELOAD AC -1,,-1 1245 031132 402 00 0 00 031134 SETZM .+2 ;PRELOAD E WITH 0 1246 031133 266 00 0 00 031134 JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E 1247 031134 000000 000000 0 ;E: SHOULD GET C(AC) FROM JSA 1248 031135 312 01 0 00 031134 CAME 1,.-1 ;PASS IF C(E)=-1,,-1 1249 STOP^ 1250 031136 254 04 0 00 031137 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1251 031137 324 00 0 00 031140 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1252 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1253 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1254 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1255 1256 ;********** 1257 1258 ;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. 1259 ;AC IS FIRST CLEARED AND E IS PRELOADED WITH ONES; 1260 ;THEN JSA IS EXECUTED. E IS CHECKED FOR ZEROS. IF C(E)=0, 1261 ;THIS TEST PASSES. 1262 1263 031140 201 00 0 00 777777 C25200: MOVEI -1 ;PRELOAD AC WITH 0,,-1 1264 031141 266 00 0 00 031142 JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E 1265 031142 000000 000000 0 ;E: SHOULD GET C(AC) FROM JSA 1266 031143 200 01 0 00 031142 MOVE 1,.-1 ;PASS IF C(E)=0,,-1 1267 031144 302 01 0 00 777777 CAIE 1,-1 1268 STOP^ 1269 031145 254 04 0 00 031146 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1270 031146 324 00 0 00 031147 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1271 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1272 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1273 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1274 1275 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 12 DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0039 1276 ;THIS TEST VERIFIES THAT JSA DOES NOT MODIFY AC+1 1277 ;IN THIS TEST, AC+1 IS PRELOADED WITH -1,,-1; THEN JSA IS EXECUTED 1278 ;AC+1 IS THEN CHECKED FOR ITS ORIGINAL CONTENTS, -1,,-1. 1279 ;IF C(AC+1)=-1,,-1, THIS TEST PASSES 1280 1281 031147 476 00 0 00 000001 C25300: SETOM 1 ;PRELOAD AC+1 WITH -1,,-1 1282 031150 266 00 0 00 031151 JSA .+1 ;*JSA SHOULD NOT MODIFY AC+1 1283 031151 310 00 0 00 000000 CAM ;JSA SHOULD JUMP OVER THIS, E:PC: 1284 031152 312 01 0 00 033462 CAME 1,[-1] ;PASS IF AC+1 WAS NOT MODIFIED BY JSA 1285 STOP^ 1286 031153 254 04 0 00 031154 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1287 031154 324 00 0 00 031155 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1288 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1289 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1290 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1291 1292 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 13 DAKAEM MAC 28-Dec-78 13:35 TEST OF JRA INSTRUCTION SEQ 0040 1293 SUBTTL TEST OF JRA INSTRUCTION 1294 1295 ;********** 1296 1297 ;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E 1298 ;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. 1299 1300 031155 200 00 0 00 033467 C25400: MOVE [JRST .+4] ;PRELOAD AC0 WITH JRST .+4 1301 031156 205 01 0 00 031160 MOVSI 1,.+2 ;PRELOAD AC WITH E,,0 1302 031157 267 01 0 00 031160 JRA 1,.+1 ;*JRA SHOULD JUMP TO NEXT INSTRUCTION 1303 031160 334 00 0 00 000000 SKIPA ;PASS IF JRA JUMPS TO E 1304 STOP^ 1305 031161 254 04 0 00 031162 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1306 031162 324 00 0 00 031163 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1307 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1308 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1309 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1310 1311 ;********** 1312 1313 ;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E 1314 ;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. 1315 1316 031163 205 00 0 00 031166 C25500: MOVSI .+3 ;PRELOAD AC WITH E+1 1317 031164 267 00 0 00 031165 JRA .+1 ;*JRA SHOULD JUMP TO NEXT SEQUENTIAL INSTRUCTION 1318 031165 334 00 0 00 000000 SKIPA ;PASS IF JRA JUMPS TO E 1319 STOP^ 1320 031166 254 04 0 00 031167 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1321 031167 324 00 0 00 031170 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1322 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1323 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1324 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1325 1326 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 14 DAKAEM MAC 28-Dec-78 13:35 TEST OF JRA INSTRUCTION SEQ 0041 1327 ;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E 1328 ;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. 1329 1330 031170 403 00 0 00 000001 C25600: SETZB 1 ;PRELOAD AC0, AC1 WITH ZEROS 1331 031171 267 00 0 00 031173 JRA .+2 ;*JRA SHOULD JUMP OVER NEXT SEQUENTIAL INSTRUCTION 1332 031172 474 01 0 00 000000 SETO 1, ;LOAD AC1 WITH ONES IF JRA DOES NOT JUMP 1333 031173 332 00 0 00 000001 SKIPE 1 ;PASS IF JRA JUMPED 1334 STOP^ 1335 031174 254 04 0 00 031175 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1336 031175 324 00 0 00 031176 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1337 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1338 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1339 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1340 1341 ;********** 1342 1343 ;THIS TEST VERIFIES THAT JRA PLACES C(C(AC-LEFT)) INTO THE AC AND JUMPS TO E 1344 ;THIS TEST FAILS IF JRA JUMPS TO E+1 OR DOES NOT LOAD THE AC CORRECTLY. 1345 1346 031176 400 00 0 00 000000 C25700: SETZ ;CLEAR AC 1347 031177 267 00 0 00 031200 JRA .+1 ;*JRA SHOULD PLACE 0 INTO THE AC AND JUMP .+1 1348 031200 332 00 0 00 000000 SKIPE ;PASS IF AC WAS LOADED CORRECTLY 1349 ;AND JRA JUMPED CORRECTLY. 1350 STOP^ 1351 031201 254 04 0 00 031202 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1352 031202 324 00 0 00 031203 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1353 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1354 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1355 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1356 1357 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 15 DAKAEM MAC 28-Dec-78 13:35 TEST OF JRA INSTRUCTION SEQ 0042 1358 ;THIS TEST VERIFIES THAT JRA PLACES C(C(AC-LEFT)) INTO THE AC 1359 ;FIRST, THE AC IS PRELOADED WITH 1,,2 AND AC1 AND AC2 ARE 1360 ;INITIALIZED WITH THEIR RESPECTIVE ADDRESSES; JRA IS EXECUTED, AND 1361 ;THE AC IS CHECKED FOR 0,,1, THE ORIGINAL C(C(AC-LEFT)). IF C(AC)=0,,1, 1362 ;THIS TEST PASSES 1363 1364 031203 200 00 0 00 033470 C26200: MOVE [XWD 1,2] ;PRELOAD AC WITH 1,,2 1365 031204 201 01 0 00 000001 MOVEI 1,1 ;INITIALIZE AC1 WITH 0,,1 1366 031205 201 02 0 00 000002 MOVEI 2,2 ;INITIALIZE AC2 WITH 0,,2 1367 031206 267 00 0 00 031207 JRA .+1 ;*JRA SHOULD PLACE 0,,1 INTO THE AC 1368 031207 302 00 0 00 000001 CAIE 1 ;PASS IF C(AC)=0,,1 1369 STOP^ 1370 031210 254 04 0 00 031211 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1371 031211 324 00 0 00 031212 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1372 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1373 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1374 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1375 1376 ;********** 1377 1378 ;THIS TEST VERIFIES THAT JRA CAN RESTORE AC0 FROM AC0 WHEN AC0 IS THE 1379 ;SPECIFIED AC AND C(AC0-LEFT)=0. 1380 ;FIRST, AC0 IS PRELOADED AND JRA IS EXECUTED. THEN, AC0 IS CHECKED FOR 1381 ;ITS INITIAL CONTENTS. IF THE RESULT IN AC0, IS CORRECT, THIS TEST PASSES. 1382 1383 031212 551 00 0 00 033471 C26300: HRRZI [135531,,246642] ;PRELOAD AC0 WITH 0,, LITERAL ADDRESS 1384 031213 267 00 0 00 031214 JRA .+1 ;*JRA SHOULD PLACE C(AC0) INTO AC0 1385 031214 302 00 0 00 033471 CAIE [135531,,246642] ;PASS IF JRA PLACED C(AC0) INTO AC0 1386 STOP^ 1387 031215 254 04 0 00 031216 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1388 031216 324 00 0 00 031217 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1389 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1390 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1391 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1392 1393 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 16 DAKAEM MAC 28-Dec-78 13:35 TEST OF JRA INSTRUCTION SEQ 0043 1394 ;THIS TEST VERIFIES THAT JRA CAN RESOTRE AC0 FROM MEMORY WHEN AC0 IS THE 1395 ;SPECIFIED AC. 1396 ;FIRST, AC0 IS PRELOADED WITH [LITERAL ADDRESS ,,0] AND JRA IS EXECUTED. THEN, 1397 ;AC0 IS CHECKED FOR THE SPECIFIED LITERAL, 135246,,246135. IF 1398 ;C(AC0)=135246,,246135, THE TEST PASSES. 1399 1400 031217 515 00 0 00 033472 C26400: HRLZI [135246,,246135] ;PRELOAD AC0 WITH [LITERAL ADDRESS ,,0] 1401 031220 267 00 0 00 031221 JRA .+1 ;*JRA SHOULD PLACE 135246,,246135 INTO AC0 1402 031221 312 00 0 00 033472 CAME [135246,,246135];PASS IF C(AC0)=135246,,246135 1403 STOP^ 1404 031222 254 04 0 00 031223 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1405 031223 324 00 0 00 031224 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1406 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1407 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1408 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1409 1410 ;********** 1411 1412 ;THIS TEST VERIFIES THAT JRA CAN RESOTRE AC0 FROM MEMORY WHEN AC0 IS THE 1413 ;SPECIFIED AC. 1414 ;FIRST, AC0 IS PRELOADED WITH [-1,, ADDRESS OF JCA INSTRUCTION] AND JRA IS EXECUTED. 1415 ;THEN, AC0 IS CHECKED FOR THE JRA INSTRUCTION. IF 1416 ;C(AC0)= THE JRA INSTRUCTION, THE TEST PASSES. 1417 1418 031224 525 00 0 00 031225 C26500: HRLOI .+1 ;PRELOAD AC WITH -1,, ADDRESS OF JRA INSTRUCTION 1419 031225 267 00 0 00 031226 JRA .+1 ;*JRA SHOULD PLACE ITSELF INTO AC0 1420 031226 312 00 0 00 031225 CAME .-1 ;PASS IF AC CONTAINS JRA INSTRUCTION 1421 STOP^ 1422 031227 254 04 0 00 031230 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1423 031230 324 00 0 00 031231 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1424 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1425 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1426 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1427 1428 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 17 DAKAEM MAC 28-Dec-78 13:35 TESTS OF BIS FLAG SEQ 0044 1429 SUBTTL TESTS OF BIS FLAG 1430 1431 ;********** 1432 1433 ;THIS TEST VERIFIES THAT JRST 2, CAN CLEAR BIS 1434 ;FIRST, BIS IS SET VIA JRST 2, ;THEN, BIS IS CLEARED VIA JRST 2,. 1435 ;THE FLAGS ARE SAVED AND BIS IS CHECKED. THIS TEST PASSES IF BIS IS RESET; 1436 ;OTHERWISE JRST 2, FAILED TO RESET BIS. 1437 1438 031231 C26600: SFLAG BIS ^;SET BIS FLAG 1439 1440 031231 205 01 0 00 020000 MOVSI 1,BIS 1441 031232 255 17 0 00 031233 JFCL 17,.+1 ;RESET ALL FLAGS 1442 031233 254 02 0 01 031234 JRST 2,.+1(1) ;SET BIS FLAG 1443 SFLAG ^;*RESET BIS FLAG 1444 1445 031234 205 01 0 00 000000 MOVSI 1, 1446 031235 255 17 0 00 031236 JFCL 17,.+1 ;RESET ALL FLAGS 1447 031236 254 02 0 01 031237 JRST 2,.+1(1) ;SET FLAG 1448 031237 265 00 0 00 031240 JSP .+1 ;SAVE FLAGS 1449 031240 603 00 0 00 020037 TLNE BIS+37 ;PASS IF BIS FLAG IS RESET 1450 STOP^ 1451 031241 254 04 0 00 031242 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1452 031242 324 00 0 00 031243 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1453 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1454 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1455 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1456 1457 ;********** 1458 1459 ;THIS TEST VERIFIES THAT JRST 2, CAN SET BIS. 1460 ;FIRST, BIS IS SET VIA JRST 2, AND THE FLAGS ARE SAVED. 1461 ;BIS IS THEN CHECKED. IF BIS IS SET, THIS TEST PASSES. 1462 1463 031243 C26700: SFLAG BIS ^;*SET BIS FLAG VIA JRST 1464 1465 031243 205 01 0 00 020000 MOVSI 1,BIS 1466 031244 255 17 0 00 031245 JFCL 17,.+1 ;RESET ALL FLAGS 1467 031245 254 02 0 01 031246 JRST 2,.+1(1) ;SET BIS FLAG 1468 031246 265 00 0 00 031247 JSP .+1 ;SAVE FLAGS 1469 031247 607 00 0 00 020000 TLNN BIS ;PASS IF BIS FLAG IS SET 1470 STOP^ 1471 031250 254 04 0 00 031251 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1472 031251 324 00 0 00 031252 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1473 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1474 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1475 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1476 1477 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 18 DAKAEM MAC 28-Dec-78 13:35 TESTS OF BIS FLAG SEQ 0045 1478 ;THIS TEST VERIFIES THAT JSR ALWAYS RESETS BIS. 1479 ;FIRST BIS IS SET; THEN JSR IS EXECUTED. THE FLAGS ARE 1480 ;THEN SAVED AND CHECKED. IF BIS WAS RESET VIA JSR, THIS TEST PASSES. 1481 1482 031252 C27000: SFLAG BIS ^;SET BIS 1483 1484 031252 205 01 0 00 020000 MOVSI 1,BIS 1485 031253 255 17 0 00 031254 JFCL 17,.+1 ;RESET ALL FLAGS 1486 031254 254 02 0 01 031255 JRST 2,.+1(1) ;SET BIS FLAG 1487 031255 264 00 0 00 031256 JSR .+1 ;*JSR SHOULD RESET BIS 1488 031256 000000 000000 0 ;JSR SAVES FLAGS HERE 1489 031257 265 00 0 00 031260 JSP .+1 ;SAVE FLAGS 1490 031260 603 00 0 00 020000 TLNE BIS ;PASS IF BIS FLAG IS RESET 1491 STOP^ 1492 031261 254 04 0 00 031262 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1493 031262 324 00 0 00 031263 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1494 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1495 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1496 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1497 1498 ;********** 1499 1500 ;THIS TEST VERIFIES THAT JSP ALWAYS RESETS BIS. 1501 ;FIRST BIS IS SET; THEN JSP IS EXECUTED. THE FLAGS ARE 1502 ;THEN SAVED AND CHECKED. IF BIS WAS RESET VIA JSP, THIS TEST PASSES. 1503 1504 031263 C27001: SFLAG BIS ^;SET BIS 1505 1506 031263 205 01 0 00 020000 MOVSI 1,BIS 1507 031264 255 17 0 00 031265 JFCL 17,.+1 ;RESET ALL FLAGS 1508 031265 254 02 0 01 031266 JRST 2,.+1(1) ;SET BIS FLAG 1509 031266 265 00 0 00 031267 JSP .+1 ;*JSP SHOULD RESET BIS 1510 031267 265 00 0 00 031270 JSP .+1 ;SAVE FLAGS 1511 031270 603 00 0 00 020000 TLNE BIS ;PASS IF BIS FLAG IS RESET 1512 STOP^ 1513 031271 254 04 0 00 031272 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1514 031272 324 00 0 00 031273 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1515 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1516 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1517 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1518 1519 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 19 DAKAEM MAC 28-Dec-78 13:35 TESTS OF BIS FLAG SEQ 0046 1520 ;THIS TEST VERIFIES THAT THE BITS IN POSITIONS 8, 9 AND 10 ARE CLEARABLE. 1521 ;FIRST, THE ARITHMETIC FLAGS ARE CLEARED; 1522 ;THEN, BITS 8, 9 AND 10 OF THE PC-WORD IS EXAMINED. 1523 ;IF ANY OF THESE BITS ARE SET, THIS TEST FAILS BECAUSE THEY SHOULD BE CLEAR. 1524 1525 031273 C27100: SFLAG ^;CLEAR ARITHMETIC FLAGS 1526 1527 031273 205 01 0 00 000000 MOVSI 1, 1528 031274 255 17 0 00 031275 JFCL 17,.+1 ;RESET ALL FLAGS 1529 031275 254 02 0 01 031276 JRST 2,.+1(1) ;SET FLAG 1530 031276 265 00 0 00 031277 JSP .+1 ;SAVE FLAGS 1531 031277 603 00 0 00 001600 TLNE 1600 ;PASS IF THESE BITS ARE CLEAR 1532 STOP^ 1533 031300 254 04 0 00 031301 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1534 031301 324 00 0 00 031302 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1535 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1536 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1537 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1538 1539 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 20 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0047 1540 SUBTTL TEST OF MSCL FWT INSTRUCTIONS 1541 1542 ;********** 1543 1544 ;THIS TEST VERIFIES THAT MOVEM PLACES C(AC) INTO E AND DOES 1545 ;NOT MODIFY C(AC). 1546 ;IN THIS CASE, C(AC)=252525,,252525 ANS C(E)=707070,,707070. 1547 ;HENCE, THE RESULT IN E SHOULD BE 252525,,252525. 1548 ;THE AC IS CHECKED FOR 252525,,252525. IF ANY OTHER NUMBER IS 1549 ;FOUND IN THE AC, IT WAS CLOBBERED BY MOVEM, AND THIS TEST FAILS. 1550 ;E IS CHECKED FOR 252525,,252525. IF ANY OTHER NUMBER IS FOUND 1551 ;IN E, IT WAS UPDATED INCORRECTLY BY MOVEM. 1552 1553 031302 200 00 0 00 033473 C50000: MOVE [252525,,252525] ;PRELOAD AC WITH 252525,,252525 1554 031303 200 01 0 00 033474 MOVE 1,[707070,,707070] ;PRELOAD E WITH 707070,,707070 1555 031304 202 00 0 00 000001 MOVEM 0,1 ;*MOVEM SHOULD PLACE 252525,,252525 1556 ;INTO E AND NOT AFFECT THE AC 1557 031305 312 00 0 00 033473 CAME 0,[252525,,252525] ;PASS IF C(AC) IS NOT CLOBBERED 1558 STOP^ 1559 031306 254 04 0 00 031307 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1560 031307 324 00 0 00 031310 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1561 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1562 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1563 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1564 031310 312 01 0 00 033473 CAME 1,[252525,,252525] ;PASS IF E WAS UPDATED CORRECTLY 1565 STOP^ 1566 031311 254 04 0 00 031312 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1567 031312 324 00 0 00 031313 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1568 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1569 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1570 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1571 1572 ;********** 1573 1574 ;THIS TEST VERIFIES THAT MOVES PLACES C(E) INTO THE AC IF AC IS NON-ZERO. 1575 ;IN THIS CASE, C(AC)=707070,,707070 AND C(E)=123456,,123456. HENCE, BOTH 1576 ;THE AC AND E SHOULD CONTAIN 123456,,123456 AFTER MOVES IS EXECUTED. 1577 ;BOTH AC AND E ARE CHECKED FOR 123456,,123456. IF EITHER AC OR E 1578 ;CONTAIN A DIFFERENT RESULT, THIS TEST FAILS 1579 1580 031313 200 02 0 00 033474 C50100: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 1581 031314 200 01 0 00 033475 MOVE 1,[123456,,123456] ;PRELOAD E WITH 123456,,123456 1582 031315 203 02 0 00 000001 MOVES 2,1 ;*MOVES SHOULD PLACE 123456,,123456 1583 ;INTO BOTH AC AND E 1584 031316 312 02 0 00 033475 CAME 2,[123456,,123456] ;PASS IF C(AC)=123456,,123456 1585 STOP^ 1586 031317 254 04 0 00 031320 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1587 031320 324 00 0 00 031321 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1588 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1589 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1590 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1591 031321 312 01 0 00 033475 CAME 1,[123456,,123456] ;PASS IF C(E)=123456,,123456 1592 STOP^ 1593 031322 254 04 0 00 031323 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1594 031323 324 00 0 00 031324 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 20-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0048 1595 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1596 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1597 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1598 1599 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 21 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0049 1600 ;THIS TEST VERIFIES THAT MOVES IS A NO-OP IF AC=0 1601 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=707070,,707070 1602 ;AFTER MOVES IS EXECUTED, AC AND E ARE CHECKED FOR THEIR ORIGINAL DATA. 1603 ;IF EITHER C(AC) OR C(E) CHANGED AS A RESULT OF MOVES, THIS TEST FAILS. 1604 1605 031324 200 01 0 00 033474 C50110: MOVE 1,[707070,,707070] ;PRELOAD E WITH 707070,,707070 1606 031325 474 00 0 00 000000 SETO ;PRELOAD AC WITH -1,,-1 1607 031326 203 00 0 00 000001 MOVES 0,1 ;*MOVES SHOULD FUNCTION AS A NO-OP 1608 031327 312 00 0 00 033462 CAME 0,[-1,,-1] ;PASS IF C(AC) WAS NOT MODIFIED 1609 STOP^ 1610 031330 254 04 0 00 031331 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1611 031331 324 00 0 00 031332 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1612 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1613 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1614 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1615 031332 312 01 0 00 033474 CAME 1,[707070,,707070] ;PASS IF C(E) WAS NOT MODIFIED 1616 STOP^ 1617 031333 254 04 0 00 031334 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1618 031334 324 00 0 00 031335 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1619 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1620 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1621 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1622 1623 ;********** 1624 1625 ;THIS TEST VERIFIES THAT MOVSI LOADS THE WORD E,0 INTO THE AC. 1626 ;IN THIS CASE, C(AC)=707070,,707070 AND E=0,,-1. 1627 ;HENCE, THE RESULT IN THE AC SHOULD BE -1,,0. 1628 ;THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. 1629 1630 031335 200 01 0 00 033474 C50200: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 1631 031336 205 01 0 00 777777 MOVSI 1,-1 ;*MOVSI SHOULD PLACE -1,,0 INTO THE AC 1632 031337 312 01 0 00 033476 CAME 1,[-1,,0] ;PASS IF C(AC)=1,,0 1633 STOP^ 1634 031340 254 04 0 00 031341 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1635 031341 324 00 0 00 031342 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1636 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1637 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1638 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1639 1640 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 22 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0050 1641 ;THIS TEST VERIFIES THAT MOVNM PLACES THE NEGATIVE OF C(AC) 1642 ;INTO E. IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-3. 1643 ;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 AND THE RESULT 1644 ;IN E SHOULD BE 0,,1 1645 1646 031342 474 01 0 00 000000 C50300: SETO 1, ;PRELOAD AC WITH -1,,-1 1647 031343 200 02 0 00 033477 MOVE 2,[-1,,-3] ;PRELOAD E WITH -1,,-3 1648 031344 212 01 0 00 000002 MOVNM 1,2 ;*MOVNM SHOULD PLACE 0,,1 INTO E 1649 ;AND NOT AFFTECT C(AC) 1650 031345 312 01 0 00 033462 CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 1651 STOP^ 1652 031346 254 04 0 00 031347 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1653 031347 324 00 0 00 031350 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1654 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1655 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1656 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1657 031350 302 02 0 00 000001 CAIE 2,1 ;PASS IF C(E)=0,,1 1658 STOP^ 1659 031351 254 04 0 00 031352 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1660 031352 324 00 0 00 031353 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1661 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1662 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1663 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1664 1665 ;********** 1666 1667 ;THIS TEST VERIFIES THAT MOVNM PLACES THE NEGATIVE OF C(AC) 1668 ;INTO E. IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-3. 1669 ;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 AND THE RESULT 1670 ;IN E SHOULD BE 0,,1 1671 1672 031353 474 01 0 00 000000 C50301: SETO 1, ;PRELOAD AC WITH -1,,-1 1673 031354 200 02 0 00 033477 MOVE 2,[-1,,-3] ;PRELOAD E WITH -1,,-3 1674 031355 202 02 0 00 031367 MOVEM 2,E50301 1675 031356 212 01 0 00 031367 MOVNM 1,E50301 ;*MOVNM SHOULD PLACE 0,,1 INTO E 1676 ;AND NOT AFFTECT C(AC) 1677 031357 312 01 0 00 033462 CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 1678 STOP^ 1679 031360 254 04 0 00 031361 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1680 031361 324 00 0 00 031362 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1681 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1682 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1683 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1684 031362 200 02 0 00 031367 MOVE 2,E50301 1685 031363 302 02 0 00 000001 CAIE 2,1 ;PASS IF C(E)=0,,1 1686 STOP^ 1687 031364 254 04 0 00 031365 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1688 031365 324 00 0 00 031366 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1689 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1690 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1691 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1692 1693 031366 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST 1694 031367 000000 000000 E50301: 0 ;TESTED MEMORY LOCATION 1695 DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 22-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0051 1696 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 23 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0052 1697 ;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E 1698 ;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=0, 1699 ;C(AC)=0 AND C(E)=0,,1 1700 ;HENCE, THE RESULT IN THE AC SHOULD BE 0 1701 ;AND THE RESULT IN E SHOULD BE -1,,-1 1702 1703 031370 400 00 0 00 000000 C50400: SETZ ;CLEAR AC 1704 031371 201 02 0 00 000001 MOVEI 2,1 ;PRELOAD E WITH 0,,1 1705 031372 213 00 0 00 000002 MOVNS 0,2 ;*MOVNS SHOULD PLACE -1,,-1 INTO E 1706 ;AND SHOULD NOT AFFECT THE AC 1707 031373 332 00 0 00 000000 SKIPE ;PASS IF THE AC IS UNALTERED 1708 STOP^ 1709 031374 254 04 0 00 031375 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1710 031375 324 00 0 00 031376 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1711 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1712 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1713 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1714 031376 312 02 0 00 033462 CAME 2,[-1] ;PASS IF C(E)=-1,,-1 1715 STOP^ 1716 031377 254 04 0 00 031400 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1717 031400 324 00 0 00 031401 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1718 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1719 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1720 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1721 1722 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 24 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0053 1723 ;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E 1724 ;AND INTO THE AC IF THE AC IS NON-ZO. IN THIS CASE, AC=0, 1725 ;C(AC)=0 AND C(E)=0,,1 1726 ;HENCE, THE RESULT IN THE AC SHOULD BE 0 1727 ;AND THE RESULT IN E SHOULD BE -1,,-1 1728 1729 031401 400 00 0 00 000000 C50401: SETZ ;CLEAR AC 1730 031402 201 02 0 00 000001 MOVEI 2,1 ;PRELOAD E WITH 0,,1 1731 031403 202 02 0 00 031415 MOVEM 2,E50401 1732 031404 213 00 0 00 031415 MOVNS 0,E50401 ;*MOVNS SHOULD PLACE -1,,-1 INTO E 1733 ;AND SHOULD NOT AFFECT THE AC 1734 031405 332 00 0 00 000000 SKIPE ;PASS IF THE AC IS UNALTERED 1735 STOP^ 1736 031406 254 04 0 00 031407 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1737 031407 324 00 0 00 031410 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1738 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1739 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1740 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1741 031410 200 02 0 00 031415 MOVE 2,E50401 1742 031411 312 02 0 00 033462 CAME 2,[-1] ;PASS IF C(E)=-1,,-1 1743 STOP^ 1744 031412 254 04 0 00 031413 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1745 031413 324 00 0 00 031414 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1746 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1747 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1748 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1749 1750 031414 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST 1751 031415 000000 000000 E50401: 0 ;TESTED MEMORY LOCATION 1752 1753 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 25 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0054 1754 ;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E 1755 ;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=1, 1756 ;C(AC=0 AND C(E)=3 1757 ;HENCE, THE RESULT IN THE AC SHOULD BE -1,,3 1758 ;AND THE RESULT IN E SHOULD BE -1,,3. 1759 1760 031416 400 01 0 00 000000 C50410: SETZ 1, ;CLEAR AC 1761 031417 201 02 0 00 000003 MOVEI 2,3 ;PRELOAD WITH 0,,3 1762 031420 213 01 0 00 000002 MOVNS 1,2 ;*MOVNS SHOULD PLACE -1,,-3 INTO E 1763 ;AND -1,,-3 INTO THE AC 1764 031421 312 01 0 00 033477 CAME 1,[-1,,-3] ;PASS IF C(AC)=-1,,-3 1765 STOP^ 1766 031422 254 04 0 00 031423 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1767 031423 324 00 0 00 031424 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1768 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1769 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1770 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1771 031424 312 02 0 00 033477 CAME 2,[-1,,-3] ;PASS IF C(E)=-1,,-3 1772 STOP^ 1773 031425 254 04 0 00 031426 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1774 031426 324 00 0 00 031427 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1775 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1776 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1777 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1778 1779 ;********** 1780 1781 ;THIS TEST VERIFIES THAT MOVMI MOVES THE WORD 0,,E INTO THE AC. 1782 ;IN THIS CASE, C(AC)=0 AND E=0,,-2. HENCE, THE RESULT IN THE AC 1783 ;SHOULD BE 0,,-2. 1784 1785 031427 400 01 0 00 000000 C50500: SETZ 1, ;CLEAR AC 1786 031430 215 01 0 00 777776 MOVMI 1,-2 ;*MOVMI SHOULD PLACE 0,,-2 INTO AC 1787 031431 302 01 0 00 777776 CAIE 1,-2 ;PASS IF C(AC)=0,,-2 1788 STOP^ 1789 031432 254 04 0 00 031433 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1790 031433 324 00 0 00 031434 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1791 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1792 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1793 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1794 1795 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 26 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0055 1796 ;THIS TEST VERIFIES THAT MOVM MOVES THE MAGNITUDE OF C(E) NTO THE AC. 1797 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-2. HENCE, THE RESULT IN THE AC 1798 ;SHOULD BE 0,,2. 1799 1800 031434 400 01 0 00 000000 C50501: SETZ 1, ;CLEAR AC 1801 031435 200 03 0 00 033500 MOVE 3,[-2] ;PRELOAD E WITH -1,,-2 1802 031436 214 01 0 00 000003 MOVM 1,3 ;*MOVM SHOULD PLACE 0,,2 INTO AC 1803 031437 302 01 0 00 000002 CAIE 1,2 ;PASS IF C(AC)=0,,2 1804 STOP^ 1805 031440 254 04 0 00 031441 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1806 031441 324 00 0 00 031442 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1807 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1808 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1809 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1810 1811 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 27 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0056 1812 ;THIS TEST VERIFIES THAT MOVMM PLACES THE MAGNITUDE OF C(AC) 1813 ;INTO E. IN THIS CASE, C(AC)=-1,,-2 AND C(E)=0. HENCE, THE 1814 ;RESULT IN E SHOULD BE 0,,2 AND C(AC) SHOULD REMAIN UNCHANGED. 1815 1816 031442 200 01 0 00 033500 C50600: MOVE 1,[-1,,-2] ;PRELOAD AC WITH -1,,-2 1817 031443 400 02 0 00 000000 SETZ 2, ;CLEAR E 1818 031444 216 01 0 00 000002 MOVMM 1,2 ;*MOVMM SHOULD PLACE 0,,2 INTO E 1819 ;AND SHOULD NOT CHANGE C(AC) 1820 031445 312 01 0 00 033500 CAME 1,[-1,,-2] ;PASS IF C(AC) IS NOT ALTERED 1821 STOP^ 1822 031446 254 04 0 00 031447 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1823 031447 324 00 0 00 031450 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1824 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1825 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1826 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1827 031450 302 02 0 00 000002 CAIE 2,2 ;PASS IF C(E)=0,,2 1828 STOP^ 1829 031451 254 04 0 00 031452 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1830 031452 324 00 0 00 031453 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1831 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1832 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1833 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1834 1835 ;********** 1836 1837 ;THIS TEST VERIFIES THAT MONMS PLACES THE MAGNITUDE OF C(E) INTO E 1838 ;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=0, C(AC)=0 1839 ;AND C(E)=-1,,-2. 1840 ;HENCE, THE RESULT IN THE AC SHOULD BE 0 AND THE RESULT IN 1841 ;E SHOULD BE 0,,2. 1842 1843 031453 400 00 0 00 000000 C50700: SETZ ;CLEAR AC 1844 031454 200 02 0 00 033500 MOVE 2,[-1,,-2] ;PRELOAD E WITH -1,,-1 1845 031455 217 00 0 00 000002 MOVMS 0,2 ;*MOVMS SHOULD PLACE 0,,1 INTO E 1846 ;AND SHOULD NOT CHANGE C(AC) 1847 031456 332 00 0 00 000000 SKIPE ;PASS IF C(AC) IS UNALTERED 1848 STOP^ 1849 031457 254 04 0 00 031460 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1850 031460 324 00 0 00 031461 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1851 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1852 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1853 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1854 031461 302 02 0 00 000002 CAIE 2,2 ;PASS IF C(E)=0,,2 1855 STOP^ 1856 031462 254 04 0 00 031463 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1857 031463 324 00 0 00 031464 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1858 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1859 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1860 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1861 1862 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 28 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0057 1863 ;THIS TEST VERIFIES THAT MOVMS PLACES THE MAGNITUDE OF C(E) INTO E 1864 ;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=1, C(AC)=-1,,-1 1865 ;AND C(E)=-1,,-2. 1866 ;HENCE, THE RESULT IN THE AC SHOULD BE 0,,2 AND THE RESULT 1867 ;IN E SHOULD BE 0,,2. 1868 1869 031464 474 01 0 00 000000 C50710: SETO 1, ;PRELOAD AC WITH -1,,-1 1870 031465 200 02 0 00 033500 MOVE 2,[-1,,-2] ;PRELOAD E WITH -1,,-2 1871 031466 217 01 0 00 000002 MOVMS 1,2 ;*MOVMS SHOULD PLACE 0,,2 INTO E 1872 ;AND SHOULD PLACE 0,,2 INTO THE AC 1873 031467 302 01 0 00 000002 CAIE 1,2 ;PASS IF C(AC)=0,,2 1874 STOP^ 1875 031470 254 04 0 00 031471 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1876 031471 324 00 0 00 031472 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1877 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1878 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1879 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1880 031472 302 02 0 00 000002 CAIE 2,2 ;PASS IF C(E)=0,,2 1881 STOP^ 1882 031473 254 04 0 00 031474 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1883 031474 324 00 0 00 031475 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1884 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1885 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1886 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1887 1888 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 29 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL ADD/SUB INSTRUCTIONS SEQ 0058 1889 SUBTTL TEST OF MSCL ADD/SUB INSTRUCTIONS 1890 1891 ;********** 1892 1893 ;THIS TEST VERIFIES THAT SUBI SUBTRACTS THE WORD 0,,E FROM C(AC) 1894 ;AND PLACES THE RESULT INTO THE AC. IN THIS CASE, C(AC)=70 AND 1895 ;E=0,,2. HENCE, THE RESULT IN THE AC SHOULD BE 66. 1896 1897 031475 201 01 0 00 000070 C51000: MOVEI 1,70 ;PRELOAD AC WITH 70 1898 031476 275 01 0 00 000002 SUBI 1,2 ;*SUBI SHOULD PLACE 66 INTO AC 1899 031477 302 01 0 00 000066 CAIE 1,66 ;PASS IF C(AC)=66 1900 STOP^ 1901 031500 254 04 0 00 031501 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1902 031501 324 00 0 00 031502 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1903 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1904 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1905 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1906 1907 ;********** 1908 1909 ;THIS TEST VERIFIES THAT SUBM SUBTRACTS C(E) FROM C(AC) AND 1910 ;PLACES THE RESULT INTO E. THE AC IS UNAFFECTED. IN THIS CASE, 1911 ;C(AC)=100 AND C(E)=37. HENCE, THE RESULTS IN AC AND 1912 ;E SHOULD BE 0,,100 AND 0,,41 RESPECTIVELY. 1913 1914 031502 201 01 0 00 000100 C51100: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 1915 031503 201 02 0 00 000037 MOVEI 2,37 ;PRELOAD E WITH 0,,37 1916 031504 276 01 0 00 000002 SUBM 1,2 ;*SUBM SHOULD PLACE 1917 ;0,,41 INTO E AND NOT CHANGE C(AC) 1918 031505 302 01 0 00 000100 CAIE 1,100 ;PASS IF C(AC) IS UNCHANGED 1919 STOP^ 1920 031506 254 04 0 00 031507 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1921 031507 324 00 0 00 031510 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1922 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1923 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1924 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1925 031510 302 02 0 00 000041 CAIE 2,41 ;PASS IF C(E)=0,,41 1926 STOP^ 1927 031511 254 04 0 00 031512 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1928 031512 324 00 0 00 031513 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1929 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1930 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1931 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1932 1933 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 30 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL ADD/SUB INSTRUCTIONS SEQ 0059 1934 ;THIS TEST VERIFIES THAT SUBM SUBTRACTS C(E) FROM C(AC) AND 1935 ;PLACES THE RESULT INTO E. THE AC IS UNAFFECTED. IN THIS CASE, 1936 ;C(AC)=100 AND C(E)=37. HENCE, THE RESULTS IN AC AND 1937 ;E SHOULD BE 0,,100 AND 0,,41 RESPECTIVELY. 1938 1939 031513 201 01 0 00 000100 C51101: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 1940 031514 201 02 0 00 000037 MOVEI 2,37 ;PRELOAD E WITH 0,,37 1941 031515 202 02 0 00 031527 MOVEM 2,E51101 1942 031516 276 01 0 00 031527 SUBM 1,E51101 ;*SUBM SHOULD PLACE 1943 ;0,,41 INTO E AND NOT CHANGE C(AC) 1944 031517 302 01 0 00 000100 CAIE 1,100 ;PASS IF C(AC) IS UNCHANGED 1945 STOP^ 1946 031520 254 04 0 00 031521 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1947 031521 324 00 0 00 031522 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1948 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1949 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1950 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1951 031522 200 02 0 00 031527 MOVE 2,E51101 1952 031523 302 02 0 00 000041 CAIE 2,41 ;PASS IF C(E)=0,,41 1953 STOP^ 1954 031524 254 04 0 00 031525 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1955 031525 324 00 0 00 031526 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1956 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1957 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1958 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1959 1960 031526 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST 1961 031527 000000 000000 E51101: 0 ;TEST WORD MEMORY 1962 1963 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 31 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL ADD/SUB INSTRUCTIONS SEQ 0060 1964 ;THIS TEST VERIFIES THAT SUBB SUBTRACTS C(E) FROM C(AC) AND 1965 ;PLACES THE RESULT INTO BOTH AC AND E. IN THIS CASE, 1966 ;C(AC)=0,,100 AND C(E)=0,,37. HENCE, THE RESULT IN BOTH 1967 ;AC AND E SHOULD BE 0,,41. 1968 1969 031530 201 01 0 00 000100 C51200: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 1970 031531 201 02 0 00 000037 MOVEI 2,37 ;PRELOAD E WITH O,,37 1971 031532 277 01 0 00 000002 SUBB 1,2 ;*SUBB SHOULD PLACE 0,,41 INTO BOTH AC AND E 1972 031533 302 01 0 00 000041 CAIE 1,41 ;PASS IF C(AC)=0,,41 1973 STOP^ 1974 031534 254 04 0 00 031535 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1975 031535 324 00 0 00 031536 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1976 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1977 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1978 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1979 031536 302 02 0 00 000041 CAIE 2,41 ;PASS IF C(E)=0,,41 1980 STOP^ 1981 031537 254 04 0 00 031540 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1982 031540 324 00 0 00 031541 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 1983 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 1984 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 1985 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 1986 1987 ;********** 1988 1989 ;THIS TEST VERIFIES THAT SUBB SUBTRACTS C(E) FROM C(AC) AND 1990 ;PLACES THE RESULT INTO BOTH AC AND E. IN THIS CASE, 1991 ;C(AC)=0,,100 AND C(E)=0,,37. HENCE, THE RESULT IN BOTH 1992 ;AC AND E SHOULD BE 0,,41. 1993 1994 031541 201 01 0 00 000100 C51201: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 1995 031542 201 02 0 00 000037 MOVEI 2,37 ;PRELOAD E WITH O,,37 1996 031543 202 02 0 00 031555 MOVEM 2,E51201 1997 031544 277 01 0 00 031555 SUBB 1,E51201 ;*SUBB SHOULD PLACE 0,,41 INTO BOTH AC AND E 1998 031545 302 01 0 00 000041 CAIE 1,41 ;PASS IF C(AC)=0,,41 1999 STOP^ 2000 031546 254 04 0 00 031547 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2001 031547 324 00 0 00 031550 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2002 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2003 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2004 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2005 031550 200 02 0 00 031555 MOVE 2,E51201 2006 031551 302 02 0 00 000041 CAIE 2,41 ;PASS IF C(E)=0,,41 2007 STOP^ 2008 031552 254 04 0 00 031553 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2009 031553 324 00 0 00 031554 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2010 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2011 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2012 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2013 2014 031554 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST 2015 031555 000000 000000 E51201: 0 ;TEST WORD MEMORY 2016 2017 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 32 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0061 2018 SUBTTL TEST OF MSCL CAIX INSTRUCTIONS 2019 2020 ;********** 2021 2022 ;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND 2023 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E. 2024 ;IN THIS CASE, C(AC)=0,,1 AND E=0,,2 2025 ;HENCE, CAIL SHOULD SKIP THE NEXT INSTRUCTION. 2026 ;IF CAIL SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES 2027 2028 031556 201 01 0 00 000001 C51300: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 2029 031557 301 01 0 00 000002 CAIL 1,2 ;*CAIL SHOULD SKIP THE NEXT INSTRUCTION 2030 STOP^ 2031 031560 254 04 0 00 031561 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2032 031561 324 00 0 00 031562 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2033 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2034 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2035 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2036 2037 ;********** 2038 2039 ;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND 2040 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E. 2041 ;IN THIS CASE, C(AC)=0,,2 AND E=0,,2. 2042 ;HENCE, CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION. 2043 ;IF CAIL DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. 2044 2045 031562 201 01 0 00 000002 C51310: MOVEI 1,2 ;PRELOAD AC WITH 0,,2 2046 031563 301 01 0 00 000002 CAIL 1,2 ;*CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION 2047 031564 334 00 0 00 000000 SKIPA ;PASS IF CAIL DOES NOT SKIP 2048 STOP^ 2049 031565 254 04 0 00 031566 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2050 031566 324 00 0 00 031567 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2051 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2052 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2053 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2054 2055 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 33 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0062 2056 ;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND 2057 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E 2058 ;IN THIS CASE, C(AC)=0,,3 AND E=0,,2 2059 ;HENCE, CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION. 2060 ;IF CAIL DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. 2061 2062 031567 201 01 0 00 000003 C51320: MOVEI 1,3 ;PRELOAD AC WITH 0,,3 2063 031570 301 01 0 00 000002 CAIL 1,2 ;*CAIL SHOULD SKIP THE NEXT INSTRUCTION 2064 031571 334 00 0 00 000000 SKIPA ;PASS IF CAIL DOES NOT SKIP 2065 STOP^ 2066 031572 254 04 0 00 031573 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2067 031573 324 00 0 00 031574 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2068 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2069 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2070 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2071 2072 ;********** 2073 2074 ;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND 2075 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E 2076 ;IN THIS CASE, C(AC)=-1,,-1 AND E=0 2077 ;HENCE, CAILE SHOULD SKIP THE NEXT INSTRUCTION 2078 ;IF CAILE SKIPS THE NEXT INSTRUCTION, THE TEST PASSES 2079 2080 031574 474 01 0 00 000000 C51400: SETO 1, ;PRELOAD AC WITH -1,,-1 2081 031575 303 01 0 00 000000 CAILE 1,0 ;*CAILE SHOULD SKIP THE NEXT INSTRUCTION 2082 STOP^ 2083 031576 254 04 0 00 031577 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2084 031577 324 00 0 00 031600 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2085 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2086 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2087 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2088 2089 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 34 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0063 2090 ;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND 2091 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E 2092 ;IN THIS CASE, C(AC)=0 AND E=0 2093 ;HENCE, CAILE SHOULD SKIP THE NEXT INSTRUCTION. 2094 ;IF CAILE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. 2095 2096 031600 400 01 0 00 000000 C51410: SETZ 1, ;PRELOAD AC WITH 0 2097 031601 303 01 0 00 000000 CAILE 1,0 ;*CAILE SHOULD SKIP THE NEXT INSTRUCTION. 2098 STOP^ 2099 031602 254 04 0 00 031603 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2100 031603 324 00 0 00 031604 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2101 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2102 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2103 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2104 2105 ;********** 2106 2107 ;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND 2108 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E 2109 ;IN THIS CASE, C(AC)=0,,1 AND E=0 2110 ;HENCE, CAILE SHOULD NOT SKIP THE NEXT INSTRUCTION. 2111 ;IF CAILE DOES NOT SKIP THE NEXT INSTRUCTION, THE TEST PASSES 2112 2113 031604 201 01 0 00 000001 C51420: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 2114 031605 303 01 0 00 000000 CAILE 1,0 ;*CAILE SHOULD NOT SKIP THE NEXT INSTRUCTION 2115 031606 334 00 0 00 000000 SKIPA ;PASS IF CAILE DOES NOT SKIP 2116 STOP^ 2117 031607 254 04 0 00 031610 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2118 031610 324 00 0 00 031611 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2119 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2120 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2121 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2122 2123 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 35 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0064 2124 ;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS 2125 ;SKIPS THE NEXT INSTRUCTION 2126 ;IN THIS CASE, C(AC)=-1,,-1 AND E=0 2127 ;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION 2128 ;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES 2129 2130 031611 474 01 0 00 000000 C51500: SETO 1, ;PRELOAD AC WITH -1,,-1 2131 031612 304 01 0 00 000000 CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION 2132 STOP^ 2133 031613 254 04 0 00 031614 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2134 031614 324 00 0 00 031615 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2135 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2136 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2137 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2138 2139 ;********** 2140 2141 ;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS 2142 ;SKIPS THE NEXT INSTRUCTION 2143 ;IN THIS CASE, C(AC)=0 AND E=0 2144 ;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION. 2145 ;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES 2146 2147 031615 400 01 0 00 000000 C51510: SETZ 1, ;PRELOAD AC WITH 0 2148 031616 304 01 0 00 000000 CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION 2149 STOP^ 2150 031617 254 04 0 00 031620 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2151 031620 324 00 0 00 031621 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2152 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2153 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2154 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2155 2156 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 36 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0065 2157 ;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS 2158 ;SKIPS THE NEXT INSTRUCTION 2159 ;IN THIS CASE, C(AC)=0,,1 AND E=0 2160 ;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION. 2161 ;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. 2162 2163 031621 201 01 0 00 000001 C51520: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 2164 031622 304 01 0 00 000000 CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION 2165 STOP^ 2166 031623 254 04 0 00 031624 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2167 031624 324 00 0 00 031625 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2168 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2169 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2170 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2171 2172 ;********** 2173 2174 ;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND 2175 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E. 2176 ;IN THIS CASE, C(AC)=0,,5 AND E=0,,6 2177 ;HENCE, CAIGE SHOULD NOT SKIP THE NEXT INSTRUCTION. 2178 ;IF CAIGE DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES 2179 2180 031625 201 02 0 00 000005 C51600: MOVEI 2,5 ;PRELOAD AC WITH 0,,5 2181 031626 305 02 0 00 000006 CAIGE 2,6 ;*CAIGE SHOULD NOT SKIP THE NEXT INSTRUCTION 2182 031627 334 00 0 00 000000 SKIPA ;PASS IF CAIGE DOES NOT SKIP 2183 STOP^ 2184 031630 254 04 0 00 031631 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2185 031631 324 00 0 00 031632 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2186 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2187 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2188 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2189 2190 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 37 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0066 2191 ;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND 2192 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E 2193 ;IN THIS CASE, C(AC)=0,,6 AND E=0,,6 2194 ;HENCE, CAIGE SHOULD SKIP THE NEXT INSTRUCTION. 2195 ;IF CAIGE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. 2196 2197 031632 201 02 0 00 000006 C51610: MOVEI 2,6 ;PRELOAD AC WITH 0,,6 2198 031633 305 00 0 00 000000 CAIGE ;*CAIGE SHOULD SKIP THE NEXT INSTRUCTION 2199 STOP^ 2200 031634 254 04 0 00 031635 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2201 031635 324 00 0 00 031636 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2202 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2203 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2204 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2205 2206 ;********** 2207 2208 ;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND 2209 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E. 2210 ;IN THIS CASE, C(AC)=0,,7 AND E=0,,6 2211 ;HENCE, CAIGE SHOULD SKIP THE NEXT INSTRUCTION. 2212 ;IF CAIGE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES 2213 2214 031636 201 02 0 00 000007 C51620: MOVEI 2,7 ;PRELOAD AC WITH 0,,7 2215 031637 305 02 0 00 000006 CAIGE 2,6 ;*CAIGE SHOULD SKIP THE NEXT INSTRUCTION 2216 STOP^ 2217 031640 254 04 0 00 031641 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2218 031641 324 00 0 00 031642 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2219 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2220 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2221 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2222 2223 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 38 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0067 2224 ;THIS TEST VERIRIES THAT CAIN COMPARES C(AC) WITH E AND 2225 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. 2226 ;IN THIS CASE, C(AC)=0 AND E=0,,1 2227 ;HENCE, CAIN SHOULD SKIP THE NEXT INSTRUCTION. 2228 ;IF CAIN SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. 2229 2230 031642 400 06 0 00 000000 C51700: SETZ 6, ;PRELOAD AC WITH 0 2231 031643 306 06 0 00 000001 CAIN 6,1 ;*CAIN SHOULD SKIP THE NEXT INSTRUCTION 2232 STOP^ 2233 031644 254 04 0 00 031645 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2234 031645 324 00 0 00 031646 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2235 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2236 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2237 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2238 2239 ;********** 2240 2241 ;THIS TEST VERIFIES THAT CAIN COMPARES C(AC) WITH E AND 2242 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. 2243 ;IN THIS CASE, C(AC)=0,,1 AND E=0,,1 2244 ;HENCE, CAIN SHOULD NOT SKIP THE NEXT INSTRUCTION. 2245 ;IF CAIN DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES 2246 2247 031646 200 06 0 00 000001 C51710: MOVE 6,1 ;PRELOAD AC WITH 0,,1 2248 031647 306 06 0 00 000001 CAIN 6,1 ;*CAIN SHOULD NOT SKIP THE NEXT INSTRUCTION 2249 031650 334 00 0 00 000000 SKIPA ;PASS IF CAIN SKIPS 2250 STOP^ 2251 031651 254 04 0 00 031652 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2252 031652 324 00 0 00 031653 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2253 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2254 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2255 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2256 2257 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 39 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0068 2258 ;THIS TEST VERIFIES THAT CAIN COMPARES C(AC) WITH E AND 2259 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. 2260 ;IN THIS CASE, C(AC)=0,,2 AND E=0,,1 2261 ;HENCE, CAIN SHOULD SKIP THE NEXT INSTRUCTION. 2262 ;IF CAIN SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES 2263 2264 031653 201 06 0 00 000002 C51720: MOVEI 6,2 ;PRELOAD AC WITH 2265 031654 306 06 0 00 000001 CAIN 6,1 ;*CAIN SHOULD SKIP THE NEXT INSTRUCTION 2266 STOP^ 2267 031655 254 04 0 00 031656 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2268 031656 324 00 0 00 031657 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2269 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2270 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2271 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2272 2273 ;********** 2274 2275 ;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND 2276 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. 2277 ;IN THIS CASE, C(AC)=0,,2 AND E=0,,3. 2278 ;HENCE, CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION. 2279 ;IF CAIG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES 2280 2281 031657 201 11 0 00 000002 C52000: MOVEI 11,2 ;PRELOAD AC WITH 0,,2 2282 031660 307 11 0 00 000003 CAIG 11,3 ;*CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION 2283 031661 334 00 0 00 000000 SKIPA ;PASS IF CAIG DID NOT SKIP 2284 STOP^ 2285 031662 254 04 0 00 031663 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2286 031663 324 00 0 00 031664 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2287 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2288 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2289 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2290 2291 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 40 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0069 2292 ;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND 2293 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. 2294 ;IN THIS CASE, C(AC)=0,,3 AND E=0,,3. 2295 ;HENCE, CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION. 2296 ;IF CAIG DOES NOT SKIP THE NEXT INSTRUCTION, THE TEST PASSES. 2297 2298 031664 201 11 0 00 000003 C52010: MOVEI 11,3 ;PRELOAD AC WITH 0,,3 2299 031665 307 11 0 00 000003 CAIG 11,3 ;*CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION 2300 031666 334 00 0 00 000000 SKIPA ;PASS IF CAIG DID NOT SKIP 2301 STOP^ 2302 031667 254 04 0 00 031670 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2303 031670 324 00 0 00 031671 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2304 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2305 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2306 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2307 2308 ;********** 2309 2310 ;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND 2311 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. 2312 ;IN THIS CASE, C(AC)=0,,4 AND E=0,,3. 2313 ;HENCE, CAIG SHOULD SKIP THE NEXT INSTRUCTION. 2314 ;IF CAIG SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. 2315 2316 031671 201 11 0 00 000004 C52020: MOVEI 11,4 ;PRELOAD AC WITH 0,,4 2317 031672 307 11 0 00 000003 CAIG 11,3 ;*CAIG SHOULD SKIP THE NEXT INSTRUCTION 2318 STOP^ 2319 031673 254 04 0 00 031674 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2320 031674 324 00 0 00 031675 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2321 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2322 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2323 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2324 2325 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 41 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAMX INSTRUCTIONS SEQ 0070 2326 SUBTTL TEST OF MSCL CAMX INSTRUCTIONS 2327 2328 ;********** 2329 2330 ;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND 2331 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAT OR EQUAL TO C(E). 2332 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0 2333 ;HENCE, CAMLE SHOULD SKIP THE NEXT INSTRUCTION. 2334 ;IF CAMLE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. 2335 2336 031675 474 01 0 00 000000 C52100: SETO 1, ;PRELOAD AC WITH -1,,-1 2337 031676 400 02 0 00 000000 SETZ 2, ;PRELOAD E WITH 0 2338 031677 313 01 0 00 000002 CAMLE 1,2 ;*CAMLE SHOULD SKIP THE NEXT INSTRUCTION 2339 STOP^ 2340 031700 254 04 0 00 031701 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2341 031701 324 00 0 00 031702 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2342 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2343 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2344 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2345 2346 ;********** 2347 2348 ;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND 2349 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO C(E). 2350 ;IN THIS CASE, C(AC)=0 AND C(E)=0 2351 ;HENCE, CAMLE SHOULD SKIP THE NEXT INSTRUCTION. 2352 ;IF CAMLE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES 2353 2354 031702 400 01 0 00 000000 C52110: SETZ 1, ;CLEAR AC 2355 031703 313 01 0 00 033501 CAMLE 1,[0] ;*CAMLE SHOULD SKIP THE NEXT INSTRUCTION 2356 STOP^ 2357 031704 254 04 0 00 031705 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2358 031705 324 00 0 00 031706 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2359 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2360 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2361 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2362 2363 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 42 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAMX INSTRUCTIONS SEQ 0071 2364 ;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND 2365 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO C(E). 2366 ;IN THIS CASE, C(AC)=0,,1 AND C(E)=0 2367 ;HENCE, CAMLE SHOULD NOT SKIP THE NEXT INSTRUCTION. 2368 ;IF CAMLE DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. 2369 2370 031706 201 01 0 00 000001 C52120: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 2371 031707 400 02 0 00 000000 SETZ 2, ;PRELOAD E WITH 0 2372 031710 313 01 0 00 000002 CAMLE 1,2 ;*CAMLE SHOULD NOT SKIP THE NEXT INSTRUCTION 2373 031711 334 00 0 00 000000 SKIPA ;PASS IF CAMLE DOES NOT SKIP 2374 STOP^ 2375 031712 254 04 0 00 031713 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2376 031713 324 00 0 00 031714 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2377 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2378 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2379 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2380 2381 ;********** 2382 2383 ;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND 2384 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). 2385 ;IN THIS CASE, C(AC)=-1,,-2 AND C(E)=-1,,-1. 2386 ;HENCE, CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. 2387 ;IF CAMG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. 2388 2389 031714 561 10 0 00 777776 C52200: HRROI 10,-2 ;PRELOAD AC WITH -1,,-2 2390 031715 317 10 0 00 033462 CAMG 10,[-1,,-1] ;*CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. 2391 031716 334 00 0 00 000000 SKIPA ;PASS IF CAMG DOES NOT SKIP 2392 STOP^ 2393 031717 254 04 0 00 031720 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2394 031720 324 00 0 00 031721 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2395 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2396 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2397 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2398 ;********** 2399 2400 ;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND 2401 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). 2402 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-2. 2403 ;HENCE, CAMG SHOULD SKIP THE NEXT INSTRUCTION. 2404 2405 031721 561 10 0 00 777777 C52205: HRROI 10,-1 ;PRELOAD AC WITH -1,,-1 2406 031722 317 10 0 00 033500 CAMG 10,[-1,,-2] ;*CAMG SHOULD SKIP THE NEXT INSTRUCTION. 2407 STOP^ 2408 031723 254 04 0 00 031724 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2409 031724 324 00 0 00 031725 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2410 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2411 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2412 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2413 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 43 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAMX INSTRUCTIONS SEQ 0072 2414 ;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND 2415 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). 2416 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. 2417 ;HENCE, CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. 2418 ;IF CAMG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. 2419 031725 474 10 0 00 000000 C52210: SETO 10, ;PRELOAD AC WITH -1,,-1. 2420 031726 317 10 0 00 033462 CAMG 10,[-1,,-1] ;*CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION 2421 031727 334 00 0 00 000000 SKIPA ;PASS IF CAMG DOES NOT SKIP 2422 STOP^ 2423 031730 254 04 0 00 031731 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2424 031731 324 00 0 00 031732 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2425 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2426 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2427 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2428 2429 ;********** 2430 2431 ;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND 2432 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). 2433 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. 2434 ;HENCE, CAMG SHOULD SKIP THE NEXT INSTRUCTION. 2435 ;IF CAMG SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. 2436 2437 031732 400 10 0 00 000000 C52220: SETZ 10, ;PRELOAD AC WITH 0 2438 031733 317 10 0 00 033462 CAMG 10,[-1,,-1] ;*CAMG SHOULD SKIP THE NEXT INSTRUCTION 2439 STOP^ 2440 031734 254 04 0 00 031735 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2441 031735 324 00 0 00 031736 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2442 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2443 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2444 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2445 2446 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 44 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL JUMPX INSTRUCTIONS SEQ 0073 2447 SUBTTL TEST OF MSCL JUMPX INSTRUCTIONS 2448 2449 ;********** 2450 2451 ;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND 2452 ;JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR 2453 ;EQUAL TO 0. IN THIS CASE, C(AC)=-1,,-1. HENCE, JUMPLE SHOULD JUMP. 2454 2455 031736 474 17 0 00 000000 C52300: SETO 17, ;PRELOAD AC WITH -1,,-1 2456 031737 323 17 0 00 031741 JUMPLE 17,.+2 ;*JUMPLE SHOULD JUMP 2457 STOP^ 2458 031740 254 04 0 00 031741 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2459 031741 324 00 0 00 031742 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2460 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2461 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2462 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2463 2464 ;********** 2465 2466 ;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND 2467 ;JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR 2468 ;EQUAL TO 0. IN THIS CASE, C(AC)=0. HENCE, JUMPLE SHOULD JUMP. 2469 2470 031742 400 17 0 00 000000 C52310: SETZ 17, ;PRELOAD AC WITH 0 2471 031743 323 17 0 00 031745 JUMPLE 17,.+2 ;*JUMPLE SHOULD JUMP 2472 STOP^ 2473 031744 254 04 0 00 031745 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2474 031745 324 00 0 00 031746 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2475 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2476 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2477 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2478 2479 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 45 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL JUMPX INSTRUCTIONS SEQ 0074 2480 ;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND JUMPS 2481 ;TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 2482 ;0. IN THIS CASE, C(AC)=0,,1. HENCE, JUMPLE SHOULD NOT JUMP. 2483 2484 031746 201 17 0 00 000001 C52320: MOVEI 17,1 ;PRELOAD AC WITH 0,,1 2485 031747 320 17 0 00 031751 JUMP 17,.+2 ;*JUMPLE SHOULD NOT JUMP 2486 031750 334 00 0 00 000000 SKIPA ;PASS IF JUMPLE DOES NOT JUMP 2487 STOP^ 2488 031751 254 04 0 00 031752 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2489 031752 324 00 0 00 031753 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2490 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2491 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2492 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2493 2494 ;********** 2495 2496 ;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH 0 AND JUMPS TO 2497 ;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. 2498 ;IN THIS CASE, C(AC)=-1,,-1. HENCE, JUMPGE SHOULD NOT JUMP. 2499 2500 031753 474 16 0 00 000000 C52400: SETO 16, ;PRELOAD AC WITH -1,,-1 2501 031754 325 16 0 00 031756 JUMPGE 16,.+2 ;*JUMPGE SHOULD NOT JUMP 2502 031755 334 00 0 00 000000 SKIPA ;PASS IF JUMPGE DOES NOT JUMP 2503 STOP^ 2504 031756 254 04 0 00 031757 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2505 031757 324 00 0 00 031760 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2506 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2507 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2508 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2509 2510 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 46 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL JUMPX INSTRUCTIONS SEQ 0075 2511 ;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH O AND JUMPS TO 2512 ;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. 2513 ;IN THIS CASE, C(AC)=0. HENCE, JUMPGE SHOULD JUMP. 2514 2515 031760 400 16 0 00 000000 C52410: SETZ 16, ;PRELOAD AC WITH 0 2516 031761 325 16 0 00 031763 JUMPGE 16,.+2 ;*JUMPGE SHOULD JUMP 2517 STOP^ 2518 031762 254 04 0 00 031763 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2519 031763 324 00 0 00 031764 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2520 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2521 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2522 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2523 2524 ;********** 2525 2526 ;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH 0 AND JUMPS TO 2527 ;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. 2528 ;IN THIS CASE, C(AC)=0,,1. HENCE, JUMPGE SHOULD JUMP. 2529 2530 031764 201 16 0 00 000001 C52420: MOVEI 16,1 ;PRELOAD AC WITH 0,,1 2531 031765 325 16 0 00 031767 JUMPGE 16,.+2 ;*JUMPGE SHOULD JUMP 2532 STOP^ 2533 031766 254 04 0 00 031767 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2534 031767 324 00 0 00 031770 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2535 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2536 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2537 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2538 2539 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 47 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0076 2540 SUBTTL TEST OF MSCL AOJX INSTRUCTIONS 2541 2542 ;********** 2543 2544 ;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND PLACES 2545 ;THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS COMPARED 2546 ;TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) 2547 ;IS LESS THAN 0. IN THIS CASE, C(AC)=-1,,-2 BEFORE INCREMENTING. 2548 ;HENCE, AOJL SHOULD JUMP. 2549 2550 031770 561 15 0 00 777776 C52500: HRROI 15,-2 ;PRELOAD AC WITH -1,,-2 2551 031771 341 15 0 00 031773 AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) AND JUMP 2552 STOP^ 2553 031772 254 04 0 00 031773 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2554 031773 324 00 0 00 031774 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2555 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2556 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2557 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2558 031774 312 15 0 00 033462 CAME 15,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY 2559 STOP^ 2560 031775 254 04 0 00 031776 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2561 031776 324 00 0 00 031777 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2562 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2563 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2564 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2565 2566 ;********** 2567 2568 ;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND 2569 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2570 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2571 ;SPECIFIED BY E IF C(AC) IS LESS THAN 0. 2572 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING 2573 ;HENCE, AOJ SHOULD NOT JUMP 2574 2575 031777 474 15 0 00 000000 C52510: SETO 15, ;PRELOAD AC WITH 2576 032000 341 15 0 00 032002 AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) 2577 ;AND NOT JUMP 2578 032001 334 00 0 00 000000 SKIPA ;PASS IF AOJL DID NOT JUMP 2579 STOP^ 2580 032002 254 04 0 00 032003 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2581 032003 324 00 0 00 032004 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2582 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2583 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2584 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2585 032004 302 15 0 00 000000 CAIE 15,0 ;PASS IF C(AC) INCREMENTED CORRECTLY 2586 STOP^ 2587 032005 254 04 0 00 032006 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2588 032006 324 00 0 00 032007 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2589 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2590 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2591 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2592 2593 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 48 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0077 2594 ;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND 2595 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2596 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2597 ;SPECIFIED BY E IF C(AC) IS 0 BEFORE INCREMENTING 2598 ;HENCE, AOJL SHOULD NOT JUMP 2599 2600 032007 400 15 0 00 000000 C52520: SETZ 15, ;PRELOAD AC WITH 0 2601 032010 341 15 0 00 032012 AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) 2602 ;AND NOT JUMP 2603 032011 334 00 0 00 000000 SKIPA ;PASS IF AOJL DID NOT JUMP 2604 STOP^ 2605 032012 254 04 0 00 032013 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2606 032013 324 00 0 00 032014 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2607 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2608 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2609 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2610 032014 302 15 0 00 000001 CAIE 15,1 ;PASS IF C(AC) INCREMENTED CORRECTLY 2611 STOP^ 2612 032015 254 04 0 00 032016 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2613 032016 324 00 0 00 032017 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2614 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2615 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2616 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2617 2618 ;********** 2619 2620 ;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND 2621 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2622 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2623 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0 2624 ;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING 2625 ;HENCE, AOJE SHOULD NOT JUMP 2626 2627 032017 561 14 0 00 777776 C52600: HRROI 14,-2 ;PRELOAD AC WITH -1,,-2 2628 032020 342 14 0 00 032022 AOJE 14,.+2 ;*AOJE SHOULD ADD 0,,1 TO C(AC) 2629 ;AND NOT JUMP 2630 032021 334 00 0 00 000000 SKIPA ;PASS IF AOJE DID NOT JUMP 2631 STOP^ 2632 032022 254 04 0 00 032023 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2633 032023 324 00 0 00 032024 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2634 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2635 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2636 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2637 032024 312 14 0 00 033462 CAME 14,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY 2638 STOP^ 2639 032025 254 04 0 00 032026 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2640 032026 324 00 0 00 032027 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2641 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2642 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2643 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2644 2645 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 49 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0078 2646 ;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND 2647 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2648 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2649 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. 2650 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING. 2651 ;HENCE, AOJE SHOULD JUMP 2652 2653 032027 474 14 0 00 000000 C52610: SETO 14, ;PRELOAD AC WITH -1,,-1 2654 032030 342 14 0 00 032032 AOJE 14,.+2 ;*AOJ SHOULD ADD 0,,1 TO C(AC) 2655 ;AND JUMP 2656 STOP^ 2657 032031 254 04 0 00 032032 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2658 032032 324 00 0 00 032033 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2659 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2660 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2661 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2662 032033 302 14 0 00 000000 CAIE 14,0 ;PASS IF C(AC) INCREMENTED CORRECTLY 2663 STOP^ 2664 032034 254 04 0 00 032035 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2665 032035 324 00 0 00 032036 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2666 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2667 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2668 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2669 2670 ;********** 2671 2672 ;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND 2673 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2674 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2675 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. 2676 ;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING 2677 ;HENCE, AOJE SHOULD NOT JUMP 2678 2679 032036 400 14 0 00 000000 C52620: SETZ 14, ;PRELOAD AC WITH 0 2680 032037 342 14 0 00 032041 AOJE 14,.+2 ;*AOJE SHOULD ADD 0,11 TO C(AC) 2681 ;AND NOT JUMP 2682 032040 334 00 0 00 000000 SKIPA ;PASS IF AOJE DID NOT JUMP 2683 STOP^ 2684 032041 254 04 0 00 032042 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2685 032042 324 00 0 00 032043 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2686 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2687 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2688 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2689 032043 302 14 0 00 000001 CAIE 14,1 ;PASS IF C(AC) INCREMENTED CORRECTLY 2690 STOP^ 2691 032044 254 04 0 00 032045 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2692 032045 324 00 0 00 032046 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2693 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2694 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2695 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2696 2697 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 50 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0079 2698 ;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND 2699 ;PLACES THE RESULT BACK INTO TLE$EC. THE RESULT IN THE AC IS 2700 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2701 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. 2702 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING 2703 ;HENCE, AOJLE SHOULD 2704 2705 032046 561 13 0 00 777776 C52700: HRROI 13,-2 ;PRELOAD AC WITH -1,,-2 2706 032047 343 13 0 00 032051 AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) 2707 ;AND JUMP 2708 STOP^ 2709 032050 254 04 0 00 032051 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2710 032051 324 00 0 00 032052 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2711 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2712 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2713 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2714 032052 312 13 0 00 033462 CAME 13,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY 2715 STOP^ 2716 032053 254 04 0 00 032054 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2717 032054 324 00 0 00 032055 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2718 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2719 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2720 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2721 2722 ;********** 2723 2724 ;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND 2725 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2726 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2727 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0 2728 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING 2729 ;HENCE, AOJLE SHOULD JUMP. 2730 2731 032055 474 13 0 00 000000 C52710: SETO 13, ;PRELOAD AC WITH -1,,-1 2732 032056 343 13 0 00 032060 AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) 2733 ;AND JUMP 2734 STOP^ 2735 032057 254 04 0 00 032060 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2736 032060 324 00 0 00 032061 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2737 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2738 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2739 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2740 032061 302 13 0 00 000000 CAIE 13,0 ;PASS IF C(AC) INCREMENTED CORRECTLY 2741 STOP^ 2742 032062 254 04 0 00 032063 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2743 032063 324 00 0 00 032064 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2744 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2745 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2746 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2747 2748 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 51 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0080 2749 ;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND 2750 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2751 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2752 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. 2753 ;IN THIS CASE, C(AC) IS 0 2754 ;HENCE, AOJLE SHOULD NOT JUMP. 2755 2756 032064 400 13 0 00 000000 C52720: SETZ 13, ;PRELOAD AC WITH 0 2757 032065 343 13 0 00 032067 AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) 2758 ;AND NOT JUMP 2759 032066 334 00 0 00 000000 SKIPA ;PASS IF AOJLE DID NOT JUMP 2760 STOP^ 2761 032067 254 04 0 00 032070 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2762 032070 324 00 0 00 032071 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2763 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2764 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2765 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2766 032071 302 13 0 00 000001 CAIE 13,1 ;PASS IF C(AC) INCREMENTED CORRECTLY 2767 STOP^ 2768 032072 254 04 0 00 032073 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2769 032073 324 00 0 00 032074 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2770 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2771 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2772 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2773 2774 ;********** 2775 2776 ;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND 2777 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2778 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION 2779 ;SPECIFIED BY E. 2780 ;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING 2781 ;HENCE, AOJA SHOULD JUMP 2782 2783 032074 561 12 0 00 777776 C53000: HRROI 12,-2 ;PRELOAD AC WITH -1,,-2 2784 032075 344 12 0 00 032077 AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) 2785 ;AND JUMP 2786 STOP^ 2787 032076 254 04 0 00 032077 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2788 032077 324 00 0 00 032100 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2789 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2790 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2791 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2792 032100 312 12 0 00 033462 CAME 12,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY 2793 STOP^ 2794 032101 254 04 0 00 032102 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2795 032102 324 00 0 00 032103 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2796 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2797 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2798 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2799 2800 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 52 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0081 2801 ;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND 2802 ;PLACES THE RESULT BACK INTO AC. THE RESULT IN THE AC IS 2803 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION 2804 ;SPECIFIED BY E. 2805 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING 2806 ;HENCE, AOJA SHOULD JUMP 2807 2808 032103 474 12 0 00 000000 C53010: SETO 12, ;PRELOAD AC WITH -1,,-1 2809 032104 344 12 0 00 032106 AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) 2810 ;AND JUMP 2811 STOP^ 2812 032105 254 04 0 00 032106 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2813 032106 324 00 0 00 032107 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2814 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2815 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2816 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2817 032107 302 12 0 00 000000 CAIE 12,0 ;PASS IF C(AC) INCREMENTED CORRECTLY 2818 STOP^ 2819 032110 254 04 0 00 032111 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2820 032111 324 00 0 00 032112 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2821 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2822 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2823 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2824 2825 ;********** 2826 2827 ;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND 2828 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2829 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION 2830 ;SPECIFIED BY E. 2831 ;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING 2832 ;HENCE, AOJA SHOULD JUMP 2833 2834 032112 400 12 0 00 000000 C53020: SETZ 12, ;PRELOAD AC WITH 0 2835 032113 344 12 0 00 032115 AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) 2836 ;AND JUMP 2837 STOP^ 2838 032114 254 04 0 00 032115 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2839 032115 324 00 0 00 032116 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2840 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2841 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2842 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2843 032116 302 12 0 00 000001 CAIE 12,1 ;PASS IF C(AC) INCREMENTED CORRECTLY 2844 STOP^ 2845 032117 254 04 0 00 032120 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2846 032120 324 00 0 00 032121 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2847 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2848 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2849 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2850 2851 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 53 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0082 2852 ;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND 2853 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2854 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2855 ;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 2856 ;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING 2857 ;HENCE, AOJGE SHOULD NOT JUMP 2858 2859 032121 561 11 0 00 777776 C53100: HRROI 11,-2 ;PRELOAD AC WITH -1,,-2 2860 032122 345 11 0 00 032124 AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) 2861 ;AND NOT JUMP 2862 032123 334 00 0 00 000000 SKIPA ;PASS IF AOJGE DID NOT JUMP 2863 STOP^ 2864 032124 254 04 0 00 032125 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2865 032125 324 00 0 00 032126 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2866 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2867 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2868 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2869 032126 312 11 0 00 033462 CAME 11,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY 2870 STOP^ 2871 032127 254 04 0 00 032130 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2872 032130 324 00 0 00 032131 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2873 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2874 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2875 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2876 2877 ;********** 2878 2879 ;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND 2880 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2881 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2882 ;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. 2883 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING 2884 ;HENCE, AOJ SHOULD JUMP 2885 2886 032131 474 11 0 00 000000 C53110: SETO 11, ;PRELOAD AC WITH -1,,-1 2887 032132 345 11 0 00 032134 AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) 2888 ;AND JUMP 2889 STOP^ 2890 032133 254 04 0 00 032134 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2891 032134 324 00 0 00 032135 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2892 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2893 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2894 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2895 032135 302 11 0 00 000000 CAIE 11,0 ;PASS IF C(AC) INCREMENTED CORRECTLY 2896 STOP^ 2897 032136 254 04 0 00 032137 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2898 032137 324 00 0 00 032140 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2899 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2900 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2901 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2902 2903 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 54 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0083 2904 ;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND 2905 ;PLACES THE RESULT BACK INTO AC. THE RESULT IN THE AC IS 2906 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2907 ;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 2908 ;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING 2909 ;HENCE, AOJGE SHOULD JUMP 2910 2911 032140 400 11 0 00 000000 C53120: SETZ 11, ;PRELOAD AC WITH 0 2912 032141 345 11 0 00 032143 AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) 2913 ;AND JUMP 2914 STOP^ 2915 032142 254 04 0 00 032143 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2916 032143 324 00 0 00 032144 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2917 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2918 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2919 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2920 032144 302 11 0 00 000001 CAIE 11,1 ;PASS IF C(AC) INCREMENTED CORRECTLY 2921 STOP^ 2922 032145 254 04 0 00 032146 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2923 032146 324 00 0 00 032147 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2924 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2925 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2926 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2927 2928 ;********** 2929 2930 ;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND 2931 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2932 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2933 ;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. 2934 ;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING 2935 ;HENCE, AOJN SHOULD JUMP 2936 2937 032147 561 10 0 00 777776 C53200: HRROI 10,-2 ;PRELOAD AC WITH -1,,-2 2938 032150 346 10 0 00 032152 AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) 2939 ;AND JUMP 2940 STOP^ 2941 032151 254 04 0 00 032152 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2942 032152 324 00 0 00 032153 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2943 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2944 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2945 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2946 032153 312 10 0 00 033462 CAME 10,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY 2947 STOP^ 2948 032154 254 04 0 00 032155 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2949 032155 324 00 0 00 032156 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2950 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2951 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2952 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2953 2954 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 55 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0084 2955 ;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND 2956 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2957 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2958 ;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. 2959 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING 2960 ;HENCE, AOJ SHOULD NOT JUMP. 2961 2962 032156 474 10 0 00 000000 C53210: SETO 10, ;PRELOAD AC WITH -1,,-1 2963 032157 346 10 0 00 032161 AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) 2964 ;AND NOT JUMP 2965 032160 334 00 0 00 000000 SKIPA ;PASS IF AOJN DID NOT JUMP 2966 STOP^ 2967 032161 254 04 0 00 032162 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2968 032162 324 00 0 00 032163 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2969 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2970 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2971 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2972 032163 302 10 0 00 000000 CAIE 10,0 ;PASS IF C(AC) INCREMENTED CORRRECTLY 2973 STOP^ 2974 032164 254 04 0 00 032165 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2975 032165 324 00 0 00 032166 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2976 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2977 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2978 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2979 2980 ;********** 2981 2982 ;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND 2983 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 2984 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 2985 ;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. 2986 ;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING 2987 ;HENCE, AOJN SHOULD JUMP. 2988 2989 032166 400 10 0 00 000000 C53220: SETZ 10, ;PRELOAD AC WITH 0 2990 032167 346 10 0 00 032171 AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) 2991 ;AND JUMP 2992 STOP^ 2993 032170 254 04 0 00 032171 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2994 032171 324 00 0 00 032172 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 2995 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 2996 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 2997 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 2998 032172 302 10 0 00 000001 CAIE 10,1 ;PASS IF C(AC) INCREMENTED CORRECTLY 2999 STOP^ 3000 032173 254 04 0 00 032174 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3001 032174 324 00 0 00 032175 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3002 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3003 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3004 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3005 3006 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 56 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0085 3007 ;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND 3008 ;PLACES THE RESULT BACK INTO THE AC. THE REAULT IN THE AC IS 3009 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 3010 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0 3011 ;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INC 3012 ;HENCE, AOJG SHOULD NOT JUMP 3013 3014 032175 561 07 0 00 777776 C53300: HRROI 7,-2 ;PRELOAD AC WITH -1,,-2 3015 032176 347 07 0 00 032200 AOJG 7,.+2 ;*AOJG SHOULD ADD 0,11 TO C(AC) 3016 ;AND NOT JUMP 3017 032177 334 00 0 00 000000 SKIPA ;PASS IF AOJG DID NOT JUMP 3018 STOP^ 3019 032200 254 04 0 00 032201 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3020 032201 324 00 0 00 032202 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3021 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3022 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3023 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3024 032202 312 07 0 00 033462 CAME 7,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY 3025 STOP^ 3026 032203 254 04 0 00 032204 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3027 032204 324 00 0 00 032205 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3028 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3029 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3030 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3031 3032 ;********** 3033 3034 ;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND 3035 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 3036 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 3037 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. 3038 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING 3039 ;HENCE, AOJG SHOULD NOT JUMP. 3040 3041 032205 474 07 0 00 000000 C53310: SETO 7, ;PRELOAD AC WITH -1,,-1 3042 032206 347 07 0 00 032210 AOJG 7,.+2 ;*AOJG SHOULD ADD 0,,1 TO C(AC) 3043 ;AND NOT JUMP 3044 032207 334 00 0 00 000000 SKIPA ;PASS IF AOJG DID NOT JUMP 3045 STOP^ 3046 032210 254 04 0 00 032211 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3047 032211 324 00 0 00 032212 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3048 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3049 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3050 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3051 032212 302 07 0 00 000000 CAIE 7,0 ;PASS IF C(AC) INCREMENTED CORRECTLY 3052 STOP^ 3053 032213 254 04 0 00 032214 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3054 032214 324 00 0 00 032215 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3055 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3056 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3057 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3058 3059 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 57 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0086 3060 ;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND 3061 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 3062 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 3063 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. 3064 ;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING 3065 ;HENCE, AOJG SHOULD JUMP 3066 3067 032215 400 07 0 00 000000 C53320: SETZ 7, ;PRELOAD AC WITH 0 3068 032216 347 07 0 00 032220 AOJG 7,.+2 ;*AOJG SHOULD ADD 0,,1 TO C(AC) 3069 ;AND JUMP 3070 STOP^ 3071 032217 254 04 0 00 032220 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3072 032220 324 00 0 00 032221 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3073 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3074 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3075 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3076 032221 302 07 0 00 000001 CAIE 7,1 ;PASS IF C(AC) INCREMENTED CORRECTLY 3077 STOP^ 3078 032222 254 04 0 00 032223 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3079 032223 324 00 0 00 032224 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3080 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3081 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3082 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3083 3084 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 58 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0087 3085 SUBTTL TEST OF MSCL AOSX INSTRUCTIONS 3086 3087 ;********** 3088 3089 ;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES 3090 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3091 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0 3092 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3093 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-2 3094 ;BEFORE INCREMENTING. HENCE, AOSL SHOULD SKIP ; AND THE 3095 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 3096 ;RESPECTIVELY. 3097 3098 032224 200 06 0 00 033474 C53400: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3099 032225 561 07 0 00 777776 HRROI 7,-2 ;PRELOAD E WITH -1,,-2 3100 032226 351 06 0 00 000007 AOSL 6,7 ;*AOSL SHOULD ADD 0,,1 TO C(E), 3101 ;UPDATE AC AND SKIP 3102 STOP^ 3103 032227 254 04 0 00 032230 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3104 032230 324 00 0 00 032231 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3105 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3106 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3107 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3108 032231 312 07 0 00 033462 CAME 7,[-1] ;PASS IF E INCREMENTED CORRECTLY 3109 STOP^ 3110 032232 254 04 0 00 032233 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3111 032233 324 00 0 00 032234 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3112 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3113 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3114 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3115 032234 312 06 0 00 033462 CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3116 STOP^ 3117 032235 254 04 0 00 032236 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3118 032236 324 00 0 00 032237 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3119 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3120 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3121 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3122 3123 ;********** 3124 3125 ;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES 3126 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3127 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0 3128 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3129 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-2 3130 ;BEFORE INCREMENTING. HENCE, AOSL SHOULD SKIP ; AND THE 3131 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 3132 ;RESPECTIVELY. 3133 3134 032237 200 06 0 00 033474 C53401: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3135 032240 561 07 0 00 777776 HRROI 7,-2 ;PRELOAD E WITH -1,,-2 3136 032241 202 07 0 00 032255 MOVEM 7,E53401 3137 032242 351 06 0 00 032255 AOSL 6,E53401 ;*AOSL SHOULD ADD 0,,1 TO C(E), 3138 ;UPDATE AC AND SKIP 3139 STOP^ DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 58-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0088 3140 032243 254 04 0 00 032244 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3141 032244 324 00 0 00 032245 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3142 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3143 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3144 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3145 032245 200 07 0 00 032255 MOVE 7,E53401 3146 032246 312 07 0 00 033462 CAME 7,[-1] ;PASS IF E INCREMENTED CORRECTLY 3147 STOP^ 3148 032247 254 04 0 00 032250 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3149 032250 324 00 0 00 032251 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3150 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3151 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3152 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3153 032251 312 06 0 00 033462 CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3154 STOP^ 3155 032252 254 04 0 00 032253 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3156 032253 324 00 0 00 032254 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3157 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3158 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3159 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3160 3161 032254 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST 3162 032255 000000 000000 E53401: 0 ;TEST WORD MEMORY 3163 3164 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 59 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0089 3165 ;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES 3166 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3167 ;THE NEXT INSTRUCTION IF C(E) ISLESS THAN 0 3168 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3169 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-1 3170 ;BEFORE INCREMENTING. HENCE, AOSL SHOULD NOT SKIP; AND THE 3171 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 3172 ;RESPECTIVELY. 3173 3174 032256 200 06 0 00 033474 C53410: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3175 032257 474 07 0 00 000000 SETO 7, ;PRELOAD E WITH -1,,-1 3176 032260 351 06 0 00 000007 AOSL 6,7 ;*AOSL SHOULD ADD 00,1 TO C(E) 3177 ;UPDATE AC AND NOT SKIP 3178 032261 334 00 0 00 000000 SKIPA ;PASS IF AOSL DID NOT SKIP 3179 STOP^ 3180 032262 254 04 0 00 032263 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3181 032263 324 00 0 00 032264 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3182 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3183 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3184 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3185 032264 312 07 0 00 033501 CAME 7,[0] ;PASS IF E INCREMENTED CORRECTLY 3186 STOP^ 3187 032265 254 04 0 00 032266 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3188 032266 324 00 0 00 032267 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3189 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3190 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3191 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3192 032267 312 06 0 00 033501 CAME 6,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3193 STOP^ 3194 032270 254 04 0 00 032271 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3195 032271 324 00 0 00 032272 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3196 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3197 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3198 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3199 3200 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 60 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0090 3201 ;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES 3202 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3203 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. 3204 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3205 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0 3206 ;BEFORE INCREMENTING. HENCE, AOSL SHOULD NOT SKIP; AND THE 3207 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 3208 ;RESPECTIVELY 3209 3210 032272 200 06 0 00 033474 C53420: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3211 032273 400 07 0 00 000000 SETZ 7, ;PRELOAD E WITH 0 3212 032274 351 06 0 00 000007 AOSL 6,7 ;*AOSL SHOULD ADD 0,,1 TO C(E). 3213 ;UPDATE AC AND NOT SKIP 3214 032275 334 00 0 00 000000 SKIPA ;PASS IF AOSL DID NOT SKIP 3215 STOP^ 3216 032276 254 04 0 00 032277 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3217 032277 324 00 0 00 032300 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3218 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3219 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3220 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3221 032300 312 07 0 00 033502 CAME 7,[1] ;PASS IF E INCREMENTED CORRECTLY 3222 STOP^ 3223 032301 254 04 0 00 032302 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3224 032302 324 00 0 00 032303 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3225 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3226 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3227 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3228 032303 312 06 0 00 033502 CAME 6,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3229 STOP^ 3230 032304 254 04 0 00 032305 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3231 032305 324 00 0 00 032306 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3232 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3233 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3234 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3235 3236 ;********** 3237 3238 ;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES 3239 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3240 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0. 3241 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3242 ;IN THIS CASE, AC=5, C(AC)=707070,,707070AND C(E)=-1,,-2 3243 ;BEFORE INCREMENTING. HENCE, AOSE SHOULD NOT SKIP; AND THE 3244 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 3245 ;RESPECTIVELY. 3246 3247 032306 200 05 0 00 033474 C53500: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3248 032307 561 06 0 00 777776 HRROI 6,-2 ;PRELOAD E WITH -1,,-2 3249 032310 352 05 0 00 000006 AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), 3250 ;UPDATE AC AND NOT SKIP 3251 032311 334 00 0 00 000000 SKIPA ;PASS IF AOSE DID NOT SKIP 3252 STOP^ 3253 032312 254 04 0 00 032313 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3254 032313 324 00 0 00 032314 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3255 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 60-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0091 3256 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3257 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3258 032314 312 06 0 00 033462 CAME 6,[-1] ;PASS IF E INCREMENTED CORRECTLY 3259 STOP^ 3260 032315 254 04 0 00 032316 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3261 032316 324 00 0 00 032317 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3262 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3263 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3264 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3265 032317 312 05 0 00 033462 CAME 5,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3266 STOP^ 3267 032320 254 04 0 00 032321 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3268 032321 324 00 0 00 032322 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3269 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3270 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3271 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3272 3273 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 61 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0092 3274 ;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES 3275 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3276 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 3277 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3278 ;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=-1,,-1 3279 ;BEFORE INCREMENTING. HENCE, AOSE SHOULD SKIP; AND THE 3280 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 3281 ;RESPECTIVELY. 3282 3283 032322 200 05 0 00 033474 C53510: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3284 032323 474 06 0 00 000000 SETO 6, ;PRELOAD E WITH -1,,-1 3285 032324 352 05 0 00 000006 AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), 3286 ;UPDATE AC AND SKIP 3287 STOP^ 3288 032325 254 04 0 00 032326 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3289 032326 324 00 0 00 032327 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3290 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3291 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3292 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3293 032327 312 06 0 00 033501 CAME 6,[0] ;PASS IF E INCREMENTED CORRECTLY 3294 STOP^ 3295 032330 254 04 0 00 032331 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3296 032331 324 00 0 00 032332 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3297 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3298 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3299 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3300 032332 312 05 0 00 033501 CAME 5,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3301 STOP^ 3302 032333 254 04 0 00 032334 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3303 032334 324 00 0 00 032335 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3304 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3305 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3306 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3307 3308 ;********** 3309 3310 ;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES 3311 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3312 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 3313 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3314 ;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(AC)=0 3315 ;BEFORE INCREMENTING. HENCE, AOSE SHOULD NOT SKIP; AND THE 3316 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 3317 ;RESPECTIVELY. 3318 3319 032335 200 05 0 00 033474 C53520: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3320 032336 400 06 0 00 000000 SETZ 6, ;PRELOAD E WITH 0 3321 032337 352 05 0 00 000006 AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), 3322 ;UPDATE AC AND NOT SKIP 3323 032340 334 00 0 00 000000 SKIPA ;PASS IF AOSE DID NOT SKIP 3324 STOP^ 3325 032341 254 04 0 00 032342 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3326 032342 324 00 0 00 032343 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3327 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3328 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 61-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0093 3329 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3330 032343 312 06 0 00 033502 CAME 6,[1] ;PASS IF E INCREMENTED CORRECTLY 3331 STOP^ 3332 032344 254 04 0 00 032345 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3333 032345 324 00 0 00 032346 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3334 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3335 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3336 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3337 032346 312 05 0 00 033502 CAME 5,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3338 STOP^ 3339 032347 254 04 0 00 032350 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3340 032350 324 00 0 00 032351 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3341 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3342 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3343 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3344 3345 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 62 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0094 3346 ;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES 3347 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3348 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO0 3349 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3350 ;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=-1,,-2 3351 ;BEFORE INCREMENTING. HENCE, AOSLE SHOULD SKIP; AND THE 3352 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 3353 ;RESPECTIVELY. 3354 3355 032351 200 04 0 00 033474 C53600: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3356 032352 561 05 0 00 777776 HRROI 5,-2 ;PRELOAD E WITH -1,,-2 3357 032353 353 04 0 00 000005 AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E), 3358 ;UPDATE AC AND SKIP ZERO 3359 STOP^ 3360 032354 254 04 0 00 032355 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3361 032355 324 00 0 00 032356 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3362 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3363 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3364 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3365 032356 312 05 0 00 033462 CAME 5,[-1] ;PASS IF E INCREMENTED CORRECTLY 3366 STOP^ 3367 032357 254 04 0 00 032360 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3368 032360 324 00 0 00 032361 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3369 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3370 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3371 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3372 032361 312 04 0 00 033462 CAME 4,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3373 STOP^ 3374 032362 254 04 0 00 032363 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3375 032363 324 00 0 00 032364 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3376 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3377 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3378 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3379 3380 ;********** 3381 3382 ;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES 3383 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3384 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. 3385 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3386 ;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=-1,,-1 3387 ;BEFORE INCREMENTING. HENCE, AOSLE SHOULD SKIP; AND THE 3388 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 3389 ;RESPECTIVELY. 3390 3391 032364 200 04 0 00 033474 C53610: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3392 032365 476 05 0 00 000000 SETOM 5, ;PRELOAD E WITH -1,,-1 3393 032366 353 04 0 00 000005 AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E) 3394 ;UPDATE AC AND SKIP 3395 STOP^ 3396 032367 254 04 0 00 032370 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3397 032370 324 00 0 00 032371 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3398 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3399 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3400 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 62-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0095 3401 032371 312 05 0 00 033501 CAME 5,[0] ;PASS IF E INCREMENTED CORRECTLY 3402 STOP^ 3403 032372 254 04 0 00 032373 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3404 032373 324 00 0 00 032374 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3405 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3406 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3407 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3408 032374 312 04 0 00 033501 CAME 4,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3409 STOP^ 3410 032375 254 04 0 00 032376 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3411 032376 324 00 0 00 032377 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3412 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3413 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3414 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3415 3416 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 63 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0096 3417 ;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES 3418 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3419 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0 3420 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3421 ;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0 3422 ;BEFORE INCREMENTING. HENCE, AOSLE SHOULD NOT SKIP ; AND THE 3423 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 3424 ;RESPECTIVELY. 3425 3426 032377 200 04 0 00 033474 C53620: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3427 032400 400 00 0 00 000005 SETZ 5 ;PRELOAD E WITH 0 3428 032401 353 04 0 00 000005 AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E) 3429 ;UPDATE AC AND NOT SKIP 3430 032402 334 00 0 00 000000 SKIPA ;PASS IF AOSLE DID NOT SKIP 3431 STOP^ 3432 032403 254 04 0 00 032404 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3433 032404 324 00 0 00 032405 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3434 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3435 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3436 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3437 032405 312 05 0 00 033502 CAME 5,[1] ;PASS IF E INCREMENTED CORRECTLY 3438 STOP^ 3439 032406 254 04 0 00 032407 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3440 032407 324 00 0 00 032410 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3441 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3442 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3443 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3444 032410 312 04 0 00 033502 CAME 4,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3445 STOP^ 3446 032411 254 04 0 00 032412 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3447 032412 324 00 0 00 032413 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3448 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3449 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3450 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3451 3452 ;********** 3453 3454 ;THIS TEST VERIFIES THAT AOSA INCREMENTS C(E) BY 0,,1 AND PLACES 3455 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS 3456 ;THE NEXT INSTRUCTION. 3457 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3458 ;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=-1,,-2 3459 ;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP ; AND THE 3460 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 3461 ;RESPECTIVELY. 3462 3463 032413 200 03 0 00 033474 C53700: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3464 032414 561 04 0 00 777776 HRROI 4,-2 ;PRELOAD E WITH -1,,-2 3465 032415 354 03 0 00 000004 AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), 3466 ;UPDATE AC AND SKIP 3467 STOP^ 3468 032416 254 04 0 00 032417 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3469 032417 324 00 0 00 032420 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3470 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3471 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 63-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0097 3472 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3473 032420 312 04 0 00 033462 CAME 4,[-1] ;PASS IF E INCREMENTED CORRECTLY 3474 STOP^ 3475 032421 254 04 0 00 032422 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3476 032422 324 00 0 00 032423 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3477 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3478 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3479 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3480 032423 312 03 0 00 033462 CAME 3,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3481 STOP^ 3482 032424 254 04 0 00 032425 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3483 032425 324 00 0 00 032426 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3484 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3485 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3486 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3487 3488 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 64 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0098 3489 ;THIS TEST VERIFIES THAT AOSA INCREMENTS C(E) BY 0,,1 AND PLACES 3490 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS 3491 ;THE NEXT INSTRUCTION. 3492 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3493 ;;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=-1,,-1 3494 ;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP AND THE 3495 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 3496 ;RESPECTIVELY 3497 3498 032426 200 03 0 00 033474 C53710: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3499 032427 474 04 0 00 000000 SETO 4, ;PRELOAD E WITH -1,,-1 3500 032430 354 03 0 00 000004 AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), 3501 ;UPDATE AC AND SKIP 3502 STOP^ 3503 032431 254 04 0 00 032432 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3504 032432 324 00 0 00 032433 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3505 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3506 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3507 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3508 032433 312 04 0 00 033501 CAME 4,[0] ;PASS IF E INCREMENTED CORRECTLY 3509 STOP^ 3510 032434 254 04 0 00 032435 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3511 032435 324 00 0 00 032436 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3512 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3513 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3514 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3515 032436 312 03 0 00 033501 CAME 3,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3516 STOP^ 3517 032437 254 04 0 00 032440 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3518 032440 324 00 0 00 032441 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3519 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3520 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3521 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3522 3523 ;********** 3524 3525 ;THIS TEST VERIFIES THAT AOS INCREMENTS C(E) BY 0,,1 AND PLACES 3526 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS 3527 ;THE NEXT INSTRUCTION. 3528 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3529 ;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0 3530 ;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP ; AND THE 3531 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 3532 ;RESPECTIVELY 3533 3534 032441 200 03 0 00 033474 C53720: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3535 032442 400 04 0 00 000000 SETZ 4, ;PRELOAD E WITH 0 3536 032443 354 03 0 00 000004 AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), 3537 ;UPDATE AC AND SKIP 3538 STOP^ 3539 032444 254 04 0 00 032445 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3540 032445 324 00 0 00 032446 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3541 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3542 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3543 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 64-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0099 3544 032446 312 04 0 00 033502 CAME 4,[1] ;PASS IF E INCREMENTED CORRECTLY 3545 STOP^ 3546 032447 254 04 0 00 032450 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3547 032450 324 00 0 00 032451 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3548 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3549 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3550 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3551 032451 312 03 0 00 033502 CAME 3,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3552 STOP^ 3553 032452 254 04 0 00 032453 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3554 032453 324 00 0 00 032454 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3555 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3556 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3557 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3558 3559 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 65 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0100 3560 ;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES 3561 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3562 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 3563 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3564 ;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=-1,,-2 3565 ;BEFORE INCREMENTING. HENCE, AOSGE SHOULD NOT SKIP; AND THE 3566 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 3567 ;RESPECTIVELY 3568 3569 032454 200 02 0 00 033474 C54000: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3570 032455 561 03 0 00 777776 HRROI 3,-2 ;PRELOAD E WITH -1,,-2 3571 032456 355 02 0 00 000003 AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), 3572 ;UPDATE AC AND NOT SKIP 3573 032457 334 00 0 00 000000 SKIPA ;PASS IF AOSGE DID NOT SKIP 3574 STOP^ 3575 032460 254 04 0 00 032461 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3576 032461 324 00 0 00 032462 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3577 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3578 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3579 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3580 032462 312 03 0 00 033462 CAME 3,[-1] ;PASS IF E INCREMENTED CORRECTLY 3581 STOP^ 3582 032463 254 04 0 00 032464 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3583 032464 324 00 0 00 032465 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3584 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3585 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3586 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3587 032465 312 02 0 00 033462 CAME 2,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3588 STOP^ 3589 032466 254 04 0 00 032467 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3590 032467 324 00 0 00 032470 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3591 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3592 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3593 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3594 3595 ;********** 3596 3597 ;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES 3598 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3599 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 3600 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3601 ;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=-1,,-1 3602 ;BEFORE INCREMENTING. HENCE, AOSGE SHOULD SKIP; AND THE 3603 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 3604 ;RESPECTIVELY 3605 3606 032470 200 02 0 00 033474 C54010: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3607 032471 474 03 0 00 000000 SETO 3, ;PRELOAD E WITH 0 3608 032472 355 02 0 00 000003 AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), 3609 ;UPDATE AC AND SKIP 3610 STOP^ 3611 032473 254 04 0 00 032474 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3612 032474 324 00 0 00 032475 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3613 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3614 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 65-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0101 3615 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3616 032475 312 03 0 00 033501 CAME 3,[0] ;PASS IF E INCREMENTED CORRECTLY 3617 STOP^ 3618 032476 254 04 0 00 032477 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3619 032477 324 00 0 00 032500 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3620 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3621 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3622 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3623 032500 312 02 0 00 033501 CAME 2,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3624 STOP^ 3625 032501 254 04 0 00 032502 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3626 032502 324 00 0 00 032503 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3627 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3628 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3629 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3630 3631 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 66 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0102 3632 ;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES 3633 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3634 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 3635 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3636 ;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=0 3637 ;BEFORE INCREMENTING. HENCE, AOSGE SHOULD SKIP; AND THE 3638 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 3639 ;RESPECTIVELY 3640 3641 032503 200 02 0 00 033474 C54020: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3642 032504 400 03 0 00 000000 SETZ 3, ;PRELOAD E WITH 0 3643 032505 355 02 0 00 000003 AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), 3644 ;UPDATE AC AND SKIP 3645 STOP^ 3646 032506 254 04 0 00 032507 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3647 032507 324 00 0 00 032510 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3648 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3649 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3650 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3651 032510 312 03 0 00 033502 CAME 3,[1] ;PASS IF E INCREMENTED CORRECTLY 3652 STOP^ 3653 032511 254 04 0 00 032512 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3654 032512 324 00 0 00 032513 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3655 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3656 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3657 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3658 032513 312 02 0 00 033502 CAME 2,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3659 STOP^ 3660 032514 254 04 0 00 032515 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3661 032515 324 00 0 00 032516 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3662 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3663 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3664 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3665 3666 ;********** 3667 3668 ;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES 3669 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3670 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO. 3671 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3672 ;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=-1,,-2 3673 ;BEFORE INCREMENTING. HENCE, AOSN SHOULD NOT SKIP; AND THE 3674 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 3675 ;RESPECTIVELY 3676 3677 032516 200 01 0 00 033474 C54100: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3678 032517 561 02 0 00 777776 HRROI 2,-2 ;PRELOAD E WITH -1,,-2 3679 032520 356 01 0 00 000002 AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), 3680 ;UPDATE AC AND SKIP 3681 STOP^ 3682 032521 254 04 0 00 032522 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3683 032522 324 00 0 00 032523 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3684 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3685 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3686 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 66-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0103 3687 032523 312 02 0 00 033462 CAME 2,[-1] ;PASS IF E INCREMENTED CORRECTLY 3688 STOP^ 3689 032524 254 04 0 00 032525 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3690 032525 324 00 0 00 032526 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3691 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3692 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3693 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3694 032526 312 01 0 00 033462 CAME 1,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3695 STOP^ 3696 032527 254 04 0 00 032530 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3697 032530 324 00 0 00 032531 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3698 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3699 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3700 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3701 3702 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 67 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0104 3703 ;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES 3704 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3705 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO 3706 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3707 ;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=-1,,-1 3708 ;BEFORE INCREMENTING. HENCE, AOSN SHOULD NOT SKIP; AND THE 3709 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 3710 ;RESPECTIVELY 3711 3712 032531 200 01 0 00 033474 C54110: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3713 032532 474 02 0 00 000000 SETO 2, ;PRELOAD E WITH -1,,-1 3714 032533 356 01 0 00 000002 AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), 3715 ;UPDATE AC AND NOT SKIP 3716 032534 334 00 0 00 000000 SKIPA ;PASS IF AOSN DID NOT SKIP 3717 STOP^ 3718 032535 254 04 0 00 032536 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3719 032536 324 00 0 00 032537 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3720 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3721 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3722 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3723 032537 312 02 0 00 033501 CAME 2,[0] ;PASS IF E INCREMENTED CORRECTLY 3724 STOP^ 3725 032540 254 04 0 00 032541 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3726 032541 324 00 0 00 032542 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3727 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3728 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3729 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3730 032542 312 01 0 00 033501 CAME 1,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3731 STOP^ 3732 032543 254 04 0 00 032544 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3733 032544 324 00 0 00 032545 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3734 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3735 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3736 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3737 3738 ;********** 3739 3740 ;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES 3741 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3742 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO 3743 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3744 ;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=0 3745 ;BEFORE INCREMENTING. HENCE, AOSN SHOULD SKIP; AND THE 3746 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 3747 ;RESPECTIVELY 3748 3749 032545 200 01 0 00 033474 C54120: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3750 032546 400 02 0 00 000000 SETZ 2, ;PRELOAD E WITH 0 3751 032547 356 01 0 00 000002 AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), 3752 ;UPDATE AC AND SKIP 3753 STOP^ 3754 032550 254 04 0 00 032551 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3755 032551 324 00 0 00 032552 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3756 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3757 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 67-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0105 3758 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3759 032552 312 02 0 00 033502 CAME 2,[1] ;PASS IF E INCREMENTED CORRECTLY 3760 STOP^ 3761 032553 254 04 0 00 032554 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3762 032554 324 00 0 00 032555 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3763 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3764 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3765 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3766 032555 312 01 0 00 033502 CAME 1,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 3767 STOP^ 3768 032556 254 04 0 00 032557 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3769 032557 324 00 0 00 032560 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3770 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3771 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3772 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3773 3774 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 68 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0106 3775 ;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES 3776 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3777 ;THE NEST INSTRUCTION IF C(E) IS GREATER THAN 0 3778 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3779 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=-1,,-2 3780 ;BEFORE INCREMENTING. HENCE, AOSG SHOULD NOT SKIP; AND THE 3781 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND -1,,-1 3782 ;RESPECTIVELY 3783 3784 032560 200 00 0 00 033474 C54200: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3785 032561 561 01 0 00 777776 HRROI 1,-2 ;PRELOAD E WITH -1,,-2 3786 032562 357 00 0 00 000001 AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), 3787 ;AND NOT SKIP 3788 032563 334 00 0 00 000000 SKIPA ;PASS IF AOSG DID NOT SKIP 3789 STOP^ 3790 032564 254 04 0 00 032565 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3791 032565 324 00 0 00 032566 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3792 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3793 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3794 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3795 032566 312 01 0 00 033462 CAME 1,[-1] ;PASS IF E INCREMENTED CORRECTLY 3796 STOP^ 3797 032567 254 04 0 00 032570 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3798 032570 324 00 0 00 032571 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3799 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3800 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3801 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3802 032571 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED 3803 STOP^ 3804 032572 254 04 0 00 032573 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3805 032573 324 00 0 00 032574 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3806 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3807 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3808 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3809 3810 ;********** 3811 3812 ;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES 3813 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3814 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 3815 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3816 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=-1,,-1 3817 ;BEFORE INCREMENTING. HENCE, AOSG SHOULD NOT SKIP; AND THE 3818 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 3819 ;RESPECTIVELY 3820 3821 032574 200 00 0 00 033474 C54210: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3822 032575 474 01 0 00 000000 SETO 1, ;PRELOAD E WITH -1,,-1 3823 032576 357 00 0 00 000001 AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), 3824 ;AND NOT SKIP 3825 032577 334 00 0 00 000000 SKIPA ;PASS IF AOSG DID NOT SKIP 3826 STOP^ 3827 032600 254 04 0 00 032601 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3828 032601 324 00 0 00 032602 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3829 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 68-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0107 3830 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3831 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3832 032602 312 01 0 00 033501 CAME 1,[0] ;PASS IF E INCREMENTED CORRECTLY 3833 STOP^ 3834 032603 254 04 0 00 032604 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3835 032604 324 00 0 00 032605 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3836 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3837 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3838 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3839 032605 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED 3840 STOP^ 3841 032606 254 04 0 00 032607 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3842 032607 324 00 0 00 032610 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3843 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3844 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3845 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3846 3847 ;*********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 69 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0108 3848 ;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES 3849 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 3850 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 3851 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 3852 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0 3853 ;BEFORE INCREMENTING. HENCE, AOSG SHOULD SKIP; AND THE 3854 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0,,1 3855 ;RESPECTIVELY 3856 3857 032610 200 00 0 00 033474 C54220: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 3858 032611 400 01 0 00 000000 SETZ 1, ;PRELOAD E WITH 0 3859 032612 357 00 0 00 000001 AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), 3860 ;AND SKIP 3861 STOP^ 3862 032613 254 04 0 00 032614 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3863 032614 324 00 0 00 032615 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3864 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3865 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3866 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3867 032615 312 01 0 00 033502 CAME 1,[1] ;PASS IF E INCREMENTED CORRECTLY 3868 STOP^ 3869 032616 254 04 0 00 032617 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3870 032617 324 00 0 00 032620 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3871 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3872 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3873 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3874 032620 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED 3875 STOP^ 3876 032621 254 04 0 00 032622 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3877 032622 324 00 0 00 032623 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3878 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3879 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3880 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3881 3882 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 70 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0109 3883 SUBTTL TEST OF MSCL SOJX INSTRUCTIONS 3884 3885 ;********** 3886 3887 ;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND 3888 ;PLACES THE RESTULT BACK INTO THE AC. THE RESULT IN THE AC IS 3889 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 3890 ;SPECIFIED BY E IF C(AC) IS LESS THAN 0. 3891 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJL 3892 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 3893 3894 032623 201 17 0 00 000000 C54300: MOVEI 17,0 ;PRELOAD AC WITH 0 3895 032624 361 17 0 00 032626 SOJL 17,.+2 ;*SOJL SHOULD SUBTRACT 0,,1 FROM C(AC) 3896 ;AND JUMP 3897 STOP^ 3898 032625 254 04 0 00 032626 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3899 032626 324 00 0 00 032627 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3900 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3901 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3902 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3903 032627 312 17 0 00 033462 CAME 17,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY 3904 STOP^ 3905 032630 254 04 0 00 032631 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3906 032631 324 00 0 00 032632 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3907 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3908 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3909 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3910 3911 ;*********** 3912 3913 ;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND 3914 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 3915 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 3916 ;SPECIFIED BY E IF C(AC) IS LESS THAN 0. 3917 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJL 3918 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. 3919 3920 032632 201 17 0 00 000001 C54310: MOVEI 17,1 ;PRELOAD AC WITH 0,,1 3921 032633 361 17 0 00 032635 SOJL 17,.+2 ;*SOJL SHOULD SUBTRACT 0,,1 FROM C(AC) 3922 032634 334 00 0 00 000000 SKIPA ;PASS IF SOJL DID NOT JUMP 3923 STOP^ 3924 032635 254 04 0 00 032636 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3925 032636 324 00 0 00 032637 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3926 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3927 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3928 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3929 032637 312 17 0 00 033501 CAME 17,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY 3930 STOP^ 3931 032640 254 04 0 00 032641 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3932 032641 324 00 0 00 032642 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3933 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3934 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3935 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3936 3937 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 71 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0110 3938 ;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND 3939 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 3940 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 3941 ;SPECIFIED BY E IF C(AC) IS LESS THAN 0 3942 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJ 3943 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 3944 3945 032642 201 17 0 00 000002 C54320: MOVEI 17,2 ;PRELOAD AC WITH 0,,2 3946 032643 361 17 0 00 032645 SOJL 17,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) 3947 ;AND NOT JUMP. 3948 032644 334 00 0 00 000000 SKIPA ;PASS IF SOJL DID NOT JUMP 3949 STOP^ 3950 032645 254 04 0 00 032646 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3951 032646 324 00 0 00 032647 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3952 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3953 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3954 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3955 032647 312 17 0 00 033502 CAME 17,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY 3956 STOP^ 3957 032650 254 04 0 00 032651 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3958 032651 324 00 0 00 032652 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3959 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3960 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3961 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3962 3963 ;********** 3964 3965 ;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND 3966 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 3967 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 3968 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. 3969 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJE 3970 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 3971 3972 032652 201 16 0 00 000000 C54400: MOVEI 16,0 ;PRELOAD AC WITH 0 3973 032653 362 16 0 00 032655 SOJE 16,.+2 ;*SOJE SHOULD SUBTRACT 0,,1 FROM C(AC) 3974 ;AND NOT JUMP. 3975 032654 334 00 0 00 000000 SKIPA ;PASS IF SOJE DID NOT JUMP 3976 STOP^ 3977 032655 254 04 0 00 032656 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3978 032656 324 00 0 00 032657 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3979 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3980 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3981 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3982 032657 312 16 0 00 033462 CAME 16,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY 3983 STOP^ 3984 032660 254 04 0 00 032661 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3985 032661 324 00 0 00 032662 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 3986 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 3987 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 3988 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 3989 3990 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 72 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0111 3991 ;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND 3992 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 3993 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 3994 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0 3995 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJ 3996 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 3997 3998 032662 201 16 0 00 000001 C54410: MOVEI 16,1 ;PRELOAD AC WITH 0,,1 3999 032663 362 16 0 00 032665 SOJE 16,.+2 ;*SOJE SHOULD SUBTRACT 0,,1 FROM C(AC) 4000 ;AND JUMP 4001 STOP^ 4002 032664 254 04 0 00 032665 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4003 032665 324 00 0 00 032666 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4004 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4005 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4006 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4007 032666 312 16 0 00 033501 CAME 16,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY 4008 STOP^ 4009 032667 254 04 0 00 032670 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4010 032670 324 00 0 00 032671 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4011 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4012 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4013 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4014 4015 ;********** 4016 4017 ;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND 4018 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4019 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 4020 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. 4021 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJE 4022 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 4023 4024 032671 201 16 0 00 000002 C54420: MOVEI 16,2 ;PRELOAD AC WITH 0,,2 4025 032672 362 16 0 00 032674 SOJE 16,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) 4026 ;AND NOT JUMP. 4027 032673 334 00 0 00 000000 SKIPA ;PASS IF SOJE DID NOT JUMP 4028 STOP^ 4029 032674 254 04 0 00 032675 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4030 032675 324 00 0 00 032676 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4031 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4032 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4033 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4034 032676 312 16 0 00 033502 CAME 16,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY 4035 STOP^ 4036 032677 254 04 0 00 032700 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4037 032700 324 00 0 00 032701 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4038 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4039 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4040 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4041 4042 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 73 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0112 4043 ;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND 4044 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4045 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 4046 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0 4047 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJLE 4048 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 4049 4050 032701 201 15 0 00 000000 C54500: MOVEI 15,0 ;PRELOAD AC WITH 0 4051 032702 363 15 0 00 032704 SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) 4052 ;AND JUMP 4053 STOP^ 4054 032703 254 04 0 00 032704 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4055 032704 324 00 0 00 032705 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4056 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4057 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4058 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4059 032705 312 15 0 00 033462 CAME 15,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY 4060 STOP^ 4061 032706 254 04 0 00 032707 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4062 032707 324 00 0 00 032710 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4063 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4064 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4065 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4066 4067 ;********** 4068 4069 ;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND 4070 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4071 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 4072 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUALTO 0. 4073 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJLE 4074 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 4075 4076 032710 201 15 0 00 000001 C54510: MOVEI 15,1 ;PRELOAD AC WITH 0,,1 4077 032711 363 15 0 00 032713 SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) 4078 ;AND JUMP 4079 STOP^ 4080 032712 254 04 0 00 032713 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4081 032713 324 00 0 00 032714 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4082 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4083 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4084 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4085 032714 312 15 0 00 033501 CAME 15,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY 4086 STOP^ 4087 032715 254 04 0 00 032716 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4088 032716 324 00 0 00 032717 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4089 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4090 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4091 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4092 4093 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 74 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0113 4094 ;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND 4095 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4096 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 4097 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. 4098 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJLE 4099 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 4100 4101 032717 201 15 0 00 000002 C54520: MOVEI 15,2 ;PRELOAD AC WITH 0,,2 4102 032720 363 15 0 00 032722 SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) 4103 ;AND NOT JUMP 4104 032721 334 00 0 00 000000 SKIPA ;PASS IF SOJLE DID NOT JUMP 4105 STOP^ 4106 032722 254 04 0 00 032723 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4107 032723 324 00 0 00 032724 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4108 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4109 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4110 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4111 032724 312 15 0 00 033502 CAME 15,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY 4112 STOP^ 4113 032725 254 04 0 00 032726 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4114 032726 324 00 0 00 032727 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4115 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4116 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4117 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4118 4119 ;********** 4120 4121 ;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND 4122 ;PLACES THE RESULT INTO THE AC. THE RESULT IN THE AC IS 4123 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION 4124 ;SPECIFIED BY E 4125 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJA 4126 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 4127 4128 032727 201 14 0 00 000000 C54600: MOVEI 14,0 ;PRELOAD AC WITH 0 4129 032730 364 14 0 00 032732 SOJA 14,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) 4130 ;AND JUMP 4131 STOP^ 4132 032731 254 04 0 00 032732 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4133 032732 324 00 0 00 032733 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4134 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4135 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4136 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4137 032733 312 14 0 00 033462 CAME 14,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY 4138 STOP^ 4139 032734 254 04 0 00 032735 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4140 032735 324 00 0 00 032736 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4141 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4142 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4143 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4144 4145 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 75 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0114 4146 ;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND 4147 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4148 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION 4149 ;SPECIFIED BY E 4150 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJA 4151 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 4152 4153 032736 201 14 0 00 000001 C54610: MOVEI 14,1 ;PRELOAD AC WITH 0,,1 4154 032737 364 14 0 00 032741 SOJA 14,.+2 ;*SOJA SHOULD SUBTRACT 0,,1 FROM C(AC) 4155 ;AND JUMP 4156 STOP^ 4157 032740 254 04 0 00 032741 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4158 032741 324 00 0 00 032742 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4159 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4160 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4161 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4162 032742 312 14 0 00 033501 CAME 14,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY 4163 STOP^ 4164 032743 254 04 0 00 032744 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4165 032744 324 00 0 00 032745 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4166 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4167 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4168 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4169 4170 ;********** 4171 4172 ;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND 4173 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4174 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION 4175 ;SPECIFIED BY E 4176 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJA 4177 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 4178 4179 032745 201 14 0 00 000002 C54620: MOVEI 14,2 ;PRELOAD AC WITH 0,,2 4180 032746 364 14 0 00 032750 SOJA 14,.+2 ;*SOJA SHOULD SUBTRACT 0,,1 FROM C(AC) 4181 ;AND JUMP 4182 STOP^ 4183 032747 254 04 0 00 032750 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4184 032750 324 00 0 00 032751 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4185 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4186 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4187 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4188 032751 312 14 0 00 033502 CAME 14,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY 4189 STOP^ 4190 032752 254 04 0 00 032753 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4191 032753 324 00 0 00 032754 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4192 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4193 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4194 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4195 4196 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 76 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0115 4197 ;THIS TEST VERIFIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND 4198 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4199 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 4200 ;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 4201 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJGE 4202 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 4203 4204 032754 201 13 0 00 000000 C54700: MOVEI 13,0 ;PRELOAD A C WITH 0 4205 032755 365 13 0 00 032757 SOJGE 13,.+2 ;*SOJGE SHOULD SUBTRACT 0,,1 FROM C(AC) 4206 ;AND NOT JUMP 4207 032756 334 00 0 00 000000 SKIPA ;PASS IF SOJGE DID NOT JUMP 4208 STOP^ 4209 032757 254 04 0 00 032760 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4210 032760 324 00 0 00 032761 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4211 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4212 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4213 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4214 032761 312 13 0 00 033462 CAME 13,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY 4215 STOP^ 4216 032762 254 04 0 00 032763 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4217 032763 324 00 0 00 032764 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4218 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4219 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4220 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4221 4222 ;********** 4223 4224 ;THIS TEST VERIFIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND 4225 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4226 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 4227 ;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 4228 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJGE 4229 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 4230 4231 032764 201 13 0 00 000001 C54710: MOVEI 13,1 ;PRELOAD AC WITH 0,,1 4232 032765 365 13 0 00 032767 SOJGE 13,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) 4233 ;AND JUMP 4234 STOP^ 4235 032766 254 04 0 00 032767 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4236 032767 324 00 0 00 032770 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4237 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4238 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4239 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4240 032770 312 13 0 00 033501 CAME 13,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY 4241 STOP^ 4242 032771 254 04 0 00 032772 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4243 032772 324 00 0 00 032773 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4244 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4245 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4246 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4247 4248 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 77 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0116 4249 ;THIS TEST VERIRIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND PLACES THE 4250 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS COMPARED 4251 ;TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC IS 4252 ;GREATER THAN OR EQUAL TO 0. IN THIS CASE, C(AC = 0,,2 BEFORE 4253 ;DECREMENTING. HENCE, SOJGE SHOULD JUMP AND THE RESULT IN THE AC SHOULD 4254 ;BE 0,,1. 4255 4256 032773 201 13 0 00 000002 C54720: MOVEI 13,2 ;PRELOAD AC WITH 0,,2 4257 032774 365 13 0 00 032776 SOJGE 13,.+2 ;*SOJGE SHOULD SUBTRACT0,,1 FROM C(AC) 4258 ;AND JUMP. 4259 STOP^ 4260 032775 254 04 0 00 032776 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4261 032776 324 00 0 00 032777 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4262 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4263 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4264 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4265 032777 312 13 0 00 033502 CAME 13,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY 4266 STOP^ 4267 033000 254 04 0 00 033001 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4268 033001 324 00 0 00 033002 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4269 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4270 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4271 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4272 4273 ;********** 4274 4275 ;THIS TEST VERIFIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND 4276 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4277 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 4278 ;SPECIFIED BY E IF C(AC) IS NON-ZERO. 4279 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE,SOJN 4280 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1. 4281 4282 033002 201 12 0 00 000000 C55000: MOVEI 12,0 ;PRELOAD AC WITH 0 4283 033003 366 12 0 00 033005 SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) 4284 ;AND JUMP. 4285 STOP^ 4286 033004 254 04 0 00 033005 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4287 033005 324 00 0 00 033006 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4288 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4289 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4290 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4291 033006 312 12 0 00 033462 CAME 12,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY 4292 STOP^ 4293 033007 254 04 0 00 033010 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4294 033010 324 00 0 00 033011 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4295 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4296 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4297 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4298 4299 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 78 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0117 4300 ;THIS TEST VERIRIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND 4301 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4302 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED 4303 ;BY E IF C(AC) IS NON-ZERO. 4304 ;IN THIS CASE, C(AC) = 0,,1 BEFORE DECREMENTING. HENCE, SOJN 4305 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. 4306 4307 033011 201 12 0 00 000001 C55010: MOVEI 12,1 ;PRELOAD AC WITH 0,,1 4308 033012 366 12 0 00 033014 SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) 4309 ;AND NOT JUMP. 4310 033013 334 00 0 00 000000 SKIPA ;PASS IF SOJN DID NOT JUMP 4311 STOP^ 4312 033014 254 04 0 00 033015 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4313 033015 324 00 0 00 033016 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4314 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4315 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4316 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4317 033016 312 12 0 00 033501 CAME 12,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY 4318 STOP^ 4319 033017 254 04 0 00 033020 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4320 033020 324 00 0 00 033021 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4321 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4322 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4323 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4324 4325 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 79 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0118 4326 ;THIS TEST VERIFIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND 4327 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4328 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 4329 ;SPECIFIED BY E IF C(AC) IS NON-ZERO. 4330 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJN 4331 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1. 4332 4333 033021 201 12 0 00 000002 C55020: MOVEI 12,2 ;PRELOAD AC WITH 0,,2 4334 033022 366 12 0 00 033024 SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) 4335 ;AND JUMP. 4336 STOP^ 4337 033023 254 04 0 00 033024 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4338 033024 324 00 0 00 033025 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4339 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4340 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4341 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4342 033025 312 12 0 00 033502 CAME 12,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY 4343 STOP^ 4344 033026 254 04 0 00 033027 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4345 033027 324 00 0 00 033030 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4346 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4347 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4348 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4349 4350 ;********** 4351 4352 ;THIS TEST VERIFIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND 4353 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4354 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 4355 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. 4356 ;IN THIS CASE, C(AC) = 0 BEFORE DECREMENTING. HENCE, SOJG 4357 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1. 4358 4359 033030 201 11 0 00 000000 C55100: MOVEI 11,0 ;PRELOAD AC WITH 0 4360 033031 367 11 0 00 033033 SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT 0,,1 FROM C(AC) 4361 ;AND NOT JUMP. 4362 033032 334 00 0 00 000000 SKIPA ;PASS IF SOJG DID NOT JUMP 4363 STOP^ 4364 033033 254 04 0 00 033034 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4365 033034 324 00 0 00 033035 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4366 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4367 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4368 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4369 033035 312 11 0 00 033462 CAME 11,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY 4370 STOP^ 4371 033036 254 04 0 00 033037 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4372 033037 324 00 0 00 033040 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4373 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4374 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4375 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4376 4377 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 80 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0119 4378 ;THIS TEST VERIRIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND 4379 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4380 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 4381 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. 4382 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJG 4383 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. 4384 4385 033040 201 11 0 00 000001 C55110: MOVEI 11,1 ;PRELOAD AC WITH 0,,1 4386 033041 367 11 0 00 033043 SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT 0,,1 FROM C(AC) 4387 ;AND NOT JUMP. 4388 033042 334 00 0 00 000000 SKIPA ;PASS IF SOJG DID NOT JUMP 4389 STOP^ 4390 033043 254 04 0 00 033044 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4391 033044 324 00 0 00 033045 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4392 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4393 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4394 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4395 033045 312 11 0 00 033501 CAME 11,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY 4396 STOP^ 4397 033046 254 04 0 00 033047 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4398 033047 324 00 0 00 033050 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4399 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4400 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4401 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4402 4403 ;********** 4404 4405 ;THIS TEST VERIFIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND 4406 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS 4407 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION 4408 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. 4409 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJG 4410 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1. 4411 4412 033050 201 11 0 00 000002 C55120: MOVEI 11,2 ;PRELOAD AC WITH 0,,2 4413 033051 367 11 0 00 033053 SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT O,,1 FROM C(AC) 4414 ;AND JUMP. 4415 STOP^ 4416 033052 254 04 0 00 033053 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4417 033053 324 00 0 00 033054 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4418 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4419 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4420 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4421 033054 312 11 0 00 033502 CAME 11,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY 4422 STOP^ 4423 033055 254 04 0 00 033056 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4424 033056 324 00 0 00 033057 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4425 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4426 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4427 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4428 4429 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 81 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0120 4430 SUBTTL TEST OF MSCL SOSX INSTRUCTIONS 4431 4432 ;********** 4433 4434 ;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES 4435 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4436 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. 4437 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4438 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0 4439 ;BEFORE INCREMENTING. HENCE, SOSL SHOULD SKIP; AND THE 4440 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND -1,,-1 4441 ;RESPECTIVELY. 4442 4443 033057 200 00 0 00 033474 C55200: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4444 033060 201 01 0 00 000000 MOVEI 1,0 ;PRELOAD E WITH 0 4445 033061 371 00 0 00 000001 SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E) 4446 ;AND SKIP 4447 STOP^ 4448 033062 254 04 0 00 033063 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4449 033063 324 00 0 00 033064 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4450 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4451 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4452 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4453 033064 312 01 0 00 033462 CAME 1,[-1] ;PASS IF E DECREMENTED CORRECTLY 4454 STOP^ 4455 033065 254 04 0 00 033066 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4456 033066 324 00 0 00 033067 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4457 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4458 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4459 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4460 033067 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED 4461 STOP^ 4462 033070 254 04 0 00 033071 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4463 033071 324 00 0 00 033072 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4464 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4465 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4466 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4467 4468 ;********** 4469 4470 ;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES 4471 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4472 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. 4473 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4474 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0,,1 4475 ;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE 4476 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 4477 ;RESPECTIVELY. 4478 4479 033072 200 00 0 00 033474 C55210: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4480 033073 201 01 0 00 000001 MOVEI 1,1 ;PRELOAD E WITH 0,,1 4481 033074 371 00 0 00 000001 SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), 4482 ;AND NOT SKIP. 4483 033075 334 00 0 00 000000 SKIPA ;PASS IF SOSL DID NOT SKIP 4484 STOP^ DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 81-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0121 4485 033076 254 04 0 00 033077 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4486 033077 324 00 0 00 033100 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4487 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4488 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4489 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4490 033100 312 01 0 00 033501 CAME 1,[0] ;PASS IF E DECREMENTED CORRECTLY 4491 STOP^ 4492 033101 254 04 0 00 033102 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4493 033102 324 00 0 00 033103 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4494 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4495 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4496 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4497 033103 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED 4498 STOP^ 4499 033104 254 04 0 00 033105 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4500 033105 324 00 0 00 033106 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4501 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4502 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4503 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4504 4505 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 82 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0122 4506 ;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES 4507 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4508 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. 4509 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4510 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0,,1 4511 ;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE 4512 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 4513 ;RESPECTIVELY. 4514 4515 033106 200 00 0 00 033474 C55211: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4516 033107 201 01 0 00 000001 MOVEI 1,1 ;PRELOAD E WITH 0,,1 4517 033110 202 01 0 00 033125 MOVEM 1,E55211 4518 033111 371 00 0 00 033125 SOSL 0,E55211 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), 4519 ;AND NOT SKIP. 4520 033112 334 00 0 00 000000 SKIPA ;PASS IF SOSL DID NOT SKIP 4521 STOP^ 4522 033113 254 04 0 00 033114 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4523 033114 324 00 0 00 033115 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4524 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4525 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4526 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4527 033115 200 01 0 00 033125 MOVE 1,E55211 4528 033116 312 01 0 00 033501 CAME 1,[0] ;PASS IF E DECREMENTED CORRECTLY 4529 STOP^ 4530 033117 254 04 0 00 033120 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4531 033120 324 00 0 00 033121 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4532 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4533 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4534 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4535 033121 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED 4536 STOP^ 4537 033122 254 04 0 00 033123 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4538 033123 324 00 0 00 033124 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4539 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4540 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4541 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4542 4543 033124 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST 4544 033125 000000 000000 E55211: 0 ;TEST WORD MEMORY 4545 4546 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 83 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0123 4547 ;THIS TEST VERIFIES THAT SOS DECREMENTS C(E) BY 0,,1 AND PLACES 4548 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4549 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. 4550 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4551 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E) 0,,2 4552 ;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE 4553 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0,,1 4554 ;RESPECTIVELY. 4555 4556 033126 200 00 0 00 033474 C55220: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4557 033127 201 01 0 00 000002 MOVEI 1,2 ;PRELOAD E WITH 0,,2 4558 033130 371 00 0 00 000001 SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), 4559 ;AND NOT SKIP 4560 4561 033131 334 00 0 00 000000 SKIPA ;PASS IF SOSL DID NOT SKIP 4562 STOP^ 4563 033132 254 04 0 00 033133 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4564 033133 324 00 0 00 033134 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4565 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4566 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4567 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4568 033134 312 01 0 00 033502 CAME 1,[1] ;PASS IF E DECREMENTED CORRECTLY 4569 STOP^ 4570 033135 254 04 0 00 033136 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4571 033136 324 00 0 00 033137 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4572 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4573 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4574 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4575 033137 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4576 STOP^ 4577 033140 254 04 0 00 033141 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4578 033141 324 00 0 00 033142 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4579 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4580 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4581 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4582 4583 ;********** 4584 4585 ;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,,1 AND PLACES 4586 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4587 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 4588 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4589 ;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0 4590 ;BEFORE INCREMENTING. HENCE, SOSE SHOULD NOT SKIP ; AND THE 4591 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 4592 ;RESPECTIVELY. 4593 4594 033142 200 10 0 00 033474 C55300: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4595 033143 201 11 0 00 000000 MOVEI 11,0 ;PRELOAD E WITH 0 4596 033144 372 10 0 00 000011 SOSE 10,11 ;*SOSE SHOULD SUBTRACT 0,,1 FROM C(E), 4597 ;UPDATE AC AND NOT SKIP 4598 4599 033145 334 00 0 00 000000 SKIPA ;PASS IF SOSE DID NOT SKIP 4600 STOP^ 4601 033146 254 04 0 00 033147 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 83-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0124 4602 033147 324 00 0 00 033150 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4603 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4604 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4605 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4606 033150 312 11 0 00 033462 CAME 11,[-1] ;PASS IF E DECREMENTED CORRECTLY 4607 STOP^ 4608 033151 254 04 0 00 033152 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4609 033152 324 00 0 00 033153 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4610 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4611 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4612 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4613 033153 312 10 0 00 033462 CAME 10,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4614 STOP^ 4615 033154 254 04 0 00 033155 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4616 033155 324 00 0 00 033156 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4617 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4618 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4619 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4620 4621 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 84 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0125 4622 ;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,,1 AND PLACES 4623 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4624 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 4625 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4626 ;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0,,1 4627 ;BEFORE INCREMENTING. HENCE, SOSE SHOULD SKIP ; AND THE 4628 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 4629 ;RESPECTIVELY. 4630 4631 033156 200 10 0 00 033474 C55310: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4632 033157 201 11 0 00 000001 MOVEI 11,1 ;PRELOAD E WITH 0,,1 4633 033160 372 10 0 00 000011 SOSE 10,11 ;*SOS SHOULD SUBTRACT 0,,1 FROM C(E) 4634 ;UPDATE AC AND SKIP 4635 STOP^ 4636 033161 254 04 0 00 033162 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4637 033162 324 00 0 00 033163 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4638 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4639 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4640 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4641 033163 312 11 0 00 033501 CAME 11,[0] ;PASS IF E DECREMENTED CORRECTLY 4642 STOP^ 4643 033164 254 04 0 00 033165 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4644 033165 324 00 0 00 033166 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4645 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4646 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4647 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4648 033166 312 10 0 00 033501 CAME 10,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4649 STOP^ 4650 033167 254 04 0 00 033170 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4651 033170 324 00 0 00 033171 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4652 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4653 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4654 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4655 4656 ;********** 4657 4658 ;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,11 AND PLACES 4659 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4660 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0. 4661 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4662 ;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0,,2 4663 ;BEFORE INCREMENTING. HENCE, SOSE SHOULD NOT SKIP ; AND THE 4664 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 4665 ;RESPECTIVELY. 4666 4667 033171 200 10 0 00 033474 C55320: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4668 033172 201 11 0 00 000002 MOVEI 11,2 ;PRELOAD E WITH 0,,2 4669 033173 372 10 0 00 000011 SOSE 10,11 ;*SOSE SHOULD SUBTRACT 0,,1 FROM C(E), 4670 ;UPDATE AC AND NOT SKIP 4671 4672 033174 334 00 0 00 000000 SKIPA ;PASS IF SOSE DID NOT SKIP 4673 STOP^ 4674 033175 254 04 0 00 033176 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4675 033176 324 00 0 00 033177 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4676 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 84-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0126 4677 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4678 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4679 033177 312 11 0 00 033502 CAME 11,[1] ;PASS IF E DECREMENTED CORRECTLY 4680 STOP^ 4681 033200 254 04 0 00 033201 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4682 033201 324 00 0 00 033202 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4683 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4684 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4685 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4686 033202 312 10 0 00 033502 CAME 10,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4687 STOP^ 4688 033203 254 04 0 00 033204 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4689 033204 324 00 0 00 033205 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4690 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4691 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4692 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4693 4694 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 85 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0127 4695 ;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES 4696 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4697 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. 4698 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4699 ;IN THIS CASE, AC=7, C(AC)=707070,,707070 AND C(E)=0 4700 ;BEFORE INCREMENTING. HENCE, SOSLE SHOULD SKIP ; AND THE 4701 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 4702 ;RESPECTIVELY. 4703 4704 033205 200 07 0 00 033474 C55400: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4705 033206 201 10 0 00 000000 MOVEI 10,0 ;PRELOAD E WITH 0 4706 033207 373 07 0 00 000010 SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), 4707 ;UPDATE AC AND SKIP 4708 STOP^ 4709 033210 254 04 0 00 033211 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4710 033211 324 00 0 00 033212 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4711 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4712 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4713 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4714 033212 312 10 0 00 033462 CAME 10,[-1] ;PASS IF E DECREMENTED CORRECTLY 4715 STOP^ 4716 033213 254 04 0 00 033214 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4717 033214 324 00 0 00 033215 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4718 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4719 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4720 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4721 033215 312 07 0 00 033462 CAME 7,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4722 STOP^ 4723 033216 254 04 0 00 033217 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4724 033217 324 00 0 00 033220 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4725 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4726 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4727 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4728 4729 ;********** 4730 4731 ;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES 4732 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4733 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. 4734 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4735 ;IN THIS CASE, AC=7, C(AC)=070707,,070707 AND C(E)=0,,1 4736 ;BEFORE INCREMENTING. HENCE, SOSLE SHOULD SKIP ; AND THE 4737 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 4738 ;RESPECTIVELY. 4739 4740 033220 200 07 0 00 033474 C55410: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4741 033221 201 10 0 00 000001 MOVEI 10,1 ;PRELOAD E WITH 0,,1 4742 033222 373 07 0 00 000010 SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), 4743 ;UPDATE AC AND SKIP 4744 STOP^ 4745 033223 254 04 0 00 033224 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4746 033224 324 00 0 00 033225 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4747 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4748 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4749 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 85-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0128 4750 033225 312 10 0 00 033501 CAME 10,[0] ;PASS IF E DECREMENTED CORRECTLY 4751 STOP^ 4752 033226 254 04 0 00 033227 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4753 033227 324 00 0 00 033230 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4754 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4755 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4756 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4757 033230 312 07 0 00 033501 CAME 7,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4758 STOP^ 4759 033231 254 04 0 00 033232 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4760 033232 324 00 0 00 033233 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4761 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4762 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4763 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4764 4765 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 86 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0129 4766 ;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES 4767 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4768 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. 4769 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4770 ;IN THIS CASE, AC=7, C(AC)=707070,,707070 AND C(E)=0,,2 4771 ;BEFORE INCREMENTING. HENCE, SOSLE SHOULD NOT SKIP; AND THE 4772 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 4773 ;RESPECTIVELY. 4774 4775 033233 200 07 0 00 033474 C55420: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4776 033234 201 10 0 00 000002 MOVEI 10,2 ;PRELOAD E WITH 0,,2 4777 033235 373 07 0 00 000010 SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), 4778 ;UPDATE AC AND NOT SKIP 4779 033236 334 00 0 00 000000 SKIPA ;PASS IF SOSLE DID NOT SKIP 4780 STOP^ 4781 033237 254 04 0 00 033240 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4782 033240 324 00 0 00 033241 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4783 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4784 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4785 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4786 033241 312 10 0 00 033502 CAME 10,[1] ;PASS IF E DECREMENTED CORRECTLY 4787 STOP^ 4788 033242 254 04 0 00 033243 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4789 033243 324 00 0 00 033244 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4790 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4791 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4792 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4793 033244 312 07 0 00 033502 CAME 7,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4794 STOP^ 4795 033245 254 04 0 00 033246 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4796 033246 324 00 0 00 033247 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4797 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4798 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4799 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4800 4801 ;********** 4802 4803 ;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES 4804 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS 4805 ;THE NEXT INSTRUCTION. 4806 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4807 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0 4808 ;BEFORE INCREMENTING. HENCE, SOSA SHOULD SKIP ; AND THE 4809 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 4810 ;RESPECTIVELY. 4811 4812 033247 200 06 0 00 033474 C55500: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4813 033250 201 07 0 00 000000 MOVEI 7,0 ;PRELOAD E WITH 0 4814 033251 374 06 0 00 000007 SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), 4815 ;UPDATE AC AND SKIP 4816 STOP^ 4817 033252 254 04 0 00 033253 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4818 033253 324 00 0 00 033254 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4819 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4820 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 86-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0130 4821 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4822 033254 312 07 0 00 033462 CAME 7,[-1] ;PASS IF E DECREMENTED CORRECTLY 4823 STOP^ 4824 033255 254 04 0 00 033256 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4825 033256 324 00 0 00 033257 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4826 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4827 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4828 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4829 033257 312 06 0 00 033462 CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4830 STOP^ 4831 033260 254 04 0 00 033261 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4832 033261 324 00 0 00 033262 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4833 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4834 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4835 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4836 4837 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 87 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0131 4838 ;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES 4839 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS 4840 ;THE NEXT INSTRUCTION. 4841 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THEAC. 4842 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0,,1 4843 ;BEFORE INCREMENTING. HENCE, SOSA SHOULD BE 0 AND 0 4844 ;RESPECTIVELY. 4845 4846 033262 200 06 0 00 033474 C55510: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4847 033263 201 07 0 00 000001 MOVEI 7,1 ;PRELOAD E WITH 0,,1 4848 033264 374 06 0 00 000007 SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), 4849 ;UPDATE AC AND SKIP 4850 STOP^ 4851 033265 254 04 0 00 033266 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4852 033266 324 00 0 00 033267 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4853 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4854 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4855 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4856 033267 312 07 0 00 033501 CAME 7,[0] ;PASS IF E DECREMENTED CORRECTLY 4857 STOP^ 4858 033270 254 04 0 00 033271 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4859 033271 324 00 0 00 033272 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4860 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4861 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4862 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4863 033272 312 06 0 00 033501 CAME 6,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4864 STOP^ 4865 033273 254 04 0 00 033274 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4866 033274 324 00 0 00 033275 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4867 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4868 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4869 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4870 4871 ;********** 4872 4873 ;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES 4874 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS 4875 ;THE NEXT INSTRUCTION. 4876 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4877 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0,,2 4878 ;BEFORE INCREMENTING. HENCE, SOSA SHOULD SKIP ; AND THE 4879 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 4880 ;RESPECTIVELY. 4881 4882 033275 200 06 0 00 033474 C55520: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4883 033276 201 07 0 00 000002 MOVEI 7,2 ;PRELOAD E WITH 0,,2 4884 033277 374 06 0 00 000007 SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), 4885 ;UPDATE AC AND SKIP 4886 STOP^ 4887 033300 254 04 0 00 033301 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4888 033301 324 00 0 00 033302 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4889 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4890 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4891 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4892 033302 312 07 0 00 033502 CAME 7,[1] ;PASS IF E DECREMENTED CORRECTLY DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 87-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0132 4893 STOP^ 4894 033303 254 04 0 00 033304 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4895 033304 324 00 0 00 033305 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4896 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4897 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4898 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4899 033305 312 06 0 00 033502 CAME 6,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4900 STOP^ 4901 033306 254 04 0 00 033307 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4902 033307 324 00 0 00 033310 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4903 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4904 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4905 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4906 4907 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 88 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0133 4908 ;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES 4909 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4910 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0. 4911 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4912 ;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0 4913 ;BEFORE INCREMENTING. HENCE, SOSGE SHOULD NOT SKIP ; AND THE 4914 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 4915 ;RESPECTIVELY. 4916 4917 033310 200 05 0 00 033474 C55600: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4918 033311 201 06 0 00 000000 MOVEI 6,0 ;PRELOAD E WITH 0 4919 033312 375 05 0 00 000006 SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), 4920 ;UPDATE AC AND NOT SKIP 4921 033313 334 00 0 00 000000 SKIPA ;PASS IF SOSGE DID NOT SKIP 4922 STOP^ 4923 033314 254 04 0 00 033315 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4924 033315 324 00 0 00 033316 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4925 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4926 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4927 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4928 033316 312 06 0 00 033462 CAME 6,[-1] ;PASS IF E DECREMENTED CORRECTLY 4929 STOP^ 4930 033317 254 04 0 00 033320 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4931 033320 324 00 0 00 033321 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4932 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4933 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4934 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4935 033321 312 05 0 00 033462 CAME 5,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4936 STOP^ 4937 033322 254 04 0 00 033323 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4938 033323 324 00 0 00 033324 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4939 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4940 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4941 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4942 4943 ;********** 4944 4945 ;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES 4946 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4947 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0. 4948 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4949 ;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0,,1 4950 ;BEFORE INCREMENTING. HENCE, SOSGE SHOULD SKIP ; AND THE 4951 ;FINAL RESULTS IN ACAND E SHOULD BE 0 AND 0 4952 ;RESPECTIVELY. 4953 4954 033324 200 05 0 00 033474 C55610: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4955 033325 201 06 0 00 000001 MOVEI 6,1 ;PRELOAD E WITH 0,,1 4956 033326 375 05 0 00 000006 SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), 4957 ;UPDATE AC AND SKIP 4958 STOP^ 4959 033327 254 04 0 00 033330 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4960 033330 324 00 0 00 033331 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4961 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4962 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 88-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0134 4963 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4964 033331 312 06 0 00 033501 CAME 6,[0] ;PASS IF E DECREMENTED CORRECTLY 4965 STOP^ 4966 033332 254 04 0 00 033333 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4967 033333 324 00 0 00 033334 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4968 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4969 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4970 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4971 033334 312 05 0 00 033501 CAME 5,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 4972 STOP^ 4973 033335 254 04 0 00 033336 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4974 033336 324 00 0 00 033337 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4975 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4976 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4977 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4978 4979 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 89 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0135 4980 ;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES 4981 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 4982 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 4983 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 4984 ;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0,,2 4985 ;BEFORE INCREMENTING. HENCE, SOSGE SHOULD SKIP ; AND THE 4986 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 4987 ;RESPECTIVELY. 4988 4989 033337 200 05 0 00 033474 C55620: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 4990 033340 201 06 0 00 000002 MOVEI 6,2 ;PRELOAD E WITH 0,,2 4991 033341 375 05 0 00 000006 SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), 4992 ;UPDATE AC AND SKIP 4993 STOP^ 4994 033342 254 04 0 00 033343 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4995 033343 324 00 0 00 033344 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 4996 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 4997 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 4998 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 4999 033344 312 06 0 00 033502 CAME 6,[1] ;PASS IF E DECREMENTED CORRECTLY 5000 STOP^ 5001 033345 254 04 0 00 033346 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5002 033346 324 00 0 00 033347 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5003 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5004 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5005 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5006 033347 312 05 0 00 033502 CAME 5,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 5007 STOP^ 5008 033350 254 04 0 00 033351 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5009 033351 324 00 0 00 033352 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5010 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5011 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5012 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5013 5014 ;********** 5015 5016 ;THIS TEST VERIFIES SOSN DECREMENTS C(E) BY 0,,1 AND PLACES 5017 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 5018 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO 5019 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 5020 ;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0 5021 ;BEFORE INCREMENTING. HENCE, SOSN SHOULD SKIP ; AND THE 5022 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 5023 ;RESPECTIVELY. 5024 5025 033352 200 04 0 00 033474 C55700: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 5026 033353 201 05 0 00 000000 MOVEI 5,0 ;PRELOAD E WITH 0 5027 033354 376 04 0 00 000005 SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), 5028 ;UPDATE AC AND SKIP 5029 STOP^ 5030 033355 254 04 0 00 033356 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5031 033356 324 00 0 00 033357 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5032 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5033 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5034 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 89-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0136 5035 033357 312 05 0 00 033462 CAME 5,[-1] ;PASS IF E DECREMENTED CORRECTLY 5036 STOP^ 5037 033360 254 04 0 00 033361 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5038 033361 324 00 0 00 033362 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5039 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5040 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5041 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5042 033362 312 04 0 00 033462 CAME 4,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 5043 STOP^ 5044 033363 254 04 0 00 033364 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5045 033364 324 00 0 00 033365 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5046 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5047 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5048 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5049 5050 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 90 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0137 5051 ;THIS TEST VERIFIES THAT SOSN DECREMENTS C(E) BY 0,,1 AND PLACES 5052 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 5053 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO 5054 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC 5055 ;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0,,1 5056 ;BEFORE INCREMENTING. HENCE, SOSN SHOULD NOT SKIP ; AND THE 5057 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 5058 ;RESPECTIVELY. 5059 5060 033365 200 04 0 00 033474 C55710: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 5061 033366 201 05 0 00 000001 MOVEI 5,1 ;PRELOAD E WITH 0,,1 5062 033367 376 04 0 00 000005 SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), 5063 ;UPDATE AC AND NOT SKIP 5064 033370 334 00 0 00 000000 SKIPA ;PASS IF SOSN DID NOT SKIP 5065 STOP^ 5066 033371 254 04 0 00 033372 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5067 033372 324 00 0 00 033373 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5068 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5069 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5070 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5071 033373 312 05 0 00 033501 CAME 5,[0] ;PASS IF E DECREMENTED CORRECTLY 5072 STOP^ 5073 033374 254 04 0 00 033375 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5074 033375 324 00 0 00 033376 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5075 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5076 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5077 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5078 033376 312 04 0 00 033501 CAME 4,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 5079 STOP^ 5080 033377 254 04 0 00 033400 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5081 033400 324 00 0 00 033401 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5082 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5083 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5084 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5085 5086 ;********** 5087 5088 ;THIS TEST VERIFIES THAT SOSN DECREMENTS C(E) BY 0,,1 AND PLACES 5089 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 5090 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO 5091 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 5092 ;INtTHIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0,,2 5093 ;BEFORE INCREMENTING. HENCE, SOSN SHOULD SKIP ; AND THE 5094 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 5095 ;RESPECTIVELY 5096 5097 033401 200 04 0 00 033474 C55720: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 5098 033402 201 05 0 00 000002 MOVEI 5,2 ;PRELOAD E WITH 0,,2 5099 033403 376 04 0 00 000005 SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), 5100 ;UPDATE AC AND SKIP 5101 STOP^ 5102 033404 254 04 0 00 033405 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5103 033405 324 00 0 00 033406 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5104 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5105 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 90-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0138 5106 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5107 033406 312 05 0 00 033502 CAME 5,[1] ;PASS IF E DECREMENTED CORRECTLY 5108 STOP^ 5109 033407 254 04 0 00 033410 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5110 033410 324 00 0 00 033411 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5111 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5112 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5113 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5114 033411 312 04 0 00 033502 CAME 4,[1] ;PASS IF ACWAS UPDATED IF AC NON-ZERO 5115 STOP^ 5116 033412 254 04 0 00 033413 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5117 033413 324 00 0 00 033414 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5118 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5119 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5120 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5121 5122 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 91 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0139 5123 ;THIS TEST VERIFIESTHAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES 5124 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 5125 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 5126 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 5127 ;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0 5128 ;BEFORE INCREMENTING. HENCE, SOSG SHOULD NOT SKIP ; AND THE 5129 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 5130 ;RESPECTIVELY. 5131 5132 033414 200 03 0 00 033474 C56000: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 5133 033415 201 04 0 00 000000 MOVEI 4,0 ;PRELOAD E WITH 0 5134 033416 377 03 0 00 000004 SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), 5135 ;UPDATE AC AND NOT SKIP 5136 033417 334 00 0 00 000000 SKIPA ;PASS IF SOSG DID NOT SKIP 5137 STOP^ 5138 033420 254 04 0 00 033421 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5139 033421 324 00 0 00 033422 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5140 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5141 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5142 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5143 033422 312 04 0 00 033462 CAME 4,[-1] ;PASS IF E DECREMENTED CORRECTLY 5144 STOP^ 5145 033423 254 04 0 00 033424 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5146 033424 324 00 0 00 033425 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5147 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5148 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5149 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5150 033425 312 03 0 00 033462 CAME 3,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 5151 STOP^ 5152 033426 254 04 0 00 033427 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5153 033427 324 00 0 00 033430 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5154 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5155 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5156 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5157 5158 ;********** 5159 5160 ;THIS TEST VERIFIES THAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES 5161 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 5162 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0. 5163 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 5164 ;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0,,1 5165 ;BEFORE INCREMENTING. HENCE, SOSG SHOULD NOT SKIP ; AND THE 5166 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 5167 ;RESPECTIVELY. 5168 5169 033430 200 03 0 00 033474 C56010: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 5170 033431 201 04 0 00 000001 MOVEI 4,1 ;PRELOAD E WITH 0,,1 5171 033432 377 03 0 00 000004 SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), 5172 ;UPDATE AC AND NOT SKIP 5173 033433 334 00 0 00 000000 SKIPA ;PASS IF SOSG DID NOT SKIP 5174 STOP^ 5175 033434 254 04 0 00 033435 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5176 033435 324 00 0 00 033436 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5177 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 91-1 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0140 5178 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5179 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5180 033436 312 04 0 00 033501 CAME 4,[0] ;PASS IF E DECREMENTED CORRECTLY 5181 STOP^ 5182 033437 254 04 0 00 033440 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5183 033440 324 00 0 00 033441 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5184 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5185 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5186 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5187 033441 312 03 0 00 033501 CAME 3,[0] ;PASS IF AC WAS UPDATED IS AC NON-ZERO 5188 STOP^ 5189 033442 254 04 0 00 033443 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5190 033443 324 00 0 00 033444 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5191 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5192 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5193 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5194 5195 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 92 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0141 5196 ;THIS TEST VERIFIES THAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES 5197 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS 5198 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 5199 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. 5200 ;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0,,2 5201 ;BEFORE INCREMENTING. HENCE, SOSG SHOULD SKIP ; AND THE 5202 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 011, 5203 ;RESPECTIVELY. 5204 5205 033444 200 03 0 00 033474 C56020: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 5206 033445 201 04 0 00 000002 MOVEI 4,2 ;PRELOAD E WITH 0,,2 5207 033446 377 03 0 00 000004 SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), 5208 ;UPDATE AC AND SKIP 5209 STOP^ 5210 033447 254 04 0 00 033450 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5211 033450 324 00 0 00 033451 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5212 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5213 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5214 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5215 033451 312 04 0 00 033502 CAME 4,[1] ;PASS IF E DECREMENTED CORRECTLY 5216 STOP^ 5217 033452 254 04 0 00 033453 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5218 033453 324 00 0 00 033454 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5219 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5220 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5221 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5222 033454 312 03 0 00 033502 CAME 3,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO 5223 STOP^ 5224 033455 254 04 0 00 033456 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5225 033456 324 00 0 00 033457 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) 5226 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST 5227 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR 5228 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ 5229 5230 ;********** DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 93 DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0142 5231 5232 033457 254 00 0 00 030057 JRST BEGEND 5233 SUBTTL *STOR* RESERVED STORAGE, JULY 19,1977 5234 5235 ;PROGRAM LITERALS 5236 5237 XLIST 5238 IFNDEF $LPAPER, 5239 033460 LIT 5240 033460 000001 000001 5241 033461 254 00 0 00 030723 5242 033462 777777 777777 5243 033463 310 00 0 00 000000 5244 033464 201 01 0 00 001234 5245 033465 031107 031106 5246 033466 031116 031115 5247 033467 254 00 0 00 031161 5248 033470 000001 000002 5249 033471 135531 246642 5250 033472 135246 246135 5251 033473 252525 252525 5252 033474 707070 707070 5253 033475 123456 123456 5254 033476 777777 000000 5255 033477 777777 777775 5256 033500 777777 777776 5257 033501 000000 000000 5258 033502 000000 000001 5259 LIST 5260 033503 000000 000000 ENDSLD: 0 5261 5262 IFDEF DEBUG,< 5263 033504 PATCH: BLOCK DEBUG ;PATCHING AREA 5264 > 5265 5266 ;PROGRAM VARIABLES 5267 033604 VAR 5268 5269 IFDEF PGMEND,< 5270 033604 000000 000000 END: 0 5271 030000 END BEGIN > NO ERRORS DETECTED PROGRAM BREAK IS 000000 ABSOLUTE BREAK IS 033605 CPU TIME USED 00:18.474 20P CORE USED