DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 1 DAKAAT MAC 19-JAN-77 13:31 DIAGNOSTIC PARAMETERS SEQ 0007 1 ;DAKAA 2 3 4 5 000002 DECVER==2 6 000000 MCNVER==0 7 8 XLIST 9 LIST 10 LALL 11 NAME \MCNVER,\DECVER^ 12 13 TITLE DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 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 20 ;DIGITAL EQUIPMENT CORPORATION 21 ;MARLBORO, MASS. 01752 22 23 ;JOHN R. KIRCHOFF 24 ;DICK MALISKA 25 26 000137 LOC 137 27 000137 000000 000002 MCNVER,,DECVER 28 29 NOSYM DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 2 DAKAAT MAC 19-JAN-77 13:31 DIAGNOSTIC PARAMETERS SEQ 0008 30 SUBTTL DIAGNOSTIC PARAMETERS 31 32 ;PARAMETER DEFINITIONS 33 000001 EXCASB==1 34 000001 USRASB==1 35 000001 KA10==1 36 37 ;FLAG DEFINITIONS 38 010000 USERF=10000 ;USER MODE FLAG 39 40 41 ;MACROS 42 43 ; STOP - USED FOR SCOPE LOOP, IF INSTRUCTION FAILS, CHANGE (JUMPA .+1) 44 ; TO A (JUMPA .-X) TO CYCLE ON FAILING INSTRUCTION 45 46 DEFINE STOP (A)< 47 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 48 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 49 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 50 ;IN THE SUBTEST) TO LOOP ON ERROR> 51 52 ;SPECIAL FEATURE PARAMETERS 53 54 030742 SADR1=A00 55 030742 SADR2=A00 56 030742 SADR3=A00 57 030742 SADR4=A00 58 254000 030742 SADR5=JRST A00 59 254000 030742 SADR6=JRST A00 60 254000 030742 SADR7=JRST A00 61 254000 030742 SADR8=JRST A00 62 254000 030742 SADR9=JRST A00 63 254000 030742 SADR10=JRST A00 64 254000 030742 SADR11=JRST A00 65 66 000000 PAREA0=0 67 000000 PAREA1=0 68 000000 PAREA2=0 69 444153 414100 PAREA3=SIXBIT/DAKAA/ 70 645560 000000 PAREA4=SIXBIT/TMP/ 71 000000 PAREA5=0 72 000000 PAREA6=0 73 001000 ITERAT==1000 74 777777 777777 PGMEND==-1 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 1 PARAM KLM 18-JAN-77 11:38 *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, JAN 18,1977 SEQ 0009 75 SUBTTL *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, JAN 18,1977 76 77 DEFINE S,<;*********************************************************************> 78 79 S^;*********************************************************************^ 80 ;*DATA SWITCHES (READ FROM CONSOLE IN EXEC MODE OR TYPED IN IN USER MODE) 81 ;*LEFT HALF SWITCHES ARE PRE-ASSIGNED FOR SUBROUTINE PACKAGE USE 82 ;*AND CONTROL LOOPING, PRINTING (TTY OR OTHER DEVICE) AND MISC. FUNCTIONS 83 S^;*********************************************************************^ 84 85 400000 ABORT== 400000 ;ABORT PROGRAM ON PASS COMPLETION 86 200000 RSTART==200000 ;RESTART TEST, PRINT TOTALS 87 100000 TOTALS==100000 ;PRINT TOTALS, CONTINUE 88 89 040000 NOPNT== 040000 ;INHIBIT ALL PRINT/TYPE OUT (EXCEPT FORCED) 90 020000 PNTLPT==020000 ;PRINT ALL DATA ON LPT (LOGICAL DEVICE, USER MODE) 91 010000 DING== 010000 ;RING BELL ON ERROR 92 93 004000 LOOPER==004000 ;ENTER EXERCISE/CHECK LOOP ON ERROR 94 002000 ERSTOP==002000 ;HALT ON TEST ERROR 95 001000 PALERS==001000 ;PRINT ALL ERRORS 96 97 000400 RELIAB==000400 ;RELIABILITY MODE 98 000200 TXTINH==000200 ;INHIBIT ERROR TEXT 99 000100 INHPAG==000100 ;INHIBIT PAGING 100 101 000040 MODDVC==000040 ;MODIFY DEVICE CODE 102 000020 INHCSH==000020 ;INHIBIT CACHE 103 000010 OPRSEL==000010 ;OPERATOR SELECTION 104 105 000004 CHAIN== 000004 ;CHAIN CONTROL SWITCH 106 107 000002 KAHZ50==000002 ;KA10 50 HERTZ POWER 108 109 ;SWITCH 17 RESERVED !!! DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 2 PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0010 110 SUBTTL *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 111 112 S^;*********************************************************************^ 113 ;*SPECIAL SUBPROGRAM LINKAGES 114 S^;*********************************************************************^ 115 116 027772 FSELNK= 27772 ;FILE SELECT LINK 117 027773 FRDLNK= 27773 ;FILE READ LINK 118 027774 LDLNK= 27774 ;LOAD LINKAGE ADDRESS 119 027775 DDTLNK= 27775 ;DDT LINKAGE ADDRESS 120 027776 MODLNK= 27776 ;OPERATIONAL MODE CHECK LINKAGE ADDRESS 121 027777 SUBLNK= 27777 ;SUBROUTINE LINKAGE ADDRESS 122 123 S^;*********************************************************************^ 124 ;*SPECIAL SUBROUTINE FATAL HALTS 125 ;*USED TO REPORT ERRORS THAT CAUSE THE SUBROUTINES TO BE UNUSABLE 126 S^;*********************************************************************^ 127 128 ;ADDRESS TAG REASON 129 ;--------------------- 130 131 ; 1010 NOEXEC ;PROGRAM NOT CODED FOR EXEC MODE OPERATION 132 ; 1011 PLERR ;FATAL PUSH LIST POINTER ERROR 133 ; 1012 PLERR1 ;INITIAL PUSH LIST POINTER ERROR 134 ; 1013 MUOERR ;MUUO WITH LUUO HANDLER WIPED OUT 135 ; 1014 DTEBER ;DTE20 INTERRUPT WITHOUT DOORBELL 136 ; 1015 DTECER ;DTE20 CLOCK INTERRUPT WITHOUT FLAG SET 137 ; 1016 CPIERR ;CPU INITIALIZATION ERROR 138 ; 1017 EOPERR ;END OF PROGRAM ERROR 139 ; 1020 LUOERR ;INTERRUPT WITH LUUO HANDLER WIPED OUT 140 141 S^;*********************************************************************^ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 3 PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0011 142 S^;*********************************************************************^ 143 ;OPERATOR DEFINITIONS (NON-UUO'S) 144 S^;*********************************************************************^ 145 146 260740 000000 OPDEF GO [PUSHJ P,] ;SUBROUTINE CALL 147 263740 000000 OPDEF RTN [POPJ P,] ;SUBROUTINE RETURN 148 261740 000000 OPDEF PUT [PUSH P,] ;PUT DATA ON PUSH LIST 149 262740 000000 OPDEF GET [POP P,] ;GET DATA FROM PUSH LIST 150 254000 000000 OPDEF PJRST [JRST ] ;JRST TO ROUTINE THAT RTN'S 151 254200 000000 OPDEF HALT [JRST 4,] ;DEFINITION FOR DDT 152 254100 000000 OPDEF JRSTF [JRST 2,] ;DEFINITION FOR DDT 153 254500 000000 OPDEF JEN [JRST 12,] ;DEFINITION FOR DDT 154 155 S^;*********************************************************************^ 156 ;*SUBROUTINE INITIALIZATION CALL 157 S^;*********************************************************************^ 158 159 265000 030011 OPDEF PGMINT [JSP 0,SBINIT] ;SUBROUTINE INITIALIZATION 160 161 S^;*********************************************************************^ 162 ;*HALTING UUO'S (A MORE GRACEFUL HALT THAN SIMPLY USING THE HALT INSTRUCTION). 163 S^;*********************************************************************^ 164 165 037640 000004 OPDEF FATAL [37B8!15B12!4] ;FATAL PROGRAMMING HALT 166 037600 000004 OPDEF ERRHLT [37B8!14B12!4] ;PROGRAM ERROR HALT 167 168 S^;*********************************************************************^ 169 ;*TERMINAL INPUT UUO'S 170 ;*ALWAYS COME FROM THE CONSOLE TERMINAL IN EXEC MODE OR THE 171 ;*CONTROLLING TERMINAL (REAL TERMINAL OR PTY) IN USER MODE. 172 S^;*********************************************************************^ 173 174 037000 000003 OPDEF TTICHR [37B8!0B12!3] ;TTY, INPUT ANY CHARACTER 175 037040 000003 OPDEF TTIYES [37B8!1B12!3] ;TTY, NORMAL RETURN Y 176 037100 000003 OPDEF TTINO [37B8!2B12!3] ;TTY, NORMAL RETURN N 177 037140 000003 OPDEF TTIOCT [37B8!3B12!3] ;TTY, INPUT OCTAL WORD 178 037200 000003 OPDEF TTIDEC [37B8!4B12!3] ;TTY, INPUT DECIMAL WORD 179 037240 000003 OPDEF TTICNV [37B8!5B12!3] ;TTY, INPUT CONVERTABLE WORD 180 037300 000003 OPDEF TTLOOK [37B8!6B12!3] ;TTY, KEYBOARD CHECK 181 037340 000003 OPDEF TTALTM [37B8!7B12!3] ;TTY, ALT-MODE CHECK 182 037400 000003 OPDEF TTSIXB [37B8!10B12!3] ;TTY, INPUT SIXBIT WORD 183 037440 000003 OPDEF TTYINP [37B8!11B12!3] ;TTY, IMAGE MODE INPUT DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 4 PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0012 184 ;*TERMINAL OUTPUT UUO'S. 185 186 037000 000000 OPDEF PNTA [37B8!0B12!0] ;PRINT ASCII WORD 187 037000 000001 OPDEF PNTAF [37B8!0B12!1] ;PRINT ASCII WORD FORCED 188 037740 000000 OPDEF PNTAL [37B8!17B12!0] ;PRINT ASCIZ LINE 189 037740 000001 OPDEF PNTALF [37B8!17B12!1] ;PRINT ASCIZ LINE FORCED 190 037600 000003 OPDEF PSIXL [37B8!14B12!3] ;PRINT SIXBIT'Z LINE 191 037640 000003 OPDEF PSIXLF [37B8!15B12!3] ;PRINT SIXBIT'Z LINE FORCED 192 037000 000000 OPDEF PNTMSG [37B8!0B12!0] ;PRINT MESSAGE IMMEDIATE 193 037040 000000 OPDEF PNTMSF [37B8!1B12!0] ;PRINT MESSAGE IMMEDIATE FORCED 194 037100 000000 OPDEF PSIXM [37B8!2B12!0] ;PRINT SIXBIT'Z MSG IMMEDIATE 195 037200 000000 OPDEF PSIXMF [37B8!4B12!0] ;PRINT SIXBIT'Z MSG IMM FORCED 196 037000 000000 OPDEF PNTCI [37B8!0B12!0] ;PRINT CHARACTER IMMEDIATE 197 037040 000000 OPDEF PNTCIF [37B8!1B12!0] ;PRINT CHARACTER IMMEDIATE FORCED 198 037500 000000 OPDEF PNTCHR [37B8!12B12!0] ;PRINT CHARACTER 199 037500 000001 OPDEF PNTCHF [37B8!12B12!1] ;PRINT CHARACTER FORCED 200 037040 000000 OPDEF PNT1 [37B8!1B12!0] ;PRINT ONE OCTAL DIGIT 201 037040 000001 OPDEF PNT1F [37B8!1B12!1] ;PRINT 1 OCTAL DIGIT FORCED 202 037100 000000 OPDEF PNT2 [37B8!2B12!0] ;PRINT TWO OCTAL DIGITS 203 037100 000001 OPDEF PNT2F [37B8!2B12!1] ;PRINT 2 OCTAL DIGITS FORCED 204 037140 000000 OPDEF PNT3 [37B8!3B12!0] ;PRINT THREE OCTAL DIGITS 205 037140 000001 OPDEF PNT3F [37B8!3B12!1] ;PRINT THREE OCTAL DIGITS FORCED 206 037200 000000 OPDEF PNT4 [37B8!4B12!0] ;PRINT FOUR OCTAL DIGITS 207 037200 000001 OPDEF PNT4F [37B8!4B12!1] ;PRINT FOUR OCTAL DIGITS FORCED 208 037240 000000 OPDEF PNT5 [37B8!5B12!0] ;PRINT FIVE OCTAL DIGITS 209 037240 000001 OPDEF PNT5F [37B8!5B12!1] ;PRINT FIVE OCTAL DIGITS FORCED 210 037300 000000 OPDEF PNT6 [37B8!6B12!0] ;PRINT SIX OCTAL DIGITS 211 037300 000001 OPDEF PNT6F [37B8!6B12!1] ;PRINT SIX OCTAL DIGITS FORCED 212 037340 000000 OPDEF PNT7 [37B8!7B12!0] ;PRINT 7 OCTAL DIGITS 213 037340 000001 OPDEF PNT7F [37B8!7B12!1] ;PRINT 7 OCTAL DIGITS FORCED 214 037440 000000 OPDEF PNT11 [37B8!11B12!0] ;PRINT 11 OCTAL DIGITS 215 037440 000001 OPDEF PNT11F [37B8!11B12!1] ;PRINT 11 OCTAL DIGITS FORCED. 216 037400 000000 OPDEF PNTADR [37B8!10B12!0] ;PRINT PHYSICAL ADDRESS 217 037400 000001 OPDEF PNTADF [37B8!10B12!1] ;PRINT PHYSICAL ADDRESS FORCED 218 037600 000000 OPDEF PNTOCT [37B8!14B12!0] ;PRINT FULL WORD OCTAL 219 037600 000001 OPDEF PNTOTF [37B8!14B12!1] ;PRINT FULL WORD OCTAL FORCED 220 037540 000000 OPDEF PNTHW [37B8!13B12!0] ;PRINT OCTAL HALF WORDS, 6 SP 6 221 037540 000001 OPDEF PNTHWF [37B8!13B12!1] ;PRINT OCTAL HALF WORDS, 6 SP 6 FORCED 222 037700 000003 OPDEF PNTOCS [37B8!16B12!3] ;PRINT OCTAL, SUPPRESS LEADING 0'S 223 037740 000003 OPDEF PNTOCF [37B8!17B12!3] ;PRINT OCTAL, SUPPRESS LEADING 0'S FORCED 224 037640 000000 OPDEF PNTDEC [37B8!15B12!0] ;PRINT DECIMAL, SUPRESS LEADING 0'S 225 037640 000001 OPDEF PNTDCF [37B8!15B12!1] ;PRINT DECIMAL, SUPRESS LEADING 0'S FORCED 226 037700 000000 OPDEF PNTDS [37B8!16B12!0] ;PRINT DECIMAL, SPACES FOR LD 0'S 227 037700 000001 OPDEF PNTDSF [37B8!16B12!1] ;PRINT DECIMAL, SPACES FOR LD 0'S FORCED 228 037200 000002 OPDEF PNTNM [37B8!4B12!2] ;PRINT PROGRAM NAME 229 037000 000002 OPDEF PNTSIX [37B8!0B12!2] ;PRINT SIXBIT WORD 230 037040 000002 OPDEF PNTSXF [37B8!1B12!2] ;PRINT SIXBIT WORD FORCED 231 037240 000002 OPDEF DROPDV [37B8!5B12!2] ;CLOSE LOGICAL FILE, USER MODE 232 037100 000002 OPDEF PNTCW [37B8!2B12!2] ;PRINT DF10 CONTROL WORD 233 037140 000002 OPDEF PNTCWF [37B8!3B12!2] ;PRINT DF10 CONTROL WORD FORCED 234 037000 030242 OPDEF PCRL [37B8!0B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED 235 037040 030242 OPDEF PCRLF [37B8!1B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED FORCED 236 037000 000040 OPDEF PSP [37B8!0B12!40] ;PRINT SPACE 237 037040 000040 OPDEF PSPF [37B8!1B12!40] ;PRINT SPACE FORCED 238 037000 030243 OPDEF PCRL2 [37B8!0B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE) DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 4-1 PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0013 239 037040 030243 OPDEF PCRL2F [37B8!1B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE) FORCED 240 037040 000007 OPDEF PBELL [37B8!1B12!7] ;PRINT TTY BELL 241 242 037040 000026 OPDEF PFORCE [37B8!1B12!26] ;PRINT FORCE, CONTROL O OVERRIDE 243 244 DEFINE PMSG (ARG),< 245 PSIXM [SIXBIT\ARG'_\]> 246 247 DEFINE PMSGF (ARG),< 248 PSIXMF [SIXBIT\ARG'_\]> 249 250 ;*SIXBTZ -- MACRO TO GENERATE SIXBIT DATA FOR PRINTING 251 ;* CONSERVES CORE OVER ASCIZ 252 253 DEFINE SIXBTZ (ARG),< [SIXBIT\ARG'_\]> 254 255 ;*CONSOLE SWITCH INPUT UUO. 256 ;*READS CONSOLE SWITCHES IF IN EXEC MODE OR ASKS FOR THEM IF 257 ;* USER MODE. 258 259 037400 000002 OPDEF SWITCH [37B8!10B12!2] ;INPUT CONSOLE SWITCHES 260 261 ;*CLOCK INITIALIZATION UUO - TO SET DESIRED CLOCK OPERATION 262 ;*EITHER IGNORE CLOCK, ONLY LET IT TICK OR CAUSE INTERRUPT TO OCCUR. 263 264 037540 000004 OPDEF CLOKOP [37B8!13B12!4] ;CLOCK OPERATION UUO - PDP-11 CLOCK 265 037200 000004 OPDEF MTROP [37B8!4B12!4] ;CLOCK OPERATION UUO - DK20 METER 266 267 ;*KL10 ONLY CACHE OPERATION UUO'S 268 269 037040 000004 OPDEF CINVAL [37B8!1B12!4] ;CACHE INVALIDATE 270 037100 000004 OPDEF CFLUSH [37B8!2B12!4] ;CACHE FLUSH 271 037140 000004 OPDEF CWRTBI [37B8!3B12!4] ;CACHE WRITE-BACK & INVALIDATE DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 5 PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0014 272 ;*END OF PASS/PROGRAM UUOS 273 274 ;PERFORMS THE END OF PASS FUNCTIONS. INCREMENT PASS COUNT, 275 ;*DECREMENT ITERATION COUNT, CHECK IF FINISHED WITH THIS PROGRAM ETC. 276 277 037500 000004 OPDEF ENDUUO [37B8!12B12!4] ;UUO TO DISPLAY LIGHTS 278 037700 000004 OPDEF EOPUUO [37B8!16B12!4] ;END OF PROGRAM UUO 279 280 ;*MEMORY MANAGEMENT UUO'S 281 ;*UUO'S TO PERFORM VARIOUS MEMORY FUNCTIONS. MAPPING, ZEROING, PAGING, 282 ;*ADDRESS CONVERSION, ETC... 283 284 037000 000004 OPDEF MAPMEM [37B8!0B12!4] ;MAP MEMORY 285 037500 000002 OPDEF MEMZRO [37B8!12B12!2] ;ZERO MEMORY 286 037440 000002 OPDEF MEMSEG [37B8!11B12!2] ;SETUP MEMORY SEGMENT 287 037540 000002 OPDEF MAPADR [37B8!13B12!2] ;VIRTUAL TO PHYSICAL ADR CONVERT 288 037640 000002 OPDEF MAPCNK [37B8!15B12!2] ;MAP MEMORY CHUNK 289 037600 000002 OPDEF MAPSET [37B8!14B12!2] ;SET KI10 EXEC PAGE MAP 290 037740 000002 OPDEF MAPPNT [37B8!17B12!2] ;PRINT MEMORY MAP 291 292 ;*DEVICE CODE MODIFICATION UUO 293 ;*ALLOWS THE MODIFICATION OF IOT'S TO ONE DEVICE TO BE CHANGED TO 294 ;*IOT'S TO A DIFFERENT DEVICE CODE. 295 296 037340 000002 OPDEF MODPCU [37B8!7B12!2] ;MODIFY PERHIPERAL CODE, USER 297 037300 000002 OPDEF MODPCP [37B8!6B12!2] ;MODIFY PERHIPERAL CODE, PROGRAM 298 299 030000 IFNDEF MODDVL, 300 030000 IFNDEF MODDVU, 301 302 ;*"DIAMON" FILE SELECTION AND READ UUOS 303 304 037240 000004 OPDEF FSELECT [37B8!5B12!4] ;FILE SELECTION 305 037300 000004 OPDEF FREAD [37B8!6B12!4] ;FILE READ - ASCII DATA 306 037340 000004 OPDEF FRD36 [37B8!7B12!4] ;FILE READ - 36 BIT DATA 307 037400 000004 OPDEF FRD8 [37B8!10B12!4] ;FILE READ - 8 BIT DATA 308 309 ;*KI10 ONLY UUO FOR PRINTING MARGIN VALUES 310 311 037700 000002 OPDEF PNTMGN [37B8!16B12!2] ;PRINT MARGIN VALUE 312 313 XLIST 314 IFNDEF KLOLD, 340 341 ;*A MACRO TO REPORT AN ERROR AND NOT LOOP 342 343 DEFINE ERROR1 (FORMAT,CORECT,ACTUAL,F,D,ERR)< 344 SALL 345 ERUUO FORMAT,[T,,[SIXBIT\F'_\] 346 CORECT,,ACTUAL 347 [SIXBIT\D'_\],,ERR] 348 XALL > 349 350 >;END OF KLOLD CONDITIONAL 351 352 XLIST 353 LIST DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 1 FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0016 354 SUBTTL *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 355 356 030000 LOC 30000 357 358 S^;*********************************************************************^ 359 ;*PROGRAM STARTING ADDRESSES 360 ;*THESE ADDRESSES CALL VARIOUS SPECIAL START ROUTINES AND OR OPTIONS 361 ;*NORMAL START ADDRESS IS 30000 ALL OTHERS ARE SPECIAL. INVOKED BECAUSE 362 ;*OF END OF PASS, POWER FAILURE, DDT START, RE-ENTERING(TYPICALLY USER 363 ;*MODE), OR ANY NUMBER OF SPECIAL FEATURE TESTS. 364 S^;*********************************************************************^ 365 366 030000 254 00 1 00 027776 BEGIN: JRST @MODLNK ;STAND-ALONE START 367 030001 254 00 0 00 030712 $START: JRST START ;MODE CHECK STARTING ADDRESS 368 369 030002 254 00 1 00 027774 DIAGMN: JRST @LDLNK ;DIAGNOSTIC MONITOR START 370 371 030003 254 00 1 00 027774 SYSEXR: JRST @LDLNK ;SYSTEM EXERCISER START 372 373 030004 254 00 0 00 030742 SFSTRT: JRST SADR1 ;SPECIAL FEATURE START 374 375 030005 254 00 0 00 030742 PFSTRT: JRST SADR2 ;POWER FAIL RESTART 376 377 030006 254 00 0 00 030742 REENTR: JRST SADR3 ;REENTER START(USUALLY USER MODE ONLY) 378 379 030007 SRTDDT: ;COMMONLY MISTAKEN NAME FOR "DDTSRT" 380 030007 254 00 1 00 027775 DDTSRT: JRST @DDTLNK ;DDT START 381 382 030010 254 00 0 00 030741 BEGIN1: JRST STARTA ;LOOP START(END OF PASS COMES HERE) 383 030011 254 00 1 00 027777 SBINIT: JRST @SUBLNK ;PMGINT LINKAGE 384 030012 000000 000000 RETURN: 0 ;RETURN ADDRESS STORAGE 385 386 030013 254000 030742 START1: SADR7 ;OPTIONAL STARTING ADR/INSTRUCTIONS 387 030014 254000 030742 START2: SADR8 ; " 388 030015 254000 030742 START3: SADR9 ; " 389 030016 254000 030742 START4: SADR10 ; " 390 030017 254000 030742 START5: SADR11 ; " DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 2 FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0017 391 S^;*********************************************************************^ 392 ;*PROGRAM FIXED PARAMETER AREA 393 S^;*********************************************************************^ 394 395 030020 444153 414100 PNTNAM: PAREA3 ;SIXBIT PROGRAM NAME 396 030021 645560 000000 PNTEXT: PAREA4 ;SIXBIT PROGRAM EXTENSION 397 030022 000000 000000 RANDBS: PAREA1 ;RANDOM BASE NUMBER 398 030023 000000 000000 SWTEXR: PAREA2 ;SYSTEM EXERCISER SWITCHES 399 030024 000000 001000 ITRCNT: ITERAT ;PROGRAM ITERATIONS 400 030025 000000 030725 $PNAME: PGMNAM ;POINTER TO PROGRAMS NAME 401 030026 000000 000002 $PVER: MCNVER,,DECVER ;MCN & DEC VERSION LEVEL 402 030027 000000 030000 $MODVL: MODDVL ;DEVICE CODE CHANGE LOWER LIMIT 403 030030 000000 030000 $MODVU: MODDVU ;DEVICE CODE CHANGE UPPER LIMIT 404 030031 777777 777777 $EMODE: IFNDEF EXCASB,<0> IFDEF EXCASB,<-1> ;EXEC ALLOWED 405 030032 777777 777777 $UMODE: IFNDEF USRASB,<0> IFDEF USRASB,<-1> ;USER ALLOWED 406 030033 000000 000000 $DSKUP: IFNDEF DSKUPD,<0> IFDEF DSKUPD,<-1> ;DISK UPDATE MODE 407 030034 000000 000000 $MMAP: IFNDEF MEMMAP,<0> IFDEF MEMMAP,<-1> ;ALLOW MEMORY RTNS 408 030035 000000 000000 PAREA7: PAREA5 ;OPTIONAL PARAMETER 409 030036 000000 000000 PAREA8: PAREA6 ;OPTIONAL PARAMETER 410 411 S^;*********************************************************************^ 412 ;*PROGRAM VARIABLE PARAMETER AREA 413 S^;*********************************************************************^ 414 415 030037 000000 000000 USER: 0 ; 0 = EXEC, -1 = USER MODE FLAG 416 030040 000000 000000 KAIFLG: 0 ;PROCESSOR TYPE, 0 = KA10, -1 = KI10 417 030041 000000 000000 KLFLG: 0 ;PROCESSOR TYPE, 0 = KA/KI, -1 = KL10 418 030042 777777 777777 MONFLG: -1 ;DIAG MONITOR SPECIAL USER FLAG 419 030043 000000 000000 MONCTL: 0 ;DIAG MON/SYS EXR FLAG 420 030044 000000 000000 MONTEN: 0 ;-1= LOADED BY 10 421 030045 000000 000000 CLOCKF: 0 ;CLOCK TICKED FLAG 422 030046 000000 000000 CONSW: 0 ;CONSOLE SWITCH SETTINGS 423 030047 000000 000000 PASCNT: 0 ;PROGRAM PASS COUNT 424 030050 000000 000000 RUNFLG: 0 ;PROGRAM RUN FLAG 425 030051 000000 000000 TESTPC: 0 ;SUBTEST PC 426 030052 000000 000000 ERRPC: 0 ;ERROR PC 427 030053 000000 000000 ERRTLS: 0 ;ERROR TOTALS 428 030054 000000 000000 TICKS: 0 ;PROGRAM RUNNING TIME 429 030055 000000 000000 MARGIN: 0 ;KI10 MARGIN WORD VALUE 430 030056 000000 000000 $ONETM: 0 ;SUBROUTINE INITIALIZATION FLAG DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 3 FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0018 431 S^;*********************************************************************^ 432 ;*SPECIAL PROGRAM DISPATCH ADDRESSES 433 S^;*********************************************************************^ 434 435 030057 037 12 0 00 000004 BEGEND: ENDUUO ;END OF PASS 436 030060 254 00 0 00 030010 $BEND1: JRST BEGIN1 ;KEEP RUNNING PROGRAM 437 030061 037 16 0 00 000004 $BEND2: EOPUUO ;END OF PROGRAM - NO RETURN 438 030062 254000 030742 CNTLC: SADR5 ;CONTROL C XFER ADDRESS 439 030063 254000 030742 ALTMGO: SADR6 ;ALTMODE XFER ADDRESS 440 030064 CPOPJ1: ;SKIP RETURN 441 030064 350 00 0 17 000000 UUOSKP: AOS (P) ;SKIP RETURN FROM UUO 442 030065 CPOPJ: ;NON-SKIP REGULAR RETURN 443 030065 263 17 0 00 000000 UUOEXT: RTN ;UUO RETURN 444 030066 255 00 0 00 000000 UUORTN: JFCL ;ADDITIONAL USERS UUO ROUTINE 445 030067 255 00 0 00 000000 $UORTX: JFCL ;ADDITIONAL UUO LINKAGE 446 030070 255 00 0 00 000000 $UUOER: JFCL ;INITED AS (JRST $UOERX) 447 030071 255 00 0 00 000000 $ITRHL: JFCL ;ADDITIONAL INTERRUPT LINKAGE 448 030072 255 00 0 00 000000 $ITRX1: JFCL ; " 449 030073 255 00 0 00 000000 $USRHL: JFCL ; " 450 030074 255 00 0 00 000000 $RSRTX: JFCL ;ADDITIONAL POWER FAIL LINKAGE 451 030075 255 00 0 00 000000 $RSRTY: JFCL ; " 452 030076 255 00 0 00 000000 RESRT1: JFCL ; INITED AS (JRST RESRTX) 453 030077 255 00 0 00 000000 RESRT2: JFCL ; " 454 030100 255 00 0 00 000000 $PARER: JFCL ;ADDITIONAL PARITY ERROR LINKAGE 455 030101 255 00 0 00 000000 ERMORE: JFCL ;ADDITIONAL ERROR HANDLER LINKAGE 456 030102 254 04 0 00 030102 HALT . ;IMPROPER TRANSFER HALT 457 458 030103 000000 000000 $PSHER: 0 ;INITED AS (JRST PSHERR) 459 030104 000000 000000 ITRCH1: 0 ;PC & FLAGS OF CURRENT INTERRUPT 460 030105 000000 000000 0 ;INITED AS (JRST $ITRC1) 461 462 S^;*********************************************************************^ 463 ;*PROCESSOR CONTROL STORAGE 464 S^;*********************************************************************^ 465 466 030106 000000 000000 $ACC0: 0 ;INTERRUPT SAVED AC0 467 030107 000000 000000 $SVPI: 0 ;INTERRUPT SAVED PI 468 030110 000000 000000 $SVAPR: 0 ;INTERRUPT SAVED APR 469 030111 000000 000000 $SVPAG: 0 ;INTERRUPT SAVED PAG (DATAI) 470 030112 000000 000000 $SPAG1: 0 ;INTERRUPT SAVED PAG (CONI) 471 472 030113 000000 000000 $SVUUO: 0 ;CURRENT USERS UUO 473 030114 000000 000000 $SVUPC: 0 ;PC OF CURRENT USERS UUO 474 475 030115 000000 000000 REPTU: 0 ;REPEAT UUO ITERATIONS 476 030116 000000 000000 SCOPE: 0 ;ERROR HANDLER SCOPE LOOP FLAG 477 030117 000000 000000 %CORFLG:0 ; " CORRECT FLAG 478 030120 000000 000000 %COREC: 0 ; " CORRECT DATA 479 030121 000000 000000 %ACTFL: 0 ; " ACTUAL FLAG 480 030122 000000 000000 %ACTUL: 0 ; " ACTUAL DATA 481 030123 000000 000000 %DISCR: 0 ; " DISCREPENCY DATA DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 4 FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0019 482 S^;*********************************************************************^ 483 ;*UUO DISPATCH TABLE 484 S^;*********************************************************************^ 485 XLIST 486 LIST 487 030124 030070 030070 UUODIS: LUUO1,,$UUOER 488 030125 030070 030070 LUUO3,,LUUO2 489 030126 030070 030070 LUUO5,,LUUO4 490 030127 030070 030070 LUUO7,,LUUO6 491 030130 030070 030070 LUUO11,,LUUO10 492 030131 030070 030070 LUUO13,,LUUO12 493 030132 030070 030070 LUUO15,,LUUO14 494 030133 030070 030070 LUUO17,,LUUO16 495 030134 030070 030070 LUUO21,,LUUO20 496 030135 030070 030070 LUUO23,,LUUO22 497 030136 030070 030070 LUUO25,,LUUO24 498 030137 030070 030070 LUUO27,,LUUO26 499 030140 030070 030070 LUUO31,,LUUO30 500 030141 030070 030070 LUUO33,,LUUO32 501 502 S^;*********************************************************************^ 503 ;*MEMORY MANAGMENT STORAGE 504 S^;*********************************************************************^ 505 506 030142 000000 000000 DF22F: 0 ;DF10 CONTROL FLAG, 0 = 18, -1 = 22 BIT 507 030143 000000 000000 MAPNEW: 0 ;MEMORY MAPPING CONTROL FLAG, -1 = 4096K MAPPING 508 030144 000000 000000 MEMTOT: 0 ;TOTAL MEMORY SIZE IN K (1024.) 509 030145 000000 000000 MEMLOW: 0 ;LOWEST USABLE MEMORY 510 030146 MEMSIZ: BLOCK ^D41 ;MEMORY SEGMENT POINTER TABLE 511 512 S^;*********************************************************************^ 513 ;*PRINT CONTROL STORAGE 514 S^;*********************************************************************^ 515 516 030217 000000 000000 PNTFLG: 0 ;PRINT FLAG, -1 WHILE IN PRINT ROUTINE 517 030220 000000 000000 PNTENB: 0 ;PRINT ENABLE 518 030221 000000 000000 PDISF: 0 ;PRINT DISABLED FLAG 519 030222 000000 000000 PNTINH: 0 ;INHIBIT PRINT INPUT CHECKS 520 030223 000000 000000 PNTSPC: 0 ;PRINT SPACE CONTROL 521 030224 000000 000000 OPTIME: 0 ;TYPE-IN WAIT TIME 522 030225 000000 000000 $TWCNT: 0 ;TIME WAITED 523 030226 000000 000000 $DVOFF: 0 ;LOGICAL DEVICE INITED FLAG 524 030227 000000 000000 TTYFIL: 0 ;TTY EXEC FILLERS FLAG 525 030230 000000 000000 TTYSPD: 0 ;TTY EXEC BAUD RATE 526 030231 000000 000000 $TTCHR: 0 ;ACTUAL TYPED IN CHAR 527 030232 000000 000000 $CHRIN: 0 ;UPPER CASED & PARITY STRIPPED CHAR 528 030233 000000 000000 $TYPNB: 0 ;TYPED IN NUMBER 529 030234 000000 000000 $CRLF: 0 ;FREE CR/LF FLAG 530 030235 000000 000000 $TABF: 0 ;TAB CONVERSION FLAG 531 030236 000000 000000 $FFF: 0 ;FORM FEED CONVERSION FLAG 532 030237 000000 000000 $VTF: 0 ;VERTICAL TAB CONVERSION FLAG 533 030240 000000 000000 USRLFF: 0 ;USER LF FILLERS 534 030241 000000 000000 USRCRF: 0 ;USER CR FILLERS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 5 FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0020 535 S^;*********************************************************************^ 536 ;*THE FOLLOWING MISCELLANEOUS PRINT CHARACTERS ARE INCLUDED 537 ;*TO FACILITATE PRINTING AND ARE CALLED AS FOLLOWS: 538 ;* MOVEI NAME 539 ;* PNTA ;OR PNTAF 540 S^;*********************************************************************^ 541 542 030242 CRLF: ASCII/ 543 030242 015 012 000 000 000 / 544 030243 CRLF2: ASCII/ 545 546 030243 015 012 015 012 000 / 547 030244 054 000 000 000 000 COMMA: ASCII/,/ 548 030245 056 000 000 000 000 PERIOD: ASCII/./ 549 030246 040 000 000 000 000 SPACE: ASCII/ / 550 030247 011 000 000 000 000 TAB: ASCII/ / 551 030250 MINUS: 552 030250 055 000 000 000 000 HYPEN: ASCII/-/ 553 030251 053 000 000 000 000 PLUS: ASCII/+/ 554 030252 052 000 000 000 000 AST: ASCII/*/ 555 030253 100 000 000 000 000 ATSIN: ASCII/@/ 556 030254 050 000 000 000 000 LFP: ASCII/(/ 557 030255 051 000 000 000 000 RTP: ASCII/)/ 558 030256 007 0000000000 BELL: BYTE (7) 007 559 030257 077 000 000 000 000 QUEST: ASCII/?/ 560 030260 057 000 000 000 000 SLASH: ASCII!/! 561 030261 044 000 000 000 000 DOLLAR: ASCII/$/ 562 030262 000000 000012 RADIX: ^D10 ;DECIMAL PRINT RADIX 563 030263 000000 000040 RADLSP: 40 ;DECIMAL PRINT LEADING CHAR 564 030264 000000 000012 RADLSC: ^D10 ;DECIMAL PRINT LEADING CHAR COUNT 565 566 S^;*********************************************************************^ 567 ;*USER MODE OUTPUT FILE INFORMATION 568 S^;*********************************************************************^ 569 570 030265 $OBUF: BLOCK 3 ;LOGICAL FILE OUTPUT BUFFER HEADER 571 030270 60 62 51 56 64 00 $OUTNM: SIXBIT /PRINT/ ;FILE NAME 572 030271 60 56 64 00 00 00 $OUTEX: SIXBIT /PNT/ ;FILE NAME EXTENSION 573 030272 BLOCK 2 574 575 S^;*********************************************************************^ 576 ;*DISK UPDATE MODE FILE INFORMATION 577 S^;*********************************************************************^ 578 579 030274 $IBUF: BLOCK 3 580 030277 60 62 51 56 64 00 $INNM: SIXBIT /PRINT/ 581 030300 60 56 64 00 00 00 $INEXT: SIXBIT /PNT/ 582 030301 BLOCK 2 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 6 FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0021 583 S^;*********************************************************************^ 584 ;*PUSHDOWN LIST CONTROL INFORMATION 585 S^;*********************************************************************^ 586 587 030303 777577 030303 PLIST: PLIST-PLISTE,,PLIST 588 030304 PLISTS: BLOCK 200 589 030504 000000 000000 PLISTE: 0 ;END OF PUSHDOWN LIST 590 591 S^;*********************************************************************^ 592 ;*POWER LINE CLOCK FREQUENCY FLAG 593 S^;*********************************************************************^ 594 595 030505 000000 000000 CYCL60: 0 ;0 = 60, -1 = 50 CYCLE 596 597 S^;*********************************************************************^ 598 ;*KL10 CACHE CONTROL FLAGS 599 S^;*********************************************************************^ 600 601 030506 000000 000000 CSHFLG: 0 ;ALLOW CACHE IF 0 602 030507 000000 000000 CSHMEM: 0 ;CACHE MEMORY SEGMENTS IF 0 603 604 S^;*********************************************************************^ 605 ;*NUMBER INPUT DIGIT FLAG 606 S^;*********************************************************************^ 607 608 030510 000000 000000 TTNBRF: 0 ;-1 IF ANY DIGIT TYPED 609 610 S^;*********************************************************************^ 611 ;*KL10 & KI10 "INHPAG" SWITCH PAGING PREVENTION 612 S^;*********************************************************************^ 613 614 030511 000000 000000 PVPAGI: 0 ;IF NON-ZERO, OVERRIDE "INHPAG" SWITCH ACTION 615 616 S^;*********************************************************************^ 617 ;*ERROR REPORTING ROUTINE ADDITIONAL USERS CONTROL INSTRUCTIONS 618 S^;*********************************************************************^ 619 620 030512 000000 000000 %ERHI1: 0 ;IF NON-ZERO, XCT'D AT START OF %ERUUO 621 030513 000000 000000 %ERHI2: 0 ;IF NON-ZERO, XCT'D AT END OF %ERUUO 622 030514 000000 000000 %ERHI3: 0 ;IF NON-ZERO, XCT'D AFTER "PC" OF %ERUUO 623 624 S^;*********************************************************************^ 625 ;*SPECIAL USERS UUO INTERCEPT INSTRUCTION 626 S^;*********************************************************************^ 627 628 030515 000000 000000 $$UUO: 0 ;IF NON-ZERO, XCT'D AT START OF $UORTN DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 7 FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0022 629 S^;*********************************************************************^ 630 ;*KL10 PROCESSOR TYPE FLAG, 0=P0, 1=BBD NEW, 2=BBD OLD 631 S^;*********************************************************************^ 632 633 030516 000000 000000 KLTYP: 0 634 635 S^;*********************************************************************^ 636 ;*SPECIAL USERS MUUO INTERCEPT INSTRUCTION 637 S^;*********************************************************************^ 638 639 030517 000000 000000 $$MUUO: 0 ;IF NON-ZERO, XCT'D AT START OF MUUOER 640 641 S^;*********************************************************************^ 642 ;*SPECIAL USERS USER MODE OUTPUT ERROR INTERCEPT INSTUCTION 643 S^;*********************************************************************^ 644 645 030520 000000 000000 $$OUTER:0 ;IF NON-ZERO, XCT'D AT END OF USER MODE ERROR 646 647 S^;*********************************************************************^ 648 ;*"SWITCH" CALL USAGE CONTROL 649 S^;*********************************************************************^ 650 651 030521 000000 000000 $$TOGGLE:0 ;IF NON-ZERO, USE C(CONSW) FOR SWITCHES 652 653 S^;*********************************************************************^ 654 ;*SPECIAL USERS ALTMODE SWITCH CALL INTERCEPT INSTRUCTIONS 655 S^;*********************************************************************^ 656 657 030522 000000 000000 $$TAX1: 0 ;IF NON-ZERO, XCT'D AT START OF ALTMODE SWITCH CALL 658 030523 000000 000000 $$TAX2: 0 ;IF NON-ZERO, XCT'D AT END OF ALTMODE SWITCH CALL 659 660 S^;*********************************************************************^ 661 ;*SPECIAL FUTURE EXPANSION ROOM 662 ;*IF ANY FIXED AREA TAGS ARE ADDED, REDUCE THE SIZE OF 663 ;*THIS BLOCK STATEMENT ACCORDINGLY. THIS MUST BE DONE 664 ;*SO THAT PREVIOUS FIXED ASSIGNMENTS DO NOT CHANGE. 665 S^;*********************************************************************^ 666 667 030524 BLOCK 53 ;HOPEFULLY THIS IS ENOUGH FOREVER 668 669 S^;*********************************************************************^ 670 ;*END OF FIXED STORAGE 671 S^;*********************************************************************^ 672 673 030577 $ENDFX=&<777700>-1 674 030577 LOC $ENDFX 675 030577 000000 000000 ENDFIX: 0 ;END OF FIXED STORAGE DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 1 SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0023 676 SUBTTL *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 677 678 ;NEW DEFINITIONS USED BY THE KL10 SUBROUTINE PACKAGE 679 680 000000 AC0= 0 681 030000 DIAGNOS=30000 ;PDP-10 DIAGNOSTIC START ADDRESS 682 010000 DDT= 10000 ;PDP-10 DDT START ADDRESS 683 020000 DIAMON= 20000 ;PDP-10 DIAMON LOADER START ADDRESS 684 020000 DONG11= 1B22 ;11 DOORBELL (FROM THE 10) 685 686 ;DTE20 DEVICE CODES 687 688 000200 DTE== 200 ;DTE0 689 000204 DTE0== 204 690 000204 DTE1== 204 691 000210 DTE2== 210 692 000214 DTE3== 214 693 694 ;KL10 EPT COMMUNICATION AREA 695 696 000440 $STD= 440 ;PDP-10 DIAGNOSTIC START ADDRESS 697 000441 $DDT= 441 ;PDP-10 DDT START ADDRESS 698 000442 $STL= 442 ;PDP-10 LOADER START ADDRESS 699 000443 $STM= 443 ;PDP-10 MONITOR START ADDRESS 700 701 000444 $DTFLG= 444 ;DTE20 OPERATION COMPLETE FLAG 702 000445 $DTCLK= 445 ;DTE20 CLOCK INTERRUPT FLAG 703 000446 $DTCI= 446 ;DTE20 CLOCK INTERRUPT INSTRUCTION 704 000447 $DTT11= 447 ;DTE20 10 TO 11 ARGUMENT 705 000450 $DTF11= 450 ;DTE20 11 TO 10 ARGUMENT 706 000451 $DTCMD= 451 ;DTE20 TO 11 COMMAND WORD 707 000452 $DTSEQ= 452 ;DTE20 OPERATION SEQUENCE NUMBER 708 000453 $DTOPR= 453 ;DTE20 OPERATIONAL DTE # 709 000454 $DTCHR= 454 ;DTE20 LAST TYPED CHARACTER 710 000455 $DTMTD= 455 ;DTE20 MONITOR TTY OUTPUT COMPLETE FLAG 711 000456 $DTMTI= 456 ;DTE20 MONITOR TTY INPUT FLAG 712 713 000457 $DTSWR= 457 ;DTE20 CONSOLE SWITCH REGISTER DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 2 SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0024 714 ;SPECIAL "FIXED" REASSIGNMENTS 715 716 030600 $$LOC=. ;SAVE CURRENT LOCATION 717 718 030000 LOC 30000 719 030000 254 00 0 00 030600 $$BEGIN:JRST $$START ;SETUP SPECIAL START 720 030001 254 00 0 00 030600 JRST $$START ;"DIAMON" CHAIN START ADDRESS 721 722 000440 LOC 440 723 000440 254 00 0 00 030000 $STD: JRST BEGIN ;SETUP FOR "STD" 724 000443 LOC 443 725 000443 254 00 0 00 030636 $STM: JRST $SPEC ;SIMPLE RUN CONTROL 726 727 030057 LOC 30057 728 030057 254 00 0 00 030641 $BEGEND:JRST $SPBEND ;SETUP SPECIAL "BEGEND" 729 730 ;SPECIAL MUUO, TRAP & PAGE FAIL SETUP 731 732 000420 LOC 420 733 000420 254 04 0 00 000420 $$420: HALT . ;KI10 PAGE FAIL 734 000421 255 00 0 00 000000 $$421: JFCL ;OVERFLOW 735 000422 254 04 0 00 000422 $$422: HALT . ;PUSHDOWN OVERFLOW 736 000423 254 04 0 00 000423 $$423: HALT . ;TRAP 3 737 000424 000000 000000 $$424: 0 ;MMUO 738 000425 000000 000000 $$425: 0 ;MMUO PC 739 000426 000000 000000 $$426: 0 ;KI10-PAGE FAIL, KL10-PROCESS CONTEXT 740 000427 254 04 0 00 000427 $$427: HALT . 741 000430 000000 000427 $$430: 427 ;MMUO NEW PC'S 742 000431 000000 000427 $$431: 427 743 000432 000000 000427 $$432: 427 744 000433 000000 000427 $$433: 427 745 000434 000000 000427 $$434: 427 746 000435 000000 000427 $$435: 427 747 000436 000000 000427 $$436: 427 748 000437 000000 000427 $$437: 427 749 750 000500 LOC 500 751 000500 000000 000000 $$500: 0 ;KL10 PAGE FAIL WORD 752 000501 000000 000000 $$501: 0 ;KL10 PAGE FAIL PC 753 000502 000000 000503 $$502: 503 ;KL10 PAGE FAIL NEW PC 754 000503 254 04 0 00 000503 $$503: HALT . DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 3 SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0025 755 030600 LOC $$LOC ;RESET CURRENT LOCATION 756 757 ;SPECIAL STARTUP SEQUENCE 758 759 030600 402 00 0 00 030037 $$START:SETZM USER 760 030601 265 00 0 00 030602 JSP 0,.+1 ;IN USER MODE ? 761 030602 603 00 0 00 010000 TLNE 0,USERF 762 030603 476 00 0 00 030037 SETOM USER ;YES, SET CONTROL WORD 763 030604 336 00 0 00 030042 SKIPN MONFLG ;SPECIAL USER MODE ? 764 030605 402 00 0 00 030037 SETZM USER ;YES, RUN AS EXEC 765 030606 332 00 0 00 030037 SKIPE USER 766 030607 254 00 0 00 030712 JRST START ;USER MODE, DON'T NEED CPU TYPE 767 768 030610 336 00 0 00 030044 $STKIL: SKIPN MONTEN ;LOADED BY "DIAMON" ? 769 030611 476 00 0 00 030024 SETOM ITRCNT ;NO, RUN FOREVER 770 030612 402 00 0 00 030516 SETZM KLTYP 771 030613 402 00 0 00 030041 SETZM KLFLG ;ASSUME KI10 772 030614 200 01 0 00 035060 MOVE 1,[1,,1] 773 030615 251 01 0 00 000001 BLT 1,1 ;HOPE THIS WORKS 774 030616 316 01 0 00 035060 CAMN 1,[1,,1] ;IF AC NE 1,,1 AFTER BLT, KL10 775 030617 254 00 0 00 030712 JRST START ;KI10, NO ADDITIONAL SETUP 776 777 030620 7 000 20 0 00 010040 $STKL: CONO APR,10040 ;SET BBD NOT BIT 778 030621 7 000 24 0 00 000000 CONI APR,0 779 030622 7 000 20 0 00 020040 CONO APR,20040 ;CLEAR BBD NOT BIT 780 030623 606 00 0 00 000040 TRNN 0,40 ;IF SET, KL10 781 030624 350 00 0 00 030516 AOS KLTYP ;IF NOT, BBD 782 030625 402 00 0 00 000444 SETZM $DTFLG 783 030626 402 00 0 00 000445 SETZM $DTCLK 784 030627 200 00 0 00 000453 MOVE $DTOPR ;GET DTE # 785 030630 436 00 0 00 030670 ORM $$DTE0 ;INSERT IN DTE I/O INSTS 786 030631 436 00 0 00 030672 ORM $$DTE1 787 030632 436 00 0 00 030704 ORM $$DTE2 788 030633 436 00 0 00 030706 ORM $$DTE3 789 030634 476 00 0 00 030041 SETOM KLFLG ;SET KL10 CONTROL FLAG 790 030635 254 00 0 00 030712 JRST START 791 792 030636 200 00 0 00 035061 $SPEC: MOVE [JRST STARTA] ;SIMPLE RUN CONTROL 793 030637 202 00 0 00 030643 MOVEM $SPB1 794 030640 254 00 0 00 030712 JRST START DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 4 SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0026 795 ;SPECIAL "BEGEND" ROUTINE 796 797 030641 350 00 0 00 030047 $SPBEND:AOS PASCNT ;INCREMENT PASS COUNT 798 030642 370 00 0 00 030024 SOS ITRCNT ;DECREMENT ITERATION COUNT 799 030643 336 00 0 00 030037 $SPB1: SKIPN USER 800 030644 254 00 0 00 030652 JRST $SPBEX ;EXEC MODE 801 802 030645 332 00 0 00 030024 $SPBUS: SKIPE ITRCNT ;USER MODE, COMPLETED ? 803 030646 254 00 0 00 030741 JRST STARTA ;NO, KEEP RUNNING 804 030647 336 00 0 00 030044 SKIPN MONTEN ;DONE, LOADED BY "DIAMON" ? 805 030650 047 00 0 00 000012 EXIT ;NO, RETURN TO MONITOR 806 030651 254 00 1 00 030012 JRST @RETURN ;YES, RETURN TO "DIAMON" 807 808 030652 332 00 0 00 030041 $SPBEX: SKIPE KLFLG 809 030653 254 00 0 00 030660 JRST $SPBKL ;KL10 & EXEC 810 030654 7 004 14 0 00 030024 DATAO PI,ITRCNT ;KI10 & EXEC, DISPLAY ITER COUNT 811 030655 332 00 0 00 030024 SKIPE ITRCNT 812 030656 254 00 0 00 030741 JRST STARTA ;NOT COMPLETED YET 813 030657 254 00 1 00 030012 JRST @RETURN ;DONE 814 815 030660 336 00 0 00 030024 $SPBKL: SKIPN ITRCNT 816 030661 254 00 0 00 030676 JRST $SPKLD ;KL10, EXEC & COMPLETED 817 818 030662 335 00 0 00 030043 SKIPGE MONCTL 819 030663 254 00 0 00 030741 JRST STARTA ;"DIAMON" CONTROL 820 030664 201 00 0 00 000404 MOVEI 0,404 ;NOTIFY PDP-11 OF END OF PASS 821 030665 202 00 0 00 000451 MOVEM 0,$DTCMD 822 030666 402 00 0 00 000444 SETZM $DTFLG 823 030667 336 00 0 00 030516 SKIPN KLTYP 824 030670 7 200 20 0 00 020000 $$DTE0: CONO DTE,DONG11 825 030671 332 00 0 00 030516 SKIPE KLTYP 826 030672 7 200 20 0 00 010000 $$DTE1: CONO DTE,10000 827 030673 336 00 0 00 000444 SKIPN $DTFLG ;WAIT TILL 11 RESPONDS 828 030674 254 00 0 00 030673 JRST .-1 829 030675 254 00 0 00 030741 JRST STARTA ;KEEP RUNNING 830 831 ;SPECIAL KL10 COMPLETED ROUTINE 832 833 030676 332 00 0 00 030044 $SPKLD: SKIPE MONTEN 834 030677 254 00 1 00 030012 JRST @RETURN ;LOADED BY "DIAMON" 835 836 030700 201 00 0 00 000403 MOVEI 0,403 ;NOTIFY PDP-11 OF COMPLETION 837 030701 202 00 0 00 000451 MOVEM 0,$DTCMD 838 030702 402 00 0 00 000444 SETZM $DTFLG 839 030703 336 00 0 00 030516 SKIPN KLTYP 840 030704 7 200 20 0 00 020000 $$DTE2: CONO DTE,DONG11 841 030705 332 00 0 00 030516 SKIPE KLTYP 842 030706 7 200 20 0 00 010000 $$DTE3: CONO DTE,10000 843 030707 336 00 0 00 000444 SKIPN $DTFLG ;SHOULD NEVER HAPPEN 844 030710 254 00 0 00 030707 JRST .-1 ;11 NEVER RETURNS ON END OF PROGRAM 845 030711 254 04 0 00 030000 HALT BEGIN ;IF IT DOES, HALT. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 1 DAKAAM MAC 19-JAN-77 13:42 DIAGNOSTIC SECTION SEQ 0027 846 SUBTTL DIAGNOSTIC SECTION 847 848 030712 402 00 0 00 030037 START: SETZM USER# ;CLEAR USER CONTROL WORD 849 030713 265 00 0 00 030714 JSP 0,.+1 ;GET FLAGS 850 030714 603 00 0 00 010000 TLNE USERF ;IN USER MODE? 851 030715 476 00 0 00 030037 SETOM USER ;YES, SET USER CONTROL WORD 852 030716 336 00 0 00 030042 SKIPN MONFLG ;SPECIAL USER MODE? 853 030717 402 00 0 00 030037 SETZM USER ;YES, CLEAR USER CONTROL WORD 854 030720 336 00 0 00 030037 SKIPN USER 855 030721 254 00 0 00 030741 JRST STARTA 856 030722 331 00 0 00 030043 SKIPL MONCTL 857 030723 051 03 0 00 030725 TTCALL 3,PGMNAM ;MENTION OUR NAME 858 030724 254 00 0 00 030741 JRST STARTA 859 860 030725 PGMNAM: ASCIZ/ 861 030725 015 012 120 104 120 PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) [DAKAA] 862 030726 055 061 060 040 113 863 030727 101 061 060 040 102 864 030730 101 123 111 103 040 865 030731 111 116 123 124 122 866 030732 125 103 124 111 117 867 030733 116 040 104 111 101 868 030734 107 116 117 123 124 869 030735 111 103 040 050 061 870 030736 051 040 133 104 101 871 030737 113 101 101 135 015 872 030740 012 000 000 000 000 / 873 874 ;BASIC INSTRUCTION TEST (3) 875 ;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF 876 ;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES 877 ;IN THE FIELD. 878 879 880 030741 254 00 0 00 030742 STARTA: JRST .+1 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 2 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0028 881 SUBTTL TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS 882 883 ;NOTE: AN "*" IN THE COMMENT FIELD OF AN INSTRUCTION INDICATES THAT IT IS THE TESTED 884 ;INSTRUCTION. 885 ;********** 886 887 ;THIS TEST VERIFIES THAT SKIPA ALWAYS SKIPS THE NEXT INSTRUCTION 888 889 030742 A00=. 890 030742 334 00 0 00 000000 A12500: SKIPA ;*SKIPA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION 891 030743 254 04 0 00 000000 HALT ;IF PROGRAM HALTS, SKIPA DID NOT SKIP 892 893 ;IF PROGRAM HANGS UP ON SKIPA INSTRUCTION, CHECK AB PC EN [ABC], AB PC F/F [ABC], 894 ;AB PC B [ABC OR AB], AB PC (FETCH) EN [ABC], IR SKIPS [IR3], IR SKIPX [IR1], 895 ;IR 3XX [IR1], IR BITS 00 - 08 [IR1], F CYC ACT EN C [FI], FT6 F/F [F2], 896 ;PC CLOCK EN [PCC], ET2 J F/F [E], PC CLK (ET2) EN [PCC], ADZ COND P [ADZ] AND 897 ;ADZ COND R [ADZ], PC CLOCK A [PCC], PC CLOCK B [PCC] 898 899 ;IF PROGRAM HALTED ON HALT INSTRUCTION, CHECK ST1 COND [ST2] 900 901 ;********** 902 903 ;THIS TEST VERIFIES THAT JUMP NEVER JUMPS 904 905 030744 320 00 0 00 030745 A15000: JUMP .+1 ;*JUMP SHOULD NEVER JUMP 906 030745 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF JUMP IS SUCCESSFUL 907 030746 254 04 0 00 000000 HALT ;HALT IF JUMP FAILS 908 909 ;IF PROGRAM HANGS UP ON JUMP .+1 INSTRUCTION, THE JUMP INSTRUCTION 910 ;MAY HAVE FAILED. CHECK ST1 COND [ST2], ST INST FET ST1 EN [ST2], ET2 D F/F [E], 911 ;IR JUMPS [IR1], IR JUMPX [IR1] 912 913 ;********** 914 ;THIS TEST VERIFIES THAT JUMP NEVER JUMPS 915 916 030747 320 00 0 00 030751 A15100: JUMP .+2 ;*JUMP SHOULD NEVER JUMP 917 030750 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF JUMP IS SUCCESSFUL 918 030751 254 04 0 00 000000 HALT ;HALT IF JUMP FAILS 919 920 ;AB PC EN [ABC] 921 922 ;********** 923 924 ;THIS TEST VERIFIES THAT JUMPA .+1 ALWAYS JUMPS TO THE NEXT INSTRUCTION 925 926 030752 324 00 0 00 030753 A12700: JUMPA .+1 ;*JUMPA .+1 SHOULD NEVER JUMP 927 030753 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF JUMPA IS SUCCESSFUL 928 030754 254 04 0 00 000000 HALT ;HALT IF JUMPA .+1 FAILED 929 930 ;********** 931 932 ;THIS TEST VERIFIES THAT JUMPA JUMPS TO THE LOCATION SPECIFIED BY E WHEN E=.+2 933 934 030755 324 00 0 00 030757 A12600: JUMPA .+2 ;*JUMPA .+2 SHOULD ALWAYS SKIP THE NEXT INSTRUCTION 935 030756 254 04 0 00 000000 HALT ;PROGRAM HALTS HERE IF JUMPA .+2 FAILS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 2-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0029 936 937 ;ST1 COND [ST2] 938 939 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 3 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0030 940 ;THIS TEST VERIFIES THAT SKIPA IS DATA INDEPENDENT. HENCE, IT ALWAYS SKIPS THE NEXT 941 ;INSTRUCTION. 942 ;THE MOVE [0] INSTRUCTION IS USED TO TEST THE DATA INDEPENDENCE OF SKIPA. 943 944 030757 200 00 0 00 035062 A100: MOVE [0] ;PRESET LOCATION 0 TO ALL ZEROS 945 030760 334 00 0 00 000000 SKIPA ;*SKIPA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION 946 STOP^ 947 030761 254 04 0 00 030762 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 948 030762 324 00 0 00 030763 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 949 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 950 ;IN THE SUBTEST) TO LOOP ON ERROR^ 951 952 ;********** 953 ;THIS TEST INSURES THAT SKIPA IS DATA INDEPENDENT. HENCE, IT ALWAYS SKIPS THE NEXT 954 ;INSTRUCTION. 955 ;THE MOVE [-1] INSTRUCTION IS USED TO TEST THE DATA INDEPENDENCE OF SKIPA. 956 957 030763 200 00 0 00 035063 A200: MOVE [-1] ;PRESET LOCATION 0 TO ALL ONES 958 030764 334 00 0 00 000000 SKIPA ;*SKIPA SKOULD ALWAYS SKIP THE NEXT INSTRUCTION 959 STOP^ 960 030765 254 04 0 00 030766 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 961 030766 324 00 0 00 030767 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 962 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 963 ;IN THE SUBTEST) TO LOOP ON ERROR^ 964 965 ;COND P [ADZ] 966 967 ;********** 968 ;THIS TEST VERIFIES THAT SKIPGE SKIPS THE NEXT INSTRUCTION WHEN C(E) 969 ;IS ALL ZEROS. THE MOVE INSTRUCTION IS USED TO LOAD E WITH ALL ZEROS. 970 971 030767 200 00 0 00 035062 A300: MOVE [0] ;PRESET E TO ALL ZEROS 972 030770 335 00 0 00 000000 SKIPGE ;*SKIPGE SHOULD SKIP THE NEXT INSTRUCTION 973 STOP^ 974 030771 254 04 0 00 030772 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 975 030772 324 00 0 00 030773 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 976 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 977 ;IN THE SUBTEST) TO LOOP ON ERROR^ 978 979 ;COND R [ADZ], AD00 S-A-1, AD AR + EN [ADAP], AD LT AR + EN [ADAP], 980 ;AD RT AR + EN [ADAP], AD AR + EN C [ADAP], F CYC ACT EN A [F1] 981 982 ;********** 983 984 ;THIS TEST VERIFIES THAT SKIP IS DATA INDEPENDENT. HENCE, SKIP NEVER SKIPS. IT ALWAYS 985 ;CONTINUES ON TO THE NEXT INSTRUCTION. 986 987 030773 200 00 0 00 035063 A400: MOVE [-1] ;PRESET E TO ALL ONES 988 030774 330 00 0 00 000000 SKIP ;*SKIP SHOULD NEVER SKIP THE NEXT INSTRUCTION 989 030775 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES 990 STOP^ 991 030776 254 04 0 00 030777 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 992 030777 324 00 0 00 031000 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 993 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 994 ;IN THE SUBTEST) TO LOOP ON ERROR^ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 3-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0031 995 996 ;PC CHANGE [PCC], PC CHANGE A [PCC], SEE MEMORY CONTROL DWGS [MC1-4] 997 998 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 4 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0032 999 ;THIS TEST VERIFIES THAT SKIPGE WILL NOT SKIP THE NEXT INSTRUCTION WHEN C(E) IS 1000 ;NEGATIVE. THE MOVE INSTRUCTION LOADS E WITH -1, A NEGATIVE NUMBER. 1001 1002 031000 200 00 0 00 035063 A500: MOVE [-1] ;PRESET E WITH ALL ONES, A NEGATIVE NUMBER 1003 031001 335 00 0 00 000000 SKIPGE ;*SKIPGE SHOULD NOT SKIP THE NEXT INSTRUCTION 1004 031002 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES 1005 STOP^ 1006 031003 254 04 0 00 031004 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1007 031004 324 00 0 00 031005 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1008 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1009 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1010 1011 ;IF MOVE INSTRUCTION FAILED, CHECK MOVX-: FCE [F1], -IR XXXI [IR1], -IR XXXM [IR1], 1012 ;IR HWTFWT [IR3], IR FWT [IR2], IR2XX [IR1] 1013 1014 ;IF SKIPGE FAILED, CHECK SKIPX: FCE [F1] 1015 1016 ;********** 1017 1018 ;THIS TEST VERIFIES THAT SKIPN WILL NOT SKIP THE NEXT INSTRUCTION WHEN 1019 ;C(E) IS ZERO. THE MOVE INSTRUCTION LOADS E WITH ALL ZEROS. 1020 1021 031005 200 00 0 00 035062 A600: MOVE [0] ;PRESET E WITH ALL ZEROS 1022 031006 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD NOT SKIP THE NEXT INSTRUCTION 1023 031007 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES 1024 STOP^ 1025 031010 254 04 0 00 031011 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1026 031011 324 00 0 00 031012 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1027 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1028 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1029 1030 ;********** 1031 1032 ;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT SHOULD SKIP 1033 ;THE NEXT INSTRUCTION WHEN C(E) IS NON-ZERO. THE MOVE INSTRUCTION LOADS 1034 ;E WITH -1, A NON-ZERO NUMBER. 1035 1036 031012 200 00 0 00 035063 A700: MOVE [-1] ;PRESET E WITH ALL ONES, A NON-ZERO NUMBER 1037 031013 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1038 STOP^ 1039 031014 254 04 0 00 031015 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1040 031015 324 00 0 00 031016 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1041 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1042 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1043 1044 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 5 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0033 1045 ;THIS TEST VERIFIES THAT SKIPE IS DATA DEPENDENT. HENCE, IT SHOULD NOT 1046 ;SKIP THE NEXT INSTRUCTION WHEN C(E) IS NON-ZERO. THE MOVE INSTRUCTION LOADS E 1047 ;WITH -1, A NON-ZERO NUMBER. 1048 1049 031016 200 00 0 00 035063 A1000: MOVE [-1] ;PRESET E WITH ALL ONES, A NON-ZERO NUMBER 1050 031017 332 00 0 00 000000 SKIPE ;*SKIPE SHOULD NOT SKIP THE NEXT INSTRUCTION 1051 031020 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES 1052 STOP^ 1053 031021 254 04 0 00 031022 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1054 031022 324 00 0 00 031023 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1055 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1056 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1057 1058 ;********** 1059 1060 ;THIS TEST VERIFIES THAT SKIPE IS DATA DEPENDENT. HENCE, IT SHOULD SKIP 1061 ;THE NEXT INSTRUCTION WHEN C(E) IS ZERO. THE MOVE INSTRUCTION LOADS ALL 1062 ;ZEROS INTO E. 1063 1064 031023 200 00 0 00 035062 A1100: MOVE [0] ;PRESET E TO ALL ZEROS 1065 031024 332 00 0 00 000000 SKIPE ;*SKIPE SHOULD SKIP THE NEXT INSTRUCTION 1066 STOP^ 1067 031025 254 04 0 00 031026 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1068 031026 324 00 0 00 031027 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1069 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1070 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1071 1072 ;********** 1073 1074 ;THIS TEST VERIFIES THAT SKIP IS DATA INDEPENDENT. HENCE, IT NEVER SKIPS. IT ALWAYS 1075 ;CONTINUES ON TO THE NEXT INSTRUCTION. 1076 1077 031027 200 00 0 00 035062 A1200: MOVE [0] ;PRESET E TO ALL ZEROS 1078 031030 330 00 0 00 000000 SKIP ;*SKIP SHOULD NEVER SKIP THE NEXT INSTRUCTION 1079 031031 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES 1080 STOP^ 1081 031032 254 04 0 00 031033 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1082 031033 324 00 0 00 031034 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1083 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1084 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1085 1086 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 6 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0034 1087 ;THIS TEST VERIFIES THAT SKIPL IS DATA DEPENDENT. HENCE, IT WILL NOT SKIP THE NEXT 1088 ;INSTRUCTION WHEN C(E) IS NOT NEGATIVE. THE MOVE INSTRUCTION IS USED TO LOAD 1089 ;E WITH ALL ZEROS, A NON-NEGATIVE NUMBER. 1090 1091 031034 200 00 0 00 035062 A1300: MOVE [0] ;PRESET E T0 ZERO, A NON-NEGATIVE NUMBER 1092 031035 331 00 0 00 000000 SKIPL ;*SKIPL SHOULD NOT SKIP THE NEXT INSTRUCTION 1093 031036 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES 1094 STOP^ 1095 031037 254 04 0 00 031040 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1096 031040 324 00 0 00 031041 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1097 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1098 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1099 1100 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 7 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0035 1101 ;THIS TEST VERIFIES THAT SKIPL IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT 1102 ;INSTRUCTION WHEN C(E) IS NEGATIVE. THE MOVE INSTRUCTION IS USED TO LOAD E WITH -1, 1103 ;A NEGATIVE NUMBER. 1104 1105 031041 200 00 0 00 035063 A1400: MOVE [-1] ;PRESET E TO -1, A NEGATIVE NUMBER 1106 031042 331 00 0 00 000000 SKIPL ;*SKIPL SHOULD SKIP THE NEXT INSTRUCTION 1107 STOP^ 1108 031043 254 04 0 00 031044 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1109 031044 324 00 0 00 031045 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1110 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1111 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1112 1113 ;********** 1114 1115 ;THIS TEST VERIFIES THAT SKIPG IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT 1116 ;INSTRUCTION WHEN C(E) IS GREATER THAN ZERO. THE MOVE INSTRUCTION IS USED TO LOAD 1117 ;E WITH A NON-ZERO POSITIVE NUMBER. 1118 1119 031045 200 00 0 00 035064 A1500: MOVE [XWD 377777,-1] ;PRESET E TO 377777777777, A NON-ZERO POSITIVE NUMBER 1120 031046 337 00 0 00 000000 SKIPG ;*SKIPG SHOULD SKIP THE NEXT INSTRUCTION 1121 STOP^ 1122 031047 254 04 0 00 031050 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1123 031050 324 00 0 00 031051 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1124 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1125 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1126 1127 ;********** 1128 1129 ;THIS TEST VERIFIES THAT SKIPG IS DATA DEPENDENT. HENCE, IT WILL NOT SKIP THE NEXT 1130 ;INSTRUCTION WHEN C(E) IS NOT GREATER THAN ZERO. THE MOVE INSTRUCTION IS USED TO 1131 ;LOAD E WITH -1, A NUMBER NOT GREATER THAN ZERO. 1132 1133 031051 200 00 0 00 035063 A1600: MOVE [-1] ;PRESET E TO -1, A NEGATIVE NUMBER 1134 031052 337 00 0 00 000000 SKIPG ;*SKIPG SHOULD NOT SKIP THE NEXT INSTRUCTION 1135 031053 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES 1136 STOP^ 1137 031054 254 04 0 00 031055 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1138 031055 324 00 0 00 031056 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1139 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1140 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1141 1142 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 8 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0036 1143 ;THIS TEST VERIFIES THAT SKIPL IS DATA DEPENDENT. HENCE, IT WILL NOT SKIP THE NEXT 1144 ;INSTRUCTION WHEN C(E) IS NON-NEGATIVE. THE MOVE INSTRUCTION IS USED TO LOAD E WITH 1145 ;377777777777, A NON-NEGATIVE NUMBER. 1146 1147 031056 200 00 0 00 035064 A1700: MOVE [XWD 377777,-1] ;PRESET E TO 377777777777, A NON-NEGATIVE NUMBER 1148 031057 331 00 0 00 000000 SKIPL ;*SKIPL SHOULD NOT SKIP THE NEXT INSTRUCTION 1149 031060 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES 1150 STOP^ 1151 031061 254 04 0 00 031062 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1152 031062 324 00 0 00 031063 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1153 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1154 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1155 1156 ;********** 1157 1158 ;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT 1159 ;INSTRUCTION WHEN C(E) IS ZERO. THE MOVE INSTRUCTION LOADS E WITH ALL ZEROS. 1160 1161 031063 200 00 0 00 035062 A2000: MOVE [0] ;PRESET E TO ALL ZEROS 1162 031064 333 00 0 00 000000 SKIPLE ;*SKIPLE SHOULD SKIP THE NEXT INSTRUCTION 1163 STOP^ 1164 031065 254 04 0 00 031066 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1165 031066 324 00 0 00 031067 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1166 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1167 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1168 1169 ;********** 1170 1171 ;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT 1172 ;INSTRUCTION WHEN E CONTAINS A NEGATIVE NUMBER. THE MOVE INSTRUCTION IS USED TO LOAD 1173 ;E WITH 400000000000, A NEGATIVE NUMBER. 1174 1175 031067 200 00 0 00 035065 A2100: MOVE [XWD 400000,0] ;PRESET E TO 400000000000, A NEGATIVE NUMBER. 1176 031070 333 00 0 00 000000 SKIPLE ;*SKIPLE SHOULD SKIP THE NEXT INSTRUCTION 1177 STOP^ 1178 031071 254 04 0 00 031072 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1179 031072 324 00 0 00 031073 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1180 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1181 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1182 1183 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 9 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0037 1184 ;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT. HENCE, IT WILL NOT SKIP THE NEXT 1185 ;INSTRUCTION WHEN E CONTAINS A POSITIVE NUMBER. THE MOVE INSTRUCTION LOADS 1186 ;E WITH 377777777777, A POSITIVE NUMBER. 1187 1188 031073 200 00 0 00 035064 A2200: MOVE [XWD 377777,-1] ;PRESET E TO 377777777777, A POSITIVE NUMBER 1189 031074 333 00 0 00 000000 SKIPLE ;*SKIPLE SHOULD NOT SKIP THE NEXT INSTRUCTION 1190 031075 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF TEST PASSES 1191 STOP^ 1192 031076 254 04 0 00 031077 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1193 031077 324 00 0 00 031100 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1194 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1195 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1196 1197 ;********* DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 10 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0038 1198 ;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT 1199 ;INSTRUCTION ;WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO 1200 ;LOAD 777000000000, A NON-ZERO NUMBER INTO E. 1201 1202 031100 200 00 0 00 035066 A2300: MOVE [XWD 777000,0] ;PRESET E WITH 777000000000, A NON-ZERO NUMBER 1203 031101 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1204 STOP^ 1205 031102 254 04 0 00 031103 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1206 031103 324 00 0 00 031104 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1207 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1208 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1209 1210 ;********** 1211 1212 ;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT 1213 ;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO 1214 ;LOAD A NON-ZERO NUMBER, 377000000 INTO E. 1215 1216 031104 200 00 0 00 035067 A2400: MOVE [XWD 377,0] ;PRESET E TO 377000000, A NON ZERO NUMBER 1217 031105 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1218 STOP^ 1219 031106 254 04 0 00 031107 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1220 031107 324 00 0 00 031110 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1221 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1222 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1223 1224 ;********** 1225 1226 ;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT 1227 ;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO 1228 ;LOAD E WITH A NON-ZERO NUMBER, 177000. 1229 1230 031110 200 00 0 00 035070 A2500: MOVE [177000] ;PRESET E WITH 177000, A NON ZERO NUMBER 1231 031111 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1232 STOP^ 1233 031112 254 04 0 00 031113 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1234 031113 324 00 0 00 031114 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1235 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1236 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1237 1238 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 11 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0039 1239 ;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT 1240 ;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO 1241 ;LOAD 777, A NON-ZERO NUMBER INTO E. 1242 1243 031114 200 00 0 00 035071 A2600: MOVE [777] ;PRESET E WITH 777, A NON-ZERO NUMBER 1244 031115 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1245 STOP^ 1246 031116 254 04 0 00 031117 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1247 031117 324 00 0 00 031120 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1248 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1249 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1250 1251 ;********** 1252 1253 ;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT 1254 ;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO 1255 ;LOAD E WITH 600000, A NON-ZERO NUMBER. 1256 1257 031120 200 00 0 00 035072 A2700: MOVE [600000] ;PRESET E WITK 600000, A NON-ZERO NUMBER 1258 031121 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1259 STOP^ 1260 031122 254 04 0 00 031123 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1261 031123 324 00 0 00 031124 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1262 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1263 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1264 1265 ;********** 1266 1267 ;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT. HENCE, IT WILL SKIP THE NEXT 1268 ;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER. THE MOVE INSTRUCTION IS USED TO 1269 ;LOAD E WITH 400000000, A NON-ZERO NUMBER. 1270 1271 031124 200 00 0 00 035073 A3000: MOVE [XWD 400,000] ;PRESET E WITH 400000000, A NON-ZERO NUMBER 1272 031125 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1273 STOP^ 1274 031126 254 04 0 00 031127 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1275 031127 324 00 0 00 031130 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1276 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1277 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1278 1279 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0040 1280 003100 SN=3100 1281 000000 ZZ=0 1282 1283 A3100: REPEAT ^D36, 1284 <;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1285 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1286 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1287 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1288 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1289 1290 SN=SN+1 1291 ZZ=ZZ+ZZ 1292 IFE ZZ, 1293 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1294 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1295 STOP 1296 1297 ;********** 1298 > 1299 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1300 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1301 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1302 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1303 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1304 1305 003101 SN=SN+1 1306 000000 ZZ=ZZ+ZZ 1307 000001 IFE ZZ, 1308 031130 200 00 0 00 035074 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1309 031131 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1310 STOP^ 1311 031132 254 04 0 00 031133 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1312 031133 324 00 0 00 031134 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1313 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1314 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1315 1316 ;********** 1317 1318 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1319 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1320 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1321 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1322 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1323 1324 003102 SN=SN+1 1325 000002 ZZ=ZZ+ZZ 1326 IFE ZZ, 1327 031134 200 00 0 00 035075 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1328 031135 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1329 STOP^ 1330 031136 254 04 0 00 031137 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1331 031137 324 00 0 00 031140 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1332 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1333 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1334 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0041 1335 ;********** 1336 1337 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1338 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1339 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1340 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1341 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1342 1343 003103 SN=SN+1 1344 000004 ZZ=ZZ+ZZ 1345 IFE ZZ, 1346 031140 200 00 0 00 035076 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1347 031141 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1348 STOP^ 1349 031142 254 04 0 00 031143 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1350 031143 324 00 0 00 031144 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1351 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1352 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1353 1354 ;********** 1355 1356 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1357 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1358 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1359 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1360 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1361 1362 003104 SN=SN+1 1363 000010 ZZ=ZZ+ZZ 1364 IFE ZZ, 1365 031144 200 00 0 00 035077 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1366 031145 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1367 STOP^ 1368 031146 254 04 0 00 031147 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1369 031147 324 00 0 00 031150 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1370 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1371 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1372 1373 ;********** 1374 1375 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1376 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1377 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1378 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1379 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1380 1381 003105 SN=SN+1 1382 000020 ZZ=ZZ+ZZ 1383 IFE ZZ, 1384 031150 200 00 0 00 035100 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1385 031151 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1386 STOP^ 1387 031152 254 04 0 00 031153 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1388 031153 324 00 0 00 031154 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1389 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-2 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0042 1390 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1391 1392 ;********** 1393 1394 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1395 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1396 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1397 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1398 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1399 1400 003106 SN=SN+1 1401 000040 ZZ=ZZ+ZZ 1402 IFE ZZ, 1403 031154 200 00 0 00 035101 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1404 031155 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1405 STOP^ 1406 031156 254 04 0 00 031157 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1407 031157 324 00 0 00 031160 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1408 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1409 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1410 1411 ;********** 1412 1413 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1414 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1415 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1416 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1417 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1418 1419 003107 SN=SN+1 1420 000100 ZZ=ZZ+ZZ 1421 IFE ZZ, 1422 031160 200 00 0 00 035102 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1423 031161 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1424 STOP^ 1425 031162 254 04 0 00 031163 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1426 031163 324 00 0 00 031164 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1427 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1428 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1429 1430 ;********** 1431 1432 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1433 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1434 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1435 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1436 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1437 1438 003110 SN=SN+1 1439 000200 ZZ=ZZ+ZZ 1440 IFE ZZ, 1441 031164 200 00 0 00 035103 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1442 031165 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1443 STOP^ 1444 031166 254 04 0 00 031167 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-3 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0043 1445 031167 324 00 0 00 031170 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1446 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1447 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1448 1449 ;********** 1450 1451 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1452 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1453 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1454 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1455 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1456 1457 003111 SN=SN+1 1458 000400 ZZ=ZZ+ZZ 1459 IFE ZZ, 1460 031170 200 00 0 00 035104 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1461 031171 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1462 STOP^ 1463 031172 254 04 0 00 031173 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1464 031173 324 00 0 00 031174 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1465 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1466 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1467 1468 ;********** 1469 1470 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1471 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1472 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1473 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1474 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1475 1476 003112 SN=SN+1 1477 001000 ZZ=ZZ+ZZ 1478 IFE ZZ, 1479 031174 200 00 0 00 035105 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1480 031175 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1481 STOP^ 1482 031176 254 04 0 00 031177 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1483 031177 324 00 0 00 031200 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1484 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1485 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1486 1487 ;********** 1488 1489 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1490 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1491 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1492 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1493 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1494 1495 003113 SN=SN+1 1496 002000 ZZ=ZZ+ZZ 1497 IFE ZZ, 1498 031200 200 00 0 00 035106 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1499 031201 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-4 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0044 1500 STOP^ 1501 031202 254 04 0 00 031203 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1502 031203 324 00 0 00 031204 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1503 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1504 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1505 1506 ;********** 1507 1508 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1509 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1510 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1511 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1512 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1513 1514 003114 SN=SN+1 1515 004000 ZZ=ZZ+ZZ 1516 IFE ZZ, 1517 031204 200 00 0 00 035107 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1518 031205 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1519 STOP^ 1520 031206 254 04 0 00 031207 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1521 031207 324 00 0 00 031210 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1522 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1523 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1524 1525 ;********** 1526 1527 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1528 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1529 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1530 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1531 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1532 1533 003115 SN=SN+1 1534 010000 ZZ=ZZ+ZZ 1535 IFE ZZ, 1536 031210 200 00 0 00 035110 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1537 031211 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1538 STOP^ 1539 031212 254 04 0 00 031213 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1540 031213 324 00 0 00 031214 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1541 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1542 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1543 1544 ;********** 1545 1546 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1547 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1548 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1549 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1550 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1551 1552 003116 SN=SN+1 1553 020000 ZZ=ZZ+ZZ 1554 IFE ZZ, DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-5 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0045 1555 031214 200 00 0 00 035111 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1556 031215 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1557 STOP^ 1558 031216 254 04 0 00 031217 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1559 031217 324 00 0 00 031220 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1560 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1561 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1562 1563 ;********** 1564 1565 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1566 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1567 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1568 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1569 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1570 1571 003117 SN=SN+1 1572 040000 ZZ=ZZ+ZZ 1573 IFE ZZ, 1574 031220 200 00 0 00 035112 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1575 031221 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1576 STOP^ 1577 031222 254 04 0 00 031223 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1578 031223 324 00 0 00 031224 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1579 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1580 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1581 1582 ;********** 1583 1584 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1585 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1586 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1587 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1588 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1589 1590 003120 SN=SN+1 1591 100000 ZZ=ZZ+ZZ 1592 IFE ZZ, 1593 031224 200 00 0 00 035113 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1594 031225 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1595 STOP^ 1596 031226 254 04 0 00 031227 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1597 031227 324 00 0 00 031230 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1598 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1599 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1600 1601 ;********** 1602 1603 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1604 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1605 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1606 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1607 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1608 1609 003121 SN=SN+1 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-6 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0046 1610 200000 ZZ=ZZ+ZZ 1611 IFE ZZ, 1612 031230 200 00 0 00 035114 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1613 031231 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1614 STOP^ 1615 031232 254 04 0 00 031233 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1616 031233 324 00 0 00 031234 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1617 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1618 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1619 1620 ;********** 1621 1622 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1623 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1624 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1625 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1626 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1627 1628 003122 SN=SN+1 1629 400000 ZZ=ZZ+ZZ 1630 IFE ZZ, 1631 031234 200 00 0 00 035115 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1632 031235 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1633 STOP^ 1634 031236 254 04 0 00 031237 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1635 031237 324 00 0 00 031240 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1636 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1637 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1638 1639 ;********** 1640 1641 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1642 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1643 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1644 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1645 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1646 1647 003123 SN=SN+1 1648 000001 000000 ZZ=ZZ+ZZ 1649 IFE ZZ, 1650 031240 200 00 0 00 035116 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1651 031241 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1652 STOP^ 1653 031242 254 04 0 00 031243 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1654 031243 324 00 0 00 031244 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1655 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1656 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1657 1658 ;********** 1659 1660 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1661 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1662 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1663 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1664 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-7 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0047 1665 1666 003124 SN=SN+1 1667 000002 000000 ZZ=ZZ+ZZ 1668 IFE ZZ, 1669 031244 200 00 0 00 035117 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1670 031245 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1671 STOP^ 1672 031246 254 04 0 00 031247 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1673 031247 324 00 0 00 031250 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1674 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1675 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1676 1677 ;********** 1678 1679 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1680 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1681 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1682 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1683 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1684 1685 003125 SN=SN+1 1686 000004 000000 ZZ=ZZ+ZZ 1687 IFE ZZ, 1688 031250 200 00 0 00 035120 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1689 031251 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1690 STOP^ 1691 031252 254 04 0 00 031253 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1692 031253 324 00 0 00 031254 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1693 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1694 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1695 1696 ;********** 1697 1698 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1699 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1700 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1701 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1702 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1703 1704 003126 SN=SN+1 1705 000010 000000 ZZ=ZZ+ZZ 1706 IFE ZZ, 1707 031254 200 00 0 00 035121 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1708 031255 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1709 STOP^ 1710 031256 254 04 0 00 031257 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1711 031257 324 00 0 00 031260 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1712 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1713 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1714 1715 ;********** 1716 1717 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1718 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1719 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-8 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0048 1720 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1721 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1722 1723 003127 SN=SN+1 1724 000020 000000 ZZ=ZZ+ZZ 1725 IFE ZZ, 1726 031260 200 00 0 00 035122 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1727 031261 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1728 STOP^ 1729 031262 254 04 0 00 031263 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1730 031263 324 00 0 00 031264 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1731 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1732 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1733 1734 ;********** 1735 1736 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1737 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1738 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1739 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1740 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1741 1742 003130 SN=SN+1 1743 000040 000000 ZZ=ZZ+ZZ 1744 IFE ZZ, 1745 031264 200 00 0 00 035123 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1746 031265 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1747 STOP^ 1748 031266 254 04 0 00 031267 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1749 031267 324 00 0 00 031270 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1750 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1751 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1752 1753 ;********** 1754 1755 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1756 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1757 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1758 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1759 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1760 1761 003131 SN=SN+1 1762 000100 000000 ZZ=ZZ+ZZ 1763 IFE ZZ, 1764 031270 200 00 0 00 035124 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1765 031271 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1766 STOP^ 1767 031272 254 04 0 00 031273 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1768 031273 324 00 0 00 031274 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1769 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1770 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1771 1772 ;********** 1773 1774 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-9 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0049 1775 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1776 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1777 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1778 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1779 1780 003132 SN=SN+1 1781 000200 000000 ZZ=ZZ+ZZ 1782 IFE ZZ, 1783 031274 200 00 0 00 035125 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1784 031275 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1785 STOP^ 1786 031276 254 04 0 00 031277 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1787 031277 324 00 0 00 031300 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1788 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1789 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1790 1791 ;********** 1792 1793 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1794 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1795 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1796 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1797 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1798 1799 003133 SN=SN+1 1800 000400 000000 ZZ=ZZ+ZZ 1801 IFE ZZ, 1802 031300 200 00 0 00 035073 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1803 031301 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1804 STOP^ 1805 031302 254 04 0 00 031303 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1806 031303 324 00 0 00 031304 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1807 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1808 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1809 1810 ;********** 1811 1812 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1813 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1814 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1815 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1816 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1817 1818 003134 SN=SN+1 1819 001000 000000 ZZ=ZZ+ZZ 1820 IFE ZZ, 1821 031304 200 00 0 00 035126 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1822 031305 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1823 STOP^ 1824 031306 254 04 0 00 031307 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1825 031307 324 00 0 00 031310 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1826 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1827 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1828 1829 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-10 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0050 1830 1831 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1832 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1833 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1834 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1835 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1836 1837 003135 SN=SN+1 1838 002000 000000 ZZ=ZZ+ZZ 1839 IFE ZZ, 1840 031310 200 00 0 00 035127 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1841 031311 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1842 STOP^ 1843 031312 254 04 0 00 031313 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1844 031313 324 00 0 00 031314 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1845 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1846 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1847 1848 ;********** 1849 1850 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1851 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1852 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1853 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1854 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1855 1856 003136 SN=SN+1 1857 004000 000000 ZZ=ZZ+ZZ 1858 IFE ZZ, 1859 031314 200 00 0 00 035130 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1860 031315 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1861 STOP^ 1862 031316 254 04 0 00 031317 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1863 031317 324 00 0 00 031320 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1864 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1865 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1866 1867 ;********** 1868 1869 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1870 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1871 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1872 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1873 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1874 1875 003137 SN=SN+1 1876 010000 000000 ZZ=ZZ+ZZ 1877 IFE ZZ, 1878 031320 200 00 0 00 035131 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1879 031321 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1880 STOP^ 1881 031322 254 04 0 00 031323 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1882 031323 324 00 0 00 031324 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1883 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1884 ;IN THE SUBTEST) TO LOOP ON ERROR^ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-11 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0051 1885 1886 ;********** 1887 1888 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1889 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1890 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1891 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1892 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1893 1894 003140 SN=SN+1 1895 020000 000000 ZZ=ZZ+ZZ 1896 IFE ZZ, 1897 031324 200 00 0 00 035132 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1898 031325 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1899 STOP^ 1900 031326 254 04 0 00 031327 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1901 031327 324 00 0 00 031330 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1902 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1903 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1904 1905 ;********** 1906 1907 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1908 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1909 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1910 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1911 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1912 1913 003141 SN=SN+1 1914 040000 000000 ZZ=ZZ+ZZ 1915 IFE ZZ, 1916 031330 200 00 0 00 035133 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1917 031331 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1918 STOP^ 1919 031332 254 04 0 00 031333 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1920 031333 324 00 0 00 031334 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1921 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1922 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1923 1924 ;********** 1925 1926 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1927 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1928 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1929 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1930 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1931 1932 003142 SN=SN+1 1933 100000 000000 ZZ=ZZ+ZZ 1934 IFE ZZ, 1935 031334 200 00 0 00 035134 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1936 031335 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1937 STOP^ 1938 031336 254 04 0 00 031337 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1939 031337 324 00 0 00 031340 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 12-12 DAKAAM MAC 19-JAN-77 13:42 TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS SEQ 0052 1940 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1941 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1942 1943 ;********** 1944 1945 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1946 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1947 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1948 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1949 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1950 1951 003143 SN=SN+1 1952 200000 000000 ZZ=ZZ+ZZ 1953 IFE ZZ, 1954 031340 200 00 0 00 035135 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1955 031341 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1956 STOP^ 1957 031342 254 04 0 00 031343 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1958 031343 324 00 0 00 031344 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1959 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1960 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1961 1962 ;********** 1963 1964 ;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION. THIS TEST 1965 ;IS REPEATED 36 TIMES. EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE 1966 ;BIT POSITION IS MOVED INTO E. THEN SKIPN IS EXECUTED. THIS TEST ALSO 1967 ;CHECKS ADDER GATING. IF THIS TEST FAILS, CHECK C(E). 1968 ;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED. 1969 1970 003144 SN=SN+1 1971 400000 000000 ZZ=ZZ+ZZ 1972 IFE ZZ, 1973 031344 200 00 0 00 035065 MOVE [ZZ] ;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO 1974 031345 336 00 0 00 000000 SKIPN ;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION 1975 STOP^ 1976 031346 254 04 0 00 031347 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1977 031347 324 00 0 00 031350 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1978 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1979 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1980 1981 ;********** 1982 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 13 DAKAAM MAC 19-JAN-77 13:42 TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS SEQ 0053 1983 SUBTTL TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS 1984 1985 ;THIS TEST VERIFIES THAT MOVEI LOADS E INTO THE AC. SKIPG IS USED TO CHECK THAT 1986 ;THE AC WAS INDEED MODIFIED BY MOVEI. 1987 1988 031350 201 00 0 00 035063 A3200: MOVEI [-1] ;*MOVEI SHOULD LOAD A POSITIVE NUMBER INTO AC0 1989 031351 337 00 0 00 000000 SKIPG ;SKIP HALT INSTRUCTION IF MOVEI LOADED AC CORRECTLY 1990 STOP^ 1991 031352 254 04 0 00 031353 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 1992 031353 324 00 0 00 031354 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 1993 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 1994 ;IN THE SUBTEST) TO LOOP ON ERROR^ 1995 1996 ;IF PROGRAM HANGS UP ON MOVEI INSTRUCTION, CHECK AD FM +EN [ADFP], AD FM + EN A [ADFP], 1997 ;AD FM + F/F [ADFP], F CYC ACT EN C [F1] 1998 1999 ;********** 2000 2001 ;THIS TEST VERIFIES THAT SKIPL IS SENSITIVE TO THE DATA IN E AND NOT SENSITIVE TO 2002 ;THE DATA IN THE AC. HENCE, SKIPL WILL SKIP THE NEXT INSTRUCTION ONLY IF 2003 ;C(E) IS LESS THAN ZERO. E IS SET TO -1, A NEGATIVE NUMBER; AND 2004 ;THE AC IS SET TO 0 IN THIS TEST. THEREFORE SKIPL SHOULD SKIP. 2005 2006 031354 200 00 0 00 035062 A3300: MOVE [0] ;SET THE AC TO ALL ZEROS 2007 031355 331 00 0 00 035063 SKIPL [-1] ;*SKIPL SHOULD SKIP BECAUSE C(E) IS NEGATIVE 2008 STOP^ 2009 031356 254 04 0 00 031357 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2010 031357 324 00 0 00 031360 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2011 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2012 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2013 2014 ;********** 2015 2016 ;THIS TEST VERIFIES THAT SKIPL IS SENSITIVE TO THE SIGN BIT IN E. SKIPL SHOULD 2017 ;SKIP THE NEXT INSTRUCTION WHEN AND ONLY WHEN THE SIGN BIT IS SET. IN THIS 2018 ;TEST, C(AC) IS PRESET TO ALL ZEROS, THEN SKIPL IS EXECUTED WITH C(E)=400000,,0. 2019 ;A FAILURE UCCURS IF SKIPL DOES NOT SKIP. 2020 2021 031360 200 00 0 00 035062 A13100: MOVE [0] ;SET THE AC TO ALL ZEROS 2022 031361 331 00 0 00 035065 SKIPL [400000,,0] ;*SKIPL SHOULD SKIP BECAUSE C(E) IS NEGATIVE 2023 STOP^ 2024 031362 254 04 0 00 031363 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2025 031363 324 00 0 00 031364 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2026 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2027 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2028 2029 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 14 DAKAAM MAC 19-JAN-77 13:42 TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS SEQ 0054 2030 ;THIS TEST VERIFIES THAT THE CAM INSTRUCTION DOES NOT MODIFY C(AC). THE AC IS 2031 ;INITIALLY LOADED WITH ALL ZEROS; THEN CAM IS EXECUTED WITH C(E) NON-ZERO. 2032 ;THE AC IS THEN CHECKED FOR ALL ZEROS. THIS TEST FAILS IF THE AC WAS MODIFIED BY CAM. 2033 2034 031364 200 00 0 00 035062 A3400: MOVE [0] ;PRESET THE AC TO ALL ZEROS 2035 031365 310 00 0 00 035136 CAM [1234] ;*CAM SHOULD NOT MODIFY THE AC 2036 031366 200 00 0 00 000000 MOVE ;MOVE C(0) INTO 0 (THIS INSTRUCTION SERVES AS A NO-OP. 2037 ;IT IS A PROGRAM FILLER IN CASE CAM SKIPS.) 2038 031367 332 00 0 00 000000 SKIPE ;SKIP HALT INSTRUCTION IF AC WAS NOT MODIFIED BY CAM 2039 STOP^ 2040 031370 254 04 0 00 031371 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2041 031371 324 00 0 00 031372 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2042 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2043 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2044 2045 ;IF TEST HANGS ON CAM INSTRUCTION, AB PC EN [ABC], AB PC (FETCH) EN [ABC], 2046 ;IR CAXX [IR3] 2047 2048 ;IF TEST LOOPS ON CAM INSTRUCTION, MC INSTR FETCH EN [MC1], MC INST FET ET2 EN [MC1], 2049 ;ET2 J F/F [E], IR CAXX [IR3] 2050 2051 ;IF TEST HALTS AT HALT INSTRUCTION, SAC INH [ST2], IR CAXX [IR3], IR CAMX [IR1] 2052 2053 ;********** 2054 2055 ;THIS TEST VERIFIES THAT THE CAI INSTRUCTION DOES NOT MODIFY C(AC). THE AC IS 2056 ;INITIALLY LOADED WITH ALL ZEROS; THEN CAI IS EXECUTED WITH E NON-ZERO. THE AC IS 2057 ;THEN CHECKED FOR ALL ZEROS. THIS TEST FAILS IF THE AC WAS MODIFIED BY CAM. 2058 2059 031372 200 00 0 00 035062 A3500: MOVE [0] ;PRESET THE AC TO ALL ZEROS 2060 031373 300 00 0 00 035136 CAI [1234] ;*CAI SHOULD NOT MODIFY THE AC 2061 031374 200 00 0 00 000000 MOVE ;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A PROGRAM FILLER 2062 ;IN CASE CAI MODIFIES THE AC. IT SERVES AS A NO-OP) 2063 031375 332 00 0 00 000000 SKIPE ;SKIP HALT INSTRUCTION IF CAI DID NOT MODIFY THE AC 2064 STOP^ 2065 031376 254 04 0 00 031377 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2066 031377 324 00 0 00 031400 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2067 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2068 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2069 2070 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 15 DAKAAM MAC 19-JAN-77 13:42 TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS SEQ 0055 2071 ;THIS TEST VERIFIES THAT CAI DOES NOT MODIFY C(AC0) WHEN AN AC OTHER THAN AC0 IS 2072 ;SPECIFIED BY THE CAI INSTRUCTION. 2073 ;THIS IS THE FIRST TEST THAT USES AN AC OTHER THAN AC0. 2074 ;FIRST, AC0 IS LOADED WITH ALL ZEROS; THEN, THE CAI INSTRUCTION IS EXECUTED WITH 2075 ;A NON-ZERO E. AC 0 IS THEN TESTED F0R ALL ZEROS. 2076 2077 031400 200 00 0 00 035062 A3600: MOVE [0] ;LOAD AC0 WITH ALL ZEROS 2078 031401 300 17 0 00 035136 CAI 17,[1234] ;*CAI SHOULD NOT MODIFY AC0 2079 031402 200 00 0 00 000000 MOVE ;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE 2080 ;CAI SKIPS THE NEXT INSTRUCTION. IT ACTS AS A NO-OP) 2081 031403 332 00 0 00 000000 SKIPE ;SKIP HALT INSTRUCTION IF C(AC0) WAS NOT MODIFIED 2082 STOP^ 2083 031404 254 04 0 00 031405 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2084 031405 324 00 0 00 031406 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2085 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2086 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2087 2088 ;********** 2089 2090 ;THIS TEST VERIFIES THAT CAM DOES NOT MODIFY C(AC0) WHEN AN AC OTHER THAN AC0 IS 2091 ;SPECIFIED BY THE CAM INSTRUCTION. 2092 ;FIRST, AC0 IS LOADED WITH ALL ZEROS; THEN, THE CAM INSTRUCTION IS EXECUTED WITH 2093 ;A NON-ZERO E. AC 0 IS THEN TESTED F0R ALL ZEROS. 2094 2095 031406 200 00 0 00 035062 A3700: MOVE [0] ;PRESET C(AC0) TO ALL ZEROS 2096 031407 310 17 0 00 035136 CAM 17,[1234] ;*CAM SHOULD NOT MODIFY AC0 2097 031410 200 00 0 00 000000 MOVE ;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE 2098 ;CAM SKIPS THE NEXT INSTRUCTION. IT SERVES AS A NO-OP) 2099 031411 332 00 0 00 000000 SKIPE ;SKIP HALT INSTRUCTION IF AC0 WAS NOT MODIFIED BY CAM 2100 STOP^ 2101 031412 254 04 0 00 031413 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2102 031413 324 00 0 00 031414 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2103 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2104 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2105 2106 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 16 DAKAAM MAC 19-JAN-77 13:42 TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS SEQ 0056 2107 ;THIS TEST VERIFIES THAT MOVE WILL PLACE C(E) INTO THE AC. AC, E AND C(E) ARE NON-ZERO 2108 ;IN THIS TEST. THIS TEST PASSES IF FINAL C(AC) OF THE MOVE INSTRUCTION IS NON-ZERO. 2109 2110 031414 200 01 0 00 035062 A4500: MOVE 1,[0] ;LOAD THE AC WITH ALL ZEROS 2111 031415 200 01 0 00 035063 MOVE 1,[-1] ;*MOVE SHOULD PLACE ALL ONES IN THE AC 2112 031416 336 00 0 00 000001 SKIPN 1 ;SKIP HALT INSTRUCTION IF MOVE MODIFIED THE AC 2113 STOP^ 2114 031417 254 04 0 00 031420 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2115 031420 324 00 0 00 031421 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2116 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2117 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2118 2119 ;********** 2120 2121 ;THIS TEST VERIFIES THAT THE MOVE INSTRUCTION WILL PLACE C(E) INTO THE AC. 2122 ;AC, E ARE NON-ZERO AND C(E)=0. 2123 ;THIS TEST FAILS IF THE FINAL C(AC) IS NOT EQUAL TO ZERO, THE ORIGINAL C(E) 2124 2125 031421 200 01 0 00 035062 A4600: MOVE 1,[0] ;*PLACE ALL ZEROS INTO THE AC 2126 031422 332 00 0 00 000001 SKIPE 1 ;SKIP HALT INSTRUCTION IF MOVE PLACED ALL ZEROS INTO AC 2127 STOP^ 2128 031423 254 04 0 00 031424 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2129 031424 324 00 0 00 031425 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2130 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2131 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2132 2133 ;IF JUMP .+1 OF PREVIOUS TEST FAILED, CHECK JUMPS: AD FM + EN [ADFP], IR JUMPS [IR1], 2134 ;IR JUMPX [IR1], AR AD EN [ARMA], AR AD EN A [ARMA], AR LT AD EN A [ARMA], 2135 ;AR LT ADD EN B [ARMA], AR RT AD EN A [ARMA], 2136 ;AR RT AD EN B [ARMA], AR A CLK INPUT [ARMA], 2137 ;ET2 C F/F [E], AR AD ET2 EN [ARMA], AR AD BR (ET2) B [ARMA] 2138 2139 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 17 DAKAAM MAC 19-JAN-77 13:42 TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS SEQ 0057 2140 ;THIS TEST VERIFIES THAT SOS DOES NOT MODIFY C(AC) WHEN THE AC IS AC0. 2141 ;FIRST, AC0 IS LOADED WITH ALL ZEROS AND E IS LOADED WITH A POSITIVE NUMBER; 2142 ;THEN, SOS IS EXECUTED. SOS SHOULD SUBTRACT ONE FROM C((E) 2143 ;AND EXECUTE THE NEXT INSTRUCTION. IT SHOULD NOT MODIFY AC0. 2144 ;THE TEST PASSES IF AC0 WAS NOT MODIFIED. 2145 2146 031425 200 00 0 00 035062 A4000: MOVE [0] ;PRESET AC0 TO ALL ZEROS 2147 031426 200 07 0 00 035136 MOVE 7,[1234] ;PRESET E WITH A POSITIVE NUMBER 2148 031427 370 00 0 00 000007 SOS 7 ;*SOS SHOULD NOT MODIFY C(AC0) 2149 031430 200 00 0 00 000000 MOVE ;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE 2150 ;SOS SKIPS THE NEXT INSTRUCTION. IT SERVES AS A NO-OP) 2151 031431 332 00 0 00 000000 SKIPE ;SKIP THE HALT INSTRUCTION IF C(AC0) WAS NOT MODIFIED 2152 STOP^ 2153 031432 254 04 0 00 031433 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2154 031433 324 00 0 00 031434 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2155 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2156 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2157 2158 ;********** 2159 004100 SN=4100 2160 000000 AC=0 2161 2162 A4100: REPEAT 4, 2163 <;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC 2164 ;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10. 2165 ;FIRST, THE AC IS LOADED WITH ALL ZEROS; THEN, THE SKIP INSTRUCTION IS EXECUTED 2166 ;WITH AC1, AC2, AC4 OR AC10. C(E) IS EQUAL TO -1. THE SKIP INSTRUCTION SHOULD CAUSE 2167 ;THE AC TO CONTAIN -1. THE AC IS THEN CHECKED FOR 2168 ;NON-ZERO CONTENTS. THE TEST FAILS IF C(AC)=0. 2169 ;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0. 2170 2171 SN=SN+1 2172 AC=AC+AC 2173 IFE AC, 2174 MOVE 0,[0] ;PRESET AC0 TO ALL ZEROS 2175 MOVE AC,[0] ;PRESET THE AC TO ALL ZEROS 2176 SKIP AC,[-1] ;*SKIP SHOULD PLACE -1 INTO THE AC 2177 SKIPN AC ;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO 2178 STOP 2179 SKIPE 0 ;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP 2180 STOP 2181 2182 ;********** 2183 > 2184 ;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC 2185 ;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10. 2186 ;FIRST, THE AC IS LOADED WITH ALL ZEROS; THEN, THE SKIP INSTRUCTION IS EXECUTED 2187 ;WITH AC1, AC2, AC4 OR AC10. C(E) IS EQUAL TO -1. THE SKIP INSTRUCTION SHOULD CAUSE 2188 ;THE AC TO CONTAIN -1. THE AC IS THEN CHECKED FOR 2189 ;NON-ZERO CONTENTS. THE TEST FAILS IF C(AC)=0. 2190 ;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0. 2191 2192 004101 SN=SN+1 2193 000000 AC=AC+AC 2194 000001 IFE AC, DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 17-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS SEQ 0058 2195 031434 200 00 0 00 035062 MOVE 0,[0] ;PRESET AC0 TO ALL ZEROS 2196 031435 200 01 0 00 035062 MOVE AC,[0] ;PRESET THE AC TO ALL ZEROS 2197 031436 330 01 0 00 035063 SKIP AC,[-1] ;*SKIP SHOULD PLACE -1 INTO THE AC 2198 031437 336 00 0 00 000001 SKIPN AC ;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO 2199 STOP^ 2200 031440 254 04 0 00 031441 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2201 031441 324 00 0 00 031442 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2202 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2203 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2204 031442 332 00 0 00 000000 SKIPE 0 ;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP 2205 STOP^ 2206 031443 254 04 0 00 031444 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2207 031444 324 00 0 00 031445 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2208 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2209 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2210 2211 ;********** 2212 2213 ;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC 2214 ;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10. 2215 ;FIRST, THE AC IS LOADED WITH ALL ZEROS; THEN, THE SKIP INSTRUCTION IS EXECUTED 2216 ;WITH AC1, AC2, AC4 OR AC10. C(E) IS EQUAL TO -1. THE SKIP INSTRUCTION SHOULD CAUSE 2217 ;THE AC TO CONTAIN -1. THE AC IS THEN CHECKED FOR 2218 ;NON-ZERO CONTENTS. THE TEST FAILS IF C(AC)=0. 2219 ;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0. 2220 2221 004102 SN=SN+1 2222 000002 AC=AC+AC 2223 IFE AC, 2224 031445 200 00 0 00 035062 MOVE 0,[0] ;PRESET AC0 TO ALL ZEROS 2225 031446 200 02 0 00 035062 MOVE AC,[0] ;PRESET THE AC TO ALL ZEROS 2226 031447 330 02 0 00 035063 SKIP AC,[-1] ;*SKIP SHOULD PLACE -1 INTO THE AC 2227 031450 336 00 0 00 000002 SKIPN AC ;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO 2228 STOP^ 2229 031451 254 04 0 00 031452 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2230 031452 324 00 0 00 031453 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2231 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2232 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2233 031453 332 00 0 00 000000 SKIPE 0 ;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP 2234 STOP^ 2235 031454 254 04 0 00 031455 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2236 031455 324 00 0 00 031456 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2237 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2238 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2239 2240 ;********** 2241 2242 ;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC 2243 ;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10. 2244 ;FIRST, THE AC IS LOADED WITH ALL ZEROS; THEN, THE SKIP INSTRUCTION IS EXECUTED 2245 ;WITH AC1, AC2, AC4 OR AC10. C(E) IS EQUAL TO -1. THE SKIP INSTRUCTION SHOULD CAUSE 2246 ;THE AC TO CONTAIN -1. THE AC IS THEN CHECKED FOR 2247 ;NON-ZERO CONTENTS. THE TEST FAILS IF C(AC)=0. 2248 ;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0. 2249 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 17-2 DAKAAM MAC 19-JAN-77 13:42 TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS SEQ 0059 2250 004103 SN=SN+1 2251 000004 AC=AC+AC 2252 IFE AC, 2253 031456 200 00 0 00 035062 MOVE 0,[0] ;PRESET AC0 TO ALL ZEROS 2254 031457 200 04 0 00 035062 MOVE AC,[0] ;PRESET THE AC TO ALL ZEROS 2255 031460 330 04 0 00 035063 SKIP AC,[-1] ;*SKIP SHOULD PLACE -1 INTO THE AC 2256 031461 336 00 0 00 000004 SKIPN AC ;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO 2257 STOP^ 2258 031462 254 04 0 00 031463 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2259 031463 324 00 0 00 031464 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2260 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2261 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2262 031464 332 00 0 00 000000 SKIPE 0 ;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP 2263 STOP^ 2264 031465 254 04 0 00 031466 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2265 031466 324 00 0 00 031467 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2266 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2267 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2268 2269 ;********** 2270 2271 ;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC 2272 ;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10. 2273 ;FIRST, THE AC IS LOADED WITH ALL ZEROS; THEN, THE SKIP INSTRUCTION IS EXECUTED 2274 ;WITH AC1, AC2, AC4 OR AC10. C(E) IS EQUAL TO -1. THE SKIP INSTRUCTION SHOULD CAUSE 2275 ;THE AC TO CONTAIN -1. THE AC IS THEN CHECKED FOR 2276 ;NON-ZERO CONTENTS. THE TEST FAILS IF C(AC)=0. 2277 ;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0. 2278 2279 004104 SN=SN+1 2280 000010 AC=AC+AC 2281 IFE AC, 2282 031467 200 00 0 00 035062 MOVE 0,[0] ;PRESET AC0 TO ALL ZEROS 2283 031470 200 10 0 00 035062 MOVE AC,[0] ;PRESET THE AC TO ALL ZEROS 2284 031471 330 10 0 00 035063 SKIP AC,[-1] ;*SKIP SHOULD PLACE -1 INTO THE AC 2285 031472 336 00 0 00 000010 SKIPN AC ;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO 2286 STOP^ 2287 031473 254 04 0 00 031474 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2288 031474 324 00 0 00 031475 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2289 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2290 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2291 031475 332 00 0 00 000000 SKIPE 0 ;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP 2292 STOP^ 2293 031476 254 04 0 00 031477 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2294 031477 324 00 0 00 031500 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2295 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2296 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2297 2298 ;********** 2299 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 18 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0060 2300 SUBTTL TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS 2301 2302 ;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL NOT MODIFY THE CONTENTS OF AC0. 2303 ;FIRST, AC0 IS LOADED WITH ALL ZEROS; THEN, 2304 ;THE SKIP INSTRUCTION IS EXECUTED WITH C(E)=-1 AND AC0. AC0 IS THEN TESTED FOR ALL 2305 ;ZEROS. THE TEST FAILS IF AC0 WAS MODIFIED BY THE SKIP INSTRUCTION. 2306 2307 031500 200 00 0 00 035062 A4200: MOVE [0] ;PRESET AC0 TO ALL ZEROS 2308 031501 330 00 0 00 035063 SKIP [-1] ;*SKIP SHOULD NOT MODIFY AC0 2309 031502 332 00 0 00 000000 SKIPE ;SKIP HALT INSTRUCTION IF AC0 WAS NOT MODIFIED BY SKIP 2310 STOP^ 2311 031503 254 04 0 00 031504 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2312 031504 324 00 0 00 031505 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2313 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2314 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2315 2316 ;AC=0: SAC INH, IR BIT 9, 10, 11 OR 12 S-A-1 2317 2318 ;********** 2319 2320 ;THIS TEST VERIFIES THAT MOVSS DOES NOT MODIFY C(AC0) WHEN AC0 IS SPECIFIED AS THE AC. 2321 ;FIRST, E IS LOADED WITH ALL ONES AND THE AC (AC0) 2322 ;IS LOADED WITH ALL ZEROS; THEN, MOVSS IS EXECUTED. MOVSS SHOULD NOT MODIFY AC0. 2323 ;AC0 IS THEN CHECKED TO INSURE THAT IT WAS NOT MODIFIED BY MOVSS. 2324 2325 031505 200 07 0 00 035063 A4300: MOVE 7,[-1] ;LOAD E OF THE MOVSS INSTRUCTION WITH ALL ONES 2326 031506 200 00 0 00 035062 MOVE [0] ;PRESET AC0 TO ALL ZEROS 2327 031507 207 00 0 00 000007 MOVSS 7 ;*MOVSS SHOULD NOT MODIFY AC0 2328 031510 332 00 0 00 000000 SKIPE ;SKIP HALT INSTRUCTION IF AC0 WAS INTACT 2329 STOP^ 2330 031511 254 04 0 00 031512 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2331 031512 324 00 0 00 031513 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2332 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2333 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2334 2335 ;MOVX & AC=0: SAC INH [ST2], IR XXXS [IR1] 2336 2337 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 19 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0061 2338 ;THIS TEST VERIFIES THAT HRRS DOES NOT MODIFY C(AC0) WHEN AC0 IS THE SPECIFIED AC. 2339 ;FIRST, E IS LOADED WITH ALL ONES AND AC0 IS LOADED WITH ALL ZEROS; 2340 ;THEN, HRRS IS EXECUTED WITH AC=AC0. AC0 IS THEN CHECKED FOR ALL ZEROS. 2341 ;IF AC0 WAS MODIFIED BY THE HRRS INSTRUCTION, THE TEST FAIL. 2342 2343 031513 200 07 0 00 035063 A4400: MOVE 7,[-1] ;PRESET E OF THE HRRS INSTRUCTION TO ALL ONES 2344 031514 200 00 0 00 035062 MOVE [0] ;PRESET AC0 TO ALL ZEROS 2345 031515 543 00 0 00 000007 HRRS 7 ;*HRRS SHOULD NOT MODIFY THE AC WHEN THE AC IS AC0 2346 031516 332 00 0 00 000000 SKIPE ;SKIP THE HALT INSTRUCTION IF AC0 WAS INTACT 2347 STOP^ 2348 031517 254 04 0 00 031520 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2349 031520 324 00 0 00 031521 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2350 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2351 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2352 2353 ;(HXXXS&AC=0): SAC INH [ST2], IR HWTFWT [IR3], IR XXXS [IR1], IR HWT [IR1], 2354 ;IR BITS S-A-1 2355 2356 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 20 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0062 2357 ;THIS TEST VERIFIES THAT THE JUMP INSTRUCTION DOES NOT MODIFY C(AC). 2358 ;THE AC IS FIRST LOADED WITH ALL ZEROS; 2359 ;THEN JUMP .+1 IS EXECUTED. THE AC IS THEN CHECKED TO INSURE THAT IT WAS NOT MODIFIED 2360 ;BY JUMP. THE TEST FAILS IF THE AC WAS MODIFIED 2361 2362 031521 200 00 0 00 035062 A4700: MOVE [0] ; PRESET THE AC TO ALL ZEROS 2363 031522 320 00 0 00 031523 JUMP .+1 ;*JUMP SHOULD NOT MODIFY THE AC 2364 031523 332 00 0 00 000000 SKIPE ;SKIP HALT INSTRUCTION IF AC WAS INTACT 2365 STOP^ 2366 031524 254 04 0 00 031525 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2367 031525 324 00 0 00 031526 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2368 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2369 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2370 2371 ;********** 2372 2373 ;THIS TEST VERIFIES THAT MOVS WILL NOT PICK UP ANY ONES WHEN SWAPPING A WORD 2374 ;OF ALL ZEROS. FIRST, E IS LOADED WITH A WORD OF ALL ZEROS; 2375 ;THEN, MOVS IS EXECUTED. THE AC IS THEN CHECKED TO INSURE THAT THE RESULT DOES NOT 2376 ;CONTAIN ANY ONES. 2377 2378 031526 200 00 0 00 035062 A5000: MOVE [0] ;PRESET E WITH ALL ZEROS 2379 031527 204 00 0 00 000000 MOVS ;*MOVS SHOULD RESULT WITH AN AC 0F ALL ZEROS 2380 031530 332 00 0 00 000000 SKIPE ;SKIP HALT INSTRUCTION IF C(AC)=0 2381 STOP^ 2382 031531 254 04 0 00 031532 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2383 031532 324 00 0 00 031533 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2384 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2385 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2386 2387 ;********** 2388 2389 ;THIS TEST VERIFIES THAT A MOVS EXECUTED ON AN E CONTAINING A NON-ZERO NUMBER 2390 ;RESULTS IN A NON-ZERO NUMBER IN THE AC. FIRST A NON-ZERO WORD 2391 ;IS LOADED INTO E; THEN, MOVS IS EXECUTED. THE AC IS CHECKED FOR A NON-ZERO RESULT. 2392 ;IF C(AC)=0, THE TEST FAILS. 2393 2394 031533 200 00 0 00 035137 A5100: MOVE [XWD 0,-1] ;LOAD E WITH A NON-ZERO VALUE 2395 031534 204 00 0 00 000000 MOVS ;*MOVS SHOULD RESULT IN C(AC) NON-ZERO 2396 031535 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF C(AC) OF MOVS IS NON-ZERO 2397 STOP^ 2398 031536 254 04 0 00 031537 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2399 031537 324 00 0 00 031540 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2400 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2401 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2402 2403 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 21 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0063 2404 ;THIS TEST VERIFIES THAT A MOVS EXECUTED ON AN E CONTAINING A NON-ZERO NUMBER 2405 ;RESULTS IN A NON-ZERO NUMBER IN THE AC. FIRST A NON-ZERO WORD 2406 ;IS LOADED INTO E; THEN, MOVS IS EXECUTED. THE AC IS CHECKED FOR A NON-ZERO 2407 ;RESULT. IF C(AC)=0, THE TEST FAILS. 2408 2409 031540 200 00 0 00 035140 A5200: MOVE [XWD -1,0] ;LOAD E OF MOVS WITH A NON-ZERO NUMBER 2410 031541 204 00 0 00 000000 MOVS ;*MOVS SHOULD RESULT WITH C(AC) NON-ZERO 2411 031542 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF C(AC) OF MOVS IS NON-ZERO 2412 STOP^ 2413 031543 254 04 0 00 031544 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2414 031544 324 00 0 00 031545 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2415 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2416 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2417 2418 ;********** 2419 2420 ;THIS TEST VERIFIES THAT THE MOVS INSTRUCTION SWAPS BITS 0 AND 188 OF E 2421 ;AND STORES THEM IN THE AC UNLESS AR BIT 0 IS S-A-0. FIRST, A WORD 2422 ;WITH BIT 0 SET TO A ONE AND BIT 18 CLEARED IS LOADED INTO E. THEN, MOVS 2423 ;IS EXECUTED. THE AC IS THEN CHECKED FOR A 0 IN BIT 0, WHICH IS THE 2424 ;CORRECT RESULT. 2425 2426 031545 200 00 0 00 035140 A5300: MOVE [XWD -1,0] ;LOAD E OF MOVS WITH 777777000000 2427 031546 204 00 0 00 000000 MOVS ;*MOVS SHOULD RESULT WITH AC BIT 0 EQUAL TO 0 2428 031547 337 00 0 00 000000 SKIPG ;SKIP HALT INSTRUCTION IF BIT 0 OF AC IS 0 2429 STOP^ 2430 031550 254 04 0 00 031551 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2431 031551 324 00 0 00 031552 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2432 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2433 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2434 2435 ;MOVSX: AR SWAP [ARMB], AR LT AR RT A [ARMB], AR LT AR RT B [ARMB], 2436 ;AR RT AR LT A [ARMB], AR RT AR LT B [ARMB], ET2 A F/F [E], IR MOVSX [IR1], 2437 ;IR MOV(E,S)X [IR1] 2438 2439 ;********** 2440 2441 ;THIS TEST VERIFIES THAT THE MOVS INSTRUCTION SWAPS BITS 0 AND 18 OF E AND 2442 ;STORES THEM IN THE AC UNLESS AR BIT 0 IS S-A-1. FIRST, A WORD WITH BIT 0 2443 ;SET TO A ONE AND BIT 18 CLEARED IS LOADED INTO E. THEN, MOVS IS EXECUTED. 2444 ;THE AC IS CHECKED FOR A ZERO IN BIT ZERO, WHICH IS THE CORRECT RESULT. 2445 2446 031552 200 00 0 00 035137 A5400: MOVE [XWD 0,-1] ;LOAD E OF MOVS WITH 777777 2447 031553 204 00 0 00 000000 MOVS ;*MOVS SHOULD RESULT WITH BIT 0 OF THE AC SET 2448 031554 331 00 0 00 000000 SKIPL ;PASS IF AC BIT 0 IS SET 2449 STOP^ 2450 031555 254 04 0 00 031556 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2451 031556 324 00 0 00 031557 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2452 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2453 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2454 2455 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0064 2456 005500 SN=5500 2457 000000 ZZ=0 2458 2459 A5500: REPEAT ^D18, 2460 <;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2461 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2462 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2463 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2464 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2465 SN=SN+1 2466 ZZ=ZZ+ZZ 2467 IFE ZZ, 2468 MOVE [0] ;CLEAR AC 2469 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2470 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2471 STOP 2472 2473 ;********** 2474 > 2475 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2476 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2477 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2478 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2479 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2480 005501 SN=SN+1 2481 000000 ZZ=ZZ+ZZ 2482 000001 IFE ZZ, 2483 031557 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2484 031560 204 00 0 00 035074 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2485 031561 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2486 STOP^ 2487 031562 254 04 0 00 031563 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2488 031563 324 00 0 00 031564 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2489 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2490 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2491 2492 ;********** 2493 2494 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2495 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2496 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2497 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2498 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2499 005502 SN=SN+1 2500 000002 ZZ=ZZ+ZZ 2501 IFE ZZ, 2502 031564 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2503 031565 204 00 0 00 035075 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2504 031566 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2505 STOP^ 2506 031567 254 04 0 00 031570 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2507 031570 324 00 0 00 031571 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2508 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2509 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2510 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0065 2511 ;********** 2512 2513 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2514 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2515 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2516 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2517 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2518 005503 SN=SN+1 2519 000004 ZZ=ZZ+ZZ 2520 IFE ZZ, 2521 031571 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2522 031572 204 00 0 00 035076 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2523 031573 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2524 STOP^ 2525 031574 254 04 0 00 031575 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2526 031575 324 00 0 00 031576 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2527 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2528 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2529 2530 ;********** 2531 2532 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2533 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2534 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2535 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2536 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2537 005504 SN=SN+1 2538 000010 ZZ=ZZ+ZZ 2539 IFE ZZ, 2540 031576 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2541 031577 204 00 0 00 035077 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2542 031600 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2543 STOP^ 2544 031601 254 04 0 00 031602 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2545 031602 324 00 0 00 031603 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2546 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2547 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2548 2549 ;********** 2550 2551 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2552 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2553 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2554 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2555 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2556 005505 SN=SN+1 2557 000020 ZZ=ZZ+ZZ 2558 IFE ZZ, 2559 031603 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2560 031604 204 00 0 00 035100 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2561 031605 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2562 STOP^ 2563 031606 254 04 0 00 031607 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2564 031607 324 00 0 00 031610 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2565 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-2 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0066 2566 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2567 2568 ;********** 2569 2570 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2571 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2572 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2573 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2574 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2575 005506 SN=SN+1 2576 000040 ZZ=ZZ+ZZ 2577 IFE ZZ, 2578 031610 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2579 031611 204 00 0 00 035101 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2580 031612 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2581 STOP^ 2582 031613 254 04 0 00 031614 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2583 031614 324 00 0 00 031615 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2584 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2585 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2586 2587 ;********** 2588 2589 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2590 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2591 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2592 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2593 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2594 005507 SN=SN+1 2595 000100 ZZ=ZZ+ZZ 2596 IFE ZZ, 2597 031615 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2598 031616 204 00 0 00 035102 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2599 031617 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2600 STOP^ 2601 031620 254 04 0 00 031621 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2602 031621 324 00 0 00 031622 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2603 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2604 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2605 2606 ;********** 2607 2608 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2609 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2610 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2611 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2612 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2613 005510 SN=SN+1 2614 000200 ZZ=ZZ+ZZ 2615 IFE ZZ, 2616 031622 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2617 031623 204 00 0 00 035103 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2618 031624 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2619 STOP^ 2620 031625 254 04 0 00 031626 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-3 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0067 2621 031626 324 00 0 00 031627 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2622 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2623 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2624 2625 ;********** 2626 2627 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2628 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2629 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2630 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2631 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2632 005511 SN=SN+1 2633 000400 ZZ=ZZ+ZZ 2634 IFE ZZ, 2635 031627 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2636 031630 204 00 0 00 035104 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2637 031631 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2638 STOP^ 2639 031632 254 04 0 00 031633 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2640 031633 324 00 0 00 031634 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2641 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2642 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2643 2644 ;********** 2645 2646 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2647 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2648 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2649 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2650 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2651 005512 SN=SN+1 2652 001000 ZZ=ZZ+ZZ 2653 IFE ZZ, 2654 031634 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2655 031635 204 00 0 00 035105 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2656 031636 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2657 STOP^ 2658 031637 254 04 0 00 031640 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2659 031640 324 00 0 00 031641 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2660 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2661 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2662 2663 ;********** 2664 2665 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2666 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2667 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2668 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2669 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2670 005513 SN=SN+1 2671 002000 ZZ=ZZ+ZZ 2672 IFE ZZ, 2673 031641 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2674 031642 204 00 0 00 035106 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2675 031643 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-4 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0068 2676 STOP^ 2677 031644 254 04 0 00 031645 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2678 031645 324 00 0 00 031646 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2679 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2680 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2681 2682 ;********** 2683 2684 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2685 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2686 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2687 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2688 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2689 005514 SN=SN+1 2690 004000 ZZ=ZZ+ZZ 2691 IFE ZZ, 2692 031646 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2693 031647 204 00 0 00 035107 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2694 031650 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2695 STOP^ 2696 031651 254 04 0 00 031652 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2697 031652 324 00 0 00 031653 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2698 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2699 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2700 2701 ;********** 2702 2703 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2704 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2705 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2706 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2707 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2708 005515 SN=SN+1 2709 010000 ZZ=ZZ+ZZ 2710 IFE ZZ, 2711 031653 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2712 031654 204 00 0 00 035110 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2713 031655 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2714 STOP^ 2715 031656 254 04 0 00 031657 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2716 031657 324 00 0 00 031660 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2717 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2718 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2719 2720 ;********** 2721 2722 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2723 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2724 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2725 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2726 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2727 005516 SN=SN+1 2728 020000 ZZ=ZZ+ZZ 2729 IFE ZZ, 2730 031660 200 00 0 00 035062 MOVE [0] ;CLEAR AC DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-5 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0069 2731 031661 204 00 0 00 035111 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2732 031662 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2733 STOP^ 2734 031663 254 04 0 00 031664 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2735 031664 324 00 0 00 031665 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2736 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2737 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2738 2739 ;********** 2740 2741 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2742 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2743 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2744 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2745 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2746 005517 SN=SN+1 2747 040000 ZZ=ZZ+ZZ 2748 IFE ZZ, 2749 031665 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2750 031666 204 00 0 00 035112 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2751 031667 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2752 STOP^ 2753 031670 254 04 0 00 031671 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2754 031671 324 00 0 00 031672 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2755 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2756 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2757 2758 ;********** 2759 2760 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2761 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2762 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2763 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2764 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2765 005520 SN=SN+1 2766 100000 ZZ=ZZ+ZZ 2767 IFE ZZ, 2768 031672 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2769 031673 204 00 0 00 035113 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2770 031674 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2771 STOP^ 2772 031675 254 04 0 00 031676 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2773 031676 324 00 0 00 031677 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2774 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2775 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2776 2777 ;********** 2778 2779 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2780 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2781 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2782 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2783 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2784 005521 SN=SN+1 2785 200000 ZZ=ZZ+ZZ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-6 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0070 2786 IFE ZZ, 2787 031677 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2788 031700 204 00 0 00 035114 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2789 031701 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2790 STOP^ 2791 031702 254 04 0 00 031703 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2792 031703 324 00 0 00 031704 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2793 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2794 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2795 2796 ;********** 2797 2798 ;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING. A WORD OF ALL ZER0S, 2799 ;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED. 2800 ;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES 2801 ;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT 2802 ;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1. 2803 005522 SN=SN+1 2804 400000 ZZ=ZZ+ZZ 2805 IFE ZZ, 2806 031704 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2807 031705 204 00 0 00 035115 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2808 031706 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2809 STOP^ 2810 031707 254 04 0 00 031710 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2811 031710 324 00 0 00 031711 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2812 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2813 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2814 2815 ;********** 2816 2817 005600 SN=5600 2818 2819 A5600: REPEAT ^D18, 2820 <;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 2821 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 2822 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 2823 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 2824 ;HALF OF THE AC IS TESTED WITH A 1. 2825 2826 SN=SN+1 2827 ZZ=ZZ+ZZ 2828 MOVE [0] ;CLEAR AC 2829 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2830 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2831 STOP 2832 2833 ;********** 2834 > 2835 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 2836 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 2837 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 2838 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 2839 ;HALF OF THE AC IS TESTED WITH A 1. 2840 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-7 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0071 2841 005601 SN=SN+1 2842 000001 000000 ZZ=ZZ+ZZ 2843 031711 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2844 031712 204 00 0 00 035116 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2845 031713 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2846 STOP^ 2847 031714 254 04 0 00 031715 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2848 031715 324 00 0 00 031716 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2849 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2850 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2851 2852 ;********** 2853 2854 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 2855 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 2856 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 2857 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 2858 ;HALF OF THE AC IS TESTED WITH A 1. 2859 2860 005602 SN=SN+1 2861 000002 000000 ZZ=ZZ+ZZ 2862 031716 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2863 031717 204 00 0 00 035117 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2864 031720 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2865 STOP^ 2866 031721 254 04 0 00 031722 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2867 031722 324 00 0 00 031723 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2868 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2869 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2870 2871 ;********** 2872 2873 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 2874 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 2875 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 2876 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 2877 ;HALF OF THE AC IS TESTED WITH A 1. 2878 2879 005603 SN=SN+1 2880 000004 000000 ZZ=ZZ+ZZ 2881 031723 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2882 031724 204 00 0 00 035120 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2883 031725 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2884 STOP^ 2885 031726 254 04 0 00 031727 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2886 031727 324 00 0 00 031730 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2887 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2888 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2889 2890 ;********** 2891 2892 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 2893 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 2894 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 2895 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-8 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0072 2896 ;HALF OF THE AC IS TESTED WITH A 1. 2897 2898 005604 SN=SN+1 2899 000010 000000 ZZ=ZZ+ZZ 2900 031730 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2901 031731 204 00 0 00 035121 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2902 031732 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2903 STOP^ 2904 031733 254 04 0 00 031734 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2905 031734 324 00 0 00 031735 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2906 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2907 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2908 2909 ;********** 2910 2911 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 2912 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 2913 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 2914 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 2915 ;HALF OF THE AC IS TESTED WITH A 1. 2916 2917 005605 SN=SN+1 2918 000020 000000 ZZ=ZZ+ZZ 2919 031735 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2920 031736 204 00 0 00 035122 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2921 031737 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2922 STOP^ 2923 031740 254 04 0 00 031741 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2924 031741 324 00 0 00 031742 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2925 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2926 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2927 2928 ;********** 2929 2930 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 2931 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 2932 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 2933 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 2934 ;HALF OF THE AC IS TESTED WITH A 1. 2935 2936 005606 SN=SN+1 2937 000040 000000 ZZ=ZZ+ZZ 2938 031742 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2939 031743 204 00 0 00 035123 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2940 031744 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2941 STOP^ 2942 031745 254 04 0 00 031746 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2943 031746 324 00 0 00 031747 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2944 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2945 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2946 2947 ;********** 2948 2949 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 2950 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-9 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0073 2951 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 2952 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 2953 ;HALF OF THE AC IS TESTED WITH A 1. 2954 2955 005607 SN=SN+1 2956 000100 000000 ZZ=ZZ+ZZ 2957 031747 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2958 031750 204 00 0 00 035124 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2959 031751 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2960 STOP^ 2961 031752 254 04 0 00 031753 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2962 031753 324 00 0 00 031754 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2963 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2964 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2965 2966 ;********** 2967 2968 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 2969 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 2970 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 2971 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 2972 ;HALF OF THE AC IS TESTED WITH A 1. 2973 2974 005610 SN=SN+1 2975 000200 000000 ZZ=ZZ+ZZ 2976 031754 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2977 031755 204 00 0 00 035125 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2978 031756 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2979 STOP^ 2980 031757 254 04 0 00 031760 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 2981 031760 324 00 0 00 031761 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 2982 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 2983 ;IN THE SUBTEST) TO LOOP ON ERROR^ 2984 2985 ;********** 2986 2987 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 2988 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 2989 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 2990 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 2991 ;HALF OF THE AC IS TESTED WITH A 1. 2992 2993 005611 SN=SN+1 2994 000400 000000 ZZ=ZZ+ZZ 2995 031761 200 00 0 00 035062 MOVE [0] ;CLEAR AC 2996 031762 204 00 0 00 035073 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 2997 031763 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 2998 STOP^ 2999 031764 254 04 0 00 031765 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3000 031765 324 00 0 00 031766 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3001 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3002 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3003 3004 ;********** 3005 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-10 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0074 3006 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 3007 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 3008 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 3009 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 3010 ;HALF OF THE AC IS TESTED WITH A 1. 3011 3012 005612 SN=SN+1 3013 001000 000000 ZZ=ZZ+ZZ 3014 031766 200 00 0 00 035062 MOVE [0] ;CLEAR AC 3015 031767 204 00 0 00 035126 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 3016 031770 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 3017 STOP^ 3018 031771 254 04 0 00 031772 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3019 031772 324 00 0 00 031773 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3020 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3021 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3022 3023 ;********** 3024 3025 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 3026 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 3027 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 3028 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 3029 ;HALF OF THE AC IS TESTED WITH A 1. 3030 3031 005613 SN=SN+1 3032 002000 000000 ZZ=ZZ+ZZ 3033 031773 200 00 0 00 035062 MOVE [0] ;CLEAR AC 3034 031774 204 00 0 00 035127 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 3035 031775 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 3036 STOP^ 3037 031776 254 04 0 00 031777 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3038 031777 324 00 0 00 032000 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3039 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3040 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3041 3042 ;********** 3043 3044 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 3045 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 3046 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 3047 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 3048 ;HALF OF THE AC IS TESTED WITH A 1. 3049 3050 005614 SN=SN+1 3051 004000 000000 ZZ=ZZ+ZZ 3052 032000 200 00 0 00 035062 MOVE [0] ;CLEAR AC 3053 032001 204 00 0 00 035130 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 3054 032002 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 3055 STOP^ 3056 032003 254 04 0 00 032004 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3057 032004 324 00 0 00 032005 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3058 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3059 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3060 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-11 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0075 3061 ;********** 3062 3063 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 3064 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 3065 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 3066 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 3067 ;HALF OF THE AC IS TESTED WITH A 1. 3068 3069 005615 SN=SN+1 3070 010000 000000 ZZ=ZZ+ZZ 3071 032005 200 00 0 00 035062 MOVE [0] ;CLEAR AC 3072 032006 204 00 0 00 035131 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 3073 032007 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 3074 STOP^ 3075 032010 254 04 0 00 032011 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3076 032011 324 00 0 00 032012 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3077 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3078 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3079 3080 ;********** 3081 3082 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 3083 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 3084 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 3085 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 3086 ;HALF OF THE AC IS TESTED WITH A 1. 3087 3088 005616 SN=SN+1 3089 020000 000000 ZZ=ZZ+ZZ 3090 032012 200 00 0 00 035062 MOVE [0] ;CLEAR AC 3091 032013 204 00 0 00 035132 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 3092 032014 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 3093 STOP^ 3094 032015 254 04 0 00 032016 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3095 032016 324 00 0 00 032017 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3096 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3097 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3098 3099 ;********** 3100 3101 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 3102 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 3103 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 3104 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 3105 ;HALF OF THE AC IS TESTED WITH A 1. 3106 3107 005617 SN=SN+1 3108 040000 000000 ZZ=ZZ+ZZ 3109 032017 200 00 0 00 035062 MOVE [0] ;CLEAR AC 3110 032020 204 00 0 00 035133 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 3111 032021 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 3112 STOP^ 3113 032022 254 04 0 00 032023 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3114 032023 324 00 0 00 032024 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3115 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-12 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0076 3116 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3117 3118 ;********** 3119 3120 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 3121 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 3122 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 3123 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 3124 ;HALF OF THE AC IS TESTED WITH A 1. 3125 3126 005620 SN=SN+1 3127 100000 000000 ZZ=ZZ+ZZ 3128 032024 200 00 0 00 035062 MOVE [0] ;CLEAR AC 3129 032025 204 00 0 00 035134 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 3130 032026 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 3131 STOP^ 3132 032027 254 04 0 00 032030 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3133 032030 324 00 0 00 032031 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3134 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3135 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3136 3137 ;********** 3138 3139 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 3140 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 3141 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 3142 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 3143 ;HALF OF THE AC IS TESTED WITH A 1. 3144 3145 005621 SN=SN+1 3146 200000 000000 ZZ=ZZ+ZZ 3147 032031 200 00 0 00 035062 MOVE [0] ;CLEAR AC 3148 032032 204 00 0 00 035135 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 3149 032033 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 3150 STOP^ 3151 032034 254 04 0 00 032035 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3152 032035 324 00 0 00 032036 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3153 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3154 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3155 3156 ;********** 3157 3158 ;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING. A WORD OF ALL 3159 ;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED. THE AC IS 3160 ;CHECKED FOR ITS CONTENTS NON-ZERO. THE TEST PASSES IF C(AC) IS 3161 ;NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT 3162 ;HALF OF THE AC IS TESTED WITH A 1. 3163 3164 005622 SN=SN+1 3165 400000 000000 ZZ=ZZ+ZZ 3166 032036 200 00 0 00 035062 MOVE [0] ;CLEAR AC 3167 032037 204 00 0 00 035065 MOVS [ZZ] ;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC 3168 032040 336 00 0 00 000000 SKIPN ;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP. 3169 STOP^ 3170 032041 254 04 0 00 032042 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 22-13 DAKAAM MAC 19-JAN-77 13:42 TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS SEQ 0077 3171 032042 324 00 0 00 032043 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3172 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3173 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3174 3175 ;********** 3176 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 23 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0078 3177 SUBTTL TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) 3178 3179 ;THIS TEST VERIFIES THAT SETM LOADS AC FROM E. THE AC IS FIRST SET 3180 ;TO ZERO; THEN, SETM IS EXECUTED WITH ALL ONES IN E. BIT 0 OF THE AC 3181 ;IS THEN CHECKED FOR A 1. 3182 3183 032043 200 00 0 00 035062 A5700: MOVE [0] ;PRELOAD AC WITH ALL ZEROS 3184 032044 414 00 0 00 035063 SETM [-1] ;*SETM SHOULD LOAD AC WITH ALL ONES 3185 032045 331 00 0 00 000000 SKIPL ;PASS TEST IF AC BIT 0 IS A ONE 3186 STOP^ 3187 032046 254 04 0 00 032047 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3188 032047 324 00 0 00 032050 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3189 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3190 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3191 ;FCE [F1], IR BOOLE [IR1], IRXX(0,5,12,17) [IR2] 3192 3193 ;********** 3194 3195 ;THIS TEST VERIFIES THAT SETM LOADS AC FROM E. THE AC IS FIRST SET TO 3196 ;ALL ONES; THEN, SETM IS EXECUTED WITH ALL ZEROS IN E. THE AC IS CHECKED 3197 ;FOR ALL ZEROS 3198 3199 032050 200 00 0 00 035063 A6000: MOVE [-1] ;PRESET AC TO ALL ONES 3200 032051 414 00 0 00 035062 SETM [0] ;*SETM SHOULD LOAD AC WITH ALL ONES 3201 032052 332 00 0 00 000000 SKIPE ;PASSES TEST IF C(AC) = 0 3202 STOP^ 3203 032053 254 04 0 00 032054 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3204 032054 324 00 0 00 032055 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3205 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3206 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3207 3208 ;AD AR + EN [ADAP], AD AR + EN C[ADAP], 3209 ;F CYC ACT EN A[F1], IR BOOLE AD A +F[IR2], 3210 ;IR BOOLE [IR1], IRXX(1-3,6,11,15,16) [IR2] 3211 3212 ;********** 3213 3214 ;THIS TEST VERIFIES THAT SETZ LOADS TH AC WITH ALL ZEROS. FIRST, A WORD 3215 ;OF ALL ZEROS IS LOADED INTO THE AC VIA A MOVE INSTC. THEN, SETZ IS 3216 ;EXECUTED. THE AC IS CHECKED FOR ALL ZEROS. 3217 ;IF ANY BITS IN THE AC ARE SET, THE TEST FAILS. 3218 3219 032055 200 00 0 00 035062 A6100: MOVE [0] ;RESET AC TO ALL ZEROS 3220 032056 400 00 0 00 000000 SETZ ;*SETZ SHOULD CLEAR THE AC 3221 032057 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC) = 0 3222 STOP^ 3223 032060 254 04 0 00 032061 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3224 032061 324 00 0 00 032062 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3225 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3226 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3227 3228 ;AD MASK GEN EN [ADC1], AD MASK GEN F/F'S [ADC1] 3229 ;AD MASK EN B; F CYC ACT EN B[F1]; IRXX00 [IR1]; 3230 ;IR BOOLE [IR1] 3231 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 23-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0079 3232 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0080 3233 ;THIS TEST VERIFIES THAT SETZ LOADS THE AC WITH ALL ZEROS. FIRST, 3234 ;THE AC IS SET TO ALL ONES; THEN, SETZ IS EXECUTED. THE AC IS THEN 3235 ;CHECKED FOR ALL ZEROS. IF ANY BITS IN THE AC ARE SET, THE TEST FAILS. 3236 3237 032062 200 00 0 00 035063 A6200: MOVE [-1] ;PRESET AC TO ALL ONES 3238 032063 400 00 0 00 032063 SETZ . ;*SETZ SHOULD CLEAR THE AC 3239 032064 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC) = 0 3240 STOP^ 3241 032065 254 04 0 00 032066 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3242 032066 324 00 0 00 032067 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3243 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3244 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3245 3246 ;AR AD EN [ARMA], AR AD ET2 EN [ARMA], IR BOOLE [IR] 3247 3248 ;********** 3249 3250 ;THIS TEST VERIFIES THAT THE AND INSTRUCTION OPERATING ON AN AC 3251 ;CONTAINING ALL ZEROS AND AN E CONTAINING ALL ZEROS RESULTS IN AN AC 3252 ;OF ALL ZEROS. THE AC AND E ARE THE SAME IN THIS TEST. 3253 ;AC, E ARE LOADED WITH ZEROS; THEN, AND IS EXECUTED. THE AC IS THEN 3254 ;CHECKED FOR ALL ZEROS. IF ANY BITS IN THE AC ARE SET BY THE AND INSTRUCTION, 3255 ;THE TEST FAILS. 3256 3257 3258 032067 200 00 0 00 035062 A6300: MOVE [0] ;PRESET AC, E TO ALL ZEROS 3259 032070 404 00 0 00 000000 AND ;*AND SHOULD RESULT IN C(AC) = 0 3260 032071 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC) = 0 3261 STOP^ 3262 032072 254 04 0 00 032073 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3263 032073 324 00 0 00 032074 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3264 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3265 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3266 3267 ;********** 3268 006400 SN=6400 3269 000000 ZZ=0 3270 3271 A6400: REPEAT ^D36, 3272 <;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3273 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3274 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3275 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3276 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3277 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3278 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3279 3280 SN=SN+1 3281 ZZ=ZZ+ZZ 3282 IFE ZZ, 3283 SETZ ;PRESET E TO ALL ZEROS 3284 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3285 ;WHERE X VARIES FROM 0 THRU 35 3286 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3287 SKIPE 1 ;FAIL IF C(AC) NON-ZERO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0081 3288 STOP 3289 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3290 STOP 3291 ;********** 3292 > 3293 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3294 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3295 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3296 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3297 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3298 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3299 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3300 3301 006401 SN=SN+1 3302 000000 ZZ=ZZ+ZZ 3303 000001 IFE ZZ, 3304 032074 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3305 032075 200 01 0 00 035074 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3306 ;WHERE X VARIES FROM 0 THRU 35 3307 032076 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3308 032077 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3309 STOP^ 3310 032100 254 04 0 00 032101 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3311 032101 324 00 0 00 032102 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3312 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3313 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3314 032102 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3315 STOP^ 3316 032103 254 04 0 00 032104 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3317 032104 324 00 0 00 032105 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3318 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3319 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3320 ;********** 3321 3322 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3323 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3324 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3325 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3326 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3327 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3328 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3329 3330 006402 SN=SN+1 3331 000002 ZZ=ZZ+ZZ 3332 IFE ZZ, 3333 032105 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3334 032106 200 01 0 00 035075 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3335 ;WHERE X VARIES FROM 0 THRU 35 3336 032107 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3337 032110 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3338 STOP^ 3339 032111 254 04 0 00 032112 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3340 032112 324 00 0 00 032113 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3341 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3342 ;IN THE SUBTEST) TO LOOP ON ERROR^ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-2 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0082 3343 032113 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3344 STOP^ 3345 032114 254 04 0 00 032115 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3346 032115 324 00 0 00 032116 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3347 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3348 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3349 ;********** 3350 3351 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3352 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3353 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3354 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3355 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3356 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3357 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3358 3359 006403 SN=SN+1 3360 000004 ZZ=ZZ+ZZ 3361 IFE ZZ, 3362 032116 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3363 032117 200 01 0 00 035076 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3364 ;WHERE X VARIES FROM 0 THRU 35 3365 032120 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3366 032121 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3367 STOP^ 3368 032122 254 04 0 00 032123 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3369 032123 324 00 0 00 032124 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3370 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3371 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3372 032124 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3373 STOP^ 3374 032125 254 04 0 00 032126 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3375 032126 324 00 0 00 032127 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3376 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3377 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3378 ;********** 3379 3380 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3381 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3382 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3383 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3384 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3385 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3386 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3387 3388 006404 SN=SN+1 3389 000010 ZZ=ZZ+ZZ 3390 IFE ZZ, 3391 032127 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3392 032130 200 01 0 00 035077 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3393 ;WHERE X VARIES FROM 0 THRU 35 3394 032131 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3395 032132 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3396 STOP^ 3397 032133 254 04 0 00 032134 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-3 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0083 3398 032134 324 00 0 00 032135 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3399 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3400 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3401 032135 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3402 STOP^ 3403 032136 254 04 0 00 032137 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3404 032137 324 00 0 00 032140 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3405 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3406 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3407 ;********** 3408 3409 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3410 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3411 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3412 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3413 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3414 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3415 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3416 3417 006405 SN=SN+1 3418 000020 ZZ=ZZ+ZZ 3419 IFE ZZ, 3420 032140 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3421 032141 200 01 0 00 035100 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3422 ;WHERE X VARIES FROM 0 THRU 35 3423 032142 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3424 032143 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3425 STOP^ 3426 032144 254 04 0 00 032145 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3427 032145 324 00 0 00 032146 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3428 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3429 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3430 032146 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3431 STOP^ 3432 032147 254 04 0 00 032150 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3433 032150 324 00 0 00 032151 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3434 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3435 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3436 ;********** 3437 3438 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3439 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3440 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3441 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3442 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3443 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3444 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3445 3446 006406 SN=SN+1 3447 000040 ZZ=ZZ+ZZ 3448 IFE ZZ, 3449 032151 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3450 032152 200 01 0 00 035101 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3451 ;WHERE X VARIES FROM 0 THRU 35 3452 032153 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-4 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0084 3453 032154 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3454 STOP^ 3455 032155 254 04 0 00 032156 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3456 032156 324 00 0 00 032157 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3457 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3458 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3459 032157 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3460 STOP^ 3461 032160 254 04 0 00 032161 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3462 032161 324 00 0 00 032162 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3463 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3464 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3465 ;********** 3466 3467 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3468 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3469 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3470 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3471 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3472 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3473 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3474 3475 006407 SN=SN+1 3476 000100 ZZ=ZZ+ZZ 3477 IFE ZZ, 3478 032162 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3479 032163 200 01 0 00 035102 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3480 ;WHERE X VARIES FROM 0 THRU 35 3481 032164 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3482 032165 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3483 STOP^ 3484 032166 254 04 0 00 032167 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3485 032167 324 00 0 00 032170 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3486 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3487 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3488 032170 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3489 STOP^ 3490 032171 254 04 0 00 032172 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3491 032172 324 00 0 00 032173 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3492 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3493 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3494 ;********** 3495 3496 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3497 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3498 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3499 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3500 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3501 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3502 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3503 3504 006410 SN=SN+1 3505 000200 ZZ=ZZ+ZZ 3506 IFE ZZ, 3507 032173 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-5 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0085 3508 032174 200 01 0 00 035103 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3509 ;WHERE X VARIES FROM 0 THRU 35 3510 032175 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3511 032176 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3512 STOP^ 3513 032177 254 04 0 00 032200 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3514 032200 324 00 0 00 032201 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3515 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3516 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3517 032201 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3518 STOP^ 3519 032202 254 04 0 00 032203 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3520 032203 324 00 0 00 032204 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3521 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3522 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3523 ;********** 3524 3525 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3526 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3527 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3528 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3529 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3530 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3531 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3532 3533 006411 SN=SN+1 3534 000400 ZZ=ZZ+ZZ 3535 IFE ZZ, 3536 032204 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3537 032205 200 01 0 00 035104 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3538 ;WHERE X VARIES FROM 0 THRU 35 3539 032206 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3540 032207 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3541 STOP^ 3542 032210 254 04 0 00 032211 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3543 032211 324 00 0 00 032212 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3544 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3545 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3546 032212 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3547 STOP^ 3548 032213 254 04 0 00 032214 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3549 032214 324 00 0 00 032215 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3550 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3551 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3552 ;********** 3553 3554 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3555 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3556 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3557 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3558 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3559 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3560 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3561 3562 006412 SN=SN+1 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-6 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0086 3563 001000 ZZ=ZZ+ZZ 3564 IFE ZZ, 3565 032215 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3566 032216 200 01 0 00 035105 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3567 ;WHERE X VARIES FROM 0 THRU 35 3568 032217 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3569 032220 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3570 STOP^ 3571 032221 254 04 0 00 032222 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3572 032222 324 00 0 00 032223 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3573 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3574 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3575 032223 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3576 STOP^ 3577 032224 254 04 0 00 032225 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3578 032225 324 00 0 00 032226 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3579 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3580 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3581 ;********** 3582 3583 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3584 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3585 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3586 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3587 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3588 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3589 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3590 3591 006413 SN=SN+1 3592 002000 ZZ=ZZ+ZZ 3593 IFE ZZ, 3594 032226 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3595 032227 200 01 0 00 035106 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3596 ;WHERE X VARIES FROM 0 THRU 35 3597 032230 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3598 032231 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3599 STOP^ 3600 032232 254 04 0 00 032233 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3601 032233 324 00 0 00 032234 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3602 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3603 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3604 032234 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3605 STOP^ 3606 032235 254 04 0 00 032236 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3607 032236 324 00 0 00 032237 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3608 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3609 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3610 ;********** 3611 3612 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3613 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3614 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3615 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3616 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3617 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-7 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0087 3618 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3619 3620 006414 SN=SN+1 3621 004000 ZZ=ZZ+ZZ 3622 IFE ZZ, 3623 032237 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3624 032240 200 01 0 00 035107 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3625 ;WHERE X VARIES FROM 0 THRU 35 3626 032241 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3627 032242 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3628 STOP^ 3629 032243 254 04 0 00 032244 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3630 032244 324 00 0 00 032245 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3631 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3632 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3633 032245 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3634 STOP^ 3635 032246 254 04 0 00 032247 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3636 032247 324 00 0 00 032250 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3637 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3638 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3639 ;********** 3640 3641 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3642 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3643 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3644 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3645 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3646 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3647 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3648 3649 006415 SN=SN+1 3650 010000 ZZ=ZZ+ZZ 3651 IFE ZZ, 3652 032250 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3653 032251 200 01 0 00 035110 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3654 ;WHERE X VARIES FROM 0 THRU 35 3655 032252 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3656 032253 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3657 STOP^ 3658 032254 254 04 0 00 032255 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3659 032255 324 00 0 00 032256 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3660 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3661 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3662 032256 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3663 STOP^ 3664 032257 254 04 0 00 032260 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3665 032260 324 00 0 00 032261 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3666 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3667 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3668 ;********** 3669 3670 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3671 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3672 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-8 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0088 3673 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3674 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3675 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3676 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3677 3678 006416 SN=SN+1 3679 020000 ZZ=ZZ+ZZ 3680 IFE ZZ, 3681 032261 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3682 032262 200 01 0 00 035111 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3683 ;WHERE X VARIES FROM 0 THRU 35 3684 032263 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3685 032264 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3686 STOP^ 3687 032265 254 04 0 00 032266 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3688 032266 324 00 0 00 032267 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3689 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3690 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3691 032267 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3692 STOP^ 3693 032270 254 04 0 00 032271 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3694 032271 324 00 0 00 032272 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3695 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3696 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3697 ;********** 3698 3699 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3700 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3701 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3702 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3703 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3704 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3705 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3706 3707 006417 SN=SN+1 3708 040000 ZZ=ZZ+ZZ 3709 IFE ZZ, 3710 032272 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3711 032273 200 01 0 00 035112 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3712 ;WHERE X VARIES FROM 0 THRU 35 3713 032274 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3714 032275 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3715 STOP^ 3716 032276 254 04 0 00 032277 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3717 032277 324 00 0 00 032300 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3718 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3719 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3720 032300 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3721 STOP^ 3722 032301 254 04 0 00 032302 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3723 032302 324 00 0 00 032303 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3724 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3725 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3726 ;********** 3727 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-9 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0089 3728 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3729 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3730 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3731 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3732 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3733 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3734 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3735 3736 006420 SN=SN+1 3737 100000 ZZ=ZZ+ZZ 3738 IFE ZZ, 3739 032303 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3740 032304 200 01 0 00 035113 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3741 ;WHERE X VARIES FROM 0 THRU 35 3742 032305 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3743 032306 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3744 STOP^ 3745 032307 254 04 0 00 032310 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3746 032310 324 00 0 00 032311 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3747 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3748 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3749 032311 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3750 STOP^ 3751 032312 254 04 0 00 032313 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3752 032313 324 00 0 00 032314 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3753 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3754 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3755 ;********** 3756 3757 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3758 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3759 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3760 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3761 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3762 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3763 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3764 3765 006421 SN=SN+1 3766 200000 ZZ=ZZ+ZZ 3767 IFE ZZ, 3768 032314 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3769 032315 200 01 0 00 035114 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3770 ;WHERE X VARIES FROM 0 THRU 35 3771 032316 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3772 032317 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3773 STOP^ 3774 032320 254 04 0 00 032321 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3775 032321 324 00 0 00 032322 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3776 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3777 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3778 032322 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3779 STOP^ 3780 032323 254 04 0 00 032324 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3781 032324 324 00 0 00 032325 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3782 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-10 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0090 3783 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3784 ;********** 3785 3786 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3787 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3788 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3789 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3790 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3791 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3792 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3793 3794 006422 SN=SN+1 3795 400000 ZZ=ZZ+ZZ 3796 IFE ZZ, 3797 032325 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3798 032326 200 01 0 00 035115 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3799 ;WHERE X VARIES FROM 0 THRU 35 3800 032327 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3801 032330 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3802 STOP^ 3803 032331 254 04 0 00 032332 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3804 032332 324 00 0 00 032333 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3805 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3806 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3807 032333 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3808 STOP^ 3809 032334 254 04 0 00 032335 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3810 032335 324 00 0 00 032336 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3811 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3812 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3813 ;********** 3814 3815 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3816 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3817 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3818 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3819 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3820 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3821 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3822 3823 006423 SN=SN+1 3824 000001 000000 ZZ=ZZ+ZZ 3825 IFE ZZ, 3826 032336 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3827 032337 200 01 0 00 035116 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3828 ;WHERE X VARIES FROM 0 THRU 35 3829 032340 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3830 032341 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3831 STOP^ 3832 032342 254 04 0 00 032343 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3833 032343 324 00 0 00 032344 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3834 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3835 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3836 032344 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3837 STOP^ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-11 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0091 3838 032345 254 04 0 00 032346 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3839 032346 324 00 0 00 032347 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3840 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3841 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3842 ;********** 3843 3844 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3845 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3846 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3847 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3848 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3849 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3850 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3851 3852 006424 SN=SN+1 3853 000002 000000 ZZ=ZZ+ZZ 3854 IFE ZZ, 3855 032347 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3856 032350 200 01 0 00 035117 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3857 ;WHERE X VARIES FROM 0 THRU 35 3858 032351 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3859 032352 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3860 STOP^ 3861 032353 254 04 0 00 032354 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3862 032354 324 00 0 00 032355 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3863 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3864 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3865 032355 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3866 STOP^ 3867 032356 254 04 0 00 032357 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3868 032357 324 00 0 00 032360 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3869 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3870 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3871 ;********** 3872 3873 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3874 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3875 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3876 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3877 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3878 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3879 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3880 3881 006425 SN=SN+1 3882 000004 000000 ZZ=ZZ+ZZ 3883 IFE ZZ, 3884 032360 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3885 032361 200 01 0 00 035120 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3886 ;WHERE X VARIES FROM 0 THRU 35 3887 032362 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3888 032363 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3889 STOP^ 3890 032364 254 04 0 00 032365 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3891 032365 324 00 0 00 032366 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3892 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-12 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0092 3893 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3894 032366 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3895 STOP^ 3896 032367 254 04 0 00 032370 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3897 032370 324 00 0 00 032371 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3898 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3899 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3900 ;********** 3901 3902 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3903 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3904 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3905 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3906 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3907 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3908 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3909 3910 006426 SN=SN+1 3911 000010 000000 ZZ=ZZ+ZZ 3912 IFE ZZ, 3913 032371 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3914 032372 200 01 0 00 035121 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3915 ;WHERE X VARIES FROM 0 THRU 35 3916 032373 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3917 032374 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3918 STOP^ 3919 032375 254 04 0 00 032376 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3920 032376 324 00 0 00 032377 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3921 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3922 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3923 032377 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3924 STOP^ 3925 032400 254 04 0 00 032401 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3926 032401 324 00 0 00 032402 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3927 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3928 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3929 ;********** 3930 3931 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3932 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3933 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3934 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3935 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3936 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3937 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3938 3939 006427 SN=SN+1 3940 000020 000000 ZZ=ZZ+ZZ 3941 IFE ZZ, 3942 032402 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3943 032403 200 01 0 00 035122 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3944 ;WHERE X VARIES FROM 0 THRU 35 3945 032404 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3946 032405 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3947 STOP^ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-13 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0093 3948 032406 254 04 0 00 032407 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3949 032407 324 00 0 00 032410 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3950 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3951 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3952 032410 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3953 STOP^ 3954 032411 254 04 0 00 032412 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3955 032412 324 00 0 00 032413 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3956 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3957 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3958 ;********** 3959 3960 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3961 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3962 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3963 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3964 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3965 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3966 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3967 3968 006430 SN=SN+1 3969 000040 000000 ZZ=ZZ+ZZ 3970 IFE ZZ, 3971 032413 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 3972 032414 200 01 0 00 035123 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 3973 ;WHERE X VARIES FROM 0 THRU 35 3974 032415 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 3975 032416 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 3976 STOP^ 3977 032417 254 04 0 00 032420 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3978 032420 324 00 0 00 032421 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3979 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3980 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3981 032421 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 3982 STOP^ 3983 032422 254 04 0 00 032423 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 3984 032423 324 00 0 00 032424 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 3985 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 3986 ;IN THE SUBTEST) TO LOOP ON ERROR^ 3987 ;********** 3988 3989 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 3990 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 3991 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 3992 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 3993 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 3994 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 3995 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 3996 3997 006431 SN=SN+1 3998 000100 000000 ZZ=ZZ+ZZ 3999 IFE ZZ, 4000 032424 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4001 032425 200 01 0 00 035124 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4002 ;WHERE X VARIES FROM 0 THRU 35 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-14 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0094 4003 032426 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4004 032427 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4005 STOP^ 4006 032430 254 04 0 00 032431 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4007 032431 324 00 0 00 032432 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4008 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4009 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4010 032432 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4011 STOP^ 4012 032433 254 04 0 00 032434 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4013 032434 324 00 0 00 032435 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4014 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4015 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4016 ;********** 4017 4018 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 4019 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 4020 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 4021 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 4022 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 4023 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 4024 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 4025 4026 006432 SN=SN+1 4027 000200 000000 ZZ=ZZ+ZZ 4028 IFE ZZ, 4029 032435 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4030 032436 200 01 0 00 035125 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4031 ;WHERE X VARIES FROM 0 THRU 35 4032 032437 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4033 032440 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4034 STOP^ 4035 032441 254 04 0 00 032442 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4036 032442 324 00 0 00 032443 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4037 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4038 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4039 032443 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4040 STOP^ 4041 032444 254 04 0 00 032445 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4042 032445 324 00 0 00 032446 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4043 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4044 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4045 ;********** 4046 4047 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 4048 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 4049 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 4050 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 4051 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 4052 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 4053 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 4054 4055 006433 SN=SN+1 4056 000400 000000 ZZ=ZZ+ZZ 4057 IFE ZZ, DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-15 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0095 4058 032446 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4059 032447 200 01 0 00 035073 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4060 ;WHERE X VARIES FROM 0 THRU 35 4061 032450 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4062 032451 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4063 STOP^ 4064 032452 254 04 0 00 032453 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4065 032453 324 00 0 00 032454 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4066 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4067 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4068 032454 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4069 STOP^ 4070 032455 254 04 0 00 032456 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4071 032456 324 00 0 00 032457 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4072 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4073 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4074 ;********** 4075 4076 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 4077 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 4078 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 4079 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 4080 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 4081 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 4082 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 4083 4084 006434 SN=SN+1 4085 001000 000000 ZZ=ZZ+ZZ 4086 IFE ZZ, 4087 032457 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4088 032460 200 01 0 00 035126 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4089 ;WHERE X VARIES FROM 0 THRU 35 4090 032461 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4091 032462 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4092 STOP^ 4093 032463 254 04 0 00 032464 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4094 032464 324 00 0 00 032465 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4095 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4096 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4097 032465 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4098 STOP^ 4099 032466 254 04 0 00 032467 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4100 032467 324 00 0 00 032470 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4101 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4102 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4103 ;********** 4104 4105 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 4106 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 4107 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 4108 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 4109 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 4110 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 4111 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 4112 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-16 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0096 4113 006435 SN=SN+1 4114 002000 000000 ZZ=ZZ+ZZ 4115 IFE ZZ, 4116 032470 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4117 032471 200 01 0 00 035127 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4118 ;WHERE X VARIES FROM 0 THRU 35 4119 032472 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4120 032473 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4121 STOP^ 4122 032474 254 04 0 00 032475 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4123 032475 324 00 0 00 032476 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4124 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4125 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4126 032476 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4127 STOP^ 4128 032477 254 04 0 00 032500 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4129 032500 324 00 0 00 032501 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4130 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4131 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4132 ;********** 4133 4134 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 4135 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 4136 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 4137 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 4138 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 4139 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 4140 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 4141 4142 006436 SN=SN+1 4143 004000 000000 ZZ=ZZ+ZZ 4144 IFE ZZ, 4145 032501 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4146 032502 200 01 0 00 035130 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4147 ;WHERE X VARIES FROM 0 THRU 35 4148 032503 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4149 032504 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4150 STOP^ 4151 032505 254 04 0 00 032506 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4152 032506 324 00 0 00 032507 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4153 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4154 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4155 032507 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4156 STOP^ 4157 032510 254 04 0 00 032511 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4158 032511 324 00 0 00 032512 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4159 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4160 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4161 ;********** 4162 4163 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 4164 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 4165 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 4166 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 4167 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-17 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0097 4168 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 4169 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 4170 4171 006437 SN=SN+1 4172 010000 000000 ZZ=ZZ+ZZ 4173 IFE ZZ, 4174 032512 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4175 032513 200 01 0 00 035131 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4176 ;WHERE X VARIES FROM 0 THRU 35 4177 032514 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4178 032515 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4179 STOP^ 4180 032516 254 04 0 00 032517 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4181 032517 324 00 0 00 032520 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4182 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4183 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4184 032520 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4185 STOP^ 4186 032521 254 04 0 00 032522 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4187 032522 324 00 0 00 032523 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4188 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4189 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4190 ;********** 4191 4192 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 4193 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 4194 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 4195 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 4196 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 4197 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 4198 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 4199 4200 006440 SN=SN+1 4201 020000 000000 ZZ=ZZ+ZZ 4202 IFE ZZ, 4203 032523 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4204 032524 200 01 0 00 035132 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4205 ;WHERE X VARIES FROM 0 THRU 35 4206 032525 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4207 032526 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4208 STOP^ 4209 032527 254 04 0 00 032530 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4210 032530 324 00 0 00 032531 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4211 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4212 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4213 032531 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4214 STOP^ 4215 032532 254 04 0 00 032533 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4216 032533 324 00 0 00 032534 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4217 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4218 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4219 ;********** 4220 4221 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 4222 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-18 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0098 4223 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 4224 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 4225 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 4226 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 4227 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 4228 4229 006441 SN=SN+1 4230 040000 000000 ZZ=ZZ+ZZ 4231 IFE ZZ, 4232 032534 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4233 032535 200 01 0 00 035133 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4234 ;WHERE X VARIES FROM 0 THRU 35 4235 032536 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4236 032537 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4237 STOP^ 4238 032540 254 04 0 00 032541 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4239 032541 324 00 0 00 032542 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4240 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4241 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4242 032542 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4243 STOP^ 4244 032543 254 04 0 00 032544 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4245 032544 324 00 0 00 032545 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4246 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4247 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4248 ;********** 4249 4250 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 4251 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 4252 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 4253 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 4254 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 4255 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 4256 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 4257 4258 006442 SN=SN+1 4259 100000 000000 ZZ=ZZ+ZZ 4260 IFE ZZ, 4261 032545 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4262 032546 200 01 0 00 035134 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4263 ;WHERE X VARIES FROM 0 THRU 35 4264 032547 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4265 032550 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4266 STOP^ 4267 032551 254 04 0 00 032552 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4268 032552 324 00 0 00 032553 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4269 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4270 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4271 032553 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4272 STOP^ 4273 032554 254 04 0 00 032555 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4274 032555 324 00 0 00 032556 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4275 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4276 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4277 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-19 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0099 4278 4279 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 4280 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 4281 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 4282 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 4283 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 4284 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 4285 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 4286 4287 006443 SN=SN+1 4288 200000 000000 ZZ=ZZ+ZZ 4289 IFE ZZ, 4290 032556 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4291 032557 200 01 0 00 035135 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4292 ;WHERE X VARIES FROM 0 THRU 35 4293 032560 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4294 032561 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4295 STOP^ 4296 032562 254 04 0 00 032563 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4297 032563 324 00 0 00 032564 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4298 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4299 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4300 032564 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4301 STOP^ 4302 032565 254 04 0 00 032566 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4303 032566 324 00 0 00 032567 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4304 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4305 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4306 ;********** 4307 4308 ;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION 4309 ;IS ZERO, THE RESULT WILL BE ZERO. THIS TEST IS REPEATED 36 TIMES WITH 4310 ;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X 4311 ;WHERE X TAKES ON INTEGER VALUES 0 THRU 35. E CONTAINS ALL ZEROS. 4312 ;THE RESULT SHOULD BE ALL ZEROS IN THE AC. IF C(AC) IS NON-ZERO, 4313 ;'AND' FAILED. C(0) IS ALSO CHECKED FOR ALL ZEROS. IF C(0) IS 4314 ;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'. 4315 4316 006444 SN=SN+1 4317 400000 000000 ZZ=ZZ+ZZ 4318 IFE ZZ, 4319 032567 400 00 0 00 000000 SETZ ;PRESET E TO ALL ZEROS 4320 032570 200 01 0 00 035065 MOVE 1,[ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X 4321 ;WHERE X VARIES FROM 0 THRU 35 4322 032571 404 01 0 00 000000 AND 1,0 ;*AND SHOULD RESULT IN C(AC) = 0 4323 032572 332 00 0 00 000001 SKIPE 1 ;FAIL IF C(AC) NON-ZERO 4324 STOP^ 4325 032573 254 04 0 00 032574 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4326 032574 324 00 0 00 032575 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4327 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4328 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4329 032575 332 00 0 00 000000 SKIPE 0 ;FAIL IF C(0) IS NON-ZERO 4330 STOP^ 4331 032576 254 04 0 00 032577 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4332 032577 324 00 0 00 032600 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 24-20 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0100 4333 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4334 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4335 ;********** 4336 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0101 4337 006500 SN=6500 4338 000000 ZZ=0 4339 4340 A6500: REPEAT ^D36, 4341 <;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4342 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4343 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4344 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4345 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4346 SN=SN+1 4347 ZZ=ZZ+ZZ 4348 IFE ZZ, 4349 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4350 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4351 ;POSITION WITH ITSELF SHOULD RESULT WITH 4352 ;C(AC) NONZERO 4353 SKIPN ;PASS TEST IF C(AC) NONZERO 4354 STOP 4355 4356 ;********** 4357 > 4358 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4359 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4360 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4361 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4362 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4363 006501 SN=SN+1 4364 000000 ZZ=ZZ+ZZ 4365 000001 IFE ZZ, 4366 032600 200 00 0 00 035074 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4367 032601 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4368 ;POSITION WITH ITSELF SHOULD RESULT WITH 4369 ;C(AC) NONZERO 4370 032602 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4371 STOP^ 4372 032603 254 04 0 00 032604 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4373 032604 324 00 0 00 032605 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4374 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4375 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4376 4377 ;********** 4378 4379 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4380 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4381 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4382 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4383 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4384 006502 SN=SN+1 4385 000002 ZZ=ZZ+ZZ 4386 IFE ZZ, 4387 032605 200 00 0 00 035075 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4388 032606 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4389 ;POSITION WITH ITSELF SHOULD RESULT WITH 4390 ;C(AC) NONZERO 4391 032607 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0102 4392 STOP^ 4393 032610 254 04 0 00 032611 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4394 032611 324 00 0 00 032612 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4395 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4396 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4397 4398 ;********** 4399 4400 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4401 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4402 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4403 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4404 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4405 006503 SN=SN+1 4406 000004 ZZ=ZZ+ZZ 4407 IFE ZZ, 4408 032612 200 00 0 00 035076 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4409 032613 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4410 ;POSITION WITH ITSELF SHOULD RESULT WITH 4411 ;C(AC) NONZERO 4412 032614 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4413 STOP^ 4414 032615 254 04 0 00 032616 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4415 032616 324 00 0 00 032617 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4416 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4417 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4418 4419 ;********** 4420 4421 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4422 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4423 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4424 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4425 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4426 006504 SN=SN+1 4427 000010 ZZ=ZZ+ZZ 4428 IFE ZZ, 4429 032617 200 00 0 00 035077 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4430 032620 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4431 ;POSITION WITH ITSELF SHOULD RESULT WITH 4432 ;C(AC) NONZERO 4433 032621 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4434 STOP^ 4435 032622 254 04 0 00 032623 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4436 032623 324 00 0 00 032624 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4437 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4438 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4439 4440 ;********** 4441 4442 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4443 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4444 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4445 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4446 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-2 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0103 4447 006505 SN=SN+1 4448 000020 ZZ=ZZ+ZZ 4449 IFE ZZ, 4450 032624 200 00 0 00 035100 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4451 032625 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4452 ;POSITION WITH ITSELF SHOULD RESULT WITH 4453 ;C(AC) NONZERO 4454 032626 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4455 STOP^ 4456 032627 254 04 0 00 032630 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4457 032630 324 00 0 00 032631 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4458 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4459 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4460 4461 ;********** 4462 4463 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4464 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4465 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4466 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4467 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4468 006506 SN=SN+1 4469 000040 ZZ=ZZ+ZZ 4470 IFE ZZ, 4471 032631 200 00 0 00 035101 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4472 032632 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4473 ;POSITION WITH ITSELF SHOULD RESULT WITH 4474 ;C(AC) NONZERO 4475 032633 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4476 STOP^ 4477 032634 254 04 0 00 032635 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4478 032635 324 00 0 00 032636 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4479 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4480 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4481 4482 ;********** 4483 4484 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4485 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4486 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4487 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4488 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4489 006507 SN=SN+1 4490 000100 ZZ=ZZ+ZZ 4491 IFE ZZ, 4492 032636 200 00 0 00 035102 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4493 032637 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4494 ;POSITION WITH ITSELF SHOULD RESULT WITH 4495 ;C(AC) NONZERO 4496 032640 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4497 STOP^ 4498 032641 254 04 0 00 032642 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4499 032642 324 00 0 00 032643 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4500 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4501 ;IN THE SUBTEST) TO LOOP ON ERROR^ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-3 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0104 4502 4503 ;********** 4504 4505 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4506 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4507 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4508 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4509 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4510 006510 SN=SN+1 4511 000200 ZZ=ZZ+ZZ 4512 IFE ZZ, 4513 032643 200 00 0 00 035103 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4514 032644 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4515 ;POSITION WITH ITSELF SHOULD RESULT WITH 4516 ;C(AC) NONZERO 4517 032645 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4518 STOP^ 4519 032646 254 04 0 00 032647 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4520 032647 324 00 0 00 032650 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4521 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4522 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4523 4524 ;********** 4525 4526 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4527 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4528 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4529 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4530 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4531 006511 SN=SN+1 4532 000400 ZZ=ZZ+ZZ 4533 IFE ZZ, 4534 032650 200 00 0 00 035104 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4535 032651 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4536 ;POSITION WITH ITSELF SHOULD RESULT WITH 4537 ;C(AC) NONZERO 4538 032652 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4539 STOP^ 4540 032653 254 04 0 00 032654 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4541 032654 324 00 0 00 032655 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4542 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4543 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4544 4545 ;********** 4546 4547 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4548 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4549 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4550 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4551 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4552 006512 SN=SN+1 4553 001000 ZZ=ZZ+ZZ 4554 IFE ZZ, 4555 032655 200 00 0 00 035105 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4556 032656 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-4 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0105 4557 ;POSITION WITH ITSELF SHOULD RESULT WITH 4558 ;C(AC) NONZERO 4559 032657 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4560 STOP^ 4561 032660 254 04 0 00 032661 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4562 032661 324 00 0 00 032662 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4563 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4564 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4565 4566 ;********** 4567 4568 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4569 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4570 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4571 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4572 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4573 006513 SN=SN+1 4574 002000 ZZ=ZZ+ZZ 4575 IFE ZZ, 4576 032662 200 00 0 00 035106 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4577 032663 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4578 ;POSITION WITH ITSELF SHOULD RESULT WITH 4579 ;C(AC) NONZERO 4580 032664 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4581 STOP^ 4582 032665 254 04 0 00 032666 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4583 032666 324 00 0 00 032667 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4584 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4585 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4586 4587 ;********** 4588 4589 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4590 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4591 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4592 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4593 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4594 006514 SN=SN+1 4595 004000 ZZ=ZZ+ZZ 4596 IFE ZZ, 4597 032667 200 00 0 00 035107 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4598 032670 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4599 ;POSITION WITH ITSELF SHOULD RESULT WITH 4600 ;C(AC) NONZERO 4601 032671 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4602 STOP^ 4603 032672 254 04 0 00 032673 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4604 032673 324 00 0 00 032674 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4605 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4606 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4607 4608 ;********** 4609 4610 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4611 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-5 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0106 4612 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4613 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4614 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4615 006515 SN=SN+1 4616 010000 ZZ=ZZ+ZZ 4617 IFE ZZ, 4618 032674 200 00 0 00 035110 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4619 032675 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4620 ;POSITION WITH ITSELF SHOULD RESULT WITH 4621 ;C(AC) NONZERO 4622 032676 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4623 STOP^ 4624 032677 254 04 0 00 032700 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4625 032700 324 00 0 00 032701 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4626 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4627 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4628 4629 ;********** 4630 4631 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4632 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4633 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4634 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4635 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4636 006516 SN=SN+1 4637 020000 ZZ=ZZ+ZZ 4638 IFE ZZ, 4639 032701 200 00 0 00 035111 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4640 032702 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4641 ;POSITION WITH ITSELF SHOULD RESULT WITH 4642 ;C(AC) NONZERO 4643 032703 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4644 STOP^ 4645 032704 254 04 0 00 032705 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4646 032705 324 00 0 00 032706 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4647 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4648 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4649 4650 ;********** 4651 4652 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4653 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4654 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4655 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4656 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4657 006517 SN=SN+1 4658 040000 ZZ=ZZ+ZZ 4659 IFE ZZ, 4660 032706 200 00 0 00 035112 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4661 032707 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4662 ;POSITION WITH ITSELF SHOULD RESULT WITH 4663 ;C(AC) NONZERO 4664 032710 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4665 STOP^ 4666 032711 254 04 0 00 032712 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-6 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0107 4667 032712 324 00 0 00 032713 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4668 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4669 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4670 4671 ;********** 4672 4673 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4674 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4675 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4676 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4677 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4678 006520 SN=SN+1 4679 100000 ZZ=ZZ+ZZ 4680 IFE ZZ, 4681 032713 200 00 0 00 035113 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4682 032714 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4683 ;POSITION WITH ITSELF SHOULD RESULT WITH 4684 ;C(AC) NONZERO 4685 032715 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4686 STOP^ 4687 032716 254 04 0 00 032717 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4688 032717 324 00 0 00 032720 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4689 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4690 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4691 4692 ;********** 4693 4694 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4695 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4696 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4697 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4698 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4699 006521 SN=SN+1 4700 200000 ZZ=ZZ+ZZ 4701 IFE ZZ, 4702 032720 200 00 0 00 035114 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4703 032721 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4704 ;POSITION WITH ITSELF SHOULD RESULT WITH 4705 ;C(AC) NONZERO 4706 032722 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4707 STOP^ 4708 032723 254 04 0 00 032724 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4709 032724 324 00 0 00 032725 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4710 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4711 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4712 4713 ;********** 4714 4715 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4716 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4717 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4718 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4719 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4720 006522 SN=SN+1 4721 400000 ZZ=ZZ+ZZ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-7 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0108 4722 IFE ZZ, 4723 032725 200 00 0 00 035115 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4724 032726 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4725 ;POSITION WITH ITSELF SHOULD RESULT WITH 4726 ;C(AC) NONZERO 4727 032727 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4728 STOP^ 4729 032730 254 04 0 00 032731 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4730 032731 324 00 0 00 032732 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4731 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4732 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4733 4734 ;********** 4735 4736 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4737 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4738 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4739 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4740 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4741 006523 SN=SN+1 4742 000001 000000 ZZ=ZZ+ZZ 4743 IFE ZZ, 4744 032732 200 00 0 00 035116 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4745 032733 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4746 ;POSITION WITH ITSELF SHOULD RESULT WITH 4747 ;C(AC) NONZERO 4748 032734 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4749 STOP^ 4750 032735 254 04 0 00 032736 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4751 032736 324 00 0 00 032737 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4752 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4753 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4754 4755 ;********** 4756 4757 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4758 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4759 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4760 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4761 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4762 006524 SN=SN+1 4763 000002 000000 ZZ=ZZ+ZZ 4764 IFE ZZ, 4765 032737 200 00 0 00 035117 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4766 032740 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4767 ;POSITION WITH ITSELF SHOULD RESULT WITH 4768 ;C(AC) NONZERO 4769 032741 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4770 STOP^ 4771 032742 254 04 0 00 032743 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4772 032743 324 00 0 00 032744 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4773 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4774 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4775 4776 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-8 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0109 4777 4778 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4779 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4780 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4781 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4782 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4783 006525 SN=SN+1 4784 000004 000000 ZZ=ZZ+ZZ 4785 IFE ZZ, 4786 032744 200 00 0 00 035120 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4787 032745 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4788 ;POSITION WITH ITSELF SHOULD RESULT WITH 4789 ;C(AC) NONZERO 4790 032746 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4791 STOP^ 4792 032747 254 04 0 00 032750 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4793 032750 324 00 0 00 032751 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4794 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4795 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4796 4797 ;********** 4798 4799 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4800 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4801 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4802 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4803 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4804 006526 SN=SN+1 4805 000010 000000 ZZ=ZZ+ZZ 4806 IFE ZZ, 4807 032751 200 00 0 00 035121 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4808 032752 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4809 ;POSITION WITH ITSELF SHOULD RESULT WITH 4810 ;C(AC) NONZERO 4811 032753 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4812 STOP^ 4813 032754 254 04 0 00 032755 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4814 032755 324 00 0 00 032756 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4815 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4816 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4817 4818 ;********** 4819 4820 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4821 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4822 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4823 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4824 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4825 006527 SN=SN+1 4826 000020 000000 ZZ=ZZ+ZZ 4827 IFE ZZ, 4828 032756 200 00 0 00 035122 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4829 032757 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4830 ;POSITION WITH ITSELF SHOULD RESULT WITH 4831 ;C(AC) NONZERO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-9 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0110 4832 032760 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4833 STOP^ 4834 032761 254 04 0 00 032762 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4835 032762 324 00 0 00 032763 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4836 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4837 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4838 4839 ;********** 4840 4841 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4842 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4843 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4844 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4845 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4846 006530 SN=SN+1 4847 000040 000000 ZZ=ZZ+ZZ 4848 IFE ZZ, 4849 032763 200 00 0 00 035123 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4850 032764 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4851 ;POSITION WITH ITSELF SHOULD RESULT WITH 4852 ;C(AC) NONZERO 4853 032765 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4854 STOP^ 4855 032766 254 04 0 00 032767 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4856 032767 324 00 0 00 032770 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4857 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4858 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4859 4860 ;********** 4861 4862 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4863 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4864 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4865 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4866 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4867 006531 SN=SN+1 4868 000100 000000 ZZ=ZZ+ZZ 4869 IFE ZZ, 4870 032770 200 00 0 00 035124 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4871 032771 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4872 ;POSITION WITH ITSELF SHOULD RESULT WITH 4873 ;C(AC) NONZERO 4874 032772 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4875 STOP^ 4876 032773 254 04 0 00 032774 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4877 032774 324 00 0 00 032775 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4878 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4879 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4880 4881 ;********** 4882 4883 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4884 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4885 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4886 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-10 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0111 4887 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4888 006532 SN=SN+1 4889 000200 000000 ZZ=ZZ+ZZ 4890 IFE ZZ, 4891 032775 200 00 0 00 035125 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4892 032776 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4893 ;POSITION WITH ITSELF SHOULD RESULT WITH 4894 ;C(AC) NONZERO 4895 032777 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4896 STOP^ 4897 033000 254 04 0 00 033001 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4898 033001 324 00 0 00 033002 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4899 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4900 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4901 4902 ;********** 4903 4904 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4905 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4906 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4907 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4908 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4909 006533 SN=SN+1 4910 000400 000000 ZZ=ZZ+ZZ 4911 IFE ZZ, 4912 033002 200 00 0 00 035073 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4913 033003 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4914 ;POSITION WITH ITSELF SHOULD RESULT WITH 4915 ;C(AC) NONZERO 4916 033004 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4917 STOP^ 4918 033005 254 04 0 00 033006 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4919 033006 324 00 0 00 033007 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4920 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4921 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4922 4923 ;********** 4924 4925 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4926 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4927 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4928 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4929 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4930 006534 SN=SN+1 4931 001000 000000 ZZ=ZZ+ZZ 4932 IFE ZZ, 4933 033007 200 00 0 00 035126 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4934 033010 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4935 ;POSITION WITH ITSELF SHOULD RESULT WITH 4936 ;C(AC) NONZERO 4937 033011 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4938 STOP^ 4939 033012 254 04 0 00 033013 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4940 033013 324 00 0 00 033014 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4941 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-11 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0112 4942 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4943 4944 ;********** 4945 4946 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4947 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4948 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4949 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4950 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4951 006535 SN=SN+1 4952 002000 000000 ZZ=ZZ+ZZ 4953 IFE ZZ, 4954 033014 200 00 0 00 035127 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4955 033015 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4956 ;POSITION WITH ITSELF SHOULD RESULT WITH 4957 ;C(AC) NONZERO 4958 033016 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4959 STOP^ 4960 033017 254 04 0 00 033020 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4961 033020 324 00 0 00 033021 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4962 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4963 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4964 4965 ;********** 4966 4967 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4968 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4969 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4970 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4971 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4972 006536 SN=SN+1 4973 004000 000000 ZZ=ZZ+ZZ 4974 IFE ZZ, 4975 033021 200 00 0 00 035130 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 4976 033022 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4977 ;POSITION WITH ITSELF SHOULD RESULT WITH 4978 ;C(AC) NONZERO 4979 033023 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 4980 STOP^ 4981 033024 254 04 0 00 033025 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 4982 033025 324 00 0 00 033026 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 4983 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 4984 ;IN THE SUBTEST) TO LOOP ON ERROR^ 4985 4986 ;********** 4987 4988 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 4989 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 4990 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 4991 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 4992 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 4993 006537 SN=SN+1 4994 010000 000000 ZZ=ZZ+ZZ 4995 IFE ZZ, 4996 033026 200 00 0 00 035131 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-12 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0113 4997 033027 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 4998 ;POSITION WITH ITSELF SHOULD RESULT WITH 4999 ;C(AC) NONZERO 5000 033030 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 5001 STOP^ 5002 033031 254 04 0 00 033032 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5003 033032 324 00 0 00 033033 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5004 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5005 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5006 5007 ;********** 5008 5009 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 5010 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 5011 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 5012 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 5013 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 5014 006540 SN=SN+1 5015 020000 000000 ZZ=ZZ+ZZ 5016 IFE ZZ, 5017 033033 200 00 0 00 035132 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 5018 033034 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 5019 ;POSITION WITH ITSELF SHOULD RESULT WITH 5020 ;C(AC) NONZERO 5021 033035 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 5022 STOP^ 5023 033036 254 04 0 00 033037 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5024 033037 324 00 0 00 033040 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5025 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5026 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5027 5028 ;********** 5029 5030 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 5031 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 5032 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 5033 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 5034 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 5035 006541 SN=SN+1 5036 040000 000000 ZZ=ZZ+ZZ 5037 IFE ZZ, 5038 033040 200 00 0 00 035133 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 5039 033041 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 5040 ;POSITION WITH ITSELF SHOULD RESULT WITH 5041 ;C(AC) NONZERO 5042 033042 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 5043 STOP^ 5044 033043 254 04 0 00 033044 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5045 033044 324 00 0 00 033045 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5046 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5047 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5048 5049 ;********** 5050 5051 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-13 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0114 5052 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 5053 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 5054 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 5055 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 5056 006542 SN=SN+1 5057 100000 000000 ZZ=ZZ+ZZ 5058 IFE ZZ, 5059 033045 200 00 0 00 035134 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 5060 033046 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 5061 ;POSITION WITH ITSELF SHOULD RESULT WITH 5062 ;C(AC) NONZERO 5063 033047 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 5064 STOP^ 5065 033050 254 04 0 00 033051 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5066 033051 324 00 0 00 033052 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5067 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5068 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5069 5070 ;********** 5071 5072 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 5073 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 5074 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 5075 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 5076 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 5077 006543 SN=SN+1 5078 200000 000000 ZZ=ZZ+ZZ 5079 IFE ZZ, 5080 033052 200 00 0 00 035135 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 5081 033053 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 5082 ;POSITION WITH ITSELF SHOULD RESULT WITH 5083 ;C(AC) NONZERO 5084 033054 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 5085 STOP^ 5086 033055 254 04 0 00 033056 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5087 033056 324 00 0 00 033057 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5088 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5089 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5090 5091 ;********** 5092 5093 ;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF 5094 ;SHOULD BE THAT SAME WORD. A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE 5095 ;IN ONLY ONE BIT IS ANDED WITH ITSELF. THE AC IS THEN CHECKED FOR ITS 5096 ;CONTENTS NONZERO. IF C(AC)=0, THE 'AND' INSTRUCTION FAILED. THIS TEST IS REPEATED 5097 ;36 TIMES TO CHECK EACH BIT INDIVIDUALLY. 5098 006544 SN=SN+1 5099 400000 000000 ZZ=ZZ+ZZ 5100 IFE ZZ, 5101 033057 200 00 0 00 035065 MOVE [ZZ] ;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT 5102 033060 404 00 0 00 000000 AND ;*AND OF WORD CONTAINING A ONE IN ONE BIT 5103 ;POSITION WITH ITSELF SHOULD RESULT WITH 5104 ;C(AC) NONZERO 5105 033061 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NONZERO 5106 STOP^ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 25-14 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0115 5107 033062 254 04 0 00 033063 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5108 033063 324 00 0 00 033064 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5109 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5110 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5111 5112 ;********** 5113 5114 ;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE 5115 ;C(AC)=0 AND C(E)=0 AND E OUTSIDE OF THE AC RANGE IS ALL ZEROS IN THE AC. 5116 ;FIRST, THE AC IS CLEARED; THEN, THE C(AC) IS ANDED WITH C(E) WHEN 5117 ;E GREATER THAN 20 AND C(E)=0. THE RESULT SHOULD BE C(AC)=0. 5118 ;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND. 5119 5120 033064 200 00 0 00 035062 A6600: MOVE [0] ;PRESET AC TO ALL ZEROS 5121 033065 404 00 0 00 035062 AND [0] ;*AND OF TWO WORDS OF ALL ZEROS 5122 ;SHOULD RESULT IN C(AC)=0 5123 033066 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 5124 STOP^ 5125 033067 254 04 0 00 033070 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5126 033070 324 00 0 00 033071 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5127 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5128 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5129 5130 ;********** 5131 5132 ;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(AC)=0 5133 ;AND C(E) IS ALL ONES IS AN AC CONTAINING ALL ZEROS. FIRST, THE AC IS 5134 ;CLEARED; THEN THE C(AC) IS ANDED WITH AN E CONTAINING ALL ONES, WHERE 5135 ;E IS BEYOND THE AC RANGE. THE RESULT SHOULD BE C(AC)=0. 5136 ;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND. 5137 5138 033071 200 00 0 00 035062 A6700: MOVE [0] ;PRESET AC TO ALL ZEROS 5139 033072 404 00 0 00 035063 AND [-1] ;*AND OF TWO WORDS WHERE C(AC)=0 SHOULD RESULT IN C(AC)=0 5140 033073 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 5141 STOP^ 5142 033074 254 04 0 00 033075 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5143 033075 324 00 0 00 033076 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5144 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5145 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5146 5147 ;AD FM+EN [ADFP],AD FM+EN A [ADFP], 5148 ;F CYC ACT EN C [F1],IR BOOLE AD FM+F [IR2], 5149 ;IR BOOLE [IR1],IRXX(1,4,5,11,13,16) [IR2] 5150 5151 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 26 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0116 5152 ;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(E)=0 5153 ;AND C(AC) IS ALL ONES IS AN AC CONTAINING ALL ZEROS. FIRST, THE 5154 ;AC IS SET TO ALL ONES; THEN, THE AC IS ANDED WITH AN E CONTAINING ALL 5155 ;ZEROS, WHERE E IS BEYOND THE AC RANGE. THE RESULT SHOULD BE C(AC)=0. 5156 ;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND. 5157 5158 033076 200 00 0 00 035063 A7000: MOVE [-1] ;PRESET AC TO ALL ONES 5159 033077 404 00 0 00 035062 AND [0] ;*AND OF TWO WORDS WHERE C(E)=0 SHOULD RESULT IN C(AC)=0 5160 033100 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 5161 STOP^ 5162 033101 254 04 0 00 033102 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5163 033102 324 00 0 00 033103 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5164 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5165 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5166 5167 ;********** 5168 5169 ;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(E) IS 5170 ;ALL ONES AND C(AC) IS ALL ONES IS AN AC CONTAINING ALL ONES. FIRST, THE 5171 ;AC IS SET TO ALL ONES; THEN, C(AC) IS ANDED WITH AN E CONTAINING ALL 5172 ;ONES. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5173 ;IF C(AC) IS ZERO, 'AND' FAILED WITH THE MEMORY OPERAND. 5174 5175 033103 200 00 0 00 035063 A7100: MOVE [-1] ;PRELOAD AC WITH ALL ONES 5176 033104 404 00 0 00 035063 AND [-1] ;*AND OF TWO WORDS OF ALL ONES SHOULD 5177 ;RESULT IN C(AC)=ALL ONES 5178 033105 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) IS NON ZERO 5179 STOP^ 5180 033106 254 04 0 00 033107 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5181 033107 324 00 0 00 033110 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5182 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5183 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5184 5185 ;********** 5186 5187 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5188 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHERE CONTENTS IS NON-ZERO. 5189 ;FIRST, THE AC IS CLEARED, THEN, XOR IS EXECUTED WHERE C(E) IS NON-ZERO. 5190 ;THE AC IS THEN CHECKED FOR NON-ZERO CONTENTS. 5191 033110 200 00 0 00 035062 A7200: MOVE [0] ;CLEAR AC 5192 033111 430 00 0 00 035141 XOR [707070707070] ;*XOR WITH C(AC)=0 AND C(E)=7070707070 SHOULD 5193 ;RESTULT IN C(AC)=707070707070 5194 033112 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5195 STOP^ 5196 033113 254 04 0 00 033114 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5197 033114 324 00 0 00 033115 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5198 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5199 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5200 5201 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0117 5202 007300 SN=7300 5203 000000 ZZ=0 5204 5205 A7300: REPEAT ^D36, 5206 <;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5207 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5208 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5209 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5210 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5211 SN=SN+1 5212 ZZ=ZZ+ZZ 5213 IFE ZZ, 5214 MOVE [0] ;CLEAR AC 5215 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5216 ;RESULT IN C(AC) NONZERO 5217 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5218 STOP 5219 5220 ;********** 5221 > 5222 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5223 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5224 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5225 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5226 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5227 007301 SN=SN+1 5228 000000 ZZ=ZZ+ZZ 5229 000001 IFE ZZ, 5230 033115 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5231 033116 430 00 0 00 035074 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5232 ;RESULT IN C(AC) NONZERO 5233 033117 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5234 STOP^ 5235 033120 254 04 0 00 033121 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5236 033121 324 00 0 00 033122 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5237 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5238 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5239 5240 ;********** 5241 5242 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5243 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5244 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5245 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5246 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5247 007302 SN=SN+1 5248 000002 ZZ=ZZ+ZZ 5249 IFE ZZ, 5250 033122 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5251 033123 430 00 0 00 035075 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5252 ;RESULT IN C(AC) NONZERO 5253 033124 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5254 STOP^ 5255 033125 254 04 0 00 033126 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5256 033126 324 00 0 00 033127 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0118 5257 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5258 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5259 5260 ;********** 5261 5262 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5263 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5264 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5265 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5266 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5267 007303 SN=SN+1 5268 000004 ZZ=ZZ+ZZ 5269 IFE ZZ, 5270 033127 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5271 033130 430 00 0 00 035076 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5272 ;RESULT IN C(AC) NONZERO 5273 033131 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5274 STOP^ 5275 033132 254 04 0 00 033133 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5276 033133 324 00 0 00 033134 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5277 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5278 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5279 5280 ;********** 5281 5282 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5283 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5284 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5285 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5286 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5287 007304 SN=SN+1 5288 000010 ZZ=ZZ+ZZ 5289 IFE ZZ, 5290 033134 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5291 033135 430 00 0 00 035077 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5292 ;RESULT IN C(AC) NONZERO 5293 033136 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5294 STOP^ 5295 033137 254 04 0 00 033140 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5296 033140 324 00 0 00 033141 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5297 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5298 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5299 5300 ;********** 5301 5302 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5303 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5304 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5305 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5306 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5307 007305 SN=SN+1 5308 000020 ZZ=ZZ+ZZ 5309 IFE ZZ, 5310 033141 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5311 033142 430 00 0 00 035100 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-2 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0119 5312 ;RESULT IN C(AC) NONZERO 5313 033143 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5314 STOP^ 5315 033144 254 04 0 00 033145 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5316 033145 324 00 0 00 033146 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5317 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5318 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5319 5320 ;********** 5321 5322 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5323 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5324 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5325 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5326 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5327 007306 SN=SN+1 5328 000040 ZZ=ZZ+ZZ 5329 IFE ZZ, 5330 033146 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5331 033147 430 00 0 00 035101 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5332 ;RESULT IN C(AC) NONZERO 5333 033150 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5334 STOP^ 5335 033151 254 04 0 00 033152 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5336 033152 324 00 0 00 033153 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5337 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5338 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5339 5340 ;********** 5341 5342 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5343 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5344 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5345 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5346 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5347 007307 SN=SN+1 5348 000100 ZZ=ZZ+ZZ 5349 IFE ZZ, 5350 033153 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5351 033154 430 00 0 00 035102 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5352 ;RESULT IN C(AC) NONZERO 5353 033155 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5354 STOP^ 5355 033156 254 04 0 00 033157 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5356 033157 324 00 0 00 033160 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5357 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5358 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5359 5360 ;********** 5361 5362 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5363 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5364 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5365 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5366 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-3 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0120 5367 007310 SN=SN+1 5368 000200 ZZ=ZZ+ZZ 5369 IFE ZZ, 5370 033160 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5371 033161 430 00 0 00 035103 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5372 ;RESULT IN C(AC) NONZERO 5373 033162 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5374 STOP^ 5375 033163 254 04 0 00 033164 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5376 033164 324 00 0 00 033165 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5377 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5378 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5379 5380 ;********** 5381 5382 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5383 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5384 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5385 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5386 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5387 007311 SN=SN+1 5388 000400 ZZ=ZZ+ZZ 5389 IFE ZZ, 5390 033165 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5391 033166 430 00 0 00 035104 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5392 ;RESULT IN C(AC) NONZERO 5393 033167 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5394 STOP^ 5395 033170 254 04 0 00 033171 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5396 033171 324 00 0 00 033172 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5397 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5398 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5399 5400 ;********** 5401 5402 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5403 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5404 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5405 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5406 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5407 007312 SN=SN+1 5408 001000 ZZ=ZZ+ZZ 5409 IFE ZZ, 5410 033172 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5411 033173 430 00 0 00 035105 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5412 ;RESULT IN C(AC) NONZERO 5413 033174 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5414 STOP^ 5415 033175 254 04 0 00 033176 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5416 033176 324 00 0 00 033177 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5417 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5418 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5419 5420 ;********** 5421 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-4 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0121 5422 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5423 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5424 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5425 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5426 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5427 007313 SN=SN+1 5428 002000 ZZ=ZZ+ZZ 5429 IFE ZZ, 5430 033177 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5431 033200 430 00 0 00 035106 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5432 ;RESULT IN C(AC) NONZERO 5433 033201 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5434 STOP^ 5435 033202 254 04 0 00 033203 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5436 033203 324 00 0 00 033204 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5437 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5438 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5439 5440 ;********** 5441 5442 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5443 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5444 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5445 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5446 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5447 007314 SN=SN+1 5448 004000 ZZ=ZZ+ZZ 5449 IFE ZZ, 5450 033204 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5451 033205 430 00 0 00 035107 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5452 ;RESULT IN C(AC) NONZERO 5453 033206 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5454 STOP^ 5455 033207 254 04 0 00 033210 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5456 033210 324 00 0 00 033211 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5457 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5458 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5459 5460 ;********** 5461 5462 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5463 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5464 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5465 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5466 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5467 007315 SN=SN+1 5468 010000 ZZ=ZZ+ZZ 5469 IFE ZZ, 5470 033211 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5471 033212 430 00 0 00 035110 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5472 ;RESULT IN C(AC) NONZERO 5473 033213 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5474 STOP^ 5475 033214 254 04 0 00 033215 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5476 033215 324 00 0 00 033216 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-5 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0122 5477 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5478 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5479 5480 ;********** 5481 5482 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5483 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5484 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5485 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5486 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5487 007316 SN=SN+1 5488 020000 ZZ=ZZ+ZZ 5489 IFE ZZ, 5490 033216 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5491 033217 430 00 0 00 035111 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5492 ;RESULT IN C(AC) NONZERO 5493 033220 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5494 STOP^ 5495 033221 254 04 0 00 033222 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5496 033222 324 00 0 00 033223 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5497 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5498 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5499 5500 ;********** 5501 5502 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5503 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5504 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5505 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5506 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5507 007317 SN=SN+1 5508 040000 ZZ=ZZ+ZZ 5509 IFE ZZ, 5510 033223 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5511 033224 430 00 0 00 035112 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5512 ;RESULT IN C(AC) NONZERO 5513 033225 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5514 STOP^ 5515 033226 254 04 0 00 033227 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5516 033227 324 00 0 00 033230 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5517 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5518 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5519 5520 ;********** 5521 5522 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5523 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5524 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5525 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5526 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5527 007320 SN=SN+1 5528 100000 ZZ=ZZ+ZZ 5529 IFE ZZ, 5530 033230 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5531 033231 430 00 0 00 035113 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-6 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0123 5532 ;RESULT IN C(AC) NONZERO 5533 033232 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5534 STOP^ 5535 033233 254 04 0 00 033234 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5536 033234 324 00 0 00 033235 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5537 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5538 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5539 5540 ;********** 5541 5542 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5543 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5544 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5545 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5546 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5547 007321 SN=SN+1 5548 200000 ZZ=ZZ+ZZ 5549 IFE ZZ, 5550 033235 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5551 033236 430 00 0 00 035114 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5552 ;RESULT IN C(AC) NONZERO 5553 033237 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5554 STOP^ 5555 033240 254 04 0 00 033241 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5556 033241 324 00 0 00 033242 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5557 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5558 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5559 5560 ;********** 5561 5562 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5563 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5564 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5565 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5566 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5567 007322 SN=SN+1 5568 400000 ZZ=ZZ+ZZ 5569 IFE ZZ, 5570 033242 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5571 033243 430 00 0 00 035115 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5572 ;RESULT IN C(AC) NONZERO 5573 033244 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5574 STOP^ 5575 033245 254 04 0 00 033246 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5576 033246 324 00 0 00 033247 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5577 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5578 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5579 5580 ;********** 5581 5582 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5583 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5584 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5585 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5586 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-7 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0124 5587 007323 SN=SN+1 5588 000001 000000 ZZ=ZZ+ZZ 5589 IFE ZZ, 5590 033247 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5591 033250 430 00 0 00 035116 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5592 ;RESULT IN C(AC) NONZERO 5593 033251 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5594 STOP^ 5595 033252 254 04 0 00 033253 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5596 033253 324 00 0 00 033254 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5597 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5598 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5599 5600 ;********** 5601 5602 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5603 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5604 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5605 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5606 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5607 007324 SN=SN+1 5608 000002 000000 ZZ=ZZ+ZZ 5609 IFE ZZ, 5610 033254 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5611 033255 430 00 0 00 035117 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5612 ;RESULT IN C(AC) NONZERO 5613 033256 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5614 STOP^ 5615 033257 254 04 0 00 033260 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5616 033260 324 00 0 00 033261 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5617 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5618 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5619 5620 ;********** 5621 5622 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5623 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5624 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5625 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5626 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5627 007325 SN=SN+1 5628 000004 000000 ZZ=ZZ+ZZ 5629 IFE ZZ, 5630 033261 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5631 033262 430 00 0 00 035120 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5632 ;RESULT IN C(AC) NONZERO 5633 033263 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5634 STOP^ 5635 033264 254 04 0 00 033265 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5636 033265 324 00 0 00 033266 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5637 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5638 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5639 5640 ;********** 5641 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-8 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0125 5642 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5643 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5644 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5645 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5646 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5647 007326 SN=SN+1 5648 000010 000000 ZZ=ZZ+ZZ 5649 IFE ZZ, 5650 033266 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5651 033267 430 00 0 00 035121 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5652 ;RESULT IN C(AC) NONZERO 5653 033270 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5654 STOP^ 5655 033271 254 04 0 00 033272 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5656 033272 324 00 0 00 033273 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5657 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5658 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5659 5660 ;********** 5661 5662 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5663 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5664 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5665 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5666 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5667 007327 SN=SN+1 5668 000020 000000 ZZ=ZZ+ZZ 5669 IFE ZZ, 5670 033273 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5671 033274 430 00 0 00 035122 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5672 ;RESULT IN C(AC) NONZERO 5673 033275 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5674 STOP^ 5675 033276 254 04 0 00 033277 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5676 033277 324 00 0 00 033300 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5677 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5678 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5679 5680 ;********** 5681 5682 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5683 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5684 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5685 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5686 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5687 007330 SN=SN+1 5688 000040 000000 ZZ=ZZ+ZZ 5689 IFE ZZ, 5690 033300 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5691 033301 430 00 0 00 035123 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5692 ;RESULT IN C(AC) NONZERO 5693 033302 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5694 STOP^ 5695 033303 254 04 0 00 033304 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5696 033304 324 00 0 00 033305 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-9 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0126 5697 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5698 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5699 5700 ;********** 5701 5702 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5703 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5704 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5705 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5706 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5707 007331 SN=SN+1 5708 000100 000000 ZZ=ZZ+ZZ 5709 IFE ZZ, 5710 033305 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5711 033306 430 00 0 00 035124 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5712 ;RESULT IN C(AC) NONZERO 5713 033307 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5714 STOP^ 5715 033310 254 04 0 00 033311 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5716 033311 324 00 0 00 033312 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5717 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5718 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5719 5720 ;********** 5721 5722 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5723 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5724 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5725 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5726 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5727 007332 SN=SN+1 5728 000200 000000 ZZ=ZZ+ZZ 5729 IFE ZZ, 5730 033312 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5731 033313 430 00 0 00 035125 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5732 ;RESULT IN C(AC) NONZERO 5733 033314 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5734 STOP^ 5735 033315 254 04 0 00 033316 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5736 033316 324 00 0 00 033317 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5737 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5738 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5739 5740 ;********** 5741 5742 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5743 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5744 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5745 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5746 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5747 007333 SN=SN+1 5748 000400 000000 ZZ=ZZ+ZZ 5749 IFE ZZ, 5750 033317 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5751 033320 430 00 0 00 035073 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-10 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0127 5752 ;RESULT IN C(AC) NONZERO 5753 033321 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5754 STOP^ 5755 033322 254 04 0 00 033323 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5756 033323 324 00 0 00 033324 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5757 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5758 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5759 5760 ;********** 5761 5762 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5763 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5764 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5765 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5766 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5767 007334 SN=SN+1 5768 001000 000000 ZZ=ZZ+ZZ 5769 IFE ZZ, 5770 033324 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5771 033325 430 00 0 00 035126 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5772 ;RESULT IN C(AC) NONZERO 5773 033326 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5774 STOP^ 5775 033327 254 04 0 00 033330 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5776 033330 324 00 0 00 033331 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5777 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5778 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5779 5780 ;********** 5781 5782 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5783 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5784 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5785 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5786 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5787 007335 SN=SN+1 5788 002000 000000 ZZ=ZZ+ZZ 5789 IFE ZZ, 5790 033331 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5791 033332 430 00 0 00 035127 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5792 ;RESULT IN C(AC) NONZERO 5793 033333 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5794 STOP^ 5795 033334 254 04 0 00 033335 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5796 033335 324 00 0 00 033336 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5797 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5798 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5799 5800 ;********** 5801 5802 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5803 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5804 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5805 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5806 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-11 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0128 5807 007336 SN=SN+1 5808 004000 000000 ZZ=ZZ+ZZ 5809 IFE ZZ, 5810 033336 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5811 033337 430 00 0 00 035130 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5812 ;RESULT IN C(AC) NONZERO 5813 033340 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5814 STOP^ 5815 033341 254 04 0 00 033342 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5816 033342 324 00 0 00 033343 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5817 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5818 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5819 5820 ;********** 5821 5822 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5823 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5824 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5825 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5826 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5827 007337 SN=SN+1 5828 010000 000000 ZZ=ZZ+ZZ 5829 IFE ZZ, 5830 033343 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5831 033344 430 00 0 00 035131 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5832 ;RESULT IN C(AC) NONZERO 5833 033345 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5834 STOP^ 5835 033346 254 04 0 00 033347 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5836 033347 324 00 0 00 033350 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5837 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5838 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5839 5840 ;********** 5841 5842 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5843 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5844 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5845 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5846 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5847 007340 SN=SN+1 5848 020000 000000 ZZ=ZZ+ZZ 5849 IFE ZZ, 5850 033350 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5851 033351 430 00 0 00 035132 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5852 ;RESULT IN C(AC) NONZERO 5853 033352 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5854 STOP^ 5855 033353 254 04 0 00 033354 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5856 033354 324 00 0 00 033355 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5857 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5858 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5859 5860 ;********** 5861 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-12 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0129 5862 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5863 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5864 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5865 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5866 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5867 007341 SN=SN+1 5868 040000 000000 ZZ=ZZ+ZZ 5869 IFE ZZ, 5870 033355 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5871 033356 430 00 0 00 035133 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5872 ;RESULT IN C(AC) NONZERO 5873 033357 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5874 STOP^ 5875 033360 254 04 0 00 033361 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5876 033361 324 00 0 00 033362 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5877 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5878 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5879 5880 ;********** 5881 5882 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5883 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5884 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5885 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5886 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5887 007342 SN=SN+1 5888 100000 000000 ZZ=ZZ+ZZ 5889 IFE ZZ, 5890 033362 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5891 033363 430 00 0 00 035134 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5892 ;RESULT IN C(AC) NONZERO 5893 033364 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5894 STOP^ 5895 033365 254 04 0 00 033366 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5896 033366 324 00 0 00 033367 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5897 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5898 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5899 5900 ;********** 5901 5902 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5903 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5904 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5905 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5906 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5907 007343 SN=SN+1 5908 200000 000000 ZZ=ZZ+ZZ 5909 IFE ZZ, 5910 033367 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5911 033370 430 00 0 00 035135 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5912 ;RESULT IN C(AC) NONZERO 5913 033371 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5914 STOP^ 5915 033372 254 04 0 00 033373 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5916 033373 324 00 0 00 033374 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-13 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0130 5917 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5918 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5919 5920 ;********** 5921 5922 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5923 ;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5924 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED 5925 ;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE. 5926 ;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5927 007344 SN=SN+1 5928 400000 000000 ZZ=ZZ+ZZ 5929 IFE ZZ, 5930 033374 200 00 0 00 035062 MOVE [0] ;CLEAR AC 5931 033375 430 00 0 00 035065 XOR [ZZ] ;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD 5932 ;RESULT IN C(AC) NONZERO 5933 033376 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5934 STOP^ 5935 033377 254 04 0 00 033400 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5936 033400 324 00 0 00 033401 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5937 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5938 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5939 5940 ;********** 5941 5942 007400 SN=7400 5943 000000 ZZ=0 5944 5945 A7400: REPEAT ^D36, 5946 <;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5947 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5948 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 5949 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 5950 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5951 SN=SN+1 5952 ZZ=ZZ+ZZ 5953 IFE ZZ, 5954 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 5955 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 5956 ;RESULT IN C(AC) NON-ZERO 5957 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5958 STOP 5959 5960 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 5961 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 5962 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 5963 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 5964 5965 ;********** 5966 > 5967 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5968 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5969 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 5970 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 5971 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-14 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0131 5972 007401 SN=SN+1 5973 000000 ZZ=ZZ+ZZ 5974 000001 IFE ZZ, 5975 033401 200 00 0 00 035074 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 5976 033402 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 5977 ;RESULT IN C(AC) NON-ZERO 5978 033403 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 5979 STOP^ 5980 033404 254 04 0 00 033405 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 5981 033405 324 00 0 00 033406 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 5982 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 5983 ;IN THE SUBTEST) TO LOOP ON ERROR^ 5984 5985 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 5986 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 5987 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 5988 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 5989 5990 ;********** 5991 5992 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 5993 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 5994 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 5995 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 5996 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 5997 007402 SN=SN+1 5998 000002 ZZ=ZZ+ZZ 5999 IFE ZZ, 6000 033406 200 00 0 00 035075 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6001 033407 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6002 ;RESULT IN C(AC) NON-ZERO 6003 033410 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6004 STOP^ 6005 033411 254 04 0 00 033412 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6006 033412 324 00 0 00 033413 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6007 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6008 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6009 6010 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6011 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6012 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6013 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6014 6015 ;********** 6016 6017 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6018 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6019 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6020 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6021 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6022 007403 SN=SN+1 6023 000004 ZZ=ZZ+ZZ 6024 IFE ZZ, 6025 033413 200 00 0 00 035076 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6026 033414 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-15 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0132 6027 ;RESULT IN C(AC) NON-ZERO 6028 033415 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6029 STOP^ 6030 033416 254 04 0 00 033417 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6031 033417 324 00 0 00 033420 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6032 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6033 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6034 6035 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6036 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6037 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6038 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6039 6040 ;********** 6041 6042 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6043 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6044 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6045 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6046 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6047 007404 SN=SN+1 6048 000010 ZZ=ZZ+ZZ 6049 IFE ZZ, 6050 033420 200 00 0 00 035077 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6051 033421 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6052 ;RESULT IN C(AC) NON-ZERO 6053 033422 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6054 STOP^ 6055 033423 254 04 0 00 033424 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6056 033424 324 00 0 00 033425 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6057 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6058 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6059 6060 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6061 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6062 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6063 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6064 6065 ;********** 6066 6067 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6068 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6069 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6070 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6071 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6072 007405 SN=SN+1 6073 000020 ZZ=ZZ+ZZ 6074 IFE ZZ, 6075 033425 200 00 0 00 035100 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6076 033426 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6077 ;RESULT IN C(AC) NON-ZERO 6078 033427 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6079 STOP^ 6080 033430 254 04 0 00 033431 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6081 033431 324 00 0 00 033432 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-16 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0133 6082 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6083 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6084 6085 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6086 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6087 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6088 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6089 6090 ;********** 6091 6092 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6093 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6094 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6095 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6096 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6097 007406 SN=SN+1 6098 000040 ZZ=ZZ+ZZ 6099 IFE ZZ, 6100 033432 200 00 0 00 035101 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6101 033433 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6102 ;RESULT IN C(AC) NON-ZERO 6103 033434 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6104 STOP^ 6105 033435 254 04 0 00 033436 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6106 033436 324 00 0 00 033437 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6107 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6108 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6109 6110 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6111 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6112 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6113 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6114 6115 ;********** 6116 6117 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6118 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6119 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6120 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6121 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6122 007407 SN=SN+1 6123 000100 ZZ=ZZ+ZZ 6124 IFE ZZ, 6125 033437 200 00 0 00 035102 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6126 033440 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6127 ;RESULT IN C(AC) NON-ZERO 6128 033441 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6129 STOP^ 6130 033442 254 04 0 00 033443 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6131 033443 324 00 0 00 033444 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6132 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6133 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6134 6135 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6136 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-17 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0134 6137 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6138 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6139 6140 ;********** 6141 6142 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6143 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6144 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6145 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6146 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6147 007410 SN=SN+1 6148 000200 ZZ=ZZ+ZZ 6149 IFE ZZ, 6150 033444 200 00 0 00 035103 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6151 033445 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6152 ;RESULT IN C(AC) NON-ZERO 6153 033446 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6154 STOP^ 6155 033447 254 04 0 00 033450 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6156 033450 324 00 0 00 033451 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6157 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6158 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6159 6160 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6161 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6162 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6163 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6164 6165 ;********** 6166 6167 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6168 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6169 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6170 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6171 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6172 007411 SN=SN+1 6173 000400 ZZ=ZZ+ZZ 6174 IFE ZZ, 6175 033451 200 00 0 00 035104 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6176 033452 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6177 ;RESULT IN C(AC) NON-ZERO 6178 033453 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6179 STOP^ 6180 033454 254 04 0 00 033455 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6181 033455 324 00 0 00 033456 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6182 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6183 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6184 6185 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6186 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6187 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6188 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6189 6190 ;********** 6191 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-18 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0135 6192 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6193 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6194 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6195 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6196 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6197 007412 SN=SN+1 6198 001000 ZZ=ZZ+ZZ 6199 IFE ZZ, 6200 033456 200 00 0 00 035105 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6201 033457 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6202 ;RESULT IN C(AC) NON-ZERO 6203 033460 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6204 STOP^ 6205 033461 254 04 0 00 033462 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6206 033462 324 00 0 00 033463 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6207 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6208 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6209 6210 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6211 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6212 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6213 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6214 6215 ;********** 6216 6217 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6218 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6219 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6220 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6221 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6222 007413 SN=SN+1 6223 002000 ZZ=ZZ+ZZ 6224 IFE ZZ, 6225 033463 200 00 0 00 035106 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6226 033464 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6227 ;RESULT IN C(AC) NON-ZERO 6228 033465 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6229 STOP^ 6230 033466 254 04 0 00 033467 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6231 033467 324 00 0 00 033470 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6232 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6233 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6234 6235 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6236 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6237 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6238 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6239 6240 ;********** 6241 6242 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6243 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6244 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6245 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6246 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-19 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0136 6247 007414 SN=SN+1 6248 004000 ZZ=ZZ+ZZ 6249 IFE ZZ, 6250 033470 200 00 0 00 035107 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6251 033471 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6252 ;RESULT IN C(AC) NON-ZERO 6253 033472 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6254 STOP^ 6255 033473 254 04 0 00 033474 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6256 033474 324 00 0 00 033475 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6257 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6258 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6259 6260 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6261 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6262 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6263 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6264 6265 ;********** 6266 6267 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6268 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6269 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6270 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6271 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6272 007415 SN=SN+1 6273 010000 ZZ=ZZ+ZZ 6274 IFE ZZ, 6275 033475 200 00 0 00 035110 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6276 033476 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6277 ;RESULT IN C(AC) NON-ZERO 6278 033477 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6279 STOP^ 6280 033500 254 04 0 00 033501 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6281 033501 324 00 0 00 033502 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6282 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6283 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6284 6285 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6286 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6287 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6288 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6289 6290 ;********** 6291 6292 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6293 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6294 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6295 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6296 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6297 007416 SN=SN+1 6298 020000 ZZ=ZZ+ZZ 6299 IFE ZZ, 6300 033502 200 00 0 00 035111 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6301 033503 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-20 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0137 6302 ;RESULT IN C(AC) NON-ZERO 6303 033504 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6304 STOP^ 6305 033505 254 04 0 00 033506 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6306 033506 324 00 0 00 033507 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6307 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6308 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6309 6310 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6311 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6312 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6313 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6314 6315 ;********** 6316 6317 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6318 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6319 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6320 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6321 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6322 007417 SN=SN+1 6323 040000 ZZ=ZZ+ZZ 6324 IFE ZZ, 6325 033507 200 00 0 00 035112 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6326 033510 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6327 ;RESULT IN C(AC) NON-ZERO 6328 033511 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6329 STOP^ 6330 033512 254 04 0 00 033513 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6331 033513 324 00 0 00 033514 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6332 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6333 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6334 6335 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6336 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6337 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6338 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6339 6340 ;********** 6341 6342 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6343 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6344 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6345 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6346 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6347 007420 SN=SN+1 6348 100000 ZZ=ZZ+ZZ 6349 IFE ZZ, 6350 033514 200 00 0 00 035113 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6351 033515 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6352 ;RESULT IN C(AC) NON-ZERO 6353 033516 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6354 STOP^ 6355 033517 254 04 0 00 033520 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6356 033520 324 00 0 00 033521 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-21 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0138 6357 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6358 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6359 6360 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6361 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6362 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6363 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6364 6365 ;********** 6366 6367 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6368 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6369 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6370 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6371 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6372 007421 SN=SN+1 6373 200000 ZZ=ZZ+ZZ 6374 IFE ZZ, 6375 033521 200 00 0 00 035114 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6376 033522 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6377 ;RESULT IN C(AC) NON-ZERO 6378 033523 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6379 STOP^ 6380 033524 254 04 0 00 033525 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6381 033525 324 00 0 00 033526 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6382 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6383 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6384 6385 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6386 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6387 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6388 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6389 6390 ;********** 6391 6392 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6393 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6394 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6395 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6396 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6397 007422 SN=SN+1 6398 400000 ZZ=ZZ+ZZ 6399 IFE ZZ, 6400 033526 200 00 0 00 035115 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6401 033527 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6402 ;RESULT IN C(AC) NON-ZERO 6403 033530 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6404 STOP^ 6405 033531 254 04 0 00 033532 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6406 033532 324 00 0 00 033533 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6407 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6408 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6409 6410 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6411 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-22 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0139 6412 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6413 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6414 6415 ;********** 6416 6417 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6418 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6419 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6420 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6421 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6422 007423 SN=SN+1 6423 000001 000000 ZZ=ZZ+ZZ 6424 IFE ZZ, 6425 033533 200 00 0 00 035116 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6426 033534 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6427 ;RESULT IN C(AC) NON-ZERO 6428 033535 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6429 STOP^ 6430 033536 254 04 0 00 033537 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6431 033537 324 00 0 00 033540 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6432 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6433 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6434 6435 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6436 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6437 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6438 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6439 6440 ;********** 6441 6442 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6443 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6444 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6445 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6446 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6447 007424 SN=SN+1 6448 000002 000000 ZZ=ZZ+ZZ 6449 IFE ZZ, 6450 033540 200 00 0 00 035117 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6451 033541 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6452 ;RESULT IN C(AC) NON-ZERO 6453 033542 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6454 STOP^ 6455 033543 254 04 0 00 033544 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6456 033544 324 00 0 00 033545 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6457 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6458 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6459 6460 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6461 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6462 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6463 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6464 6465 ;********** 6466 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-23 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0140 6467 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6468 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6469 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6470 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6471 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6472 007425 SN=SN+1 6473 000004 000000 ZZ=ZZ+ZZ 6474 IFE ZZ, 6475 033545 200 00 0 00 035120 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6476 033546 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6477 ;RESULT IN C(AC) NON-ZERO 6478 033547 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6479 STOP^ 6480 033550 254 04 0 00 033551 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6481 033551 324 00 0 00 033552 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6482 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6483 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6484 6485 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6486 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6487 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6488 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6489 6490 ;********** 6491 6492 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6493 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6494 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6495 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6496 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6497 007426 SN=SN+1 6498 000010 000000 ZZ=ZZ+ZZ 6499 IFE ZZ, 6500 033552 200 00 0 00 035121 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6501 033553 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6502 ;RESULT IN C(AC) NON-ZERO 6503 033554 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6504 STOP^ 6505 033555 254 04 0 00 033556 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6506 033556 324 00 0 00 033557 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6507 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6508 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6509 6510 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6511 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6512 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6513 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6514 6515 ;********** 6516 6517 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6518 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6519 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6520 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6521 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-24 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0141 6522 007427 SN=SN+1 6523 000020 000000 ZZ=ZZ+ZZ 6524 IFE ZZ, 6525 033557 200 00 0 00 035122 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6526 033560 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6527 ;RESULT IN C(AC) NON-ZERO 6528 033561 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6529 STOP^ 6530 033562 254 04 0 00 033563 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6531 033563 324 00 0 00 033564 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6532 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6533 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6534 6535 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6536 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6537 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6538 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6539 6540 ;********** 6541 6542 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6543 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6544 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6545 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6546 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6547 007430 SN=SN+1 6548 000040 000000 ZZ=ZZ+ZZ 6549 IFE ZZ, 6550 033564 200 00 0 00 035123 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6551 033565 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6552 ;RESULT IN C(AC) NON-ZERO 6553 033566 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6554 STOP^ 6555 033567 254 04 0 00 033570 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6556 033570 324 00 0 00 033571 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6557 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6558 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6559 6560 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6561 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6562 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6563 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6564 6565 ;********** 6566 6567 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6568 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6569 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6570 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6571 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6572 007431 SN=SN+1 6573 000100 000000 ZZ=ZZ+ZZ 6574 IFE ZZ, 6575 033571 200 00 0 00 035124 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6576 033572 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-25 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0142 6577 ;RESULT IN C(AC) NON-ZERO 6578 033573 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6579 STOP^ 6580 033574 254 04 0 00 033575 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6581 033575 324 00 0 00 033576 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6582 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6583 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6584 6585 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6586 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6587 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6588 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6589 6590 ;********** 6591 6592 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6593 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6594 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6595 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6596 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6597 007432 SN=SN+1 6598 000200 000000 ZZ=ZZ+ZZ 6599 IFE ZZ, 6600 033576 200 00 0 00 035125 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6601 033577 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6602 ;RESULT IN C(AC) NON-ZERO 6603 033600 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6604 STOP^ 6605 033601 254 04 0 00 033602 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6606 033602 324 00 0 00 033603 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6607 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6608 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6609 6610 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6611 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6612 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6613 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6614 6615 ;********** 6616 6617 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6618 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6619 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6620 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6621 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6622 007433 SN=SN+1 6623 000400 000000 ZZ=ZZ+ZZ 6624 IFE ZZ, 6625 033603 200 00 0 00 035073 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6626 033604 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6627 ;RESULT IN C(AC) NON-ZERO 6628 033605 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6629 STOP^ 6630 033606 254 04 0 00 033607 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6631 033607 324 00 0 00 033610 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-26 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0143 6632 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6633 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6634 6635 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6636 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6637 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6638 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6639 6640 ;********** 6641 6642 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6643 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6644 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6645 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6646 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6647 007434 SN=SN+1 6648 001000 000000 ZZ=ZZ+ZZ 6649 IFE ZZ, 6650 033610 200 00 0 00 035126 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6651 033611 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6652 ;RESULT IN C(AC) NON-ZERO 6653 033612 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6654 STOP^ 6655 033613 254 04 0 00 033614 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6656 033614 324 00 0 00 033615 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6657 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6658 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6659 6660 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6661 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6662 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6663 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6664 6665 ;********** 6666 6667 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6668 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6669 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6670 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6671 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6672 007435 SN=SN+1 6673 002000 000000 ZZ=ZZ+ZZ 6674 IFE ZZ, 6675 033615 200 00 0 00 035127 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6676 033616 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6677 ;RESULT IN C(AC) NON-ZERO 6678 033617 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6679 STOP^ 6680 033620 254 04 0 00 033621 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6681 033621 324 00 0 00 033622 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6682 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6683 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6684 6685 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6686 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-27 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0144 6687 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6688 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6689 6690 ;********** 6691 6692 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6693 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6694 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6695 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6696 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6697 007436 SN=SN+1 6698 004000 000000 ZZ=ZZ+ZZ 6699 IFE ZZ, 6700 033622 200 00 0 00 035130 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6701 033623 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6702 ;RESULT IN C(AC) NON-ZERO 6703 033624 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6704 STOP^ 6705 033625 254 04 0 00 033626 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6706 033626 324 00 0 00 033627 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6707 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6708 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6709 6710 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6711 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6712 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6713 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6714 6715 ;********** 6716 6717 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6718 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6719 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6720 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6721 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6722 007437 SN=SN+1 6723 010000 000000 ZZ=ZZ+ZZ 6724 IFE ZZ, 6725 033627 200 00 0 00 035131 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6726 033630 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6727 ;RESULT IN C(AC) NON-ZERO 6728 033631 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6729 STOP^ 6730 033632 254 04 0 00 033633 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6731 033633 324 00 0 00 033634 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6732 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6733 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6734 6735 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6736 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6737 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6738 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6739 6740 ;********** 6741 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-28 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0145 6742 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6743 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6744 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6745 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6746 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6747 007440 SN=SN+1 6748 020000 000000 ZZ=ZZ+ZZ 6749 IFE ZZ, 6750 033634 200 00 0 00 035132 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6751 033635 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6752 ;RESULT IN C(AC) NON-ZERO 6753 033636 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6754 STOP^ 6755 033637 254 04 0 00 033640 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6756 033640 324 00 0 00 033641 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6757 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6758 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6759 6760 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6761 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6762 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6763 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6764 6765 ;********** 6766 6767 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6768 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6769 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6770 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6771 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6772 007441 SN=SN+1 6773 040000 000000 ZZ=ZZ+ZZ 6774 IFE ZZ, 6775 033641 200 00 0 00 035133 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6776 033642 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6777 ;RESULT IN C(AC) NON-ZERO 6778 033643 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6779 STOP^ 6780 033644 254 04 0 00 033645 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6781 033645 324 00 0 00 033646 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6782 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6783 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6784 6785 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6786 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6787 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6788 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6789 6790 ;********** 6791 6792 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6793 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6794 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6795 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6796 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-29 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0146 6797 007442 SN=SN+1 6798 100000 000000 ZZ=ZZ+ZZ 6799 IFE ZZ, 6800 033646 200 00 0 00 035134 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6801 033647 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6802 ;RESULT IN C(AC) NON-ZERO 6803 033650 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6804 STOP^ 6805 033651 254 04 0 00 033652 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6806 033652 324 00 0 00 033653 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6807 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6808 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6809 6810 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6811 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6812 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6813 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6814 6815 ;********** 6816 6817 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6818 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6819 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6820 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6821 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6822 007443 SN=SN+1 6823 200000 000000 ZZ=ZZ+ZZ 6824 IFE ZZ, 6825 033653 200 00 0 00 035135 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6826 033654 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD 6827 ;RESULT IN C(AC) NON-ZERO 6828 033655 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6829 STOP^ 6830 033656 254 04 0 00 033657 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6831 033657 324 00 0 00 033660 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6832 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6833 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6834 6835 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6836 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6837 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6838 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6839 6840 ;********** 6841 6842 ;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 6843 ;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS 6844 ;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE 6845 ;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E 6846 ;CONTAINING ALL ZEROS. THE AC IS THEN CHECKED FOR A NON-ZERO RESULT. 6847 007444 SN=SN+1 6848 400000 000000 ZZ=ZZ+ZZ 6849 IFE ZZ, 6850 033660 200 00 0 00 035065 MOVE [ZZ] ;PRELOAD AC WITH ONE FLOATING BIT SET 6851 033661 430 00 0 00 035062 XOR [0] ;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 27-30 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0147 6852 ;RESULT IN C(AC) NON-ZERO 6853 033662 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 6854 STOP^ 6855 033663 254 04 0 00 033664 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6856 033664 324 00 0 00 033665 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6857 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6858 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6859 6860 ;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1], 6861 ;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2], 6862 ;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1], 6863 ;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2] 6864 6865 ;********** 6866 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0148 6867 007500 SN=7500 6868 000000 ZZ=0 6869 6870 A7500: REPEAT ^D36, 6871 <;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 6872 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 6873 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 6874 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 6875 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 6876 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 6877 ;INDICATE AN ILLEGAL CARRY GENERATION. 6878 SN=SN+1 6879 ZZ=ZZ+ZZ 6880 IFE ZZ, 6881 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 6882 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 6883 SKIPE ;PASS TEST IF C(AC)=0 6884 STOP 6885 6886 ;********** 6887 > 6888 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 6889 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 6890 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 6891 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 6892 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 6893 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 6894 ;INDICATE AN ILLEGAL CARRY GENERATION. 6895 007501 SN=SN+1 6896 000000 ZZ=ZZ+ZZ 6897 000001 IFE ZZ, 6898 033665 200 00 0 00 035074 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 6899 033666 430 00 0 00 035074 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 6900 033667 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 6901 STOP^ 6902 033670 254 04 0 00 033671 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6903 033671 324 00 0 00 033672 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6904 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6905 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6906 6907 ;********** 6908 6909 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 6910 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 6911 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 6912 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 6913 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 6914 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 6915 ;INDICATE AN ILLEGAL CARRY GENERATION. 6916 007502 SN=SN+1 6917 000002 ZZ=ZZ+ZZ 6918 IFE ZZ, 6919 033672 200 00 0 00 035075 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 6920 033673 430 00 0 00 035075 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 6921 033674 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0149 6922 STOP^ 6923 033675 254 04 0 00 033676 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6924 033676 324 00 0 00 033677 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6925 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6926 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6927 6928 ;********** 6929 6930 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 6931 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 6932 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 6933 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 6934 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 6935 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 6936 ;INDICATE AN ILLEGAL CARRY GENERATION. 6937 007503 SN=SN+1 6938 000004 ZZ=ZZ+ZZ 6939 IFE ZZ, 6940 033677 200 00 0 00 035076 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 6941 033700 430 00 0 00 035076 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 6942 033701 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 6943 STOP^ 6944 033702 254 04 0 00 033703 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6945 033703 324 00 0 00 033704 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6946 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6947 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6948 6949 ;********** 6950 6951 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 6952 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 6953 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 6954 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 6955 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 6956 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 6957 ;INDICATE AN ILLEGAL CARRY GENERATION. 6958 007504 SN=SN+1 6959 000010 ZZ=ZZ+ZZ 6960 IFE ZZ, 6961 033704 200 00 0 00 035077 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 6962 033705 430 00 0 00 035077 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 6963 033706 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 6964 STOP^ 6965 033707 254 04 0 00 033710 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6966 033710 324 00 0 00 033711 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6967 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6968 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6969 6970 ;********** 6971 6972 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 6973 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 6974 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 6975 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 6976 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-2 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0150 6977 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 6978 ;INDICATE AN ILLEGAL CARRY GENERATION. 6979 007505 SN=SN+1 6980 000020 ZZ=ZZ+ZZ 6981 IFE ZZ, 6982 033711 200 00 0 00 035100 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 6983 033712 430 00 0 00 035100 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 6984 033713 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 6985 STOP^ 6986 033714 254 04 0 00 033715 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 6987 033715 324 00 0 00 033716 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 6988 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 6989 ;IN THE SUBTEST) TO LOOP ON ERROR^ 6990 6991 ;********** 6992 6993 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 6994 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 6995 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 6996 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 6997 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 6998 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 6999 ;INDICATE AN ILLEGAL CARRY GENERATION. 7000 007506 SN=SN+1 7001 000040 ZZ=ZZ+ZZ 7002 IFE ZZ, 7003 033716 200 00 0 00 035101 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7004 033717 430 00 0 00 035101 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7005 033720 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7006 STOP^ 7007 033721 254 04 0 00 033722 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7008 033722 324 00 0 00 033723 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7009 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7010 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7011 7012 ;********** 7013 7014 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7015 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7016 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7017 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7018 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7019 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7020 ;INDICATE AN ILLEGAL CARRY GENERATION. 7021 007507 SN=SN+1 7022 000100 ZZ=ZZ+ZZ 7023 IFE ZZ, 7024 033723 200 00 0 00 035102 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7025 033724 430 00 0 00 035102 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7026 033725 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7027 STOP^ 7028 033726 254 04 0 00 033727 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7029 033727 324 00 0 00 033730 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7030 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7031 ;IN THE SUBTEST) TO LOOP ON ERROR^ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-3 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0151 7032 7033 ;********** 7034 7035 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7036 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7037 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7038 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7039 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7040 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7041 ;INDICATE AN ILLEGAL CARRY GENERATION. 7042 007510 SN=SN+1 7043 000200 ZZ=ZZ+ZZ 7044 IFE ZZ, 7045 033730 200 00 0 00 035103 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7046 033731 430 00 0 00 035103 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7047 033732 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7048 STOP^ 7049 033733 254 04 0 00 033734 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7050 033734 324 00 0 00 033735 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7051 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7052 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7053 7054 ;********** 7055 7056 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7057 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7058 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7059 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7060 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7061 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7062 ;INDICATE AN ILLEGAL CARRY GENERATION. 7063 007511 SN=SN+1 7064 000400 ZZ=ZZ+ZZ 7065 IFE ZZ, 7066 033735 200 00 0 00 035104 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7067 033736 430 00 0 00 035104 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7068 033737 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7069 STOP^ 7070 033740 254 04 0 00 033741 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7071 033741 324 00 0 00 033742 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7072 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7073 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7074 7075 ;********** 7076 7077 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7078 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7079 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7080 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7081 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7082 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7083 ;INDICATE AN ILLEGAL CARRY GENERATION. 7084 007512 SN=SN+1 7085 001000 ZZ=ZZ+ZZ 7086 IFE ZZ, DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-4 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0152 7087 033742 200 00 0 00 035105 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7088 033743 430 00 0 00 035105 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7089 033744 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7090 STOP^ 7091 033745 254 04 0 00 033746 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7092 033746 324 00 0 00 033747 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7093 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7094 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7095 7096 ;********** 7097 7098 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7099 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7100 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7101 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7102 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7103 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7104 ;INDICATE AN ILLEGAL CARRY GENERATION. 7105 007513 SN=SN+1 7106 002000 ZZ=ZZ+ZZ 7107 IFE ZZ, 7108 033747 200 00 0 00 035106 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7109 033750 430 00 0 00 035106 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7110 033751 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7111 STOP^ 7112 033752 254 04 0 00 033753 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7113 033753 324 00 0 00 033754 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7114 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7115 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7116 7117 ;********** 7118 7119 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7120 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7121 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7122 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7123 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7124 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7125 ;INDICATE AN ILLEGAL CARRY GENERATION. 7126 007514 SN=SN+1 7127 004000 ZZ=ZZ+ZZ 7128 IFE ZZ, 7129 033754 200 00 0 00 035107 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7130 033755 430 00 0 00 035107 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7131 033756 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7132 STOP^ 7133 033757 254 04 0 00 033760 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7134 033760 324 00 0 00 033761 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7135 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7136 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7137 7138 ;********** 7139 7140 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7141 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-5 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0153 7142 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7143 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7144 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7145 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7146 ;INDICATE AN ILLEGAL CARRY GENERATION. 7147 007515 SN=SN+1 7148 010000 ZZ=ZZ+ZZ 7149 IFE ZZ, 7150 033761 200 00 0 00 035110 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7151 033762 430 00 0 00 035110 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7152 033763 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7153 STOP^ 7154 033764 254 04 0 00 033765 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7155 033765 324 00 0 00 033766 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7156 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7157 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7158 7159 ;********** 7160 7161 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7162 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7163 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7164 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7165 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7166 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7167 ;INDICATE AN ILLEGAL CARRY GENERATION. 7168 007516 SN=SN+1 7169 020000 ZZ=ZZ+ZZ 7170 IFE ZZ, 7171 033766 200 00 0 00 035111 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7172 033767 430 00 0 00 035111 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7173 033770 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7174 STOP^ 7175 033771 254 04 0 00 033772 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7176 033772 324 00 0 00 033773 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7177 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7178 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7179 7180 ;********** 7181 7182 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7183 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7184 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7185 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7186 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7187 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7188 ;INDICATE AN ILLEGAL CARRY GENERATION. 7189 007517 SN=SN+1 7190 040000 ZZ=ZZ+ZZ 7191 IFE ZZ, 7192 033773 200 00 0 00 035112 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7193 033774 430 00 0 00 035112 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7194 033775 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7195 STOP^ 7196 033776 254 04 0 00 033777 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-6 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0154 7197 033777 324 00 0 00 034000 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7198 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7199 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7200 7201 ;********** 7202 7203 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7204 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7205 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7206 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7207 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7208 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7209 ;INDICATE AN ILLEGAL CARRY GENERATION. 7210 007520 SN=SN+1 7211 100000 ZZ=ZZ+ZZ 7212 IFE ZZ, 7213 034000 200 00 0 00 035113 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7214 034001 430 00 0 00 035113 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7215 034002 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7216 STOP^ 7217 034003 254 04 0 00 034004 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7218 034004 324 00 0 00 034005 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7219 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7220 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7221 7222 ;********** 7223 7224 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7225 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7226 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7227 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7228 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7229 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7230 ;INDICATE AN ILLEGAL CARRY GENERATION. 7231 007521 SN=SN+1 7232 200000 ZZ=ZZ+ZZ 7233 IFE ZZ, 7234 034005 200 00 0 00 035114 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7235 034006 430 00 0 00 035114 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7236 034007 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7237 STOP^ 7238 034010 254 04 0 00 034011 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7239 034011 324 00 0 00 034012 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7240 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7241 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7242 7243 ;********** 7244 7245 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7246 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7247 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7248 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7249 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7250 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7251 ;INDICATE AN ILLEGAL CARRY GENERATION. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-7 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0155 7252 007522 SN=SN+1 7253 400000 ZZ=ZZ+ZZ 7254 IFE ZZ, 7255 034012 200 00 0 00 035115 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7256 034013 430 00 0 00 035115 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7257 034014 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7258 STOP^ 7259 034015 254 04 0 00 034016 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7260 034016 324 00 0 00 034017 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7261 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7262 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7263 7264 ;********** 7265 7266 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7267 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7268 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7269 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7270 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7271 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7272 ;INDICATE AN ILLEGAL CARRY GENERATION. 7273 007523 SN=SN+1 7274 000001 000000 ZZ=ZZ+ZZ 7275 IFE ZZ, 7276 034017 200 00 0 00 035116 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7277 034020 430 00 0 00 035116 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7278 034021 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7279 STOP^ 7280 034022 254 04 0 00 034023 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7281 034023 324 00 0 00 034024 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7282 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7283 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7284 7285 ;********** 7286 7287 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7288 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7289 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7290 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7291 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7292 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7293 ;INDICATE AN ILLEGAL CARRY GENERATION. 7294 007524 SN=SN+1 7295 000002 000000 ZZ=ZZ+ZZ 7296 IFE ZZ, 7297 034024 200 00 0 00 035117 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7298 034025 430 00 0 00 035117 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7299 034026 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7300 STOP^ 7301 034027 254 04 0 00 034030 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7302 034030 324 00 0 00 034031 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7303 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7304 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7305 7306 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-8 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0156 7307 7308 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7309 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7310 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7311 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7312 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7313 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7314 ;INDICATE AN ILLEGAL CARRY GENERATION. 7315 007525 SN=SN+1 7316 000004 000000 ZZ=ZZ+ZZ 7317 IFE ZZ, 7318 034031 200 00 0 00 035120 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7319 034032 430 00 0 00 035120 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7320 034033 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7321 STOP^ 7322 034034 254 04 0 00 034035 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7323 034035 324 00 0 00 034036 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7324 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7325 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7326 7327 ;********** 7328 7329 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7330 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7331 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7332 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7333 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7334 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7335 ;INDICATE AN ILLEGAL CARRY GENERATION. 7336 007526 SN=SN+1 7337 000010 000000 ZZ=ZZ+ZZ 7338 IFE ZZ, 7339 034036 200 00 0 00 035121 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7340 034037 430 00 0 00 035121 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7341 034040 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7342 STOP^ 7343 034041 254 04 0 00 034042 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7344 034042 324 00 0 00 034043 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7345 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7346 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7347 7348 ;********** 7349 7350 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7351 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7352 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7353 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7354 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7355 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7356 ;INDICATE AN ILLEGAL CARRY GENERATION. 7357 007527 SN=SN+1 7358 000020 000000 ZZ=ZZ+ZZ 7359 IFE ZZ, 7360 034043 200 00 0 00 035122 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7361 034044 430 00 0 00 035122 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-9 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0157 7362 034045 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7363 STOP^ 7364 034046 254 04 0 00 034047 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7365 034047 324 00 0 00 034050 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7366 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7367 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7368 7369 ;********** 7370 7371 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7372 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7373 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7374 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7375 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7376 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7377 ;INDICATE AN ILLEGAL CARRY GENERATION. 7378 007530 SN=SN+1 7379 000040 000000 ZZ=ZZ+ZZ 7380 IFE ZZ, 7381 034050 200 00 0 00 035123 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7382 034051 430 00 0 00 035123 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7383 034052 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7384 STOP^ 7385 034053 254 04 0 00 034054 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7386 034054 324 00 0 00 034055 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7387 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7388 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7389 7390 ;********** 7391 7392 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7393 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7394 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7395 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7396 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7397 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7398 ;INDICATE AN ILLEGAL CARRY GENERATION. 7399 007531 SN=SN+1 7400 000100 000000 ZZ=ZZ+ZZ 7401 IFE ZZ, 7402 034055 200 00 0 00 035124 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7403 034056 430 00 0 00 035124 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7404 034057 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7405 STOP^ 7406 034060 254 04 0 00 034061 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7407 034061 324 00 0 00 034062 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7408 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7409 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7410 7411 ;********** 7412 7413 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7414 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7415 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7416 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-10 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0158 7417 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7418 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7419 ;INDICATE AN ILLEGAL CARRY GENERATION. 7420 007532 SN=SN+1 7421 000200 000000 ZZ=ZZ+ZZ 7422 IFE ZZ, 7423 034062 200 00 0 00 035125 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7424 034063 430 00 0 00 035125 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7425 034064 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7426 STOP^ 7427 034065 254 04 0 00 034066 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7428 034066 324 00 0 00 034067 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7429 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7430 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7431 7432 ;********** 7433 7434 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7435 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7436 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7437 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7438 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7439 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7440 ;INDICATE AN ILLEGAL CARRY GENERATION. 7441 007533 SN=SN+1 7442 000400 000000 ZZ=ZZ+ZZ 7443 IFE ZZ, 7444 034067 200 00 0 00 035073 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7445 034070 430 00 0 00 035073 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7446 034071 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7447 STOP^ 7448 034072 254 04 0 00 034073 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7449 034073 324 00 0 00 034074 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7450 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7451 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7452 7453 ;********** 7454 7455 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7456 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7457 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7458 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7459 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7460 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7461 ;INDICATE AN ILLEGAL CARRY GENERATION. 7462 007534 SN=SN+1 7463 001000 000000 ZZ=ZZ+ZZ 7464 IFE ZZ, 7465 034074 200 00 0 00 035126 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7466 034075 430 00 0 00 035126 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7467 034076 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7468 STOP^ 7469 034077 254 04 0 00 034100 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7470 034100 324 00 0 00 034101 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7471 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-11 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0159 7472 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7473 7474 ;********** 7475 7476 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7477 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7478 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7479 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7480 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7481 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7482 ;INDICATE AN ILLEGAL CARRY GENERATION. 7483 007535 SN=SN+1 7484 002000 000000 ZZ=ZZ+ZZ 7485 IFE ZZ, 7486 034101 200 00 0 00 035127 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7487 034102 430 00 0 00 035127 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7488 034103 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7489 STOP^ 7490 034104 254 04 0 00 034105 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7491 034105 324 00 0 00 034106 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7492 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7493 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7494 7495 ;********** 7496 7497 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7498 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7499 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7500 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7501 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7502 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7503 ;INDICATE AN ILLEGAL CARRY GENERATION. 7504 007536 SN=SN+1 7505 004000 000000 ZZ=ZZ+ZZ 7506 IFE ZZ, 7507 034106 200 00 0 00 035130 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7508 034107 430 00 0 00 035130 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7509 034110 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7510 STOP^ 7511 034111 254 04 0 00 034112 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7512 034112 324 00 0 00 034113 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7513 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7514 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7515 7516 ;********** 7517 7518 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7519 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7520 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7521 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7522 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7523 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7524 ;INDICATE AN ILLEGAL CARRY GENERATION. 7525 007537 SN=SN+1 7526 010000 000000 ZZ=ZZ+ZZ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-12 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0160 7527 IFE ZZ, 7528 034113 200 00 0 00 035131 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7529 034114 430 00 0 00 035131 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7530 034115 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7531 STOP^ 7532 034116 254 04 0 00 034117 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7533 034117 324 00 0 00 034120 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7534 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7535 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7536 7537 ;********** 7538 7539 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7540 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7541 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7542 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7543 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7544 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7545 ;INDICATE AN ILLEGAL CARRY GENERATION. 7546 007540 SN=SN+1 7547 020000 000000 ZZ=ZZ+ZZ 7548 IFE ZZ, 7549 034120 200 00 0 00 035132 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7550 034121 430 00 0 00 035132 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7551 034122 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7552 STOP^ 7553 034123 254 04 0 00 034124 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7554 034124 324 00 0 00 034125 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7555 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7556 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7557 7558 ;********** 7559 7560 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7561 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7562 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7563 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7564 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7565 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7566 ;INDICATE AN ILLEGAL CARRY GENERATION. 7567 007541 SN=SN+1 7568 040000 000000 ZZ=ZZ+ZZ 7569 IFE ZZ, 7570 034125 200 00 0 00 035133 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7571 034126 430 00 0 00 035133 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7572 034127 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7573 STOP^ 7574 034130 254 04 0 00 034131 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7575 034131 324 00 0 00 034132 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7576 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7577 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7578 7579 ;********** 7580 7581 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-13 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0161 7582 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7583 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7584 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7585 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7586 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7587 ;INDICATE AN ILLEGAL CARRY GENERATION. 7588 007542 SN=SN+1 7589 100000 000000 ZZ=ZZ+ZZ 7590 IFE ZZ, 7591 034132 200 00 0 00 035134 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7592 034133 430 00 0 00 035134 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7593 034134 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7594 STOP^ 7595 034135 254 04 0 00 034136 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7596 034136 324 00 0 00 034137 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7597 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7598 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7599 7600 ;********** 7601 7602 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7603 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7604 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7605 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7606 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7607 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7608 ;INDICATE AN ILLEGAL CARRY GENERATION. 7609 007543 SN=SN+1 7610 200000 000000 ZZ=ZZ+ZZ 7611 IFE ZZ, 7612 034137 200 00 0 00 035135 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7613 034140 430 00 0 00 035135 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7614 034141 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7615 STOP^ 7616 034142 254 04 0 00 034143 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7617 034143 324 00 0 00 034144 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7618 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7619 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7620 7621 ;********** 7622 7623 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION 7624 ;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS. FIRST, 7625 ;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT 7626 ;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME 7627 ;NUMBER. THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS. THIS TEST 7628 ;IS REPEATED 36 TIMES. IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY 7629 ;INDICATE AN ILLEGAL CARRY GENERATION. 7630 007544 SN=SN+1 7631 400000 000000 ZZ=ZZ+ZZ 7632 IFE ZZ, 7633 034144 200 00 0 00 035065 MOVE [ZZ] ;INITIALIZE AC WITH ONE FLOATING BIT SET 7634 034145 430 00 0 00 035065 XOR [ZZ] ;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0 7635 034146 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7636 STOP^ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 28-14 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0162 7637 034147 254 04 0 00 034150 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7638 034150 324 00 0 00 034151 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7639 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7640 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7641 7642 ;********** 7643 7644 ;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION WHERE 7645 ;C(AC)=C(E)=0 IS AN AC CONTAINING ALL ZEROS; FIRST THE AC IS CLEARED; THEN 7646 ;XOR IS EXECUTED WITH C(E)=0. THE RESULT IN THE AC IS CHECKED FOR ALL ZEROS 7647 7648 034151 200 00 0 00 035062 A7600: MOVE [0] ;INITIALIZE AC TO ALL ZEROS 7649 034152 430 00 0 00 035062 XOR [0] ;*XOR WITH C(AC)=C(E)=0 SHOULD RESULT INC(AC)=0 7650 034153 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7651 STOP^ 7652 034154 254 04 0 00 034155 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7653 034155 324 00 0 00 034156 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7654 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7655 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7656 7657 ;********** 7658 7659 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7660 ;C(AC)=0 AND C(E) ALL ONES IS AN AC CONTAINING ALL ZEROS SINCE 7661 ;THE EQUIVALENCE FUNCTION SHOULD SET ONLY LIKE BITS. FIRST, THE AC 7662 ;SHOULD BE CLEARED; THEN, EQV IS EXECUTED WITH E CONTAINING ALL ONES. 7663 ;THE AC IS THEN CHECKED FOR ALL ZEROS 7664 7665 034156 200 00 0 00 035062 A7700: MOVE [0] ;CLEAR THE AC 7666 034157 444 00 0 00 035063 EQV [-1] ;*EQV WITH C(AC)=0 AND C(E) ALL ONES SHOULD 7667 ;RESULT IN C(AC)=0 7668 034160 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 7669 STOP^ 7670 034161 254 04 0 00 034162 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7671 034162 324 00 0 00 034163 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7672 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7673 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7674 7675 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0163 7676 010000 SN=10000 7677 000000 ZZ=0 7678 7679 A10000: REPEAT ^D18, 7680 <;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7681 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7682 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7683 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7684 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7685 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7686 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7687 SN=SN+1 7688 ZZ=ZZ+ZZ+1 7689 IFE , 7690 MOVE [0] ;PRESET AC TO ALL ZEROS 7691 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7692 ;RESULT IN C(AC) NON-ZERO 7693 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7694 STOP 7695 7696 ;********** 7697 > 7698 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7699 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7700 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7701 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7702 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7703 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7704 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7705 010001 SN=SN+1 7706 000001 ZZ=ZZ+ZZ+1 7707 777777 777776 IFE , 7708 034163 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 7709 034164 444 00 0 00 035142 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7710 ;RESULT IN C(AC) NON-ZERO 7711 034165 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7712 STOP^ 7713 034166 254 04 0 00 034167 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7714 034167 324 00 0 00 034170 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7715 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7716 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7717 7718 ;********** 7719 7720 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7721 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7722 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7723 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7724 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7725 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7726 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7727 010002 SN=SN+1 7728 777777 777775 ZZ=ZZ+ZZ+1 7729 IFE , 7730 034170 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0164 7731 034171 444 00 0 00 035143 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7732 ;RESULT IN C(AC) NON-ZERO 7733 034172 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7734 STOP^ 7735 034173 254 04 0 00 034174 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7736 034174 324 00 0 00 034175 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7737 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7738 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7739 7740 ;********** 7741 7742 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7743 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7744 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7745 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7746 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7747 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7748 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7749 010003 SN=SN+1 7750 777777 777773 ZZ=ZZ+ZZ+1 7751 IFE , 7752 034175 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 7753 034176 444 00 0 00 035144 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7754 ;RESULT IN C(AC) NON-ZERO 7755 034177 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7756 STOP^ 7757 034200 254 04 0 00 034201 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7758 034201 324 00 0 00 034202 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7759 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7760 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7761 7762 ;********** 7763 7764 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7765 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7766 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7767 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7768 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7769 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7770 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7771 010004 SN=SN+1 7772 777777 777767 ZZ=ZZ+ZZ+1 7773 IFE , 7774 034202 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 7775 034203 444 00 0 00 035145 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7776 ;RESULT IN C(AC) NON-ZERO 7777 034204 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7778 STOP^ 7779 034205 254 04 0 00 034206 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7780 034206 324 00 0 00 034207 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7781 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7782 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7783 7784 ;********** 7785 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-2 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0165 7786 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7787 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7788 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7789 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7790 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7791 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7792 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7793 010005 SN=SN+1 7794 777777 777757 ZZ=ZZ+ZZ+1 7795 IFE , 7796 034207 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 7797 034210 444 00 0 00 035146 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7798 ;RESULT IN C(AC) NON-ZERO 7799 034211 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7800 STOP^ 7801 034212 254 04 0 00 034213 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7802 034213 324 00 0 00 034214 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7803 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7804 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7805 7806 ;********** 7807 7808 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7809 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7810 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7811 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7812 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7813 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7814 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7815 010006 SN=SN+1 7816 777777 777737 ZZ=ZZ+ZZ+1 7817 IFE , 7818 034214 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 7819 034215 444 00 0 00 035147 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7820 ;RESULT IN C(AC) NON-ZERO 7821 034216 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7822 STOP^ 7823 034217 254 04 0 00 034220 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7824 034220 324 00 0 00 034221 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7825 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7826 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7827 7828 ;********** 7829 7830 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7831 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7832 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7833 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7834 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7835 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7836 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7837 010007 SN=SN+1 7838 777777 777677 ZZ=ZZ+ZZ+1 7839 IFE , 7840 034221 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-3 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0166 7841 034222 444 00 0 00 035150 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7842 ;RESULT IN C(AC) NON-ZERO 7843 034223 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7844 STOP^ 7845 034224 254 04 0 00 034225 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7846 034225 324 00 0 00 034226 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7847 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7848 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7849 7850 ;********** 7851 7852 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7853 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7854 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7855 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7856 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7857 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7858 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7859 010010 SN=SN+1 7860 777777 777577 ZZ=ZZ+ZZ+1 7861 IFE , 7862 034226 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 7863 034227 444 00 0 00 035151 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7864 ;RESULT IN C(AC) NON-ZERO 7865 034230 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7866 STOP^ 7867 034231 254 04 0 00 034232 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7868 034232 324 00 0 00 034233 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7869 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7870 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7871 7872 ;********** 7873 7874 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7875 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7876 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7877 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7878 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7879 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7880 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7881 010011 SN=SN+1 7882 777777 777377 ZZ=ZZ+ZZ+1 7883 IFE , 7884 034233 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 7885 034234 444 00 0 00 035152 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7886 ;RESULT IN C(AC) NON-ZERO 7887 034235 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7888 STOP^ 7889 034236 254 04 0 00 034237 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7890 034237 324 00 0 00 034240 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7891 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7892 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7893 7894 ;********** 7895 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-4 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0167 7896 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7897 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7898 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7899 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7900 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7901 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7902 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7903 010012 SN=SN+1 7904 777777 776777 ZZ=ZZ+ZZ+1 7905 IFE , 7906 034240 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 7907 034241 444 00 0 00 035153 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7908 ;RESULT IN C(AC) NON-ZERO 7909 034242 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7910 STOP^ 7911 034243 254 04 0 00 034244 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7912 034244 324 00 0 00 034245 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7913 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7914 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7915 7916 ;********** 7917 7918 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7919 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7920 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7921 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7922 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7923 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7924 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7925 010013 SN=SN+1 7926 777777 775777 ZZ=ZZ+ZZ+1 7927 IFE , 7928 034245 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 7929 034246 444 00 0 00 035154 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7930 ;RESULT IN C(AC) NON-ZERO 7931 034247 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7932 STOP^ 7933 034250 254 04 0 00 034251 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7934 034251 324 00 0 00 034252 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7935 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7936 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7937 7938 ;********** 7939 7940 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7941 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7942 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7943 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7944 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7945 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7946 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7947 010014 SN=SN+1 7948 777777 773777 ZZ=ZZ+ZZ+1 7949 IFE , 7950 034252 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-5 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0168 7951 034253 444 00 0 00 035155 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7952 ;RESULT IN C(AC) NON-ZERO 7953 034254 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7954 STOP^ 7955 034255 254 04 0 00 034256 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7956 034256 324 00 0 00 034257 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7957 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7958 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7959 7960 ;********** 7961 7962 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7963 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7964 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7965 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7966 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7967 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7968 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7969 010015 SN=SN+1 7970 777777 767777 ZZ=ZZ+ZZ+1 7971 IFE , 7972 034257 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 7973 034260 444 00 0 00 035156 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7974 ;RESULT IN C(AC) NON-ZERO 7975 034261 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7976 STOP^ 7977 034262 254 04 0 00 034263 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 7978 034263 324 00 0 00 034264 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 7979 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 7980 ;IN THE SUBTEST) TO LOOP ON ERROR^ 7981 7982 ;********** 7983 7984 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 7985 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 7986 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 7987 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 7988 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 7989 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 7990 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 7991 010016 SN=SN+1 7992 777777 757777 ZZ=ZZ+ZZ+1 7993 IFE , 7994 034264 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 7995 034265 444 00 0 00 035157 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 7996 ;RESULT IN C(AC) NON-ZERO 7997 034266 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 7998 STOP^ 7999 034267 254 04 0 00 034270 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8000 034270 324 00 0 00 034271 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8001 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8002 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8003 8004 ;********** 8005 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-6 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0169 8006 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8007 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8008 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8009 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8010 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8011 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8012 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8013 010017 SN=SN+1 8014 777777 737777 ZZ=ZZ+ZZ+1 8015 IFE , 8016 034271 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8017 034272 444 00 0 00 035160 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8018 ;RESULT IN C(AC) NON-ZERO 8019 034273 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8020 STOP^ 8021 034274 254 04 0 00 034275 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8022 034275 324 00 0 00 034276 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8023 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8024 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8025 8026 ;********** 8027 8028 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8029 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8030 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8031 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8032 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8033 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8034 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8035 010020 SN=SN+1 8036 777777 677777 ZZ=ZZ+ZZ+1 8037 IFE , 8038 034276 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8039 034277 444 00 0 00 035161 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8040 ;RESULT IN C(AC) NON-ZERO 8041 034300 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8042 STOP^ 8043 034301 254 04 0 00 034302 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8044 034302 324 00 0 00 034303 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8045 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8046 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8047 8048 ;********** 8049 8050 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8051 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8052 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8053 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8054 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8055 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8056 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8057 010021 SN=SN+1 8058 777777 577777 ZZ=ZZ+ZZ+1 8059 IFE , 8060 034303 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-7 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0170 8061 034304 444 00 0 00 035162 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8062 ;RESULT IN C(AC) NON-ZERO 8063 034305 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8064 STOP^ 8065 034306 254 04 0 00 034307 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8066 034307 324 00 0 00 034310 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8067 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8068 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8069 8070 ;********** 8071 8072 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8073 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8074 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8075 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8076 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8077 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8078 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8079 010022 SN=SN+1 8080 777777 377777 ZZ=ZZ+ZZ+1 8081 IFE , 8082 034310 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8083 034311 444 00 0 00 035163 EQV [XWD -1,ZZ] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8084 ;RESULT IN C(AC) NON-ZERO 8085 034312 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8086 STOP^ 8087 034313 254 04 0 00 034314 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8088 034314 324 00 0 00 034315 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8089 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8090 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8091 8092 ;********** 8093 8094 010100 SN=10100 8095 000000 ZZ=0 8096 8097 A10100: REPEAT ^D18, 8098 <;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8099 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8100 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8101 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8102 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8103 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8104 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8105 SN=SN+1 8106 ZZ=ZZ+ZZ+1 8107 IFE , 8108 MOVE [0] ;PRESET AC TO ALL ZEROS 8109 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8110 ;RESULT IN C(AC) NON-ZERO 8111 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8112 STOP 8113 8114 ;********** 8115 > DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-8 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0171 8116 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8117 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8118 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8119 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8120 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8121 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8122 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8123 010101 SN=SN+1 8124 000001 ZZ=ZZ+ZZ+1 8125 777777 777776 IFE , 8126 034315 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8127 034316 444 00 0 00 035164 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8128 ;RESULT IN C(AC) NON-ZERO 8129 034317 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8130 STOP^ 8131 034320 254 04 0 00 034321 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8132 034321 324 00 0 00 034322 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8133 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8134 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8135 8136 ;********** 8137 8138 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8139 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8140 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8141 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8142 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8143 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8144 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8145 010102 SN=SN+1 8146 777777 777775 ZZ=ZZ+ZZ+1 8147 IFE , 8148 034322 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8149 034323 444 00 0 00 035165 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8150 ;RESULT IN C(AC) NON-ZERO 8151 034324 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8152 STOP^ 8153 034325 254 04 0 00 034326 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8154 034326 324 00 0 00 034327 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8155 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8156 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8157 8158 ;********** 8159 8160 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8161 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8162 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8163 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8164 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8165 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8166 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8167 010103 SN=SN+1 8168 777777 777773 ZZ=ZZ+ZZ+1 8169 IFE , 8170 034327 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-9 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0172 8171 034330 444 00 0 00 035166 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8172 ;RESULT IN C(AC) NON-ZERO 8173 034331 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8174 STOP^ 8175 034332 254 04 0 00 034333 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8176 034333 324 00 0 00 034334 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8177 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8178 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8179 8180 ;********** 8181 8182 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8183 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8184 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8185 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8186 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8187 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8188 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8189 010104 SN=SN+1 8190 777777 777767 ZZ=ZZ+ZZ+1 8191 IFE , 8192 034334 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8193 034335 444 00 0 00 035167 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8194 ;RESULT IN C(AC) NON-ZERO 8195 034336 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8196 STOP^ 8197 034337 254 04 0 00 034340 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8198 034340 324 00 0 00 034341 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8199 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8200 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8201 8202 ;********** 8203 8204 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8205 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8206 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8207 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8208 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8209 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8210 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8211 010105 SN=SN+1 8212 777777 777757 ZZ=ZZ+ZZ+1 8213 IFE , 8214 034341 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8215 034342 444 00 0 00 035170 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8216 ;RESULT IN C(AC) NON-ZERO 8217 034343 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8218 STOP^ 8219 034344 254 04 0 00 034345 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8220 034345 324 00 0 00 034346 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8221 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8222 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8223 8224 ;********** 8225 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-10 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0173 8226 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8227 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8228 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8229 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8230 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8231 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8232 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8233 010106 SN=SN+1 8234 777777 777737 ZZ=ZZ+ZZ+1 8235 IFE , 8236 034346 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8237 034347 444 00 0 00 035171 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8238 ;RESULT IN C(AC) NON-ZERO 8239 034350 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8240 STOP^ 8241 034351 254 04 0 00 034352 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8242 034352 324 00 0 00 034353 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8243 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8244 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8245 8246 ;********** 8247 8248 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8249 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8250 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8251 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8252 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8253 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8254 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8255 010107 SN=SN+1 8256 777777 777677 ZZ=ZZ+ZZ+1 8257 IFE , 8258 034353 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8259 034354 444 00 0 00 035172 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8260 ;RESULT IN C(AC) NON-ZERO 8261 034355 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8262 STOP^ 8263 034356 254 04 0 00 034357 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8264 034357 324 00 0 00 034360 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8265 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8266 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8267 8268 ;********** 8269 8270 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8271 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8272 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8273 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8274 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8275 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8276 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8277 010110 SN=SN+1 8278 777777 777577 ZZ=ZZ+ZZ+1 8279 IFE , 8280 034360 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-11 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0174 8281 034361 444 00 0 00 035173 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8282 ;RESULT IN C(AC) NON-ZERO 8283 034362 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8284 STOP^ 8285 034363 254 04 0 00 034364 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8286 034364 324 00 0 00 034365 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8287 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8288 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8289 8290 ;********** 8291 8292 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8293 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8294 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8295 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8296 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8297 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8298 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8299 010111 SN=SN+1 8300 777777 777377 ZZ=ZZ+ZZ+1 8301 IFE , 8302 034365 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8303 034366 444 00 0 00 035174 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8304 ;RESULT IN C(AC) NON-ZERO 8305 034367 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8306 STOP^ 8307 034370 254 04 0 00 034371 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8308 034371 324 00 0 00 034372 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8309 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8310 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8311 8312 ;********** 8313 8314 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8315 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8316 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8317 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8318 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8319 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8320 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8321 010112 SN=SN+1 8322 777777 776777 ZZ=ZZ+ZZ+1 8323 IFE , 8324 034372 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8325 034373 444 00 0 00 035175 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8326 ;RESULT IN C(AC) NON-ZERO 8327 034374 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8328 STOP^ 8329 034375 254 04 0 00 034376 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8330 034376 324 00 0 00 034377 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8331 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8332 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8333 8334 ;********** 8335 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-12 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0175 8336 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8337 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8338 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8339 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8340 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8341 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8342 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8343 010113 SN=SN+1 8344 777777 775777 ZZ=ZZ+ZZ+1 8345 IFE , 8346 034377 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8347 034400 444 00 0 00 035176 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8348 ;RESULT IN C(AC) NON-ZERO 8349 034401 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8350 STOP^ 8351 034402 254 04 0 00 034403 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8352 034403 324 00 0 00 034404 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8353 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8354 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8355 8356 ;********** 8357 8358 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8359 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8360 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8361 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8362 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8363 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8364 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8365 010114 SN=SN+1 8366 777777 773777 ZZ=ZZ+ZZ+1 8367 IFE , 8368 034404 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8369 034405 444 00 0 00 035177 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8370 ;RESULT IN C(AC) NON-ZERO 8371 034406 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8372 STOP^ 8373 034407 254 04 0 00 034410 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8374 034410 324 00 0 00 034411 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8375 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8376 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8377 8378 ;********** 8379 8380 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8381 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8382 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8383 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8384 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8385 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8386 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8387 010115 SN=SN+1 8388 777777 767777 ZZ=ZZ+ZZ+1 8389 IFE , 8390 034411 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-13 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0176 8391 034412 444 00 0 00 035200 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8392 ;RESULT IN C(AC) NON-ZERO 8393 034413 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8394 STOP^ 8395 034414 254 04 0 00 034415 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8396 034415 324 00 0 00 034416 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8397 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8398 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8399 8400 ;********** 8401 8402 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8403 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8404 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8405 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8406 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8407 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8408 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8409 010116 SN=SN+1 8410 777777 757777 ZZ=ZZ+ZZ+1 8411 IFE , 8412 034416 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8413 034417 444 00 0 00 035201 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8414 ;RESULT IN C(AC) NON-ZERO 8415 034420 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8416 STOP^ 8417 034421 254 04 0 00 034422 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8418 034422 324 00 0 00 034423 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8419 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8420 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8421 8422 ;********** 8423 8424 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8425 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8426 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8427 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8428 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8429 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8430 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8431 010117 SN=SN+1 8432 777777 737777 ZZ=ZZ+ZZ+1 8433 IFE , 8434 034423 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8435 034424 444 00 0 00 035202 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8436 ;RESULT IN C(AC) NON-ZERO 8437 034425 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8438 STOP^ 8439 034426 254 04 0 00 034427 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8440 034427 324 00 0 00 034430 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8441 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8442 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8443 8444 ;********** 8445 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-14 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0177 8446 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8447 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8448 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8449 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8450 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8451 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8452 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8453 010120 SN=SN+1 8454 777777 677777 ZZ=ZZ+ZZ+1 8455 IFE , 8456 034430 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8457 034431 444 00 0 00 035203 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8458 ;RESULT IN C(AC) NON-ZERO 8459 034432 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8460 STOP^ 8461 034433 254 04 0 00 034434 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8462 034434 324 00 0 00 034435 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8463 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8464 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8465 8466 ;********** 8467 8468 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8469 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8470 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8471 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8472 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8473 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8474 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8475 010121 SN=SN+1 8476 777777 577777 ZZ=ZZ+ZZ+1 8477 IFE , 8478 034435 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS 8479 034436 444 00 0 00 035204 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8480 ;RESULT IN C(AC) NON-ZERO 8481 034437 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8482 STOP^ 8483 034440 254 04 0 00 034441 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8484 034441 324 00 0 00 034442 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8485 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8486 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8487 8488 ;********** 8489 8490 ;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE 8491 ;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN 8492 ;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE 8493 ;E CONTAINS A ZERO). THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT 8494 ;OF THE RESULT IS A ONE ONCE AND ONLY ONCE. FIRST, THE AC IS 8495 ;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO. THE 8496 ;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO 8497 010122 SN=SN+1 8498 777777 377777 ZZ=ZZ+ZZ+1 8499 IFE , 8500 034442 200 00 0 00 035062 MOVE [0] ;PRESET AC TO ALL ZEROS DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 29-15 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0178 8501 034443 444 00 0 00 035064 EQV [XWD ZZ,-1] ;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD 8502 ;RESULT IN C(AC) NON-ZERO 8503 034444 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) NON-ZERO 8504 STOP^ 8505 034445 254 04 0 00 034446 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8506 034446 324 00 0 00 034447 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8507 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8508 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8509 8510 ;********** 8511 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 30 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0179 8512 ;THIS TEST VERIFIES THAT THE RESULT OF AN AC CONTAINING ALL ZEROS 8513 ;EQUIVALENCED WITH AN E CONTAINING ALL ZEROS IS AN AC CONTAINING ALL 8514 ;ONES; AND FUTHERMORE, IF THIS AC CONTAINING ALL ONES IS EQUIVALANCED 8515 ;WITH AN E CONTAINING ALL ZEROS, THE FINAL RESULT IN THE AC 8516 ;SHOULD BE ALL ZEROS. FIRST, THE AC IS INITIALIZED TO ALL ZEROS, THEN, 8517 ;THIS AC IS EQUIVALENCED TWICE WITH AN E CONTAINING ALL ZEROS. THE AC IS 8518 ;THEN CHECKED FOR ALL ZEROS 8519 8520 034447 200 00 0 00 035062 A10200: MOVE [0] ;CLEAR THE AC 8521 034450 444 00 0 00 035062 EQV [0] ;*EQV SHOULD RESULT IN C(AC)=ALL ONES 8522 034451 444 00 0 00 035062 EQV [0] ;*EQV SHOULD RESULT IN C(AC)=0 8523 034452 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8524 STOP^ 8525 034453 254 04 0 00 034454 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8526 034454 324 00 0 00 034455 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8527 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8528 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8529 8530 ;********** 8531 8532 ;THIS TEST VERIFIES THAT THE RESULT OF AN AC CONTAINING ALL ONES 8533 ;EQUIVALENCED WITH AN E CONTAINING ALL ONES IS AN AC CONTAINING ALL ONES; 8534 ;AND FUTHERMORE, IF THIS AC CONTAINING ALL ONES ISEQUIVALENCED WITH AN E 8535 ;CONTAINING ALL ZEROS, THE FINAL RESULT IN THE AC SHOULD BE ALL ZEROS. 8536 ;FIRST, THE AC IS INITIALIZED TO ALL ONES; THEN, THIS AC IS 8537 ;EQUIVALENCED WITH AN E OF ALL ONES. NEXT, THIS SAME AC IS EQUIVALENCED 8538 ;WITH AN E OF ALL ZEROS. THE AC IS THEN CHECKED FOR ALL ZEROS. 8539 8540 034455 200 00 0 00 035063 A10300: MOVE [-1] ;SET C(AC) TO ALL ONES 8541 034456 444 00 0 00 035063 EQV [-1] ;*EQV SHOULD RESULT IN C(AC) OF ALL ONES 8542 034457 444 00 0 00 035062 EQV [0] ;*EQV SHOULD RESULT IN C(AC)=0 8543 034460 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8544 STOP^ 8545 034461 254 04 0 00 034462 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8546 034462 324 00 0 00 034463 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8547 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8548 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8549 8550 ;********** DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0180 8551 013000 SN=13000 8552 000000 ZZ=0 8553 8554 A13000: REPEAT ^D36, 8555 <;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8556 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8557 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8558 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8559 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8560 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8561 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8562 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8563 SN=SN+1 8564 ZZ=ZZ+ZZ 8565 IFE ZZ, 8566 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8567 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8568 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8569 EQV [0] ;RESULTS IN C(AC)=0 8570 SKIPE ;PASS TEST IF C(AC)=0 8571 STOP 8572 8573 ;********** 8574 > 8575 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8576 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8577 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8578 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8579 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8580 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8581 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8582 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8583 013001 SN=SN+1 8584 000000 ZZ=ZZ+ZZ 8585 000001 IFE ZZ, 8586 034463 200 00 0 00 035074 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8587 034464 404 00 0 00 035074 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8588 034465 444 00 0 00 035074 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8589 034466 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8590 034467 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8591 STOP^ 8592 034470 254 04 0 00 034471 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8593 034471 324 00 0 00 034472 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8594 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8595 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8596 8597 ;********** 8598 8599 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8600 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8601 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8602 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8603 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8604 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8605 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-1 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0181 8606 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8607 013002 SN=SN+1 8608 000002 ZZ=ZZ+ZZ 8609 IFE ZZ, 8610 034472 200 00 0 00 035075 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8611 034473 404 00 0 00 035075 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8612 034474 444 00 0 00 035075 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8613 034475 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8614 034476 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8615 STOP^ 8616 034477 254 04 0 00 034500 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8617 034500 324 00 0 00 034501 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8618 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8619 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8620 8621 ;********** 8622 8623 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8624 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8625 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8626 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8627 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8628 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8629 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8630 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8631 013003 SN=SN+1 8632 000004 ZZ=ZZ+ZZ 8633 IFE ZZ, 8634 034501 200 00 0 00 035076 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8635 034502 404 00 0 00 035076 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8636 034503 444 00 0 00 035076 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8637 034504 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8638 034505 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8639 STOP^ 8640 034506 254 04 0 00 034507 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8641 034507 324 00 0 00 034510 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8642 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8643 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8644 8645 ;********** 8646 8647 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8648 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8649 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8650 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8651 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8652 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8653 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8654 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8655 013004 SN=SN+1 8656 000010 ZZ=ZZ+ZZ 8657 IFE ZZ, 8658 034510 200 00 0 00 035077 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8659 034511 404 00 0 00 035077 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8660 034512 444 00 0 00 035077 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-2 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0182 8661 034513 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8662 034514 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8663 STOP^ 8664 034515 254 04 0 00 034516 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8665 034516 324 00 0 00 034517 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8666 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8667 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8668 8669 ;********** 8670 8671 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8672 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8673 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8674 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8675 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8676 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8677 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8678 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8679 013005 SN=SN+1 8680 000020 ZZ=ZZ+ZZ 8681 IFE ZZ, 8682 034517 200 00 0 00 035100 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8683 034520 404 00 0 00 035100 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8684 034521 444 00 0 00 035100 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8685 034522 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8686 034523 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8687 STOP^ 8688 034524 254 04 0 00 034525 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8689 034525 324 00 0 00 034526 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8690 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8691 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8692 8693 ;********** 8694 8695 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8696 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8697 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8698 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8699 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8700 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8701 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8702 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8703 013006 SN=SN+1 8704 000040 ZZ=ZZ+ZZ 8705 IFE ZZ, 8706 034526 200 00 0 00 035101 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8707 034527 404 00 0 00 035101 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8708 034530 444 00 0 00 035101 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8709 034531 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8710 034532 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8711 STOP^ 8712 034533 254 04 0 00 034534 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8713 034534 324 00 0 00 034535 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8714 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8715 ;IN THE SUBTEST) TO LOOP ON ERROR^ DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-3 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0183 8716 8717 ;********** 8718 8719 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8720 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8721 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8722 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8723 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8724 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8725 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8726 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8727 013007 SN=SN+1 8728 000100 ZZ=ZZ+ZZ 8729 IFE ZZ, 8730 034535 200 00 0 00 035102 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8731 034536 404 00 0 00 035102 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8732 034537 444 00 0 00 035102 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8733 034540 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8734 034541 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8735 STOP^ 8736 034542 254 04 0 00 034543 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8737 034543 324 00 0 00 034544 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8738 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8739 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8740 8741 ;********** 8742 8743 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8744 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8745 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8746 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8747 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8748 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8749 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8750 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8751 013010 SN=SN+1 8752 000200 ZZ=ZZ+ZZ 8753 IFE ZZ, 8754 034544 200 00 0 00 035103 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8755 034545 404 00 0 00 035103 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8756 034546 444 00 0 00 035103 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8757 034547 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8758 034550 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8759 STOP^ 8760 034551 254 04 0 00 034552 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8761 034552 324 00 0 00 034553 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8762 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8763 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8764 8765 ;********** 8766 8767 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8768 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8769 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8770 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-4 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0184 8771 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8772 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8773 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8774 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8775 013011 SN=SN+1 8776 000400 ZZ=ZZ+ZZ 8777 IFE ZZ, 8778 034553 200 00 0 00 035104 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8779 034554 404 00 0 00 035104 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8780 034555 444 00 0 00 035104 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8781 034556 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8782 034557 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8783 STOP^ 8784 034560 254 04 0 00 034561 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8785 034561 324 00 0 00 034562 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8786 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8787 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8788 8789 ;********** 8790 8791 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8792 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8793 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8794 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8795 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8796 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8797 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8798 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8799 013012 SN=SN+1 8800 001000 ZZ=ZZ+ZZ 8801 IFE ZZ, 8802 034562 200 00 0 00 035105 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8803 034563 404 00 0 00 035105 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8804 034564 444 00 0 00 035105 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8805 034565 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8806 034566 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8807 STOP^ 8808 034567 254 04 0 00 034570 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8809 034570 324 00 0 00 034571 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8810 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8811 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8812 8813 ;********** 8814 8815 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8816 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8817 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8818 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8819 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8820 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8821 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8822 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8823 013013 SN=SN+1 8824 002000 ZZ=ZZ+ZZ 8825 IFE ZZ, DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-5 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0185 8826 034571 200 00 0 00 035106 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8827 034572 404 00 0 00 035106 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8828 034573 444 00 0 00 035106 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8829 034574 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8830 034575 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8831 STOP^ 8832 034576 254 04 0 00 034577 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8833 034577 324 00 0 00 034600 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8834 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8835 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8836 8837 ;********** 8838 8839 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8840 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8841 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8842 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8843 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8844 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8845 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8846 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8847 013014 SN=SN+1 8848 004000 ZZ=ZZ+ZZ 8849 IFE ZZ, 8850 034600 200 00 0 00 035107 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8851 034601 404 00 0 00 035107 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8852 034602 444 00 0 00 035107 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8853 034603 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8854 034604 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8855 STOP^ 8856 034605 254 04 0 00 034606 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8857 034606 324 00 0 00 034607 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8858 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8859 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8860 8861 ;********** 8862 8863 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8864 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8865 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8866 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8867 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8868 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8869 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8870 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8871 013015 SN=SN+1 8872 010000 ZZ=ZZ+ZZ 8873 IFE ZZ, 8874 034607 200 00 0 00 035110 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8875 034610 404 00 0 00 035110 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8876 034611 444 00 0 00 035110 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8877 034612 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8878 034613 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8879 STOP^ 8880 034614 254 04 0 00 034615 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-6 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0186 8881 034615 324 00 0 00 034616 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8882 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8883 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8884 8885 ;********** 8886 8887 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8888 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8889 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8890 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8891 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8892 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8893 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8894 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8895 013016 SN=SN+1 8896 020000 ZZ=ZZ+ZZ 8897 IFE ZZ, 8898 034616 200 00 0 00 035111 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8899 034617 404 00 0 00 035111 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8900 034620 444 00 0 00 035111 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8901 034621 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8902 034622 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8903 STOP^ 8904 034623 254 04 0 00 034624 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8905 034624 324 00 0 00 034625 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8906 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8907 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8908 8909 ;********** 8910 8911 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8912 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8913 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8914 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8915 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8916 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8917 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8918 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8919 013017 SN=SN+1 8920 040000 ZZ=ZZ+ZZ 8921 IFE ZZ, 8922 034625 200 00 0 00 035112 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8923 034626 404 00 0 00 035112 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8924 034627 444 00 0 00 035112 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8925 034630 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8926 034631 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8927 STOP^ 8928 034632 254 04 0 00 034633 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8929 034633 324 00 0 00 034634 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8930 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8931 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8932 8933 ;********** 8934 8935 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-7 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0187 8936 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8937 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8938 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8939 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8940 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8941 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8942 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8943 013020 SN=SN+1 8944 100000 ZZ=ZZ+ZZ 8945 IFE ZZ, 8946 034634 200 00 0 00 035113 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8947 034635 404 00 0 00 035113 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8948 034636 444 00 0 00 035113 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8949 034637 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8950 034640 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8951 STOP^ 8952 034641 254 04 0 00 034642 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8953 034642 324 00 0 00 034643 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8954 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8955 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8956 8957 ;********** 8958 8959 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8960 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8961 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8962 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8963 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8964 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8965 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8966 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 8967 013021 SN=SN+1 8968 200000 ZZ=ZZ+ZZ 8969 IFE ZZ, 8970 034643 200 00 0 00 035114 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8971 034644 404 00 0 00 035114 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8972 034645 444 00 0 00 035114 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8973 034646 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8974 034647 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8975 STOP^ 8976 034650 254 04 0 00 034651 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 8977 034651 324 00 0 00 034652 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 8978 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 8979 ;IN THE SUBTEST) TO LOOP ON ERROR^ 8980 8981 ;********** 8982 8983 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 8984 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 8985 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 8986 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 8987 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 8988 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 8989 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 8990 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-8 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0188 8991 013022 SN=SN+1 8992 400000 ZZ=ZZ+ZZ 8993 IFE ZZ, 8994 034652 200 00 0 00 035115 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 8995 034653 404 00 0 00 035115 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 8996 034654 444 00 0 00 035115 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 8997 034655 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 8998 034656 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 8999 STOP^ 9000 034657 254 04 0 00 034660 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9001 034660 324 00 0 00 034661 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9002 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9003 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9004 9005 ;********** 9006 9007 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9008 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9009 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9010 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9011 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9012 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9013 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9014 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9015 013023 SN=SN+1 9016 000001 000000 ZZ=ZZ+ZZ 9017 IFE ZZ, 9018 034661 200 00 0 00 035116 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9019 034662 404 00 0 00 035116 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9020 034663 444 00 0 00 035116 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9021 034664 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9022 034665 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9023 STOP^ 9024 034666 254 04 0 00 034667 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9025 034667 324 00 0 00 034670 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9026 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9027 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9028 9029 ;********** 9030 9031 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9032 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9033 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9034 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9035 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9036 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9037 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9038 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9039 013024 SN=SN+1 9040 000002 000000 ZZ=ZZ+ZZ 9041 IFE ZZ, 9042 034670 200 00 0 00 035117 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9043 034671 404 00 0 00 035117 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9044 034672 444 00 0 00 035117 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9045 034673 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-9 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0189 9046 034674 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9047 STOP^ 9048 034675 254 04 0 00 034676 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9049 034676 324 00 0 00 034677 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9050 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9051 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9052 9053 ;********** 9054 9055 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9056 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9057 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9058 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9059 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9060 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9061 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9062 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9063 013025 SN=SN+1 9064 000004 000000 ZZ=ZZ+ZZ 9065 IFE ZZ, 9066 034677 200 00 0 00 035120 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9067 034700 404 00 0 00 035120 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9068 034701 444 00 0 00 035120 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9069 034702 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9070 034703 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9071 STOP^ 9072 034704 254 04 0 00 034705 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9073 034705 324 00 0 00 034706 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9074 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9075 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9076 9077 ;********** 9078 9079 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9080 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9081 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9082 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9083 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9084 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9085 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9086 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9087 013026 SN=SN+1 9088 000010 000000 ZZ=ZZ+ZZ 9089 IFE ZZ, 9090 034706 200 00 0 00 035121 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9091 034707 404 00 0 00 035121 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9092 034710 444 00 0 00 035121 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9093 034711 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9094 034712 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9095 STOP^ 9096 034713 254 04 0 00 034714 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9097 034714 324 00 0 00 034715 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9098 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9099 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9100 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-10 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0190 9101 ;********** 9102 9103 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9104 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9105 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9106 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9107 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9108 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9109 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9110 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9111 013027 SN=SN+1 9112 000020 000000 ZZ=ZZ+ZZ 9113 IFE ZZ, 9114 034715 200 00 0 00 035122 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9115 034716 404 00 0 00 035122 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9116 034717 444 00 0 00 035122 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9117 034720 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9118 034721 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9119 STOP^ 9120 034722 254 04 0 00 034723 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9121 034723 324 00 0 00 034724 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9122 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9123 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9124 9125 ;********** 9126 9127 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9128 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9129 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9130 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9131 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9132 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9133 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9134 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9135 013030 SN=SN+1 9136 000040 000000 ZZ=ZZ+ZZ 9137 IFE ZZ, 9138 034724 200 00 0 00 035123 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9139 034725 404 00 0 00 035123 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9140 034726 444 00 0 00 035123 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9141 034727 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9142 034730 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9143 STOP^ 9144 034731 254 04 0 00 034732 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9145 034732 324 00 0 00 034733 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9146 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9147 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9148 9149 ;********** 9150 9151 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9152 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9153 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9154 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9155 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-11 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0191 9156 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9157 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9158 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9159 013031 SN=SN+1 9160 000100 000000 ZZ=ZZ+ZZ 9161 IFE ZZ, 9162 034733 200 00 0 00 035124 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9163 034734 404 00 0 00 035124 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9164 034735 444 00 0 00 035124 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9165 034736 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9166 034737 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9167 STOP^ 9168 034740 254 04 0 00 034741 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9169 034741 324 00 0 00 034742 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9170 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9171 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9172 9173 ;********** 9174 9175 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9176 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9177 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9178 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9179 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9180 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9181 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9182 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9183 013032 SN=SN+1 9184 000200 000000 ZZ=ZZ+ZZ 9185 IFE ZZ, 9186 034742 200 00 0 00 035125 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9187 034743 404 00 0 00 035125 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9188 034744 444 00 0 00 035125 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9189 034745 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9190 034746 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9191 STOP^ 9192 034747 254 04 0 00 034750 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9193 034750 324 00 0 00 034751 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9194 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9195 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9196 9197 ;********** 9198 9199 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9200 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9201 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9202 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9203 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9204 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9205 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9206 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9207 013033 SN=SN+1 9208 000400 000000 ZZ=ZZ+ZZ 9209 IFE ZZ, 9210 034751 200 00 0 00 035073 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-12 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0192 9211 034752 404 00 0 00 035073 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9212 034753 444 00 0 00 035073 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9213 034754 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9214 034755 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9215 STOP^ 9216 034756 254 04 0 00 034757 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9217 034757 324 00 0 00 034760 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9218 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9219 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9220 9221 ;********** 9222 9223 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9224 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9225 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9226 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9227 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9228 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9229 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9230 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9231 013034 SN=SN+1 9232 001000 000000 ZZ=ZZ+ZZ 9233 IFE ZZ, 9234 034760 200 00 0 00 035126 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9235 034761 404 00 0 00 035126 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9236 034762 444 00 0 00 035126 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9237 034763 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9238 034764 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9239 STOP^ 9240 034765 254 04 0 00 034766 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9241 034766 324 00 0 00 034767 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9242 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9243 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9244 9245 ;********** 9246 9247 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9248 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9249 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9250 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9251 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9252 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9253 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9254 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9255 013035 SN=SN+1 9256 002000 000000 ZZ=ZZ+ZZ 9257 IFE ZZ, 9258 034767 200 00 0 00 035127 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9259 034770 404 00 0 00 035127 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9260 034771 444 00 0 00 035127 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9261 034772 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9262 034773 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9263 STOP^ 9264 034774 254 04 0 00 034775 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9265 034775 324 00 0 00 034776 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-13 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0193 9266 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9267 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9268 9269 ;********** 9270 9271 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9272 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9273 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9274 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9275 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9276 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9277 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9278 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9279 013036 SN=SN+1 9280 004000 000000 ZZ=ZZ+ZZ 9281 IFE ZZ, 9282 034776 200 00 0 00 035130 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9283 034777 404 00 0 00 035130 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9284 035000 444 00 0 00 035130 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9285 035001 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9286 035002 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9287 STOP^ 9288 035003 254 04 0 00 035004 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9289 035004 324 00 0 00 035005 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9290 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9291 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9292 9293 ;********** 9294 9295 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9296 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9297 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9298 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9299 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9300 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9301 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9302 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9303 013037 SN=SN+1 9304 010000 000000 ZZ=ZZ+ZZ 9305 IFE ZZ, 9306 035005 200 00 0 00 035131 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9307 035006 404 00 0 00 035131 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9308 035007 444 00 0 00 035131 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9309 035010 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9310 035011 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9311 STOP^ 9312 035012 254 04 0 00 035013 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9313 035013 324 00 0 00 035014 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9314 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9315 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9316 9317 ;********** 9318 9319 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9320 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-14 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0194 9321 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9322 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9323 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9324 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9325 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9326 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9327 013040 SN=SN+1 9328 020000 000000 ZZ=ZZ+ZZ 9329 IFE ZZ, 9330 035014 200 00 0 00 035132 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9331 035015 404 00 0 00 035132 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9332 035016 444 00 0 00 035132 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9333 035017 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9334 035020 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9335 STOP^ 9336 035021 254 04 0 00 035022 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9337 035022 324 00 0 00 035023 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9338 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9339 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9340 9341 ;********** 9342 9343 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9344 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9345 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9346 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9347 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9348 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9349 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9350 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9351 013041 SN=SN+1 9352 040000 000000 ZZ=ZZ+ZZ 9353 IFE ZZ, 9354 035023 200 00 0 00 035133 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9355 035024 404 00 0 00 035133 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9356 035025 444 00 0 00 035133 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9357 035026 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9358 035027 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9359 STOP^ 9360 035030 254 04 0 00 035031 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9361 035031 324 00 0 00 035032 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9362 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9363 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9364 9365 ;********** 9366 9367 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9368 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9369 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9370 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9371 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9372 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9373 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9374 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9375 013042 SN=SN+1 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-15 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0195 9376 100000 000000 ZZ=ZZ+ZZ 9377 IFE ZZ, 9378 035032 200 00 0 00 035134 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9379 035033 404 00 0 00 035134 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9380 035034 444 00 0 00 035134 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9381 035035 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9382 035036 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9383 STOP^ 9384 035037 254 04 0 00 035040 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9385 035040 324 00 0 00 035041 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9386 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9387 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9388 9389 ;********** 9390 9391 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9392 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9393 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9394 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9395 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9396 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9397 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9398 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9399 013043 SN=SN+1 9400 200000 000000 ZZ=ZZ+ZZ 9401 IFE ZZ, 9402 035041 200 00 0 00 035135 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9403 035042 404 00 0 00 035135 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9404 035043 444 00 0 00 035135 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9405 035044 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9406 035045 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 9407 STOP^ 9408 035046 254 04 0 00 035047 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9409 035047 324 00 0 00 035050 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9410 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9411 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9412 9413 ;********** 9414 9415 ;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS. 9416 ;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN 9417 ;ANDED WITH C(E) WHERE C(E)=C(AC). THE NET RESULT SHOULD BE NO CHANGE TO C(AC). 9418 ;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD 9419 ;BE ALL ONES IN THE AC. THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS, 9420 ;WHICH SHOULD RESULT IN C(AC)=0. THE AC IS CHECKED FOR ALL ZEROS. 9421 ;IF C(AC) IS NON-ZERO, THE TEST FAILS. THIS TEST IS REPEATED 36 TIMES TO 9422 ;RIPPLE A ONE THROUGH EVERY BIT OF THE AC. 9423 013044 SN=SN+1 9424 400000 000000 ZZ=ZZ+ZZ 9425 IFE ZZ, 9426 035050 200 00 0 00 035065 MOVE [ZZ] ;SETUP AC WITH A ONE IN ONLY ONE BIT 9427 035051 404 00 0 00 035065 AND [ZZ] ;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC) 9428 035052 444 00 0 00 035065 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES 9429 035053 444 00 0 00 035062 EQV [0] ;RESULTS IN C(AC)=0 9430 035054 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 31-16 DAKAAM MAC 19-JAN-77 13:42 TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV) SEQ 0196 9431 STOP^ 9432 035055 254 04 0 00 035056 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE 9433 035056 324 00 0 00 035057 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO 9434 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION 9435 ;IN THE SUBTEST) TO LOOP ON ERROR^ 9436 9437 ;********** 9438 9439 035057 254 00 0 00 030057 ENDXX: JRST BEGEND ;LOOP PROGRAM DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 1 STOR KLM 18-JAN-77 11:42 *STOR* RESERVED STORAGE, JAN 18,1977 SEQ 0197 9440 SUBTTL *STOR* RESERVED STORAGE, JAN 18,1977 9441 9442 ;PROGRAM LITERALS 9443 9444 XLIST 9445 IFNDEF $LPAPER, 9446 035060 LIT 9447 035060 000001 000001 9448 035061 254 00 0 00 030741 9449 035062 000000 000000 9450 035063 777777 777777 9451 035064 377777 777777 9452 035065 400000 000000 9453 035066 777000 000000 9454 035067 000377 000000 9455 035070 000000 177000 9456 035071 000000 000777 9457 035072 000000 600000 9458 035073 000400 000000 9459 035074 000000 000001 9460 035075 000000 000002 9461 035076 000000 000004 9462 035077 000000 000010 9463 035100 000000 000020 9464 035101 000000 000040 9465 035102 000000 000100 9466 035103 000000 000200 9467 035104 000000 000400 9468 035105 000000 001000 9469 035106 000000 002000 9470 035107 000000 004000 9471 035110 000000 010000 9472 035111 000000 020000 9473 035112 000000 040000 9474 035113 000000 100000 9475 035114 000000 200000 9476 035115 000000 400000 9477 035116 000001 000000 9478 035117 000002 000000 9479 035120 000004 000000 9480 035121 000010 000000 9481 035122 000020 000000 9482 035123 000040 000000 9483 035124 000100 000000 9484 035125 000200 000000 9485 035126 001000 000000 9486 035127 002000 000000 9487 035130 004000 000000 9488 035131 010000 000000 9489 035132 020000 000000 9490 035133 040000 000000 9491 035134 100000 000000 9492 035135 200000 000000 9493 035136 000000 001234 9494 035137 000000 777777 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 1-1 STOR KLM 18-JAN-77 11:42 *STOR* RESERVED STORAGE, JAN 18,1977 SEQ 0198 9495 035140 777777 000000 9496 035141 707070 707070 9497 035142 777777 777776 9498 035143 777777 777775 9499 035144 777777 777773 9500 035145 777777 777767 9501 035146 777777 777757 9502 035147 777777 777737 9503 035150 777777 777677 9504 035151 777777 777577 9505 035152 777777 777377 9506 035153 777777 776777 9507 035154 777777 775777 9508 035155 777777 773777 9509 035156 777777 767777 9510 035157 777777 757777 9511 035160 777777 737777 9512 035161 777777 677777 9513 035162 777777 577777 9514 035163 777777 377777 9515 035164 777776 777777 9516 035165 777775 777777 9517 035166 777773 777777 9518 035167 777767 777777 9519 035170 777757 777777 9520 035171 777737 777777 9521 035172 777677 777777 9522 035173 777577 777777 9523 035174 777377 777777 9524 035175 776777 777777 9525 035176 775777 777777 9526 035177 773777 777777 9527 035200 767777 777777 9528 035201 757777 777777 9529 035202 737777 777777 9530 035203 677777 777777 9531 035204 577777 777777 9532 LIST 9533 035205 000000 000000 ENDSLD: 0 9534 9535 IFDEF DEBUG,< 9536 PATCH: BLOCK DEBUG ;PATCHING AREA 9537 > 9538 9539 ;PROGRAM VARIABLES 9540 035206 VAR 9541 9542 IFDEF PGMEND,< 9543 035206 000000 000000 END: 0 9544 030000 END BEGIN > NO ERRORS DETECTED PROGRAM BREAK IS 000000 ABSLUTE BREAK IS 035207 DAKAA PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) 0,2 MACRO %52(537) 13:54 19-JAN-77 PAGE 1-2 STOR KLM 18-JAN-77 11:42 *STOR* RESERVED STORAGE, JAN 18,1977 SEQ 0199 CPU TIME USED 00:40.863 11K CORE USED