From 2a8c2a74d28da4b9560cd96d80e0bbc0b3a9f17f Mon Sep 17 00:00:00 2001 From: Jeff Date: Mon, 27 Mar 2017 11:44:42 -0700 Subject: [PATCH] Fixed a couple of PDP-10 opcode emulation bugs (AOBJN, AOBJP, and CMP), and rounded out the set of DEC's basic instruction diagnostics --- ...24-stepping-through-pdp-10-diagnostics.md} | 94 +- apps/pdp10/diags/klad/README.md | 2 + apps/pdp10/diags/klad/dakaa/DAKAA.MAC.txt | 37 +- .../dakaa/{MYDAKAA.MAC.txt => DAKAAM.MAC.txt} | 37 +- apps/pdp10/diags/klad/dakaa/README.md | 8 +- apps/pdp10/diags/klad/dakab/DAKAB.LST.txt | 12231 ++++++++++++++++ apps/pdp10/diags/klad/dakab/DAKAB.MAC.txt | 1782 +++ apps/pdp10/diags/klad/dakab/DAKABM.MAC.txt | 1770 +++ apps/pdp10/diags/klad/dakab/README.md | 274 + apps/pdp10/diags/klad/dakac/DAKAC.LST.txt | 7750 ++++++++++ apps/pdp10/diags/klad/dakac/DAKAC.MAC.txt | 2652 ++++ apps/pdp10/diags/klad/dakac/DAKACM.MAC.txt | 2652 ++++ apps/pdp10/diags/klad/dakac/README.md | 273 + apps/pdp10/diags/klad/dakad/DAKAD.MAC.txt | 22 +- .../dakad/{MYDAKAD.MAC.txt => DAKADM.MAC.txt} | 22 +- apps/pdp10/diags/klad/dakad/README.md | 9 +- apps/pdp10/tests/opcodes/OPTEST02.simh | 12 + apps/pdp10/tests/opcodes/OPTEST02.txt | 11 + modules/pdp10/lib/cpuops.js | 6 +- modules/pdp10/lib/debugger.js | 6 +- modules/pdp10/lib/macro10.js | 4 +- 21 files changed, 29570 insertions(+), 84 deletions(-) rename _posts/{2017-03-24-stepping-through-pdp-10-diagnostica.md => 2017-03-24-stepping-through-pdp-10-diagnostics.md} (52%) rename apps/pdp10/diags/klad/dakaa/{MYDAKAA.MAC.txt => DAKAAM.MAC.txt} (97%) create mode 100644 apps/pdp10/diags/klad/dakab/DAKAB.LST.txt create mode 100644 apps/pdp10/diags/klad/dakab/DAKAB.MAC.txt create mode 100644 apps/pdp10/diags/klad/dakab/DAKABM.MAC.txt create mode 100644 apps/pdp10/diags/klad/dakab/README.md create mode 100644 apps/pdp10/diags/klad/dakac/DAKAC.LST.txt create mode 100644 apps/pdp10/diags/klad/dakac/DAKAC.MAC.txt create mode 100644 apps/pdp10/diags/klad/dakac/DAKACM.MAC.txt create mode 100644 apps/pdp10/diags/klad/dakac/README.md rename apps/pdp10/diags/klad/dakad/{MYDAKAD.MAC.txt => DAKADM.MAC.txt} (99%) create mode 100644 apps/pdp10/tests/opcodes/OPTEST02.simh create mode 100644 apps/pdp10/tests/opcodes/OPTEST02.txt diff --git a/_posts/2017-03-24-stepping-through-pdp-10-diagnostica.md b/_posts/2017-03-24-stepping-through-pdp-10-diagnostics.md similarity index 52% rename from _posts/2017-03-24-stepping-through-pdp-10-diagnostica.md rename to _posts/2017-03-24-stepping-through-pdp-10-diagnostics.md index 361b76fb6..5355ddc6a 100644 --- a/_posts/2017-03-24-stepping-through-pdp-10-diagnostica.md +++ b/_posts/2017-03-24-stepping-through-pdp-10-diagnostics.md @@ -8,10 +8,10 @@ machines: type: pdp10 config: /devices/pdp10/machine/ka10/test/debugger/machine.xml debugger: true - commands: a 30724 /apps/pdp10/diags/klad/dakaa/MYDAKAA.MAC + commands: a 30724 /apps/pdp10/diags/klad/dakaa/DAKAA.MAC --- -Now that the PDPjs MACRO-10 Mini-Assembler is [limping along](/blog/2017/03/21/), it was time to start assembling some +Now that the PDPjs MACRO-10 Mini-Assembler is [limping along](/blog/2017/03/21/), it's time to start assembling some of DEC's PDP-10 diagnostics and loading them into a test machine. The first diagnostic I tried was [KA10 Basic Instruction Diagnostic #1 (MAINDEC-10-DAKAA-B-D)](/apps/pdp10/diags/klad/dakaa/), which has been loaded into the machine below. @@ -20,9 +20,9 @@ the machine below. Here were the results of my first run attempt: - >> a 30724 /apps/pdp10/diags/klad/dakaa/MYDAKAA.MAC + >> a 30724 /apps/pdp10/diags/klad/dakaa/DAKAA.MAC starting PCjs MACRO-10 Mini-Assembler... - loading MYDAKAA.MAC + loading DAKAA.MAC CPU will not be auto-started (click Run to start) 2844 words loaded at 030724-036357 00=000000000000 01=000000000000 02=000000000000 03=000000000000 @@ -60,9 +60,9 @@ Happily, this was a good outcome, because 035057 is the end of the test. If you Next, I tried [KA10 Basic Instruction Diagnostic #4 (MAINDEC-10-DAKAD-B-D)](/apps/pdp10/diags/klad/dakad/): - >> a 30724 /apps/pdp10/diags/klad/dakad/MYDAKAD.MAC + >> a 30724 /apps/pdp10/diags/klad/dakad/DAKAD.MAC starting PCjs MACRO-10 Mini-Assembler... - loading MYDAKAD.MAC + loading DAKAD.MAC 1986 words loaded at 030724-034625 00=000000000000 01=000000000000 02=777777777777 03=000000000000 04=777777777777 05=000000000000 06=000000000000 07=777777777777 @@ -91,8 +91,88 @@ Next, I tried [KA10 Basic Instruction Diagnostic #4 (MAINDEC-10-DAKAD-B-D)](/app 032005: 312140 034462 CAME 3,34462 ;history=2 032006: 254200 032007 HALT 32007 ;history=1 -This looked less good. +This looked less good. Both AC3 and memory location 34462 contained 400000000000, so the CAME instruction should have +"skipped if equal." There was a bug in the [cpuops.js](/modules/pdp10/lib/cpuops.js) *CMP()* function: +```javascript +/** + * CMP(dst, src) + * + * Performs the SIGNED comparison (CMP) of two 36-bit operands. + * + * @param {number} dst (36-bit value) + * @param {number} src (36-bit value) + * @return {number} (dst - src) + */ +PDP10.CMP = function(dst, src) +{ + return (dst < PDP10.INT_LIMIT? dst : dst - PDP10.WORD_LIMIT) - (src < PDP10.INT_LIMIT? src : src - PDP10.INT_LIMIT); +}; +``` + +And here's the correction: + +```javascript + return (dst < PDP10.INT_LIMIT? dst : dst - PDP10.WORD_LIMIT) - (src < PDP10.INT_LIMIT? src : src - PDP10.WORD_LIMIT); +``` + +Just a stupid typo. After fixing that and trying again, the diagnostic got a bit farther: + + >> g + running + stopped (1119 instructions, 1118 cycles, 12 ms, 93167 hz) + 00=000001000001 01=000000000000 02=000000000002 03=000000000003 + 04=000000000004 05=000000000005 06=000000000006 07=000000000007 + 10=000000000010 11=000000000011 12=000000000012 13=000000000013 + 14=000000000014 15=000000000015 16=000000000016 17=000000777723 + PC=033446 RA=00033446 EA=033446 C0=0 C1=0 OV=0 ND=0 PD=0 + 033446: 324000 033447 JUMPA 0,33447 + >> dh + 033432: 253000 033434 AOBJN 0,33434 ;history=10 + 033434: 324000 033435 JUMPA 0,33435 ;history=9 + 033435: 200000 034573 MOVE 0,34573 ;history=8 + 033436: 252000 033440 AOBJP 0,33440 ;history=7 + 033437: 334000 000000 SKIPA 0,0 ;history=6 + 033441: 324000 033442 JUMPA 0,33442 ;history=5 + 033442: 474000 000000 SETO 0,0 ;history=4 + 033443: 253000 033444 AOBJN 0,33444 ;history=3 + 033444: 312000 034574 CAME 0,34574 ;history=2 + 033445: 254200 033446 HALT 33446 ;history=1 + +The problem here was that after `SETO 0,0`, AC0 contained 777777777777, so when AOBJN added 000001000001 to it, the result +should have been 000001000000, but because other another typo, this time in the *opAOBJN()* function: + +```javascript +/** + * opAOBJN(0o253000): Add One to Both Halves of AC and Jump if Negative + * + * From the DEC PDP-10 System Reference Manual (May 1968), p. 2-41: + * + * Add 1000001 [base 8] to AC and place the result back in AC. If the result is less than zero + * (ie if bit 0 is 1, and hence a negative count in the left half has not yet reached zero or a positive + * count has reached 2^17), take the next instruction from location E and continue sequential operation + * from there. + * + * The incrementing of both halves of AC simultaneously is effected by adding 1000001 [base 8]. A count + * of -2 in AC left is therefore increased to zero if 2^18 - 1 is incremented in AC right. + * + * @this {CPUStatePDP10} + * @param {number} op + * @param {number} acc + */ +PDP10.opAOBJN = function(op, acc) +{ + var dst = (this.readWord(acc) + 0o000001000001) % PDP10.WORD_MASK; + this.writeWord(acc, dst); + if (dst >= PDP10.INT_LIMIT) this.setPC(this.regEA); +}; +``` +when `dst` became 0o1000001000000 and exceeded WORD_MASK (0o777777777777), it needed to be mod'ed with WORD_LIMIT (0o1000000000000), +not WORD_MASK, to truncate the value to 36 bits. Here's the corrected line: + +```javascript + var dst = (this.readWord(acc) + 0o000001000001) % PDP10.WORD_LIMIT; +``` *[@jeffpar](http://twitter.com/jeffpar)* *Mar 24, 2017* diff --git a/apps/pdp10/diags/klad/README.md b/apps/pdp10/diags/klad/README.md index 15f7f4597..a58cca5af 100644 --- a/apps/pdp10/diags/klad/README.md +++ b/apps/pdp10/diags/klad/README.md @@ -11,4 +11,6 @@ PCjs has archived selected files from [PDP-10 KLAD Diagnostics Sources](http://pdp-10.trailing-edge.com/klad_sources/index.html), including: - [KA10 Basic Instruction Diagnostic #1 (MAINDEC-10-DAKAA-B-D)](dakaa/) +- [KA10 Basic Instruction Diagnostic #2 (MAINDEC-10-DAKAB-B-D)](dakab/) +- [KA10 Basic Instruction Diagnostic #3 (MAINDEC-10-DAKAC-B-D)](dakac/) - [KA10 Basic Instruction Diagnostic #4 (MAINDEC-10-DAKAD-B-D)](dakad/) diff --git a/apps/pdp10/diags/klad/dakaa/DAKAA.MAC.txt b/apps/pdp10/diags/klad/dakaa/DAKAA.MAC.txt index cf610bb6a..21d1b2b26 100644 --- a/apps/pdp10/diags/klad/dakaa/DAKAA.MAC.txt +++ b/apps/pdp10/diags/klad/dakaa/DAKAA.MAC.txt @@ -1,15 +1,27 @@ +;MACROS + +; STOP - USED FOR SCOPE LOOP, IF INSTRUCTION FAILS, CHANGE (JUMPA .+1) +; TO A (JUMPA X) TO CYCLE ON FAILING INSTRUCTION + +DEFINE STOP (A)< + HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1> + SUBTTL DIAGNOSTIC SECTION -START: SETZM USER# ;CLEAR USER CONTROL WORD - JSP 0,.+1 ;GET FLAGS - TLNE USERF ;IN USER MODE? - SETOM USER ;YES, SET USER CONTROL WORD - SKIPN MONFLG ;SPECIAL USER MODE? - SETZM USER ;YES, CLEAR USER CONTROL WORD - SKIPN USER - JRST STARTA - SKIPL MONCTL - TTCALL 3,PGMNAM ;MENTION OUR NAME +START: ;SETZM USER# ;CLEAR USER CONTROL WORD + ;JSP 0,.+1 ;GET FLAGS + ;TLNE USERF ;IN USER MODE? + ;SETOM USER ;YES, SET USER CONTROL WORD + ;SKIPN MONFLG ;SPECIAL USER MODE? + ;SETZM USER ;YES, CLEAR USER CONTROL WORD + ;SKIPN USER + ;JRST STARTA + ;SKIPL MONCTL + ;TTCALL 3,PGMNAM ;MENTION OUR NAME JRST STARTA PGMNAM: ASCIZ/ @@ -1037,6 +1049,5 @@ SN=SN+1 ;********** > -ENDXX: JRST BEGEND ;LOOP PROGRAM - - +ENDXX: + ;JRST BEGEND ;LOOP PROGRAM diff --git a/apps/pdp10/diags/klad/dakaa/MYDAKAA.MAC.txt b/apps/pdp10/diags/klad/dakaa/DAKAAM.MAC.txt similarity index 97% rename from apps/pdp10/diags/klad/dakaa/MYDAKAA.MAC.txt rename to apps/pdp10/diags/klad/dakaa/DAKAAM.MAC.txt index 67c484274..cf610bb6a 100644 --- a/apps/pdp10/diags/klad/dakaa/MYDAKAA.MAC.txt +++ b/apps/pdp10/diags/klad/dakaa/DAKAAM.MAC.txt @@ -1,27 +1,15 @@ -;MACROS - -; STOP - USED FOR SCOPE LOOP, IF INSTRUCTION FAILS, CHANGE (JUMPA .+1) -; TO A (JUMPA X) TO CYCLE ON FAILING INSTRUCTION - -DEFINE STOP (A)< - HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE - JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) - ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST - ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR - ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1> - SUBTTL DIAGNOSTIC SECTION -START: ;SETZM USER# ;CLEAR USER CONTROL WORD - ;JSP 0,.+1 ;GET FLAGS - ;TLNE USERF ;IN USER MODE? - ;SETOM USER ;YES, SET USER CONTROL WORD - ;SKIPN MONFLG ;SPECIAL USER MODE? - ;SETZM USER ;YES, CLEAR USER CONTROL WORD - ;SKIPN USER - ;JRST STARTA - ;SKIPL MONCTL - ;TTCALL 3,PGMNAM ;MENTION OUR NAME +START: SETZM USER# ;CLEAR USER CONTROL WORD + JSP 0,.+1 ;GET FLAGS + TLNE USERF ;IN USER MODE? + SETOM USER ;YES, SET USER CONTROL WORD + SKIPN MONFLG ;SPECIAL USER MODE? + SETZM USER ;YES, CLEAR USER CONTROL WORD + SKIPN USER + JRST STARTA + SKIPL MONCTL + TTCALL 3,PGMNAM ;MENTION OUR NAME JRST STARTA PGMNAM: ASCIZ/ @@ -1049,5 +1037,6 @@ SN=SN+1 ;********** > -ENDXX: -; JRST BEGEND ;LOOP PROGRAM +ENDXX: JRST BEGEND ;LOOP PROGRAM + + diff --git a/apps/pdp10/diags/klad/dakaa/README.md b/apps/pdp10/diags/klad/dakaa/README.md index 4e88c0dfe..c39febd1d 100644 --- a/apps/pdp10/diags/klad/dakaa/README.md +++ b/apps/pdp10/diags/klad/dakaa/README.md @@ -7,14 +7,14 @@ machines: type: pdp10 config: /devices/pdp10/machine/ka10/test/debugger/machine.xml debugger: true - commands: a 30724 MYDAKAA.MAC + commands: a 30724 DAKAA.MAC --- PDP-10 KA10 Basic Instruction Diagnostic #1 ------------------------------------------- The *PDP-10 KA10 Basic Instruction Diagnostic #1* (MAINDEC-10-DAKAA-B-D) test code has been extracted from -[DAKAA.MAC](DAKAA.MAC.txt) [[original](http://pdp-10.trailing-edge.com/klad_sources/01/klad.sources/dakaam.mac.html)] +[DAKAAM.MAC](DAKAAM.MAC.txt) [[original](http://pdp-10.trailing-edge.com/klad_sources/01/klad.sources/dakaam.mac.html)] for use with the [PDP-10 Test Machine with Debugger](/devices/pdp10/machine/ka10/test/debugger/) below. Resources for this test include: @@ -32,9 +32,9 @@ The Debugger's assemble ("a") command can be used to test the new built-in of the [MACRO-10](http://archive.pcjs.org/pubs/dec/pdp10/tops10/02_1973AsmRef_macro.pdf) assembly language. This command: - a 30724 MYDAKAA.MAC + a 30724 DAKAA.MAC -will automatically read the [MYDAKAA.MAC](MYDAKAA.MAC.txt) source file (a slightly modified copy of [DAKAA.MAC](DAKAA.MAC.txt)), +will automatically read the [DAKAA.MAC](DAKAA.MAC.txt) source file (a slightly modified copy of [DAKAAM.MAC](DAKAAM.MAC.txt)), assemble it, and then load the binary output at the specified address. --- diff --git a/apps/pdp10/diags/klad/dakab/DAKAB.LST.txt b/apps/pdp10/diags/klad/dakab/DAKAB.LST.txt new file mode 100644 index 000000000..020e8ec99 --- /dev/null +++ b/apps/pdp10/diags/klad/dakab/DAKAB.LST.txt @@ -0,0 +1,12231 @@ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 1 +DAKABT MAC 19-JAN-77 13:38 DIAGNOSTIC PARAMETERS SEQ 0007 + + 1 ;DAKAB + 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 DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 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 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 2 +DAKABT MAC 19-JAN-77 13:38 DIAGNOSTIC PARAMETERS SEQ 0008 + + 30 SUBTTL DIAGNOSTIC PARAMETERS + 31 ;PARAMETER DEFINITIONS + 32 000001 EXCASB==1 + 33 000001 USRASB==1 + 34 + 35 ;FLAG DEFINITIONS + 36 010000 USERF=10000 ;USER MODE FLAG + 37 + 38 + 39 ;MACROS + 40 + 41 ; STOP - USED FOR SCOPE LOOP, IF INSTRUCTION FAILS, CHANGE (JUMPA .+1) + 42 ; TO A (JUMPA .-X) TO CYCLE ON FAILING INSTRUCTION + 43 + 44 DEFINE STOP (A)< + 45 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 46 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 47 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 48 ;IN THE SUBTEST) TO LOOP ON ERROR> + 49 + 50 ;SPECIAL FEATURE PARAMETERS + 51 + 52 030742 SADR1=B00 + 53 030742 SADR2=B00 + 54 030742 SADR3=B00 + 55 030742 SADR4=B00 + 56 254000 030742 SADR5=JRST B00 + 57 254000 030742 SADR6=JRST B00 + 58 254000 030742 SADR7=JRST B00 + 59 254000 030742 SADR8=JRST B00 + 60 254000 030742 SADR9=JRST B00 + 61 254000 030742 SADR10=JRST B00 + 62 254000 030742 SADR11=JRST B00 + 63 + 64 000000 PAREA0=0 + 65 000000 PAREA1=0 + 66 000000 PAREA2=0 + 67 444153 414200 PAREA3=SIXBIT/DAKAB/ + 68 645560 000000 PAREA4=SIXBIT/TMP/ + 69 000000 PAREA5=0 + 70 000000 PAREA6=0 + 71 001000 ITERAT==1000 + 72 000001 PGMEND==1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 1 +PARAM KLM 18-JAN-77 11:38 *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, JAN 18,1977 SEQ 0009 + + 73 SUBTTL *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, JAN 18,1977 + 74 + 75 DEFINE S,<;*********************************************************************> + 76 + 77 S^;*********************************************************************^ + 78 ;*DATA SWITCHES (READ FROM CONSOLE IN EXEC MODE OR TYPED IN IN USER MODE) + 79 ;*LEFT HALF SWITCHES ARE PRE-ASSIGNED FOR SUBROUTINE PACKAGE USE + 80 ;*AND CONTROL LOOPING, PRINTING (TTY OR OTHER DEVICE) AND MISC. FUNCTIONS + 81 S^;*********************************************************************^ + 82 + 83 400000 ABORT== 400000 ;ABORT PROGRAM ON PASS COMPLETION + 84 200000 RSTART==200000 ;RESTART TEST, PRINT TOTALS + 85 100000 TOTALS==100000 ;PRINT TOTALS, CONTINUE + 86 + 87 040000 NOPNT== 040000 ;INHIBIT ALL PRINT/TYPE OUT (EXCEPT FORCED) + 88 020000 PNTLPT==020000 ;PRINT ALL DATA ON LPT (LOGICAL DEVICE, USER MODE) + 89 010000 DING== 010000 ;RING BELL ON ERROR + 90 + 91 004000 LOOPER==004000 ;ENTER EXERCISE/CHECK LOOP ON ERROR + 92 002000 ERSTOP==002000 ;HALT ON TEST ERROR + 93 001000 PALERS==001000 ;PRINT ALL ERRORS + 94 + 95 000400 RELIAB==000400 ;RELIABILITY MODE + 96 000200 TXTINH==000200 ;INHIBIT ERROR TEXT + 97 000100 INHPAG==000100 ;INHIBIT PAGING + 98 + 99 000040 MODDVC==000040 ;MODIFY DEVICE CODE + 100 000020 INHCSH==000020 ;INHIBIT CACHE + 101 000010 OPRSEL==000010 ;OPERATOR SELECTION + 102 + 103 000004 CHAIN== 000004 ;CHAIN CONTROL SWITCH + 104 + 105 000002 KAHZ50==000002 ;KA10 50 HERTZ POWER + 106 + 107 ;SWITCH 17 RESERVED !!! +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 2 +PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0010 + + 108 SUBTTL *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 + 109 + 110 S^;*********************************************************************^ + 111 ;*SPECIAL SUBPROGRAM LINKAGES + 112 S^;*********************************************************************^ + 113 + 114 027772 FSELNK= 27772 ;FILE SELECT LINK + 115 027773 FRDLNK= 27773 ;FILE READ LINK + 116 027774 LDLNK= 27774 ;LOAD LINKAGE ADDRESS + 117 027775 DDTLNK= 27775 ;DDT LINKAGE ADDRESS + 118 027776 MODLNK= 27776 ;OPERATIONAL MODE CHECK LINKAGE ADDRESS + 119 027777 SUBLNK= 27777 ;SUBROUTINE LINKAGE ADDRESS + 120 + 121 S^;*********************************************************************^ + 122 ;*SPECIAL SUBROUTINE FATAL HALTS + 123 ;*USED TO REPORT ERRORS THAT CAUSE THE SUBROUTINES TO BE UNUSABLE + 124 S^;*********************************************************************^ + 125 + 126 ;ADDRESS TAG REASON + 127 ;--------------------- + 128 + 129 ; 1010 NOEXEC ;PROGRAM NOT CODED FOR EXEC MODE OPERATION + 130 ; 1011 PLERR ;FATAL PUSH LIST POINTER ERROR + 131 ; 1012 PLERR1 ;INITIAL PUSH LIST POINTER ERROR + 132 ; 1013 MUOERR ;MUUO WITH LUUO HANDLER WIPED OUT + 133 ; 1014 DTEBER ;DTE20 INTERRUPT WITHOUT DOORBELL + 134 ; 1015 DTECER ;DTE20 CLOCK INTERRUPT WITHOUT FLAG SET + 135 ; 1016 CPIERR ;CPU INITIALIZATION ERROR + 136 ; 1017 EOPERR ;END OF PROGRAM ERROR + 137 ; 1020 LUOERR ;INTERRUPT WITH LUUO HANDLER WIPED OUT + 138 + 139 S^;*********************************************************************^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 3 +PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0011 + + 140 S^;*********************************************************************^ + 141 ;OPERATOR DEFINITIONS (NON-UUO'S) + 142 S^;*********************************************************************^ + 143 + 144 260740 000000 OPDEF GO [PUSHJ P,] ;SUBROUTINE CALL + 145 263740 000000 OPDEF RTN [POPJ P,] ;SUBROUTINE RETURN + 146 261740 000000 OPDEF PUT [PUSH P,] ;PUT DATA ON PUSH LIST + 147 262740 000000 OPDEF GET [POP P,] ;GET DATA FROM PUSH LIST + 148 254000 000000 OPDEF PJRST [JRST ] ;JRST TO ROUTINE THAT RTN'S + 149 254200 000000 OPDEF HALT [JRST 4,] ;DEFINITION FOR DDT + 150 254100 000000 OPDEF JRSTF [JRST 2,] ;DEFINITION FOR DDT + 151 254500 000000 OPDEF JEN [JRST 12,] ;DEFINITION FOR DDT + 152 + 153 S^;*********************************************************************^ + 154 ;*SUBROUTINE INITIALIZATION CALL + 155 S^;*********************************************************************^ + 156 + 157 265000 030011 OPDEF PGMINT [JSP 0,SBINIT] ;SUBROUTINE INITIALIZATION + 158 + 159 S^;*********************************************************************^ + 160 ;*HALTING UUO'S (A MORE GRACEFUL HALT THAN SIMPLY USING THE HALT INSTRUCTION). + 161 S^;*********************************************************************^ + 162 + 163 037640 000004 OPDEF FATAL [37B8!15B12!4] ;FATAL PROGRAMMING HALT + 164 037600 000004 OPDEF ERRHLT [37B8!14B12!4] ;PROGRAM ERROR HALT + 165 + 166 S^;*********************************************************************^ + 167 ;*TERMINAL INPUT UUO'S + 168 ;*ALWAYS COME FROM THE CONSOLE TERMINAL IN EXEC MODE OR THE + 169 ;*CONTROLLING TERMINAL (REAL TERMINAL OR PTY) IN USER MODE. + 170 S^;*********************************************************************^ + 171 + 172 037000 000003 OPDEF TTICHR [37B8!0B12!3] ;TTY, INPUT ANY CHARACTER + 173 037040 000003 OPDEF TTIYES [37B8!1B12!3] ;TTY, NORMAL RETURN Y + 174 037100 000003 OPDEF TTINO [37B8!2B12!3] ;TTY, NORMAL RETURN N + 175 037140 000003 OPDEF TTIOCT [37B8!3B12!3] ;TTY, INPUT OCTAL WORD + 176 037200 000003 OPDEF TTIDEC [37B8!4B12!3] ;TTY, INPUT DECIMAL WORD + 177 037240 000003 OPDEF TTICNV [37B8!5B12!3] ;TTY, INPUT CONVERTABLE WORD + 178 037300 000003 OPDEF TTLOOK [37B8!6B12!3] ;TTY, KEYBOARD CHECK + 179 037340 000003 OPDEF TTALTM [37B8!7B12!3] ;TTY, ALT-MODE CHECK + 180 037400 000003 OPDEF TTSIXB [37B8!10B12!3] ;TTY, INPUT SIXBIT WORD + 181 037440 000003 OPDEF TTYINP [37B8!11B12!3] ;TTY, IMAGE MODE INPUT +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 4 +PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0012 + + 182 ;*TERMINAL OUTPUT UUO'S. + 183 + 184 037000 000000 OPDEF PNTA [37B8!0B12!0] ;PRINT ASCII WORD + 185 037000 000001 OPDEF PNTAF [37B8!0B12!1] ;PRINT ASCII WORD FORCED + 186 037740 000000 OPDEF PNTAL [37B8!17B12!0] ;PRINT ASCIZ LINE + 187 037740 000001 OPDEF PNTALF [37B8!17B12!1] ;PRINT ASCIZ LINE FORCED + 188 037600 000003 OPDEF PSIXL [37B8!14B12!3] ;PRINT SIXBIT'Z LINE + 189 037640 000003 OPDEF PSIXLF [37B8!15B12!3] ;PRINT SIXBIT'Z LINE FORCED + 190 037000 000000 OPDEF PNTMSG [37B8!0B12!0] ;PRINT MESSAGE IMMEDIATE + 191 037040 000000 OPDEF PNTMSF [37B8!1B12!0] ;PRINT MESSAGE IMMEDIATE FORCED + 192 037100 000000 OPDEF PSIXM [37B8!2B12!0] ;PRINT SIXBIT'Z MSG IMMEDIATE + 193 037200 000000 OPDEF PSIXMF [37B8!4B12!0] ;PRINT SIXBIT'Z MSG IMM FORCED + 194 037000 000000 OPDEF PNTCI [37B8!0B12!0] ;PRINT CHARACTER IMMEDIATE + 195 037040 000000 OPDEF PNTCIF [37B8!1B12!0] ;PRINT CHARACTER IMMEDIATE FORCED + 196 037500 000000 OPDEF PNTCHR [37B8!12B12!0] ;PRINT CHARACTER + 197 037500 000001 OPDEF PNTCHF [37B8!12B12!1] ;PRINT CHARACTER FORCED + 198 037040 000000 OPDEF PNT1 [37B8!1B12!0] ;PRINT ONE OCTAL DIGIT + 199 037040 000001 OPDEF PNT1F [37B8!1B12!1] ;PRINT 1 OCTAL DIGIT FORCED + 200 037100 000000 OPDEF PNT2 [37B8!2B12!0] ;PRINT TWO OCTAL DIGITS + 201 037100 000001 OPDEF PNT2F [37B8!2B12!1] ;PRINT 2 OCTAL DIGITS FORCED + 202 037140 000000 OPDEF PNT3 [37B8!3B12!0] ;PRINT THREE OCTAL DIGITS + 203 037140 000001 OPDEF PNT3F [37B8!3B12!1] ;PRINT THREE OCTAL DIGITS FORCED + 204 037200 000000 OPDEF PNT4 [37B8!4B12!0] ;PRINT FOUR OCTAL DIGITS + 205 037200 000001 OPDEF PNT4F [37B8!4B12!1] ;PRINT FOUR OCTAL DIGITS FORCED + 206 037240 000000 OPDEF PNT5 [37B8!5B12!0] ;PRINT FIVE OCTAL DIGITS + 207 037240 000001 OPDEF PNT5F [37B8!5B12!1] ;PRINT FIVE OCTAL DIGITS FORCED + 208 037300 000000 OPDEF PNT6 [37B8!6B12!0] ;PRINT SIX OCTAL DIGITS + 209 037300 000001 OPDEF PNT6F [37B8!6B12!1] ;PRINT SIX OCTAL DIGITS FORCED + 210 037340 000000 OPDEF PNT7 [37B8!7B12!0] ;PRINT 7 OCTAL DIGITS + 211 037340 000001 OPDEF PNT7F [37B8!7B12!1] ;PRINT 7 OCTAL DIGITS FORCED + 212 037440 000000 OPDEF PNT11 [37B8!11B12!0] ;PRINT 11 OCTAL DIGITS + 213 037440 000001 OPDEF PNT11F [37B8!11B12!1] ;PRINT 11 OCTAL DIGITS FORCED. + 214 037400 000000 OPDEF PNTADR [37B8!10B12!0] ;PRINT PHYSICAL ADDRESS + 215 037400 000001 OPDEF PNTADF [37B8!10B12!1] ;PRINT PHYSICAL ADDRESS FORCED + 216 037600 000000 OPDEF PNTOCT [37B8!14B12!0] ;PRINT FULL WORD OCTAL + 217 037600 000001 OPDEF PNTOTF [37B8!14B12!1] ;PRINT FULL WORD OCTAL FORCED + 218 037540 000000 OPDEF PNTHW [37B8!13B12!0] ;PRINT OCTAL HALF WORDS, 6 SP 6 + 219 037540 000001 OPDEF PNTHWF [37B8!13B12!1] ;PRINT OCTAL HALF WORDS, 6 SP 6 FORCED + 220 037700 000003 OPDEF PNTOCS [37B8!16B12!3] ;PRINT OCTAL, SUPPRESS LEADING 0'S + 221 037740 000003 OPDEF PNTOCF [37B8!17B12!3] ;PRINT OCTAL, SUPPRESS LEADING 0'S FORCED + 222 037640 000000 OPDEF PNTDEC [37B8!15B12!0] ;PRINT DECIMAL, SUPRESS LEADING 0'S + 223 037640 000001 OPDEF PNTDCF [37B8!15B12!1] ;PRINT DECIMAL, SUPRESS LEADING 0'S FORCED + 224 037700 000000 OPDEF PNTDS [37B8!16B12!0] ;PRINT DECIMAL, SPACES FOR LD 0'S + 225 037700 000001 OPDEF PNTDSF [37B8!16B12!1] ;PRINT DECIMAL, SPACES FOR LD 0'S FORCED + 226 037200 000002 OPDEF PNTNM [37B8!4B12!2] ;PRINT PROGRAM NAME + 227 037000 000002 OPDEF PNTSIX [37B8!0B12!2] ;PRINT SIXBIT WORD + 228 037040 000002 OPDEF PNTSXF [37B8!1B12!2] ;PRINT SIXBIT WORD FORCED + 229 037240 000002 OPDEF DROPDV [37B8!5B12!2] ;CLOSE LOGICAL FILE, USER MODE + 230 037100 000002 OPDEF PNTCW [37B8!2B12!2] ;PRINT DF10 CONTROL WORD + 231 037140 000002 OPDEF PNTCWF [37B8!3B12!2] ;PRINT DF10 CONTROL WORD FORCED + 232 037000 030242 OPDEF PCRL [37B8!0B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED + 233 037040 030242 OPDEF PCRLF [37B8!1B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED FORCED + 234 037000 000040 OPDEF PSP [37B8!0B12!40] ;PRINT SPACE + 235 037040 000040 OPDEF PSPF [37B8!1B12!40] ;PRINT SPACE FORCED + 236 037000 030243 OPDEF PCRL2 [37B8!0B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 4-1 +PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0013 + + 237 037040 030243 OPDEF PCRL2F [37B8!1B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE) FORCED + 238 037040 000007 OPDEF PBELL [37B8!1B12!7] ;PRINT TTY BELL + 239 + 240 037040 000026 OPDEF PFORCE [37B8!1B12!26] ;PRINT FORCE, CONTROL O OVERRIDE + 241 + 242 DEFINE PMSG (ARG),< + 243 PSIXM [SIXBIT\ARG'_\]> + 244 + 245 DEFINE PMSGF (ARG),< + 246 PSIXMF [SIXBIT\ARG'_\]> + 247 + 248 ;*SIXBTZ -- MACRO TO GENERATE SIXBIT DATA FOR PRINTING + 249 ;* CONSERVES CORE OVER ASCIZ + 250 + 251 DEFINE SIXBTZ (ARG),< [SIXBIT\ARG'_\]> + 252 + 253 ;*CONSOLE SWITCH INPUT UUO. + 254 ;*READS CONSOLE SWITCHES IF IN EXEC MODE OR ASKS FOR THEM IF + 255 ;* USER MODE. + 256 + 257 037400 000002 OPDEF SWITCH [37B8!10B12!2] ;INPUT CONSOLE SWITCHES + 258 + 259 ;*CLOCK INITIALIZATION UUO - TO SET DESIRED CLOCK OPERATION + 260 ;*EITHER IGNORE CLOCK, ONLY LET IT TICK OR CAUSE INTERRUPT TO OCCUR. + 261 + 262 037540 000004 OPDEF CLOKOP [37B8!13B12!4] ;CLOCK OPERATION UUO - PDP-11 CLOCK + 263 037200 000004 OPDEF MTROP [37B8!4B12!4] ;CLOCK OPERATION UUO - DK20 METER + 264 + 265 ;*KL10 ONLY CACHE OPERATION UUO'S + 266 + 267 037040 000004 OPDEF CINVAL [37B8!1B12!4] ;CACHE INVALIDATE + 268 037100 000004 OPDEF CFLUSH [37B8!2B12!4] ;CACHE FLUSH + 269 037140 000004 OPDEF CWRTBI [37B8!3B12!4] ;CACHE WRITE-BACK & INVALIDATE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5 +PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0014 + + 270 ;*END OF PASS/PROGRAM UUOS + 271 + 272 ;PERFORMS THE END OF PASS FUNCTIONS. INCREMENT PASS COUNT, + 273 ;*DECREMENT ITERATION COUNT, CHECK IF FINISHED WITH THIS PROGRAM ETC. + 274 + 275 037500 000004 OPDEF ENDUUO [37B8!12B12!4] ;UUO TO DISPLAY LIGHTS + 276 037700 000004 OPDEF EOPUUO [37B8!16B12!4] ;END OF PROGRAM UUO + 277 + 278 ;*MEMORY MANAGEMENT UUO'S + 279 ;*UUO'S TO PERFORM VARIOUS MEMORY FUNCTIONS. MAPPING, ZEROING, PAGING, + 280 ;*ADDRESS CONVERSION, ETC... + 281 + 282 037000 000004 OPDEF MAPMEM [37B8!0B12!4] ;MAP MEMORY + 283 037500 000002 OPDEF MEMZRO [37B8!12B12!2] ;ZERO MEMORY + 284 037440 000002 OPDEF MEMSEG [37B8!11B12!2] ;SETUP MEMORY SEGMENT + 285 037540 000002 OPDEF MAPADR [37B8!13B12!2] ;VIRTUAL TO PHYSICAL ADR CONVERT + 286 037640 000002 OPDEF MAPCNK [37B8!15B12!2] ;MAP MEMORY CHUNK + 287 037600 000002 OPDEF MAPSET [37B8!14B12!2] ;SET KI10 EXEC PAGE MAP + 288 037740 000002 OPDEF MAPPNT [37B8!17B12!2] ;PRINT MEMORY MAP + 289 + 290 ;*DEVICE CODE MODIFICATION UUO + 291 ;*ALLOWS THE MODIFICATION OF IOT'S TO ONE DEVICE TO BE CHANGED TO + 292 ;*IOT'S TO A DIFFERENT DEVICE CODE. + 293 + 294 037340 000002 OPDEF MODPCU [37B8!7B12!2] ;MODIFY PERHIPERAL CODE, USER + 295 037300 000002 OPDEF MODPCP [37B8!6B12!2] ;MODIFY PERHIPERAL CODE, PROGRAM + 296 + 297 030000 IFNDEF MODDVL, + 298 030000 IFNDEF MODDVU, + 299 + 300 ;*"DIAMON" FILE SELECTION AND READ UUOS + 301 + 302 037240 000004 OPDEF FSELECT [37B8!5B12!4] ;FILE SELECTION + 303 037300 000004 OPDEF FREAD [37B8!6B12!4] ;FILE READ - ASCII DATA + 304 037340 000004 OPDEF FRD36 [37B8!7B12!4] ;FILE READ - 36 BIT DATA + 305 037400 000004 OPDEF FRD8 [37B8!10B12!4] ;FILE READ - 8 BIT DATA + 306 + 307 ;*KI10 ONLY UUO FOR PRINTING MARGIN VALUES + 308 + 309 037700 000002 OPDEF PNTMGN [37B8!16B12!2] ;PRINT MARGIN VALUE + 310 + 311 XLIST + 312 IFNDEF KLOLD, + 338 + 339 ;*A MACRO TO REPORT AN ERROR AND NOT LOOP + 340 + 341 DEFINE ERROR1 (FORMAT,CORECT,ACTUAL,F,D,ERR)< + 342 SALL + 343 ERUUO FORMAT,[T,,[SIXBIT\F'_\] + 344 CORECT,,ACTUAL + 345 [SIXBIT\D'_\],,ERR] + 346 XALL > + 347 + 348 >;END OF KLOLD CONDITIONAL + 349 + 350 XLIST + 351 LIST +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 1 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0016 + + 352 SUBTTL *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 + 353 + 354 030000 LOC 30000 + 355 + 356 S^;*********************************************************************^ + 357 ;*PROGRAM STARTING ADDRESSES + 358 ;*THESE ADDRESSES CALL VARIOUS SPECIAL START ROUTINES AND OR OPTIONS + 359 ;*NORMAL START ADDRESS IS 30000 ALL OTHERS ARE SPECIAL. INVOKED BECAUSE + 360 ;*OF END OF PASS, POWER FAILURE, DDT START, RE-ENTERING(TYPICALLY USER + 361 ;*MODE), OR ANY NUMBER OF SPECIAL FEATURE TESTS. + 362 S^;*********************************************************************^ + 363 + 364 030000 254 00 1 00 027776 BEGIN: JRST @MODLNK ;STAND-ALONE START + 365 030001 254 00 0 00 030712 $START: JRST START ;MODE CHECK STARTING ADDRESS + 366 + 367 030002 254 00 1 00 027774 DIAGMN: JRST @LDLNK ;DIAGNOSTIC MONITOR START + 368 + 369 030003 254 00 1 00 027774 SYSEXR: JRST @LDLNK ;SYSTEM EXERCISER START + 370 + 371 030004 254 00 0 00 030742 SFSTRT: JRST SADR1 ;SPECIAL FEATURE START + 372 + 373 030005 254 00 0 00 030742 PFSTRT: JRST SADR2 ;POWER FAIL RESTART + 374 + 375 030006 254 00 0 00 030742 REENTR: JRST SADR3 ;REENTER START(USUALLY USER MODE ONLY) + 376 + 377 030007 SRTDDT: ;COMMONLY MISTAKEN NAME FOR "DDTSRT" + 378 030007 254 00 1 00 027775 DDTSRT: JRST @DDTLNK ;DDT START + 379 + 380 030010 254 00 0 00 030741 BEGIN1: JRST STARTA ;LOOP START(END OF PASS COMES HERE) + 381 030011 254 00 1 00 027777 SBINIT: JRST @SUBLNK ;PMGINT LINKAGE + 382 030012 000000 000000 RETURN: 0 ;RETURN ADDRESS STORAGE + 383 + 384 030013 254000 030742 START1: SADR7 ;OPTIONAL STARTING ADR/INSTRUCTIONS + 385 030014 254000 030742 START2: SADR8 ; " + 386 030015 254000 030742 START3: SADR9 ; " + 387 030016 254000 030742 START4: SADR10 ; " + 388 030017 254000 030742 START5: SADR11 ; " +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 2 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0017 + + 389 S^;*********************************************************************^ + 390 ;*PROGRAM FIXED PARAMETER AREA + 391 S^;*********************************************************************^ + 392 + 393 030020 444153 414200 PNTNAM: PAREA3 ;SIXBIT PROGRAM NAME + 394 030021 645560 000000 PNTEXT: PAREA4 ;SIXBIT PROGRAM EXTENSION + 395 030022 000000 000000 RANDBS: PAREA1 ;RANDOM BASE NUMBER + 396 030023 000000 000000 SWTEXR: PAREA2 ;SYSTEM EXERCISER SWITCHES + 397 030024 000000 001000 ITRCNT: ITERAT ;PROGRAM ITERATIONS + 398 030025 000000 030725 $PNAME: PGMNAM ;POINTER TO PROGRAMS NAME + 399 030026 000000 000002 $PVER: MCNVER,,DECVER ;MCN & DEC VERSION LEVEL + 400 030027 000000 030000 $MODVL: MODDVL ;DEVICE CODE CHANGE LOWER LIMIT + 401 030030 000000 030000 $MODVU: MODDVU ;DEVICE CODE CHANGE UPPER LIMIT + 402 030031 777777 777777 $EMODE: IFNDEF EXCASB,<0> IFDEF EXCASB,<-1> ;EXEC ALLOWED + 403 030032 777777 777777 $UMODE: IFNDEF USRASB,<0> IFDEF USRASB,<-1> ;USER ALLOWED + 404 030033 000000 000000 $DSKUP: IFNDEF DSKUPD,<0> IFDEF DSKUPD,<-1> ;DISK UPDATE MODE + 405 030034 000000 000000 $MMAP: IFNDEF MEMMAP,<0> IFDEF MEMMAP,<-1> ;ALLOW MEMORY RTNS + 406 030035 000000 000000 PAREA7: PAREA5 ;OPTIONAL PARAMETER + 407 030036 000000 000000 PAREA8: PAREA6 ;OPTIONAL PARAMETER + 408 + 409 S^;*********************************************************************^ + 410 ;*PROGRAM VARIABLE PARAMETER AREA + 411 S^;*********************************************************************^ + 412 + 413 030037 000000 000000 USER: 0 ; 0 = EXEC, -1 = USER MODE FLAG + 414 030040 000000 000000 KAIFLG: 0 ;PROCESSOR TYPE, 0 = KA10, -1 = KI10 + 415 030041 000000 000000 KLFLG: 0 ;PROCESSOR TYPE, 0 = KA/KI, -1 = KL10 + 416 030042 777777 777777 MONFLG: -1 ;DIAG MONITOR SPECIAL USER FLAG + 417 030043 000000 000000 MONCTL: 0 ;DIAG MON/SYS EXR FLAG + 418 030044 000000 000000 MONTEN: 0 ;-1= LOADED BY 10 + 419 030045 000000 000000 CLOCKF: 0 ;CLOCK TICKED FLAG + 420 030046 000000 000000 CONSW: 0 ;CONSOLE SWITCH SETTINGS + 421 030047 000000 000000 PASCNT: 0 ;PROGRAM PASS COUNT + 422 030050 000000 000000 RUNFLG: 0 ;PROGRAM RUN FLAG + 423 030051 000000 000000 TESTPC: 0 ;SUBTEST PC + 424 030052 000000 000000 ERRPC: 0 ;ERROR PC + 425 030053 000000 000000 ERRTLS: 0 ;ERROR TOTALS + 426 030054 000000 000000 TICKS: 0 ;PROGRAM RUNNING TIME + 427 030055 000000 000000 MARGIN: 0 ;KI10 MARGIN WORD VALUE + 428 030056 000000 000000 $ONETM: 0 ;SUBROUTINE INITIALIZATION FLAG +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 3 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0018 + + 429 S^;*********************************************************************^ + 430 ;*SPECIAL PROGRAM DISPATCH ADDRESSES + 431 S^;*********************************************************************^ + 432 + 433 030057 037 12 0 00 000004 BEGEND: ENDUUO ;END OF PASS + 434 030060 254 00 0 00 030010 $BEND1: JRST BEGIN1 ;KEEP RUNNING PROGRAM + 435 030061 037 16 0 00 000004 $BEND2: EOPUUO ;END OF PROGRAM - NO RETURN + 436 030062 254000 030742 CNTLC: SADR5 ;CONTROL C XFER ADDRESS + 437 030063 254000 030742 ALTMGO: SADR6 ;ALTMODE XFER ADDRESS + 438 030064 CPOPJ1: ;SKIP RETURN + 439 030064 350 00 0 17 000000 UUOSKP: AOS (P) ;SKIP RETURN FROM UUO + 440 030065 CPOPJ: ;NON-SKIP REGULAR RETURN + 441 030065 263 17 0 00 000000 UUOEXT: RTN ;UUO RETURN + 442 030066 255 00 0 00 000000 UUORTN: JFCL ;ADDITIONAL USERS UUO ROUTINE + 443 030067 255 00 0 00 000000 $UORTX: JFCL ;ADDITIONAL UUO LINKAGE + 444 030070 255 00 0 00 000000 $UUOER: JFCL ;INITED AS (JRST $UOERX) + 445 030071 255 00 0 00 000000 $ITRHL: JFCL ;ADDITIONAL INTERRUPT LINKAGE + 446 030072 255 00 0 00 000000 $ITRX1: JFCL ; " + 447 030073 255 00 0 00 000000 $USRHL: JFCL ; " + 448 030074 255 00 0 00 000000 $RSRTX: JFCL ;ADDITIONAL POWER FAIL LINKAGE + 449 030075 255 00 0 00 000000 $RSRTY: JFCL ; " + 450 030076 255 00 0 00 000000 RESRT1: JFCL ; INITED AS (JRST RESRTX) + 451 030077 255 00 0 00 000000 RESRT2: JFCL ; " + 452 030100 255 00 0 00 000000 $PARER: JFCL ;ADDITIONAL PARITY ERROR LINKAGE + 453 030101 255 00 0 00 000000 ERMORE: JFCL ;ADDITIONAL ERROR HANDLER LINKAGE + 454 030102 254 04 0 00 030102 HALT . ;IMPROPER TRANSFER HALT + 455 + 456 030103 000000 000000 $PSHER: 0 ;INITED AS (JRST PSHERR) + 457 030104 000000 000000 ITRCH1: 0 ;PC & FLAGS OF CURRENT INTERRUPT + 458 030105 000000 000000 0 ;INITED AS (JRST $ITRC1) + 459 + 460 S^;*********************************************************************^ + 461 ;*PROCESSOR CONTROL STORAGE + 462 S^;*********************************************************************^ + 463 + 464 030106 000000 000000 $ACC0: 0 ;INTERRUPT SAVED AC0 + 465 030107 000000 000000 $SVPI: 0 ;INTERRUPT SAVED PI + 466 030110 000000 000000 $SVAPR: 0 ;INTERRUPT SAVED APR + 467 030111 000000 000000 $SVPAG: 0 ;INTERRUPT SAVED PAG (DATAI) + 468 030112 000000 000000 $SPAG1: 0 ;INTERRUPT SAVED PAG (CONI) + 469 + 470 030113 000000 000000 $SVUUO: 0 ;CURRENT USERS UUO + 471 030114 000000 000000 $SVUPC: 0 ;PC OF CURRENT USERS UUO + 472 + 473 030115 000000 000000 REPTU: 0 ;REPEAT UUO ITERATIONS + 474 030116 000000 000000 SCOPE: 0 ;ERROR HANDLER SCOPE LOOP FLAG + 475 030117 000000 000000 %CORFLG:0 ; " CORRECT FLAG + 476 030120 000000 000000 %COREC: 0 ; " CORRECT DATA + 477 030121 000000 000000 %ACTFL: 0 ; " ACTUAL FLAG + 478 030122 000000 000000 %ACTUL: 0 ; " ACTUAL DATA + 479 030123 000000 000000 %DISCR: 0 ; " DISCREPENCY DATA +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 4 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0019 + + 480 S^;*********************************************************************^ + 481 ;*UUO DISPATCH TABLE + 482 S^;*********************************************************************^ + 483 XLIST + 484 LIST + 485 030124 030070 030070 UUODIS: LUUO1,,$UUOER + 486 030125 030070 030070 LUUO3,,LUUO2 + 487 030126 030070 030070 LUUO5,,LUUO4 + 488 030127 030070 030070 LUUO7,,LUUO6 + 489 030130 030070 030070 LUUO11,,LUUO10 + 490 030131 030070 030070 LUUO13,,LUUO12 + 491 030132 030070 030070 LUUO15,,LUUO14 + 492 030133 030070 030070 LUUO17,,LUUO16 + 493 030134 030070 030070 LUUO21,,LUUO20 + 494 030135 030070 030070 LUUO23,,LUUO22 + 495 030136 030070 030070 LUUO25,,LUUO24 + 496 030137 030070 030070 LUUO27,,LUUO26 + 497 030140 030070 030070 LUUO31,,LUUO30 + 498 030141 030070 030070 LUUO33,,LUUO32 + 499 + 500 S^;*********************************************************************^ + 501 ;*MEMORY MANAGMENT STORAGE + 502 S^;*********************************************************************^ + 503 + 504 030142 000000 000000 DF22F: 0 ;DF10 CONTROL FLAG, 0 = 18, -1 = 22 BIT + 505 030143 000000 000000 MAPNEW: 0 ;MEMORY MAPPING CONTROL FLAG, -1 = 4096K MAPPING + 506 030144 000000 000000 MEMTOT: 0 ;TOTAL MEMORY SIZE IN K (1024.) + 507 030145 000000 000000 MEMLOW: 0 ;LOWEST USABLE MEMORY + 508 030146 MEMSIZ: BLOCK ^D41 ;MEMORY SEGMENT POINTER TABLE + 509 + 510 S^;*********************************************************************^ + 511 ;*PRINT CONTROL STORAGE + 512 S^;*********************************************************************^ + 513 + 514 030217 000000 000000 PNTFLG: 0 ;PRINT FLAG, -1 WHILE IN PRINT ROUTINE + 515 030220 000000 000000 PNTENB: 0 ;PRINT ENABLE + 516 030221 000000 000000 PDISF: 0 ;PRINT DISABLED FLAG + 517 030222 000000 000000 PNTINH: 0 ;INHIBIT PRINT INPUT CHECKS + 518 030223 000000 000000 PNTSPC: 0 ;PRINT SPACE CONTROL + 519 030224 000000 000000 OPTIME: 0 ;TYPE-IN WAIT TIME + 520 030225 000000 000000 $TWCNT: 0 ;TIME WAITED + 521 030226 000000 000000 $DVOFF: 0 ;LOGICAL DEVICE INITED FLAG + 522 030227 000000 000000 TTYFIL: 0 ;TTY EXEC FILLERS FLAG + 523 030230 000000 000000 TTYSPD: 0 ;TTY EXEC BAUD RATE + 524 030231 000000 000000 $TTCHR: 0 ;ACTUAL TYPED IN CHAR + 525 030232 000000 000000 $CHRIN: 0 ;UPPER CASED & PARITY STRIPPED CHAR + 526 030233 000000 000000 $TYPNB: 0 ;TYPED IN NUMBER + 527 030234 000000 000000 $CRLF: 0 ;FREE CR/LF FLAG + 528 030235 000000 000000 $TABF: 0 ;TAB CONVERSION FLAG + 529 030236 000000 000000 $FFF: 0 ;FORM FEED CONVERSION FLAG + 530 030237 000000 000000 $VTF: 0 ;VERTICAL TAB CONVERSION FLAG + 531 030240 000000 000000 USRLFF: 0 ;USER LF FILLERS + 532 030241 000000 000000 USRCRF: 0 ;USER CR FILLERS +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0020 + + 533 S^;*********************************************************************^ + 534 ;*THE FOLLOWING MISCELLANEOUS PRINT CHARACTERS ARE INCLUDED + 535 ;*TO FACILITATE PRINTING AND ARE CALLED AS FOLLOWS: + 536 ;* MOVEI NAME + 537 ;* PNTA ;OR PNTAF + 538 S^;*********************************************************************^ + 539 + 540 030242 CRLF: ASCII/ + 541 030242 015 012 000 000 000 / + 542 030243 CRLF2: ASCII/ + 543 + 544 030243 015 012 015 012 000 / + 545 030244 054 000 000 000 000 COMMA: ASCII/,/ + 546 030245 056 000 000 000 000 PERIOD: ASCII/./ + 547 030246 040 000 000 000 000 SPACE: ASCII/ / + 548 030247 011 000 000 000 000 TAB: ASCII/ / + 549 030250 MINUS: + 550 030250 055 000 000 000 000 HYPEN: ASCII/-/ + 551 030251 053 000 000 000 000 PLUS: ASCII/+/ + 552 030252 052 000 000 000 000 AST: ASCII/*/ + 553 030253 100 000 000 000 000 ATSIN: ASCII/@/ + 554 030254 050 000 000 000 000 LFP: ASCII/(/ + 555 030255 051 000 000 000 000 RTP: ASCII/)/ + 556 030256 007 0000000000 BELL: BYTE (7) 007 + 557 030257 077 000 000 000 000 QUEST: ASCII/?/ + 558 030260 057 000 000 000 000 SLASH: ASCII!/! + 559 030261 044 000 000 000 000 DOLLAR: ASCII/$/ + 560 030262 000000 000012 RADIX: ^D10 ;DECIMAL PRINT RADIX + 561 030263 000000 000040 RADLSP: 40 ;DECIMAL PRINT LEADING CHAR + 562 030264 000000 000012 RADLSC: ^D10 ;DECIMAL PRINT LEADING CHAR COUNT + 563 + 564 S^;*********************************************************************^ + 565 ;*USER MODE OUTPUT FILE INFORMATION + 566 S^;*********************************************************************^ + 567 + 568 030265 $OBUF: BLOCK 3 ;LOGICAL FILE OUTPUT BUFFER HEADER + 569 030270 60 62 51 56 64 00 $OUTNM: SIXBIT /PRINT/ ;FILE NAME + 570 030271 60 56 64 00 00 00 $OUTEX: SIXBIT /PNT/ ;FILE NAME EXTENSION + 571 030272 BLOCK 2 + 572 + 573 S^;*********************************************************************^ + 574 ;*DISK UPDATE MODE FILE INFORMATION + 575 S^;*********************************************************************^ + 576 + 577 030274 $IBUF: BLOCK 3 + 578 030277 60 62 51 56 64 00 $INNM: SIXBIT /PRINT/ + 579 030300 60 56 64 00 00 00 $INEXT: SIXBIT /PNT/ + 580 030301 BLOCK 2 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 6 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0021 + + 581 S^;*********************************************************************^ + 582 ;*PUSHDOWN LIST CONTROL INFORMATION + 583 S^;*********************************************************************^ + 584 + 585 030303 777577 030303 PLIST: PLIST-PLISTE,,PLIST + 586 030304 PLISTS: BLOCK 200 + 587 030504 000000 000000 PLISTE: 0 ;END OF PUSHDOWN LIST + 588 + 589 S^;*********************************************************************^ + 590 ;*POWER LINE CLOCK FREQUENCY FLAG + 591 S^;*********************************************************************^ + 592 + 593 030505 000000 000000 CYCL60: 0 ;0 = 60, -1 = 50 CYCLE + 594 + 595 S^;*********************************************************************^ + 596 ;*KL10 CACHE CONTROL FLAGS + 597 S^;*********************************************************************^ + 598 + 599 030506 000000 000000 CSHFLG: 0 ;ALLOW CACHE IF 0 + 600 030507 000000 000000 CSHMEM: 0 ;CACHE MEMORY SEGMENTS IF 0 + 601 + 602 S^;*********************************************************************^ + 603 ;*NUMBER INPUT DIGIT FLAG + 604 S^;*********************************************************************^ + 605 + 606 030510 000000 000000 TTNBRF: 0 ;-1 IF ANY DIGIT TYPED + 607 + 608 S^;*********************************************************************^ + 609 ;*KL10 & KI10 "INHPAG" SWITCH PAGING PREVENTION + 610 S^;*********************************************************************^ + 611 + 612 030511 000000 000000 PVPAGI: 0 ;IF NON-ZERO, OVERRIDE "INHPAG" SWITCH ACTION + 613 + 614 S^;*********************************************************************^ + 615 ;*ERROR REPORTING ROUTINE ADDITIONAL USERS CONTROL INSTRUCTIONS + 616 S^;*********************************************************************^ + 617 + 618 030512 000000 000000 %ERHI1: 0 ;IF NON-ZERO, XCT'D AT START OF %ERUUO + 619 030513 000000 000000 %ERHI2: 0 ;IF NON-ZERO, XCT'D AT END OF %ERUUO + 620 030514 000000 000000 %ERHI3: 0 ;IF NON-ZERO, XCT'D AFTER "PC" OF %ERUUO + 621 + 622 S^;*********************************************************************^ + 623 ;*SPECIAL USERS UUO INTERCEPT INSTRUCTION + 624 S^;*********************************************************************^ + 625 + 626 030515 000000 000000 $$UUO: 0 ;IF NON-ZERO, XCT'D AT START OF $UORTN +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0022 + + 627 S^;*********************************************************************^ + 628 ;*KL10 PROCESSOR TYPE FLAG, 0=P0, 1=BBD NEW, 2=BBD OLD + 629 S^;*********************************************************************^ + 630 + 631 030516 000000 000000 KLTYP: 0 + 632 + 633 S^;*********************************************************************^ + 634 ;*SPECIAL USERS MUUO INTERCEPT INSTRUCTION + 635 S^;*********************************************************************^ + 636 + 637 030517 000000 000000 $$MUUO: 0 ;IF NON-ZERO, XCT'D AT START OF MUUOER + 638 + 639 S^;*********************************************************************^ + 640 ;*SPECIAL USERS USER MODE OUTPUT ERROR INTERCEPT INSTUCTION + 641 S^;*********************************************************************^ + 642 + 643 030520 000000 000000 $$OUTER:0 ;IF NON-ZERO, XCT'D AT END OF USER MODE ERROR + 644 + 645 S^;*********************************************************************^ + 646 ;*"SWITCH" CALL USAGE CONTROL + 647 S^;*********************************************************************^ + 648 + 649 030521 000000 000000 $$TOGGLE:0 ;IF NON-ZERO, USE C(CONSW) FOR SWITCHES + 650 + 651 S^;*********************************************************************^ + 652 ;*SPECIAL USERS ALTMODE SWITCH CALL INTERCEPT INSTRUCTIONS + 653 S^;*********************************************************************^ + 654 + 655 030522 000000 000000 $$TAX1: 0 ;IF NON-ZERO, XCT'D AT START OF ALTMODE SWITCH CALL + 656 030523 000000 000000 $$TAX2: 0 ;IF NON-ZERO, XCT'D AT END OF ALTMODE SWITCH CALL + 657 + 658 S^;*********************************************************************^ + 659 ;*SPECIAL FUTURE EXPANSION ROOM + 660 ;*IF ANY FIXED AREA TAGS ARE ADDED, REDUCE THE SIZE OF + 661 ;*THIS BLOCK STATEMENT ACCORDINGLY. THIS MUST BE DONE + 662 ;*SO THAT PREVIOUS FIXED ASSIGNMENTS DO NOT CHANGE. + 663 S^;*********************************************************************^ + 664 + 665 030524 BLOCK 53 ;HOPEFULLY THIS IS ENOUGH FOREVER + 666 + 667 S^;*********************************************************************^ + 668 ;*END OF FIXED STORAGE + 669 S^;*********************************************************************^ + 670 + 671 030577 $ENDFX=&<777700>-1 + 672 030577 LOC $ENDFX + 673 030577 000000 000000 ENDFIX: 0 ;END OF FIXED STORAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 1 +SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0023 + + 674 SUBTTL *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 + 675 + 676 ;NEW DEFINITIONS USED BY THE KL10 SUBROUTINE PACKAGE + 677 + 678 000000 AC0= 0 + 679 030000 DIAGNOS=30000 ;PDP-10 DIAGNOSTIC START ADDRESS + 680 010000 DDT= 10000 ;PDP-10 DDT START ADDRESS + 681 020000 DIAMON= 20000 ;PDP-10 DIAMON LOADER START ADDRESS + 682 020000 DONG11= 1B22 ;11 DOORBELL (FROM THE 10) + 683 + 684 ;DTE20 DEVICE CODES + 685 + 686 000200 DTE== 200 ;DTE0 + 687 000204 DTE0== 204 + 688 000204 DTE1== 204 + 689 000210 DTE2== 210 + 690 000214 DTE3== 214 + 691 + 692 ;KL10 EPT COMMUNICATION AREA + 693 + 694 000440 $STD= 440 ;PDP-10 DIAGNOSTIC START ADDRESS + 695 000441 $DDT= 441 ;PDP-10 DDT START ADDRESS + 696 000442 $STL= 442 ;PDP-10 LOADER START ADDRESS + 697 000443 $STM= 443 ;PDP-10 MONITOR START ADDRESS + 698 + 699 000444 $DTFLG= 444 ;DTE20 OPERATION COMPLETE FLAG + 700 000445 $DTCLK= 445 ;DTE20 CLOCK INTERRUPT FLAG + 701 000446 $DTCI= 446 ;DTE20 CLOCK INTERRUPT INSTRUCTION + 702 000447 $DTT11= 447 ;DTE20 10 TO 11 ARGUMENT + 703 000450 $DTF11= 450 ;DTE20 11 TO 10 ARGUMENT + 704 000451 $DTCMD= 451 ;DTE20 TO 11 COMMAND WORD + 705 000452 $DTSEQ= 452 ;DTE20 OPERATION SEQUENCE NUMBER + 706 000453 $DTOPR= 453 ;DTE20 OPERATIONAL DTE # + 707 000454 $DTCHR= 454 ;DTE20 LAST TYPED CHARACTER + 708 000455 $DTMTD= 455 ;DTE20 MONITOR TTY OUTPUT COMPLETE FLAG + 709 000456 $DTMTI= 456 ;DTE20 MONITOR TTY INPUT FLAG + 710 + 711 000457 $DTSWR= 457 ;DTE20 CONSOLE SWITCH REGISTER +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 2 +SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0024 + + 712 ;SPECIAL "FIXED" REASSIGNMENTS + 713 + 714 030600 $$LOC=. ;SAVE CURRENT LOCATION + 715 + 716 030000 LOC 30000 + 717 030000 254 00 0 00 030600 $$BEGIN:JRST $$START ;SETUP SPECIAL START + 718 030001 254 00 0 00 030600 JRST $$START ;"DIAMON" CHAIN START ADDRESS + 719 + 720 000440 LOC 440 + 721 000440 254 00 0 00 030000 $STD: JRST BEGIN ;SETUP FOR "STD" + 722 000443 LOC 443 + 723 000443 254 00 0 00 030636 $STM: JRST $SPEC ;SIMPLE RUN CONTROL + 724 + 725 030057 LOC 30057 + 726 030057 254 00 0 00 030641 $BEGEND:JRST $SPBEND ;SETUP SPECIAL "BEGEND" + 727 + 728 ;SPECIAL MUUO, TRAP & PAGE FAIL SETUP + 729 + 730 000420 LOC 420 + 731 000420 254 04 0 00 000420 $$420: HALT . ;KI10 PAGE FAIL + 732 000421 255 00 0 00 000000 $$421: JFCL ;OVERFLOW + 733 000422 254 04 0 00 000422 $$422: HALT . ;PUSHDOWN OVERFLOW + 734 000423 254 04 0 00 000423 $$423: HALT . ;TRAP 3 + 735 000424 000000 000000 $$424: 0 ;MMUO + 736 000425 000000 000000 $$425: 0 ;MMUO PC + 737 000426 000000 000000 $$426: 0 ;KI10-PAGE FAIL, KL10-PROCESS CONTEXT + 738 000427 254 04 0 00 000427 $$427: HALT . + 739 000430 000000 000427 $$430: 427 ;MMUO NEW PC'S + 740 000431 000000 000427 $$431: 427 + 741 000432 000000 000427 $$432: 427 + 742 000433 000000 000427 $$433: 427 + 743 000434 000000 000427 $$434: 427 + 744 000435 000000 000427 $$435: 427 + 745 000436 000000 000427 $$436: 427 + 746 000437 000000 000427 $$437: 427 + 747 + 748 000500 LOC 500 + 749 000500 000000 000000 $$500: 0 ;KL10 PAGE FAIL WORD + 750 000501 000000 000000 $$501: 0 ;KL10 PAGE FAIL PC + 751 000502 000000 000503 $$502: 503 ;KL10 PAGE FAIL NEW PC + 752 000503 254 04 0 00 000503 $$503: HALT . +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 3 +SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0025 + + 753 030600 LOC $$LOC ;RESET CURRENT LOCATION + 754 + 755 ;SPECIAL STARTUP SEQUENCE + 756 + 757 030600 402 00 0 00 030037 $$START:SETZM USER + 758 030601 265 00 0 00 030602 JSP 0,.+1 ;IN USER MODE ? + 759 030602 603 00 0 00 010000 TLNE 0,USERF + 760 030603 476 00 0 00 030037 SETOM USER ;YES, SET CONTROL WORD + 761 030604 336 00 0 00 030042 SKIPN MONFLG ;SPECIAL USER MODE ? + 762 030605 402 00 0 00 030037 SETZM USER ;YES, RUN AS EXEC + 763 030606 332 00 0 00 030037 SKIPE USER + 764 030607 254 00 0 00 030712 JRST START ;USER MODE, DON'T NEED CPU TYPE + 765 + 766 030610 336 00 0 00 030044 $STKIL: SKIPN MONTEN ;LOADED BY "DIAMON" ? + 767 030611 476 00 0 00 030024 SETOM ITRCNT ;NO, RUN FOREVER + 768 030612 402 00 0 00 030516 SETZM KLTYP + 769 030613 402 00 0 00 030041 SETZM KLFLG ;ASSUME KI10 + 770 030614 200 01 0 00 035410 MOVE 1,[1,,1] + 771 030615 251 01 0 00 000001 BLT 1,1 ;HOPE THIS WORKS + 772 030616 316 01 0 00 035410 CAMN 1,[1,,1] ;IF AC NE 1,,1 AFTER BLT, KL10 + 773 030617 254 00 0 00 030712 JRST START ;KI10, NO ADDITIONAL SETUP + 774 + 775 030620 7 000 20 0 00 010040 $STKL: CONO APR,10040 ;SET BBD NOT BIT + 776 030621 7 000 24 0 00 000000 CONI APR,0 + 777 030622 7 000 20 0 00 020040 CONO APR,20040 ;CLEAR BBD NOT BIT + 778 030623 606 00 0 00 000040 TRNN 0,40 ;IF SET, KL10 + 779 030624 350 00 0 00 030516 AOS KLTYP ;IF NOT, BBD + 780 030625 402 00 0 00 000444 SETZM $DTFLG + 781 030626 402 00 0 00 000445 SETZM $DTCLK + 782 030627 200 00 0 00 000453 MOVE $DTOPR ;GET DTE # + 783 030630 436 00 0 00 030670 ORM $$DTE0 ;INSERT IN DTE I/O INSTS + 784 030631 436 00 0 00 030672 ORM $$DTE1 + 785 030632 436 00 0 00 030704 ORM $$DTE2 + 786 030633 436 00 0 00 030706 ORM $$DTE3 + 787 030634 476 00 0 00 030041 SETOM KLFLG ;SET KL10 CONTROL FLAG + 788 030635 254 00 0 00 030712 JRST START + 789 + 790 030636 200 00 0 00 035411 $SPEC: MOVE [JRST STARTA] ;SIMPLE RUN CONTROL + 791 030637 202 00 0 00 030643 MOVEM $SPB1 + 792 030640 254 00 0 00 030712 JRST START +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 4 +SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0026 + + 793 ;SPECIAL "BEGEND" ROUTINE + 794 + 795 030641 350 00 0 00 030047 $SPBEND:AOS PASCNT ;INCREMENT PASS COUNT + 796 030642 370 00 0 00 030024 SOS ITRCNT ;DECREMENT ITERATION COUNT + 797 030643 336 00 0 00 030037 $SPB1: SKIPN USER + 798 030644 254 00 0 00 030652 JRST $SPBEX ;EXEC MODE + 799 + 800 030645 332 00 0 00 030024 $SPBUS: SKIPE ITRCNT ;USER MODE, COMPLETED ? + 801 030646 254 00 0 00 030741 JRST STARTA ;NO, KEEP RUNNING + 802 030647 336 00 0 00 030044 SKIPN MONTEN ;DONE, LOADED BY "DIAMON" ? + 803 030650 047 00 0 00 000012 EXIT ;NO, RETURN TO MONITOR + 804 030651 254 00 1 00 030012 JRST @RETURN ;YES, RETURN TO "DIAMON" + 805 + 806 030652 332 00 0 00 030041 $SPBEX: SKIPE KLFLG + 807 030653 254 00 0 00 030660 JRST $SPBKL ;KL10 & EXEC + 808 030654 7 004 14 0 00 030024 DATAO PI,ITRCNT ;KI10 & EXEC, DISPLAY ITER COUNT + 809 030655 332 00 0 00 030024 SKIPE ITRCNT + 810 030656 254 00 0 00 030741 JRST STARTA ;NOT COMPLETED YET + 811 030657 254 00 1 00 030012 JRST @RETURN ;DONE + 812 + 813 030660 336 00 0 00 030024 $SPBKL: SKIPN ITRCNT + 814 030661 254 00 0 00 030676 JRST $SPKLD ;KL10, EXEC & COMPLETED + 815 + 816 030662 335 00 0 00 030043 SKIPGE MONCTL + 817 030663 254 00 0 00 030741 JRST STARTA ;"DIAMON" CONTROL + 818 030664 201 00 0 00 000404 MOVEI 0,404 ;NOTIFY PDP-11 OF END OF PASS + 819 030665 202 00 0 00 000451 MOVEM 0,$DTCMD + 820 030666 402 00 0 00 000444 SETZM $DTFLG + 821 030667 336 00 0 00 030516 SKIPN KLTYP + 822 030670 7 200 20 0 00 020000 $$DTE0: CONO DTE,DONG11 + 823 030671 332 00 0 00 030516 SKIPE KLTYP + 824 030672 7 200 20 0 00 010000 $$DTE1: CONO DTE,10000 + 825 030673 336 00 0 00 000444 SKIPN $DTFLG ;WAIT TILL 11 RESPONDS + 826 030674 254 00 0 00 030673 JRST .-1 + 827 030675 254 00 0 00 030741 JRST STARTA ;KEEP RUNNING + 828 + 829 ;SPECIAL KL10 COMPLETED ROUTINE + 830 + 831 030676 332 00 0 00 030044 $SPKLD: SKIPE MONTEN + 832 030677 254 00 1 00 030012 JRST @RETURN ;LOADED BY "DIAMON" + 833 + 834 030700 201 00 0 00 000403 MOVEI 0,403 ;NOTIFY PDP-11 OF COMPLETION + 835 030701 202 00 0 00 000451 MOVEM 0,$DTCMD + 836 030702 402 00 0 00 000444 SETZM $DTFLG + 837 030703 336 00 0 00 030516 SKIPN KLTYP + 838 030704 7 200 20 0 00 020000 $$DTE2: CONO DTE,DONG11 + 839 030705 332 00 0 00 030516 SKIPE KLTYP + 840 030706 7 200 20 0 00 010000 $$DTE3: CONO DTE,10000 + 841 030707 336 00 0 00 000444 SKIPN $DTFLG ;SHOULD NEVER HAPPEN + 842 030710 254 00 0 00 030707 JRST .-1 ;11 NEVER RETURNS ON END OF PROGRAM + 843 030711 254 04 0 00 030000 HALT BEGIN ;IF IT DOES, HALT. +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 1 +DAKABM MAC 19-JAN-77 13:39 DIAGNOSTIC SECTION SEQ 0027 + + 844 SUBTTL DIAGNOSTIC SECTION + 845 LALL + 846 + 847 030712 402 00 0 00 030037 START: SETZM USER# ;CLEAR USER CONTROL WORD + 848 030713 265 00 0 00 030714 JSP 0,.+1 ;GET FLAGS + 849 030714 603 00 0 00 010000 TLNE USERF ;IN USER MODE? + 850 030715 476 00 0 00 030037 SETOM USER ;YES, SET USER CONTROL WORD + 851 030716 336 00 0 00 030042 SKIPN MONFLG ;SPECIAL USER MODE? + 852 030717 402 00 0 00 030037 SETZM USER ;YES, CLEAR USER CONTROL WORD + 853 030720 336 00 0 00 030037 SKIPN USER + 854 030721 254 00 0 00 030742 JRST B00 + 855 030722 331 00 0 00 030043 SKIPL MONCTL + 856 030723 051 03 0 00 030725 TTCALL 3,PGMNAM ;MENTION OUR NAME + 857 030724 254 00 0 00 030741 JRST STARTA ; GO START + 858 + 859 030725 PGMNAM: ASCIZ/ + 860 030725 015 012 120 104 120 PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) [DAKAB] + 861 030726 055 061 060 040 113 + 862 030727 101 061 060 040 102 + 863 030730 101 123 111 103 040 + 864 030731 111 116 123 124 122 + 865 030732 125 103 124 111 117 + 866 030733 116 040 104 111 101 + 867 030734 107 116 117 123 124 + 868 030735 111 103 040 050 062 + 869 030736 051 040 133 104 101 + 870 030737 113 101 102 135 015 + 871 030740 012 000 000 000 000 / + 872 + 873 ;BASIC INSTRUCTION TEST (2) + 874 ;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF + 875 ;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES + 876 ;IN THE FIELD + 877 + 878 + 879 030741 254 00 0 00 030742 STARTA: JRST .+1 + 880 + 881 030742 B00: +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 2 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0028 + + 882 SUBTTL TEST OF THE ADD INSTRUCTION + 883 + 884 ;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED + 885 ;TO ADD A NON-ZERO NUMBER CONTAINED IN E TO AN AC CONTAINING ALL ZEROS, + 886 ;THE RESULT IS A NON-ZERO NUMBER IN THE AC. FIRST, THE AC IS CLEARED; + 887 ;THEN, ANON-ZERO POSITIVE NUMBER IS ADDED TO THE AC USING THE ADD + 888 ;INSTRUCTION. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + 889 + 890 030742 200 00 0 00 035412 A10400: MOVE [0] ;PRESET AC TO ALL ZEROS + 891 030743 270 00 0 00 035413 ADD [123456765432] ;*ADD OF A NON-ZERO NUMBER TO AN AC OF ALL + 892 ;ZEROS SHOULD RESULT + 893 ;IN AN AC CONTAINING A NON-ZERO NUMBER + 894 030744 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + 895 STOP^ + 896 030745 254 04 0 00 030746 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 897 030746 324 00 0 00 030747 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 898 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 899 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 900 + 901 ;AD ADD [ADC1], AD ADD EN [ADC1], + 902 ;F CYC ACT EN A [F1], AD FM + FETCH EN A [ADFP], + 903 ;F CYC ACT EN C[F1], IR ADSUB [IR1], IRXX [IR1] + 904 + 905 ;********** + 906 + 907 ;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD + 908 ;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE + 909 ;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS + 910 ;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS + 911 ; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + 912 + 913 030747 200 00 0 00 035413 A10500: MOVE [123456765432] ;PRESET AC WITH A NON-ZERO NUMBER + 914 030750 270 00 0 00 035412 ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC + 915 ;CONTAINING A NON-ZERO NUMBER + 916 ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + 917 030751 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + 918 STOP^ + 919 030752 254 04 0 00 030753 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 920 030753 324 00 0 00 030754 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 921 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 922 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 923 + 924 ;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F [E], + 925 ;AR AD ET2 EN [ARMA], IR ADSUB [IR1] + 926 + 927 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 3 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0029 + + 928 ;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD + 929 ;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE + 930 ;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS + 931 ;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS + 932 ; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + 933 + 934 030754 200 00 0 00 035414 A10600: MOVE [XWD 123456,0] ;PRESET AC WITH A NON-ZERO NUMBER + 935 030755 270 00 0 00 035412 ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING + 936 ;A NON-ZERO NUMBER SHOULD RESULT IN AN AC + 937 ;CONTAINING A NON-ZERO NUMBER + 938 030756 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + 939 STOP^ + 940 030757 254 04 0 00 030760 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 941 030760 324 00 0 00 030761 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 942 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 943 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 944 + 945 ;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F[E], + 946 ;AR AD ET2 EN [ARMA], IR AD SUB [IR1] + 947 + 948 ;********* + 949 + 950 ;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD + 951 ;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE + 952 ;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS + 953 ;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS + 954 ; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + 955 + 956 030761 200 00 0 00 035415 A10700: MOVE [123456] ;PRESET AC WITH A NON-ZERO NUMBER + 957 030762 270 00 0 00 035412 ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING + 958 ;A NON-ZERO NUMBER + 959 ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + 960 030763 336 00 0 00 000000 SKIPN ;PASS TEST IS C(AC) IS NON-ZERO + 961 STOP^ + 962 030764 254 04 0 00 030765 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 963 030765 324 00 0 00 030766 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 964 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 965 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 966 + 967 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 4 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0030 + + 968 ;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD + 969 ;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE + 970 ;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS + 971 ;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER + 972 ;IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + 973 + 974 030766 200 00 0 00 035412 A13300: MOVE [0] ;PRESET AC WITH ALL ZEROS + 975 030767 270 00 0 00 035414 ADD [123456,,0] ;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS + 976 ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + 977 030770 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + 978 STOP^ + 979 030771 254 04 0 00 030772 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 980 030772 324 00 0 00 030773 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 981 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 982 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 983 + 984 ;********** + 985 + 986 ;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD + 987 ;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE + 988 ;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS + 989 ;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER + 990 ;IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + 991 + 992 030773 200 00 0 00 035412 A13400: MOVE [0] ;PRESET AC WITH ALL ZEROS + 993 030774 270 00 0 00 035415 ADD [123456] ;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS + 994 ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + 995 030775 336 00 0 00 000000 SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + 996 STOP^ + 997 030776 254 04 0 00 030777 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 998 030777 324 00 0 00 031000 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 999 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1000 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1001 + 1002 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0031 + + 1003 ;ADD ZERO TO A RIPPLED ONE + 1004 + 1005 011000 SN=11000 + 1006 000000 ZZ=0 + 1007 + 1008 A11000: REPEAT ^D36, + 1009 <;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1010 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1011 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1012 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1013 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1014 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1015 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1016 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1017 ;EVERY BIT OF THE AC. + 1018 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1019 SN=SN+1 + 1020 ZZ=ZZ+ZZ + 1021 IFE ZZ, + 1022 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1023 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1024 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1025 EQV [0] ;RESULTS IN C(AC)=0 + 1026 SKIPE ;PASS TEST IF C(AC)=0 + 1027 STOP + 1028 + 1029 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1030 ;IR ADDX [IR1], IR ADSUB [IR1] + 1031 + 1032 ;********** + 1033 PAGE + 1034 > + 1035 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1036 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1037 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1038 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1039 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1040 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1041 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1042 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1043 ;EVERY BIT OF THE AC. + 1044 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1045 011001 SN=SN+1 + 1046 000000 ZZ=ZZ+ZZ + 1047 000001 IFE ZZ, + 1048 031000 200 00 0 00 035416 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1049 031001 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1050 031002 444 00 0 00 035416 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1051 031003 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1052 031004 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1053 STOP^ + 1054 031005 254 04 0 00 031006 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1055 031006 324 00 0 00 031007 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1056 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1057 ;IN THE SUBTEST) TO LOOP ON ERROR^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0032 + + 1058 + 1059 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1060 ;IR ADDX [IR1], IR ADSUB [IR1] + 1061 + 1062 ;********** + 1063 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0033 + + 1064 + 1065 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1066 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1067 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1068 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1069 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1070 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1071 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1072 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1073 ;EVERY BIT OF THE AC. + 1074 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1075 011002 SN=SN+1 + 1076 000002 ZZ=ZZ+ZZ + 1077 IFE ZZ, + 1078 031007 200 00 0 00 035417 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1079 031010 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1080 031011 444 00 0 00 035417 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1081 031012 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1082 031013 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1083 STOP^ + 1084 031014 254 04 0 00 031015 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1085 031015 324 00 0 00 031016 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1086 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1087 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1088 + 1089 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1090 ;IR ADDX [IR1], IR ADSUB [IR1] + 1091 + 1092 ;********** + 1093 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0034 + + 1094 + 1095 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1096 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1097 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1098 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1099 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1100 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1101 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1102 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1103 ;EVERY BIT OF THE AC. + 1104 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1105 011003 SN=SN+1 + 1106 000004 ZZ=ZZ+ZZ + 1107 IFE ZZ, + 1108 031016 200 00 0 00 035420 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1109 031017 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1110 031020 444 00 0 00 035420 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1111 031021 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1112 031022 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1113 STOP^ + 1114 031023 254 04 0 00 031024 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1115 031024 324 00 0 00 031025 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1116 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1117 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1118 + 1119 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1120 ;IR ADDX [IR1], IR ADSUB [IR1] + 1121 + 1122 ;********** + 1123 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0035 + + 1124 + 1125 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1126 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1127 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1128 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1129 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1130 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1131 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1132 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1133 ;EVERY BIT OF THE AC. + 1134 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1135 011004 SN=SN+1 + 1136 000010 ZZ=ZZ+ZZ + 1137 IFE ZZ, + 1138 031025 200 00 0 00 035421 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1139 031026 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1140 031027 444 00 0 00 035421 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1141 031030 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1142 031031 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1143 STOP^ + 1144 031032 254 04 0 00 031033 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1145 031033 324 00 0 00 031034 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1146 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1147 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1148 + 1149 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1150 ;IR ADDX [IR1], IR ADSUB [IR1] + 1151 + 1152 ;********** + 1153 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0036 + + 1154 + 1155 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1156 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1157 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1158 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1159 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1160 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1161 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1162 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1163 ;EVERY BIT OF THE AC. + 1164 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1165 011005 SN=SN+1 + 1166 000020 ZZ=ZZ+ZZ + 1167 IFE ZZ, + 1168 031034 200 00 0 00 035422 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1169 031035 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1170 031036 444 00 0 00 035422 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1171 031037 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1172 031040 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1173 STOP^ + 1174 031041 254 04 0 00 031042 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1175 031042 324 00 0 00 031043 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1176 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1177 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1178 + 1179 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1180 ;IR ADDX [IR1], IR ADSUB [IR1] + 1181 + 1182 ;********** + 1183 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0037 + + 1184 + 1185 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1186 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1187 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1188 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1189 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1190 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1191 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1192 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1193 ;EVERY BIT OF THE AC. + 1194 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1195 011006 SN=SN+1 + 1196 000040 ZZ=ZZ+ZZ + 1197 IFE ZZ, + 1198 031043 200 00 0 00 035423 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1199 031044 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1200 031045 444 00 0 00 035423 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1201 031046 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1202 031047 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1203 STOP^ + 1204 031050 254 04 0 00 031051 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1205 031051 324 00 0 00 031052 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1206 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1207 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1208 + 1209 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1210 ;IR ADDX [IR1], IR ADSUB [IR1] + 1211 + 1212 ;********** + 1213 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-7 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0038 + + 1214 + 1215 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1216 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1217 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1218 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1219 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1220 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1221 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1222 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1223 ;EVERY BIT OF THE AC. + 1224 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1225 011007 SN=SN+1 + 1226 000100 ZZ=ZZ+ZZ + 1227 IFE ZZ, + 1228 031052 200 00 0 00 035424 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1229 031053 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1230 031054 444 00 0 00 035424 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1231 031055 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1232 031056 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1233 STOP^ + 1234 031057 254 04 0 00 031060 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1235 031060 324 00 0 00 031061 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1236 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1237 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1238 + 1239 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1240 ;IR ADDX [IR1], IR ADSUB [IR1] + 1241 + 1242 ;********** + 1243 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-8 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0039 + + 1244 + 1245 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1246 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1247 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1248 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1249 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1250 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1251 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1252 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1253 ;EVERY BIT OF THE AC. + 1254 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1255 011010 SN=SN+1 + 1256 000200 ZZ=ZZ+ZZ + 1257 IFE ZZ, + 1258 031061 200 00 0 00 035425 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1259 031062 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1260 031063 444 00 0 00 035425 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1261 031064 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1262 031065 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1263 STOP^ + 1264 031066 254 04 0 00 031067 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1265 031067 324 00 0 00 031070 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1266 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1267 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1268 + 1269 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1270 ;IR ADDX [IR1], IR ADSUB [IR1] + 1271 + 1272 ;********** + 1273 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-9 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0040 + + 1274 + 1275 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1276 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1277 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1278 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1279 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1280 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1281 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1282 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1283 ;EVERY BIT OF THE AC. + 1284 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1285 011011 SN=SN+1 + 1286 000400 ZZ=ZZ+ZZ + 1287 IFE ZZ, + 1288 031070 200 00 0 00 035426 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1289 031071 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1290 031072 444 00 0 00 035426 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1291 031073 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1292 031074 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1293 STOP^ + 1294 031075 254 04 0 00 031076 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1295 031076 324 00 0 00 031077 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1296 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1297 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1298 + 1299 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1300 ;IR ADDX [IR1], IR ADSUB [IR1] + 1301 + 1302 ;********** + 1303 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-10 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0041 + + 1304 + 1305 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1306 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1307 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1308 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1309 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1310 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1311 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1312 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1313 ;EVERY BIT OF THE AC. + 1314 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1315 011012 SN=SN+1 + 1316 001000 ZZ=ZZ+ZZ + 1317 IFE ZZ, + 1318 031077 200 00 0 00 035427 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1319 031100 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1320 031101 444 00 0 00 035427 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1321 031102 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1322 031103 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1323 STOP^ + 1324 031104 254 04 0 00 031105 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1325 031105 324 00 0 00 031106 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1326 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1327 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1328 + 1329 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1330 ;IR ADDX [IR1], IR ADSUB [IR1] + 1331 + 1332 ;********** + 1333 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-11 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0042 + + 1334 + 1335 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1336 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1337 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1338 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1339 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1340 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1341 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1342 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1343 ;EVERY BIT OF THE AC. + 1344 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1345 011013 SN=SN+1 + 1346 002000 ZZ=ZZ+ZZ + 1347 IFE ZZ, + 1348 031106 200 00 0 00 035430 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1349 031107 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1350 031110 444 00 0 00 035430 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1351 031111 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1352 031112 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1353 STOP^ + 1354 031113 254 04 0 00 031114 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1355 031114 324 00 0 00 031115 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1356 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1357 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1358 + 1359 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1360 ;IR ADDX [IR1], IR ADSUB [IR1] + 1361 + 1362 ;********** + 1363 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-12 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0043 + + 1364 + 1365 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1366 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1367 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1368 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1369 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1370 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1371 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1372 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1373 ;EVERY BIT OF THE AC. + 1374 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1375 011014 SN=SN+1 + 1376 004000 ZZ=ZZ+ZZ + 1377 IFE ZZ, + 1378 031115 200 00 0 00 035431 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1379 031116 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1380 031117 444 00 0 00 035431 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1381 031120 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1382 031121 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1383 STOP^ + 1384 031122 254 04 0 00 031123 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1385 031123 324 00 0 00 031124 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1386 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1387 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1388 + 1389 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1390 ;IR ADDX [IR1], IR ADSUB [IR1] + 1391 + 1392 ;********** + 1393 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-13 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0044 + + 1394 + 1395 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1396 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1397 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1398 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1399 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1400 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1401 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1402 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1403 ;EVERY BIT OF THE AC. + 1404 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1405 011015 SN=SN+1 + 1406 010000 ZZ=ZZ+ZZ + 1407 IFE ZZ, + 1408 031124 200 00 0 00 035432 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1409 031125 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1410 031126 444 00 0 00 035432 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1411 031127 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1412 031130 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1413 STOP^ + 1414 031131 254 04 0 00 031132 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1415 031132 324 00 0 00 031133 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1416 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1417 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1418 + 1419 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1420 ;IR ADDX [IR1], IR ADSUB [IR1] + 1421 + 1422 ;********** + 1423 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-14 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0045 + + 1424 + 1425 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1426 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1427 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1428 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1429 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1430 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1431 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1432 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1433 ;EVERY BIT OF THE AC. + 1434 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1435 011016 SN=SN+1 + 1436 020000 ZZ=ZZ+ZZ + 1437 IFE ZZ, + 1438 031133 200 00 0 00 035433 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1439 031134 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1440 031135 444 00 0 00 035433 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1441 031136 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1442 031137 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1443 STOP^ + 1444 031140 254 04 0 00 031141 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1445 031141 324 00 0 00 031142 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 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1450 ;IR ADDX [IR1], IR ADSUB [IR1] + 1451 + 1452 ;********** + 1453 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-15 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0046 + + 1454 + 1455 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1456 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1457 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1458 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1459 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1460 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1461 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1462 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1463 ;EVERY BIT OF THE AC. + 1464 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1465 011017 SN=SN+1 + 1466 040000 ZZ=ZZ+ZZ + 1467 IFE ZZ, + 1468 031142 200 00 0 00 035434 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1469 031143 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1470 031144 444 00 0 00 035434 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1471 031145 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1472 031146 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1473 STOP^ + 1474 031147 254 04 0 00 031150 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1475 031150 324 00 0 00 031151 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1476 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1477 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1478 + 1479 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1480 ;IR ADDX [IR1], IR ADSUB [IR1] + 1481 + 1482 ;********** + 1483 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-16 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0047 + + 1484 + 1485 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1486 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1487 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1488 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1489 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1490 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1491 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1492 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1493 ;EVERY BIT OF THE AC. + 1494 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1495 011020 SN=SN+1 + 1496 100000 ZZ=ZZ+ZZ + 1497 IFE ZZ, + 1498 031151 200 00 0 00 035435 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1499 031152 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1500 031153 444 00 0 00 035435 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1501 031154 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1502 031155 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1503 STOP^ + 1504 031156 254 04 0 00 031157 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1505 031157 324 00 0 00 031160 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1506 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1507 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1508 + 1509 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1510 ;IR ADDX [IR1], IR ADSUB [IR1] + 1511 + 1512 ;********** + 1513 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-17 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0048 + + 1514 + 1515 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1516 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1517 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1518 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1519 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1520 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1521 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1522 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1523 ;EVERY BIT OF THE AC. + 1524 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1525 011021 SN=SN+1 + 1526 200000 ZZ=ZZ+ZZ + 1527 IFE ZZ, + 1528 031160 200 00 0 00 035436 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1529 031161 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1530 031162 444 00 0 00 035436 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1531 031163 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1532 031164 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1533 STOP^ + 1534 031165 254 04 0 00 031166 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1535 031166 324 00 0 00 031167 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1536 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1537 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1538 + 1539 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1540 ;IR ADDX [IR1], IR ADSUB [IR1] + 1541 + 1542 ;********** + 1543 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-18 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0049 + + 1544 + 1545 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1546 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1547 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1548 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1549 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1550 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1551 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1552 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1553 ;EVERY BIT OF THE AC. + 1554 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1555 011022 SN=SN+1 + 1556 400000 ZZ=ZZ+ZZ + 1557 IFE ZZ, + 1558 031167 200 00 0 00 035437 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1559 031170 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1560 031171 444 00 0 00 035437 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1561 031172 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1562 031173 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1563 STOP^ + 1564 031174 254 04 0 00 031175 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1565 031175 324 00 0 00 031176 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1566 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1567 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1568 + 1569 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1570 ;IR ADDX [IR1], IR ADSUB [IR1] + 1571 + 1572 ;********** + 1573 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-19 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0050 + + 1574 + 1575 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1576 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1577 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1578 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1579 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1580 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1581 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1582 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1583 ;EVERY BIT OF THE AC. + 1584 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1585 011023 SN=SN+1 + 1586 000001 000000 ZZ=ZZ+ZZ + 1587 IFE ZZ, + 1588 031176 200 00 0 00 035440 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1589 031177 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1590 031200 444 00 0 00 035440 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1591 031201 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1592 031202 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1593 STOP^ + 1594 031203 254 04 0 00 031204 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1595 031204 324 00 0 00 031205 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1596 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1597 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1598 + 1599 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1600 ;IR ADDX [IR1], IR ADSUB [IR1] + 1601 + 1602 ;********** + 1603 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-20 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0051 + + 1604 + 1605 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1606 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1607 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1608 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1609 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1610 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1611 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1612 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1613 ;EVERY BIT OF THE AC. + 1614 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1615 011024 SN=SN+1 + 1616 000002 000000 ZZ=ZZ+ZZ + 1617 IFE ZZ, + 1618 031205 200 00 0 00 035441 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1619 031206 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1620 031207 444 00 0 00 035441 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1621 031210 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1622 031211 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1623 STOP^ + 1624 031212 254 04 0 00 031213 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1625 031213 324 00 0 00 031214 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1626 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1627 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1628 + 1629 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1630 ;IR ADDX [IR1], IR ADSUB [IR1] + 1631 + 1632 ;********** + 1633 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-21 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0052 + + 1634 + 1635 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1636 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1637 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1638 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1639 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1640 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1641 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1642 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1643 ;EVERY BIT OF THE AC. + 1644 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1645 011025 SN=SN+1 + 1646 000004 000000 ZZ=ZZ+ZZ + 1647 IFE ZZ, + 1648 031214 200 00 0 00 035442 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1649 031215 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1650 031216 444 00 0 00 035442 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1651 031217 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1652 031220 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1653 STOP^ + 1654 031221 254 04 0 00 031222 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1655 031222 324 00 0 00 031223 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1656 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1657 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1658 + 1659 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1660 ;IR ADDX [IR1], IR ADSUB [IR1] + 1661 + 1662 ;********** + 1663 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-22 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0053 + + 1664 + 1665 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1666 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1667 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1668 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1669 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1670 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1671 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1672 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1673 ;EVERY BIT OF THE AC. + 1674 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1675 011026 SN=SN+1 + 1676 000010 000000 ZZ=ZZ+ZZ + 1677 IFE ZZ, + 1678 031223 200 00 0 00 035443 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1679 031224 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1680 031225 444 00 0 00 035443 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1681 031226 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1682 031227 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1683 STOP^ + 1684 031230 254 04 0 00 031231 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1685 031231 324 00 0 00 031232 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1686 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1687 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1688 + 1689 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1690 ;IR ADDX [IR1], IR ADSUB [IR1] + 1691 + 1692 ;********** + 1693 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-23 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0054 + + 1694 + 1695 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1696 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1697 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1698 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1699 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1700 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1701 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1702 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1703 ;EVERY BIT OF THE AC. + 1704 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1705 011027 SN=SN+1 + 1706 000020 000000 ZZ=ZZ+ZZ + 1707 IFE ZZ, + 1708 031232 200 00 0 00 035444 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1709 031233 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1710 031234 444 00 0 00 035444 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1711 031235 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1712 031236 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1713 STOP^ + 1714 031237 254 04 0 00 031240 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1715 031240 324 00 0 00 031241 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1716 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1717 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1718 + 1719 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1720 ;IR ADDX [IR1], IR ADSUB [IR1] + 1721 + 1722 ;********** + 1723 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-24 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0055 + + 1724 + 1725 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1726 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1727 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1728 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1729 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1730 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1731 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1732 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1733 ;EVERY BIT OF THE AC. + 1734 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1735 011030 SN=SN+1 + 1736 000040 000000 ZZ=ZZ+ZZ + 1737 IFE ZZ, + 1738 031241 200 00 0 00 035445 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1739 031242 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1740 031243 444 00 0 00 035445 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1741 031244 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1742 031245 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1743 STOP^ + 1744 031246 254 04 0 00 031247 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1745 031247 324 00 0 00 031250 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1746 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1747 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1748 + 1749 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1750 ;IR ADDX [IR1], IR ADSUB [IR1] + 1751 + 1752 ;********** + 1753 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-25 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0056 + + 1754 + 1755 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1756 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1757 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1758 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1759 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1760 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1761 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1762 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1763 ;EVERY BIT OF THE AC. + 1764 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1765 011031 SN=SN+1 + 1766 000100 000000 ZZ=ZZ+ZZ + 1767 IFE ZZ, + 1768 031250 200 00 0 00 035446 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1769 031251 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1770 031252 444 00 0 00 035446 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1771 031253 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1772 031254 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1773 STOP^ + 1774 031255 254 04 0 00 031256 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1775 031256 324 00 0 00 031257 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1776 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1777 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1778 + 1779 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1780 ;IR ADDX [IR1], IR ADSUB [IR1] + 1781 + 1782 ;********** + 1783 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-26 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0057 + + 1784 + 1785 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1786 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1787 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1788 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1789 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1790 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1791 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1792 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1793 ;EVERY BIT OF THE AC. + 1794 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1795 011032 SN=SN+1 + 1796 000200 000000 ZZ=ZZ+ZZ + 1797 IFE ZZ, + 1798 031257 200 00 0 00 035447 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1799 031260 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1800 031261 444 00 0 00 035447 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1801 031262 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1802 031263 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1803 STOP^ + 1804 031264 254 04 0 00 031265 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1805 031265 324 00 0 00 031266 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1806 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1807 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1808 + 1809 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1810 ;IR ADDX [IR1], IR ADSUB [IR1] + 1811 + 1812 ;********** + 1813 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-27 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0058 + + 1814 + 1815 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1816 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1817 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1818 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1819 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1820 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1821 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1822 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1823 ;EVERY BIT OF THE AC. + 1824 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1825 011033 SN=SN+1 + 1826 000400 000000 ZZ=ZZ+ZZ + 1827 IFE ZZ, + 1828 031266 200 00 0 00 035450 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1829 031267 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1830 031270 444 00 0 00 035450 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1831 031271 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1832 031272 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1833 STOP^ + 1834 031273 254 04 0 00 031274 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1835 031274 324 00 0 00 031275 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1836 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1837 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1838 + 1839 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1840 ;IR ADDX [IR1], IR ADSUB [IR1] + 1841 + 1842 ;********** + 1843 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-28 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0059 + + 1844 + 1845 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1846 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1847 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1848 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1849 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1850 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1851 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1852 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1853 ;EVERY BIT OF THE AC. + 1854 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1855 011034 SN=SN+1 + 1856 001000 000000 ZZ=ZZ+ZZ + 1857 IFE ZZ, + 1858 031275 200 00 0 00 035451 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1859 031276 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1860 031277 444 00 0 00 035451 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1861 031300 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1862 031301 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1863 STOP^ + 1864 031302 254 04 0 00 031303 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1865 031303 324 00 0 00 031304 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1866 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1867 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1868 + 1869 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1870 ;IR ADDX [IR1], IR ADSUB [IR1] + 1871 + 1872 ;********** + 1873 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-29 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0060 + + 1874 + 1875 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1876 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1877 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1878 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1879 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1880 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1881 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1882 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1883 ;EVERY BIT OF THE AC. + 1884 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1885 011035 SN=SN+1 + 1886 002000 000000 ZZ=ZZ+ZZ + 1887 IFE ZZ, + 1888 031304 200 00 0 00 035452 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1889 031305 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1890 031306 444 00 0 00 035452 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1891 031307 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1892 031310 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1893 STOP^ + 1894 031311 254 04 0 00 031312 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1895 031312 324 00 0 00 031313 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1896 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1897 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1898 + 1899 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1900 ;IR ADDX [IR1], IR ADSUB [IR1] + 1901 + 1902 ;********** + 1903 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-30 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0061 + + 1904 + 1905 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1906 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1907 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1908 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1909 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1910 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1911 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1912 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1913 ;EVERY BIT OF THE AC. + 1914 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1915 011036 SN=SN+1 + 1916 004000 000000 ZZ=ZZ+ZZ + 1917 IFE ZZ, + 1918 031313 200 00 0 00 035453 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1919 031314 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1920 031315 444 00 0 00 035453 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1921 031316 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1922 031317 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1923 STOP^ + 1924 031320 254 04 0 00 031321 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1925 031321 324 00 0 00 031322 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1926 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1927 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1928 + 1929 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1930 ;IR ADDX [IR1], IR ADSUB [IR1] + 1931 + 1932 ;********** + 1933 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-31 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0062 + + 1934 + 1935 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1936 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1937 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1938 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1939 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1940 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1941 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1942 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1943 ;EVERY BIT OF THE AC. + 1944 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1945 011037 SN=SN+1 + 1946 010000 000000 ZZ=ZZ+ZZ + 1947 IFE ZZ, + 1948 031322 200 00 0 00 035454 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1949 031323 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1950 031324 444 00 0 00 035454 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1951 031325 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1952 031326 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1953 STOP^ + 1954 031327 254 04 0 00 031330 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1955 031330 324 00 0 00 031331 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1956 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1957 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1958 + 1959 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1960 ;IR ADDX [IR1], IR ADSUB [IR1] + 1961 + 1962 ;********** + 1963 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-32 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0063 + + 1964 + 1965 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1966 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1967 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1968 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1969 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 1970 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 1971 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 1972 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 1973 ;EVERY BIT OF THE AC. + 1974 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 1975 011040 SN=SN+1 + 1976 020000 000000 ZZ=ZZ+ZZ + 1977 IFE ZZ, + 1978 031331 200 00 0 00 035455 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 1979 031332 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 1980 031333 444 00 0 00 035455 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 1981 031334 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 1982 031335 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1983 STOP^ + 1984 031336 254 04 0 00 031337 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1985 031337 324 00 0 00 031340 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1986 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1987 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1988 + 1989 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 1990 ;IR ADDX [IR1], IR ADSUB [IR1] + 1991 + 1992 ;********** + 1993 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-33 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0064 + + 1994 + 1995 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 1996 ;A WORD OF ALL ZEROS IS ADDED TO AN + 1997 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 1998 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 1999 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2000 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2001 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2002 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2003 ;EVERY BIT OF THE AC. + 2004 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2005 011041 SN=SN+1 + 2006 040000 000000 ZZ=ZZ+ZZ + 2007 IFE ZZ, + 2008 031340 200 00 0 00 035456 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 2009 031341 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 2010 031342 444 00 0 00 035456 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2011 031343 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2012 031344 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2013 STOP^ + 2014 031345 254 04 0 00 031346 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2015 031346 324 00 0 00 031347 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2016 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2017 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2018 + 2019 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 2020 ;IR ADDX [IR1], IR ADSUB [IR1] + 2021 + 2022 ;********** + 2023 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-34 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0065 + + 2024 + 2025 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2026 ;A WORD OF ALL ZEROS IS ADDED TO AN + 2027 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2028 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 2029 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2030 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2031 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2032 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2033 ;EVERY BIT OF THE AC. + 2034 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2035 011042 SN=SN+1 + 2036 100000 000000 ZZ=ZZ+ZZ + 2037 IFE ZZ, + 2038 031347 200 00 0 00 035457 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 2039 031350 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 2040 031351 444 00 0 00 035457 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2041 031352 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2042 031353 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2043 STOP^ + 2044 031354 254 04 0 00 031355 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2045 031355 324 00 0 00 031356 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2046 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2047 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2048 + 2049 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 2050 ;IR ADDX [IR1], IR ADSUB [IR1] + 2051 + 2052 ;********** + 2053 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-35 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0066 + + 2054 + 2055 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2056 ;A WORD OF ALL ZEROS IS ADDED TO AN + 2057 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2058 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 2059 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2060 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2061 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2062 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2063 ;EVERY BIT OF THE AC. + 2064 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2065 011043 SN=SN+1 + 2066 200000 000000 ZZ=ZZ+ZZ + 2067 IFE ZZ, + 2068 031356 200 00 0 00 035460 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 2069 031357 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 2070 031360 444 00 0 00 035460 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2071 031361 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2072 031362 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2073 STOP^ + 2074 031363 254 04 0 00 031364 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2075 031364 324 00 0 00 031365 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2076 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2077 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2078 + 2079 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 2080 ;IR ADDX [IR1], IR ADSUB [IR1] + 2081 + 2082 ;********** + 2083 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-36 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0067 + + 2084 + 2085 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2086 ;A WORD OF ALL ZEROS IS ADDED TO AN + 2087 ;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2088 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. + 2089 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2090 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2091 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2092 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2093 ;EVERY BIT OF THE AC. + 2094 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2095 011044 SN=SN+1 + 2096 400000 000000 ZZ=ZZ+ZZ + 2097 IFE ZZ, + 2098 031365 200 00 0 00 035461 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 2099 031366 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO FLOATING ONE + 2100 031367 444 00 0 00 035461 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2101 031370 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2102 031371 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2103 STOP^ + 2104 031372 254 04 0 00 031373 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2105 031373 324 00 0 00 031374 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2106 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2107 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2108 + 2109 ;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], + 2110 ;IR ADDX [IR1], IR ADSUB [IR1] + 2111 + 2112 ;********** + 2113 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 5-37 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0068 + + 2114 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 6 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0069 + + 2115 ;THIS TEST VERIFIES THAT THE ADDITION OF A WORD OF + 2116 ;ALL ZEROS TO AN AC OF ALL ZEROS RESULTS IN + 2117 ;C(AC)=0. FIRST THE AC IS CLEARED; THEN, A WORD + 2118 ;OF ALL ZEROS IS ADDED TO THE AC. THE RESULT IN + 2119 ;THE AC IS THEN CHECKED TO INSURE THAT C(AC)=0 + 2120 + 2121 031374 200 00 0 00 035412 A11100: MOVE [0] ;PRESET AC TO ZERO + 2122 031375 270 00 0 00 035412 ADD [0] ;*ADD OF ZERO TO ZERO SHOULD RESULT IN C(AC)=0 + 2123 031376 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2124 STOP^ + 2125 031377 254 04 0 00 031400 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2126 031400 324 00 0 00 031401 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2127 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2128 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2129 + 2130 ;FCE[F1], IR AD SUB [IR1] + 2131 ;AD FM + EN [ADFP], AD FM + EN A [ADFP], + 2132 ;F CYC ACT EN C[F1], IR ADSUB [IR1] + 2133 + 2134 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0070 + + 2135 ;ADD ZERO TO A RIPPLED ONE + 2136 + 2137 013200 SN=13200 + 2138 000000 ZZ=0 + 2139 + 2140 A13200: REPEAT ^D36, + 2141 <;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2142 ;TO AN AC OF ALL ZEROS IS ADDED A + 2143 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2144 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2145 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2146 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2147 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2148 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2149 ;EVERY BIT OF THE AC. + 2150 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2151 SN=SN+1 + 2152 ZZ=ZZ+ZZ + 2153 IFE ZZ, + 2154 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2155 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2156 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2157 EQV [0] ;RESULTS IN C(AC)=0 + 2158 SKIPE ;PASS TEST IF C(AC)=0 + 2159 STOP + 2160 + 2161 ;********** + 2162 > + 2163 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2164 ;TO AN AC OF ALL ZEROS IS ADDED A + 2165 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2166 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2167 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2168 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2169 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2170 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2171 ;EVERY BIT OF THE AC. + 2172 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2173 013201 SN=SN+1 + 2174 000000 ZZ=ZZ+ZZ + 2175 000001 IFE ZZ, + 2176 031401 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2177 031402 270 00 0 00 035416 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2178 031403 444 00 0 00 035416 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2179 031404 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2180 031405 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2181 STOP^ + 2182 031406 254 04 0 00 031407 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2183 031407 324 00 0 00 031410 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2184 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2185 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2186 + 2187 ;********** + 2188 + 2189 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0071 + + 2190 ;TO AN AC OF ALL ZEROS IS ADDED A + 2191 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2192 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2193 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2194 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2195 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2196 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2197 ;EVERY BIT OF THE AC. + 2198 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2199 013202 SN=SN+1 + 2200 000002 ZZ=ZZ+ZZ + 2201 IFE ZZ, + 2202 031410 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2203 031411 270 00 0 00 035417 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2204 031412 444 00 0 00 035417 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2205 031413 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2206 031414 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2207 STOP^ + 2208 031415 254 04 0 00 031416 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2209 031416 324 00 0 00 031417 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2210 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2211 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2212 + 2213 ;********** + 2214 + 2215 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2216 ;TO AN AC OF ALL ZEROS IS ADDED A + 2217 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2218 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2219 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2220 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2221 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2222 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2223 ;EVERY BIT OF THE AC. + 2224 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2225 013203 SN=SN+1 + 2226 000004 ZZ=ZZ+ZZ + 2227 IFE ZZ, + 2228 031417 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2229 031420 270 00 0 00 035420 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2230 031421 444 00 0 00 035420 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2231 031422 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2232 031423 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2233 STOP^ + 2234 031424 254 04 0 00 031425 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2235 031425 324 00 0 00 031426 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2236 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2237 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2238 + 2239 ;********** + 2240 + 2241 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2242 ;TO AN AC OF ALL ZEROS IS ADDED A + 2243 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2244 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0072 + + 2245 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2246 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2247 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2248 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2249 ;EVERY BIT OF THE AC. + 2250 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2251 013204 SN=SN+1 + 2252 000010 ZZ=ZZ+ZZ + 2253 IFE ZZ, + 2254 031426 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2255 031427 270 00 0 00 035421 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2256 031430 444 00 0 00 035421 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2257 031431 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2258 031432 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2259 STOP^ + 2260 031433 254 04 0 00 031434 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2261 031434 324 00 0 00 031435 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2262 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2263 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2264 + 2265 ;********** + 2266 + 2267 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2268 ;TO AN AC OF ALL ZEROS IS ADDED A + 2269 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2270 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2271 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2272 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2273 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2274 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2275 ;EVERY BIT OF THE AC. + 2276 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2277 013205 SN=SN+1 + 2278 000020 ZZ=ZZ+ZZ + 2279 IFE ZZ, + 2280 031435 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2281 031436 270 00 0 00 035422 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2282 031437 444 00 0 00 035422 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2283 031440 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2284 031441 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2285 STOP^ + 2286 031442 254 04 0 00 031443 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2287 031443 324 00 0 00 031444 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2288 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2289 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2290 + 2291 ;********** + 2292 + 2293 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2294 ;TO AN AC OF ALL ZEROS IS ADDED A + 2295 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2296 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2297 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2298 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2299 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0073 + + 2300 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2301 ;EVERY BIT OF THE AC. + 2302 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2303 013206 SN=SN+1 + 2304 000040 ZZ=ZZ+ZZ + 2305 IFE ZZ, + 2306 031444 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2307 031445 270 00 0 00 035423 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2308 031446 444 00 0 00 035423 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2309 031447 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2310 031450 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2311 STOP^ + 2312 031451 254 04 0 00 031452 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2313 031452 324 00 0 00 031453 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2314 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2315 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2316 + 2317 ;********** + 2318 + 2319 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2320 ;TO AN AC OF ALL ZEROS IS ADDED A + 2321 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2322 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2323 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2324 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2325 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2326 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2327 ;EVERY BIT OF THE AC. + 2328 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2329 013207 SN=SN+1 + 2330 000100 ZZ=ZZ+ZZ + 2331 IFE ZZ, + 2332 031453 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2333 031454 270 00 0 00 035424 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2334 031455 444 00 0 00 035424 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2335 031456 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2336 031457 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2337 STOP^ + 2338 031460 254 04 0 00 031461 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2339 031461 324 00 0 00 031462 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2340 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2341 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2342 + 2343 ;********** + 2344 + 2345 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2346 ;TO AN AC OF ALL ZEROS IS ADDED A + 2347 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2348 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2349 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2350 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2351 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2352 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2353 ;EVERY BIT OF THE AC. + 2354 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0074 + + 2355 013210 SN=SN+1 + 2356 000200 ZZ=ZZ+ZZ + 2357 IFE ZZ, + 2358 031462 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2359 031463 270 00 0 00 035425 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2360 031464 444 00 0 00 035425 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2361 031465 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2362 031466 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2363 STOP^ + 2364 031467 254 04 0 00 031470 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2365 031470 324 00 0 00 031471 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2366 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2367 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2368 + 2369 ;********** + 2370 + 2371 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2372 ;TO AN AC OF ALL ZEROS IS ADDED A + 2373 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2374 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2375 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2376 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2377 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2378 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2379 ;EVERY BIT OF THE AC. + 2380 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2381 013211 SN=SN+1 + 2382 000400 ZZ=ZZ+ZZ + 2383 IFE ZZ, + 2384 031471 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2385 031472 270 00 0 00 035426 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2386 031473 444 00 0 00 035426 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2387 031474 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2388 031475 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2389 STOP^ + 2390 031476 254 04 0 00 031477 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2391 031477 324 00 0 00 031500 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2392 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2393 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2394 + 2395 ;********** + 2396 + 2397 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2398 ;TO AN AC OF ALL ZEROS IS ADDED A + 2399 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2400 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2401 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2402 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2403 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2404 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2405 ;EVERY BIT OF THE AC. + 2406 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2407 013212 SN=SN+1 + 2408 001000 ZZ=ZZ+ZZ + 2409 IFE ZZ, +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0075 + + 2410 031500 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2411 031501 270 00 0 00 035427 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2412 031502 444 00 0 00 035427 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2413 031503 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2414 031504 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2415 STOP^ + 2416 031505 254 04 0 00 031506 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2417 031506 324 00 0 00 031507 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2418 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2419 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2420 + 2421 ;********** + 2422 + 2423 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2424 ;TO AN AC OF ALL ZEROS IS ADDED A + 2425 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2426 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2427 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2428 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2429 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2430 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2431 ;EVERY BIT OF THE AC. + 2432 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2433 013213 SN=SN+1 + 2434 002000 ZZ=ZZ+ZZ + 2435 IFE ZZ, + 2436 031507 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2437 031510 270 00 0 00 035430 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2438 031511 444 00 0 00 035430 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2439 031512 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2440 031513 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2441 STOP^ + 2442 031514 254 04 0 00 031515 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2443 031515 324 00 0 00 031516 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2444 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2445 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2446 + 2447 ;********** + 2448 + 2449 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2450 ;TO AN AC OF ALL ZEROS IS ADDED A + 2451 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2452 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2453 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2454 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2455 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2456 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2457 ;EVERY BIT OF THE AC. + 2458 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2459 013214 SN=SN+1 + 2460 004000 ZZ=ZZ+ZZ + 2461 IFE ZZ, + 2462 031516 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2463 031517 270 00 0 00 035431 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2464 031520 444 00 0 00 035431 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0076 + + 2465 031521 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2466 031522 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2467 STOP^ + 2468 031523 254 04 0 00 031524 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2469 031524 324 00 0 00 031525 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2470 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2471 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2472 + 2473 ;********** + 2474 + 2475 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2476 ;TO AN AC OF ALL ZEROS IS ADDED A + 2477 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2478 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2479 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2480 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2481 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2482 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2483 ;EVERY BIT OF THE AC. + 2484 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2485 013215 SN=SN+1 + 2486 010000 ZZ=ZZ+ZZ + 2487 IFE ZZ, + 2488 031525 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2489 031526 270 00 0 00 035432 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2490 031527 444 00 0 00 035432 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2491 031530 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2492 031531 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2493 STOP^ + 2494 031532 254 04 0 00 031533 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2495 031533 324 00 0 00 031534 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2496 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2497 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2498 + 2499 ;********** + 2500 + 2501 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2502 ;TO AN AC OF ALL ZEROS IS ADDED A + 2503 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2504 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2505 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2506 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2507 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2508 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2509 ;EVERY BIT OF THE AC. + 2510 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2511 013216 SN=SN+1 + 2512 020000 ZZ=ZZ+ZZ + 2513 IFE ZZ, + 2514 031534 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2515 031535 270 00 0 00 035433 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2516 031536 444 00 0 00 035433 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2517 031537 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2518 031540 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2519 STOP^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-7 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0077 + + 2520 031541 254 04 0 00 031542 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2521 031542 324 00 0 00 031543 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2522 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2523 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2524 + 2525 ;********** + 2526 + 2527 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2528 ;TO AN AC OF ALL ZEROS IS ADDED A + 2529 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2530 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2531 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2532 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2533 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2534 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2535 ;EVERY BIT OF THE AC. + 2536 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2537 013217 SN=SN+1 + 2538 040000 ZZ=ZZ+ZZ + 2539 IFE ZZ, + 2540 031543 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2541 031544 270 00 0 00 035434 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2542 031545 444 00 0 00 035434 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2543 031546 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2544 031547 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2545 STOP^ + 2546 031550 254 04 0 00 031551 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2547 031551 324 00 0 00 031552 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2548 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2549 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2550 + 2551 ;********** + 2552 + 2553 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2554 ;TO AN AC OF ALL ZEROS IS ADDED A + 2555 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2556 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2557 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2558 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2559 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2560 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2561 ;EVERY BIT OF THE AC. + 2562 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2563 013220 SN=SN+1 + 2564 100000 ZZ=ZZ+ZZ + 2565 IFE ZZ, + 2566 031552 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2567 031553 270 00 0 00 035435 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2568 031554 444 00 0 00 035435 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2569 031555 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2570 031556 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2571 STOP^ + 2572 031557 254 04 0 00 031560 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2573 031560 324 00 0 00 031561 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2574 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-8 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0078 + + 2575 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2576 + 2577 ;********** + 2578 + 2579 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2580 ;TO AN AC OF ALL ZEROS IS ADDED A + 2581 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2582 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2583 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2584 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2585 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2586 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2587 ;EVERY BIT OF THE AC. + 2588 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2589 013221 SN=SN+1 + 2590 200000 ZZ=ZZ+ZZ + 2591 IFE ZZ, + 2592 031561 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2593 031562 270 00 0 00 035436 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2594 031563 444 00 0 00 035436 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2595 031564 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2596 031565 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2597 STOP^ + 2598 031566 254 04 0 00 031567 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2599 031567 324 00 0 00 031570 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2600 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2601 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2602 + 2603 ;********** + 2604 + 2605 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2606 ;TO AN AC OF ALL ZEROS IS ADDED A + 2607 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2608 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2609 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2610 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2611 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2612 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2613 ;EVERY BIT OF THE AC. + 2614 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2615 013222 SN=SN+1 + 2616 400000 ZZ=ZZ+ZZ + 2617 IFE ZZ, + 2618 031570 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2619 031571 270 00 0 00 035437 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2620 031572 444 00 0 00 035437 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2621 031573 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2622 031574 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2623 STOP^ + 2624 031575 254 04 0 00 031576 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2625 031576 324 00 0 00 031577 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2626 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2627 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2628 + 2629 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-9 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0079 + + 2630 + 2631 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2632 ;TO AN AC OF ALL ZEROS IS ADDED A + 2633 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2634 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2635 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2636 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2637 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2638 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2639 ;EVERY BIT OF THE AC. + 2640 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2641 013223 SN=SN+1 + 2642 000001 000000 ZZ=ZZ+ZZ + 2643 IFE ZZ, + 2644 031577 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2645 031600 270 00 0 00 035440 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2646 031601 444 00 0 00 035440 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2647 031602 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2648 031603 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2649 STOP^ + 2650 031604 254 04 0 00 031605 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2651 031605 324 00 0 00 031606 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2652 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2653 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2654 + 2655 ;********** + 2656 + 2657 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2658 ;TO AN AC OF ALL ZEROS IS ADDED A + 2659 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2660 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2661 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2662 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2663 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2664 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2665 ;EVERY BIT OF THE AC. + 2666 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2667 013224 SN=SN+1 + 2668 000002 000000 ZZ=ZZ+ZZ + 2669 IFE ZZ, + 2670 031606 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2671 031607 270 00 0 00 035441 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2672 031610 444 00 0 00 035441 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2673 031611 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2674 031612 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2675 STOP^ + 2676 031613 254 04 0 00 031614 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2677 031614 324 00 0 00 031615 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2678 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2679 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2680 + 2681 ;********** + 2682 + 2683 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2684 ;TO AN AC OF ALL ZEROS IS ADDED A +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-10 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0080 + + 2685 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2686 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2687 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2688 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2689 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2690 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2691 ;EVERY BIT OF THE AC. + 2692 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2693 013225 SN=SN+1 + 2694 000004 000000 ZZ=ZZ+ZZ + 2695 IFE ZZ, + 2696 031615 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2697 031616 270 00 0 00 035442 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2698 031617 444 00 0 00 035442 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2699 031620 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2700 031621 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2701 STOP^ + 2702 031622 254 04 0 00 031623 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2703 031623 324 00 0 00 031624 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2704 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2705 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2706 + 2707 ;********** + 2708 + 2709 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2710 ;TO AN AC OF ALL ZEROS IS ADDED A + 2711 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2712 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2713 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2714 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2715 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2716 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2717 ;EVERY BIT OF THE AC. + 2718 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2719 013226 SN=SN+1 + 2720 000010 000000 ZZ=ZZ+ZZ + 2721 IFE ZZ, + 2722 031624 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2723 031625 270 00 0 00 035443 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2724 031626 444 00 0 00 035443 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2725 031627 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2726 031630 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2727 STOP^ + 2728 031631 254 04 0 00 031632 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2729 031632 324 00 0 00 031633 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2730 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2731 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2732 + 2733 ;********** + 2734 + 2735 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2736 ;TO AN AC OF ALL ZEROS IS ADDED A + 2737 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2738 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2739 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-11 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0081 + + 2740 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2741 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2742 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2743 ;EVERY BIT OF THE AC. + 2744 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2745 013227 SN=SN+1 + 2746 000020 000000 ZZ=ZZ+ZZ + 2747 IFE ZZ, + 2748 031633 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2749 031634 270 00 0 00 035444 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2750 031635 444 00 0 00 035444 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2751 031636 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2752 031637 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2753 STOP^ + 2754 031640 254 04 0 00 031641 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2755 031641 324 00 0 00 031642 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2756 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2757 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2758 + 2759 ;********** + 2760 + 2761 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2762 ;TO AN AC OF ALL ZEROS IS ADDED A + 2763 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2764 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2765 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2766 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2767 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2768 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2769 ;EVERY BIT OF THE AC. + 2770 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2771 013230 SN=SN+1 + 2772 000040 000000 ZZ=ZZ+ZZ + 2773 IFE ZZ, + 2774 031642 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2775 031643 270 00 0 00 035445 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2776 031644 444 00 0 00 035445 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2777 031645 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2778 031646 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2779 STOP^ + 2780 031647 254 04 0 00 031650 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2781 031650 324 00 0 00 031651 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2782 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2783 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2784 + 2785 ;********** + 2786 + 2787 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2788 ;TO AN AC OF ALL ZEROS IS ADDED A + 2789 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2790 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2791 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2792 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2793 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2794 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-12 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0082 + + 2795 ;EVERY BIT OF THE AC. + 2796 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2797 013231 SN=SN+1 + 2798 000100 000000 ZZ=ZZ+ZZ + 2799 IFE ZZ, + 2800 031651 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2801 031652 270 00 0 00 035446 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2802 031653 444 00 0 00 035446 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2803 031654 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2804 031655 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2805 STOP^ + 2806 031656 254 04 0 00 031657 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2807 031657 324 00 0 00 031660 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2808 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2809 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2810 + 2811 ;********** + 2812 + 2813 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2814 ;TO AN AC OF ALL ZEROS IS ADDED A + 2815 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2816 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2817 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2818 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2819 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2820 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2821 ;EVERY BIT OF THE AC. + 2822 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2823 013232 SN=SN+1 + 2824 000200 000000 ZZ=ZZ+ZZ + 2825 IFE ZZ, + 2826 031660 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2827 031661 270 00 0 00 035447 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2828 031662 444 00 0 00 035447 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2829 031663 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2830 031664 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2831 STOP^ + 2832 031665 254 04 0 00 031666 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2833 031666 324 00 0 00 031667 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2834 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2835 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2836 + 2837 ;********** + 2838 + 2839 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2840 ;TO AN AC OF ALL ZEROS IS ADDED A + 2841 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2842 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2843 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2844 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2845 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2846 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2847 ;EVERY BIT OF THE AC. + 2848 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2849 013233 SN=SN+1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-13 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0083 + + 2850 000400 000000 ZZ=ZZ+ZZ + 2851 IFE ZZ, + 2852 031667 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2853 031670 270 00 0 00 035450 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2854 031671 444 00 0 00 035450 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2855 031672 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2856 031673 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2857 STOP^ + 2858 031674 254 04 0 00 031675 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2859 031675 324 00 0 00 031676 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2860 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2861 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2862 + 2863 ;********** + 2864 + 2865 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2866 ;TO AN AC OF ALL ZEROS IS ADDED A + 2867 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2868 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2869 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2870 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2871 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2872 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2873 ;EVERY BIT OF THE AC. + 2874 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2875 013234 SN=SN+1 + 2876 001000 000000 ZZ=ZZ+ZZ + 2877 IFE ZZ, + 2878 031676 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2879 031677 270 00 0 00 035451 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2880 031700 444 00 0 00 035451 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2881 031701 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2882 031702 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2883 STOP^ + 2884 031703 254 04 0 00 031704 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2885 031704 324 00 0 00 031705 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2886 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2887 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2888 + 2889 ;********** + 2890 + 2891 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2892 ;TO AN AC OF ALL ZEROS IS ADDED A + 2893 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2894 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2895 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2896 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2897 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2898 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2899 ;EVERY BIT OF THE AC. + 2900 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2901 013235 SN=SN+1 + 2902 002000 000000 ZZ=ZZ+ZZ + 2903 IFE ZZ, + 2904 031705 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-14 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0084 + + 2905 031706 270 00 0 00 035452 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2906 031707 444 00 0 00 035452 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2907 031710 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2908 031711 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2909 STOP^ + 2910 031712 254 04 0 00 031713 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2911 031713 324 00 0 00 031714 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2912 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2913 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2914 + 2915 ;********** + 2916 + 2917 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2918 ;TO AN AC OF ALL ZEROS IS ADDED A + 2919 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2920 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2921 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2922 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2923 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2924 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2925 ;EVERY BIT OF THE AC. + 2926 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2927 013236 SN=SN+1 + 2928 004000 000000 ZZ=ZZ+ZZ + 2929 IFE ZZ, + 2930 031714 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2931 031715 270 00 0 00 035453 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2932 031716 444 00 0 00 035453 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2933 031717 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2934 031720 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2935 STOP^ + 2936 031721 254 04 0 00 031722 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2937 031722 324 00 0 00 031723 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2938 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2939 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2940 + 2941 ;********** + 2942 + 2943 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2944 ;TO AN AC OF ALL ZEROS IS ADDED A + 2945 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2946 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2947 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2948 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2949 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2950 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2951 ;EVERY BIT OF THE AC. + 2952 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2953 013237 SN=SN+1 + 2954 010000 000000 ZZ=ZZ+ZZ + 2955 IFE ZZ, + 2956 031723 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2957 031724 270 00 0 00 035454 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2958 031725 444 00 0 00 035454 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2959 031726 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-15 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0085 + + 2960 031727 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2961 STOP^ + 2962 031730 254 04 0 00 031731 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2963 031731 324 00 0 00 031732 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2964 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2965 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2966 + 2967 ;********** + 2968 + 2969 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2970 ;TO AN AC OF ALL ZEROS IS ADDED A + 2971 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2972 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2973 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 2974 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 2975 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 2976 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 2977 ;EVERY BIT OF THE AC. + 2978 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 2979 013240 SN=SN+1 + 2980 020000 000000 ZZ=ZZ+ZZ + 2981 IFE ZZ, + 2982 031732 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 2983 031733 270 00 0 00 035455 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 2984 031734 444 00 0 00 035455 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 2985 031735 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 2986 031736 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 2987 STOP^ + 2988 031737 254 04 0 00 031740 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2989 031740 324 00 0 00 031741 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2990 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2991 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2992 + 2993 ;********** + 2994 + 2995 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 2996 ;TO AN AC OF ALL ZEROS IS ADDED A + 2997 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 2998 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 2999 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 3000 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 3001 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 3002 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 3003 ;EVERY BIT OF THE AC. + 3004 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 3005 013241 SN=SN+1 + 3006 040000 000000 ZZ=ZZ+ZZ + 3007 IFE ZZ, + 3008 031741 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 3009 031742 270 00 0 00 035456 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 3010 031743 444 00 0 00 035456 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 3011 031744 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3012 031745 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3013 STOP^ + 3014 031746 254 04 0 00 031747 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-16 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0086 + + 3015 031747 324 00 0 00 031750 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3016 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3017 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3018 + 3019 ;********** + 3020 + 3021 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 3022 ;TO AN AC OF ALL ZEROS IS ADDED A + 3023 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 3024 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 3025 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 3026 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 3027 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 3028 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 3029 ;EVERY BIT OF THE AC. + 3030 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 3031 013242 SN=SN+1 + 3032 100000 000000 ZZ=ZZ+ZZ + 3033 IFE ZZ, + 3034 031750 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 3035 031751 270 00 0 00 035457 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 3036 031752 444 00 0 00 035457 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 3037 031753 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3038 031754 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3039 STOP^ + 3040 031755 254 04 0 00 031756 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3041 031756 324 00 0 00 031757 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3042 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3043 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3044 + 3045 ;********** + 3046 + 3047 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 3048 ;TO AN AC OF ALL ZEROS IS ADDED A + 3049 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 3050 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 3051 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 3052 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 3053 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 3054 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 3055 ;EVERY BIT OF THE AC. + 3056 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 3057 013243 SN=SN+1 + 3058 200000 000000 ZZ=ZZ+ZZ + 3059 IFE ZZ, + 3060 031757 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 3061 031760 270 00 0 00 035460 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 3062 031761 444 00 0 00 035460 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 3063 031762 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3064 031763 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3065 STOP^ + 3066 031764 254 04 0 00 031765 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3067 031765 324 00 0 00 031766 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3068 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3069 ;IN THE SUBTEST) TO LOOP ON ERROR^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-17 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0087 + + 3070 + 3071 ;********** + 3072 + 3073 ;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. + 3074 ;TO AN AC OF ALL ZEROS IS ADDED A + 3075 ;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, + 3076 ;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. + 3077 ;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD + 3078 ;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. + 3079 ;THE FINAL RESULT SHOULD BE C(AC)=0. THIS + 3080 ;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH + 3081 ;EVERY BIT OF THE AC. + 3082 ;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. + 3083 013244 SN=SN+1 + 3084 400000 000000 ZZ=ZZ+ZZ + 3085 IFE ZZ, + 3086 031766 200 00 0 00 035412 MOVE [0] ;LOAD AC WITH ALL ZEROS + 3087 031767 270 00 0 00 035461 ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + 3088 031770 444 00 0 00 035461 EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + 3089 031771 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3090 031772 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3091 STOP^ + 3092 031773 254 04 0 00 031774 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3093 031774 324 00 0 00 031775 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3094 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3095 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3096 + 3097 ;********** + 3098 + 3099 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-18 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0088 + + 3100 ;ADD A RIPPLED ONE TO A RIPPLED ONE + 3101 + 3102 011200 SN=11200 + 3103 000000 ZZ=0 + 3104 + 3105 A11200: REPEAT ^D35, + 3106 <;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3107 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3108 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3109 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3110 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3111 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3112 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3113 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3114 ;BITS 1 THRU 35 OF BOTH AC AND E + 3115 SN=SN+1 + 3116 ZZ=ZZ+ZZ + 3117 IFE ZZ, + 3118 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3119 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3120 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3121 EQV [0] ;RESULTS IN C(AC)=0 + 3122 SKIPE ;PASS TEST IF C(AC)=0 + 3123 STOP + 3124 + 3125 ;********** + 3126 > + 3127 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3128 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3129 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3130 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3131 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3132 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3133 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3134 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3135 ;BITS 1 THRU 35 OF BOTH AC AND E + 3136 011201 SN=SN+1 + 3137 000000 ZZ=ZZ+ZZ + 3138 000001 IFE ZZ, + 3139 031775 200 00 0 00 035416 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3140 031776 270 00 0 00 035416 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3141 031777 444 00 0 00 035417 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3142 032000 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3143 032001 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3144 STOP^ + 3145 032002 254 04 0 00 032003 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3146 032003 324 00 0 00 032004 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3147 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3148 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3149 + 3150 ;********** + 3151 + 3152 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3153 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3154 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-19 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0089 + + 3155 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3156 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3157 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3158 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3159 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3160 ;BITS 1 THRU 35 OF BOTH AC AND E + 3161 011202 SN=SN+1 + 3162 000002 ZZ=ZZ+ZZ + 3163 IFE ZZ, + 3164 032004 200 00 0 00 035417 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3165 032005 270 00 0 00 035417 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3166 032006 444 00 0 00 035420 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3167 032007 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3168 032010 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3169 STOP^ + 3170 032011 254 04 0 00 032012 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3171 032012 324 00 0 00 032013 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 + 3177 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3178 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3179 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3180 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3181 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3182 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3183 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3184 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3185 ;BITS 1 THRU 35 OF BOTH AC AND E + 3186 011203 SN=SN+1 + 3187 000004 ZZ=ZZ+ZZ + 3188 IFE ZZ, + 3189 032013 200 00 0 00 035420 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3190 032014 270 00 0 00 035420 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3191 032015 444 00 0 00 035421 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3192 032016 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3193 032017 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3194 STOP^ + 3195 032020 254 04 0 00 032021 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3196 032021 324 00 0 00 032022 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3197 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3198 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3199 + 3200 ;********** + 3201 + 3202 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3203 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3204 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3205 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3206 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3207 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3208 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3209 ;SO THAT A ONE WILL BE FLOATED THROUGH +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-20 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0090 + + 3210 ;BITS 1 THRU 35 OF BOTH AC AND E + 3211 011204 SN=SN+1 + 3212 000010 ZZ=ZZ+ZZ + 3213 IFE ZZ, + 3214 032022 200 00 0 00 035421 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3215 032023 270 00 0 00 035421 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3216 032024 444 00 0 00 035422 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3217 032025 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3218 032026 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3219 STOP^ + 3220 032027 254 04 0 00 032030 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3221 032030 324 00 0 00 032031 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3222 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3223 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3224 + 3225 ;********** + 3226 + 3227 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3228 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3229 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3230 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3231 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3232 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3233 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3234 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3235 ;BITS 1 THRU 35 OF BOTH AC AND E + 3236 011205 SN=SN+1 + 3237 000020 ZZ=ZZ+ZZ + 3238 IFE ZZ, + 3239 032031 200 00 0 00 035422 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3240 032032 270 00 0 00 035422 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3241 032033 444 00 0 00 035423 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3242 032034 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3243 032035 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3244 STOP^ + 3245 032036 254 04 0 00 032037 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3246 032037 324 00 0 00 032040 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3247 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3248 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3249 + 3250 ;********** + 3251 + 3252 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3253 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3254 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3255 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3256 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3257 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3258 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3259 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3260 ;BITS 1 THRU 35 OF BOTH AC AND E + 3261 011206 SN=SN+1 + 3262 000040 ZZ=ZZ+ZZ + 3263 IFE ZZ, + 3264 032040 200 00 0 00 035423 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-21 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0091 + + 3265 032041 270 00 0 00 035423 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3266 032042 444 00 0 00 035424 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3267 032043 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3268 032044 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3269 STOP^ + 3270 032045 254 04 0 00 032046 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3271 032046 324 00 0 00 032047 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3272 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3273 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3274 + 3275 ;********** + 3276 + 3277 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3278 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3279 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3280 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3281 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3282 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3283 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3284 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3285 ;BITS 1 THRU 35 OF BOTH AC AND E + 3286 011207 SN=SN+1 + 3287 000100 ZZ=ZZ+ZZ + 3288 IFE ZZ, + 3289 032047 200 00 0 00 035424 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3290 032050 270 00 0 00 035424 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3291 032051 444 00 0 00 035425 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3292 032052 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3293 032053 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3294 STOP^ + 3295 032054 254 04 0 00 032055 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3296 032055 324 00 0 00 032056 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3297 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3298 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3299 + 3300 ;********** + 3301 + 3302 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3303 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3304 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3305 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3306 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3307 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3308 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3309 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3310 ;BITS 1 THRU 35 OF BOTH AC AND E + 3311 011210 SN=SN+1 + 3312 000200 ZZ=ZZ+ZZ + 3313 IFE ZZ, + 3314 032056 200 00 0 00 035425 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3315 032057 270 00 0 00 035425 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3316 032060 444 00 0 00 035426 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3317 032061 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3318 032062 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3319 STOP^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-22 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0092 + + 3320 032063 254 04 0 00 032064 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3321 032064 324 00 0 00 032065 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3322 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3323 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3324 + 3325 ;********** + 3326 + 3327 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3328 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3329 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3330 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3331 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3332 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3333 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3334 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3335 ;BITS 1 THRU 35 OF BOTH AC AND E + 3336 011211 SN=SN+1 + 3337 000400 ZZ=ZZ+ZZ + 3338 IFE ZZ, + 3339 032065 200 00 0 00 035426 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3340 032066 270 00 0 00 035426 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3341 032067 444 00 0 00 035427 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3342 032070 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3343 032071 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3344 STOP^ + 3345 032072 254 04 0 00 032073 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3346 032073 324 00 0 00 032074 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 + 3352 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3353 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3354 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3355 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3356 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3357 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3358 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3359 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3360 ;BITS 1 THRU 35 OF BOTH AC AND E + 3361 011212 SN=SN+1 + 3362 001000 ZZ=ZZ+ZZ + 3363 IFE ZZ, + 3364 032074 200 00 0 00 035427 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3365 032075 270 00 0 00 035427 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3366 032076 444 00 0 00 035430 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3367 032077 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3368 032100 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3369 STOP^ + 3370 032101 254 04 0 00 032102 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3371 032102 324 00 0 00 032103 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3372 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3373 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3374 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-23 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0093 + + 3375 ;********** + 3376 + 3377 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3378 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3379 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3380 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3381 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3382 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3383 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3384 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3385 ;BITS 1 THRU 35 OF BOTH AC AND E + 3386 011213 SN=SN+1 + 3387 002000 ZZ=ZZ+ZZ + 3388 IFE ZZ, + 3389 032103 200 00 0 00 035430 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3390 032104 270 00 0 00 035430 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3391 032105 444 00 0 00 035431 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3392 032106 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3393 032107 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3394 STOP^ + 3395 032110 254 04 0 00 032111 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3396 032111 324 00 0 00 032112 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3397 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3398 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3399 + 3400 ;********** + 3401 + 3402 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3403 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3404 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3405 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3406 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3407 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3408 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3409 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3410 ;BITS 1 THRU 35 OF BOTH AC AND E + 3411 011214 SN=SN+1 + 3412 004000 ZZ=ZZ+ZZ + 3413 IFE ZZ, + 3414 032112 200 00 0 00 035431 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3415 032113 270 00 0 00 035431 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3416 032114 444 00 0 00 035432 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3417 032115 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3418 032116 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3419 STOP^ + 3420 032117 254 04 0 00 032120 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3421 032120 324 00 0 00 032121 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3422 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3423 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3424 + 3425 ;********** + 3426 + 3427 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3428 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3429 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-24 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0094 + + 3430 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3431 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3432 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3433 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3434 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3435 ;BITS 1 THRU 35 OF BOTH AC AND E + 3436 011215 SN=SN+1 + 3437 010000 ZZ=ZZ+ZZ + 3438 IFE ZZ, + 3439 032121 200 00 0 00 035432 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3440 032122 270 00 0 00 035432 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3441 032123 444 00 0 00 035433 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3442 032124 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3443 032125 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3444 STOP^ + 3445 032126 254 04 0 00 032127 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3446 032127 324 00 0 00 032130 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3447 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3448 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3449 + 3450 ;********** + 3451 + 3452 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3453 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3454 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3455 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3456 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3457 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3458 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3459 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3460 ;BITS 1 THRU 35 OF BOTH AC AND E + 3461 011216 SN=SN+1 + 3462 020000 ZZ=ZZ+ZZ + 3463 IFE ZZ, + 3464 032130 200 00 0 00 035433 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3465 032131 270 00 0 00 035433 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3466 032132 444 00 0 00 035434 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3467 032133 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3468 032134 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3469 STOP^ + 3470 032135 254 04 0 00 032136 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3471 032136 324 00 0 00 032137 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3472 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3473 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3474 + 3475 ;********** + 3476 + 3477 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3478 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3479 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3480 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3481 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3482 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3483 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3484 ;SO THAT A ONE WILL BE FLOATED THROUGH +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-25 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0095 + + 3485 ;BITS 1 THRU 35 OF BOTH AC AND E + 3486 011217 SN=SN+1 + 3487 040000 ZZ=ZZ+ZZ + 3488 IFE ZZ, + 3489 032137 200 00 0 00 035434 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3490 032140 270 00 0 00 035434 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3491 032141 444 00 0 00 035435 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3492 032142 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3493 032143 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3494 STOP^ + 3495 032144 254 04 0 00 032145 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3496 032145 324 00 0 00 032146 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3497 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3498 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3499 + 3500 ;********** + 3501 + 3502 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3503 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3504 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3505 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3506 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3507 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3508 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3509 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3510 ;BITS 1 THRU 35 OF BOTH AC AND E + 3511 011220 SN=SN+1 + 3512 100000 ZZ=ZZ+ZZ + 3513 IFE ZZ, + 3514 032146 200 00 0 00 035435 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3515 032147 270 00 0 00 035435 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3516 032150 444 00 0 00 035436 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3517 032151 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3518 032152 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3519 STOP^ + 3520 032153 254 04 0 00 032154 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3521 032154 324 00 0 00 032155 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3522 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3523 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3524 + 3525 ;********** + 3526 + 3527 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3528 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3529 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3530 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3531 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3532 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3533 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3534 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3535 ;BITS 1 THRU 35 OF BOTH AC AND E + 3536 011221 SN=SN+1 + 3537 200000 ZZ=ZZ+ZZ + 3538 IFE ZZ, + 3539 032155 200 00 0 00 035436 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-26 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0096 + + 3540 032156 270 00 0 00 035436 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3541 032157 444 00 0 00 035437 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3542 032160 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3543 032161 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3544 STOP^ + 3545 032162 254 04 0 00 032163 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3546 032163 324 00 0 00 032164 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3547 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3548 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3549 + 3550 ;********** + 3551 + 3552 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3553 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3554 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3555 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3556 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3557 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3558 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3559 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3560 ;BITS 1 THRU 35 OF BOTH AC AND E + 3561 011222 SN=SN+1 + 3562 400000 ZZ=ZZ+ZZ + 3563 IFE ZZ, + 3564 032164 200 00 0 00 035437 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3565 032165 270 00 0 00 035437 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3566 032166 444 00 0 00 035440 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3567 032167 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3568 032170 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3569 STOP^ + 3570 032171 254 04 0 00 032172 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3571 032172 324 00 0 00 032173 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3572 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3573 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3574 + 3575 ;********** + 3576 + 3577 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3578 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3579 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3580 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3581 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3582 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3583 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3584 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3585 ;BITS 1 THRU 35 OF BOTH AC AND E + 3586 011223 SN=SN+1 + 3587 000001 000000 ZZ=ZZ+ZZ + 3588 IFE ZZ, + 3589 032173 200 00 0 00 035440 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3590 032174 270 00 0 00 035440 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3591 032175 444 00 0 00 035441 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3592 032176 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3593 032177 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3594 STOP^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-27 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0097 + + 3595 032200 254 04 0 00 032201 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3596 032201 324 00 0 00 032202 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3597 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3598 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3599 + 3600 ;********** + 3601 + 3602 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3603 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3604 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3605 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3606 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3607 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3608 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3609 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3610 ;BITS 1 THRU 35 OF BOTH AC AND E + 3611 011224 SN=SN+1 + 3612 000002 000000 ZZ=ZZ+ZZ + 3613 IFE ZZ, + 3614 032202 200 00 0 00 035441 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3615 032203 270 00 0 00 035441 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3616 032204 444 00 0 00 035442 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3617 032205 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3618 032206 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3619 STOP^ + 3620 032207 254 04 0 00 032210 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3621 032210 324 00 0 00 032211 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3622 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3623 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3624 + 3625 ;********** + 3626 + 3627 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3628 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3629 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3630 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3631 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3632 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3633 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3634 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3635 ;BITS 1 THRU 35 OF BOTH AC AND E + 3636 011225 SN=SN+1 + 3637 000004 000000 ZZ=ZZ+ZZ + 3638 IFE ZZ, + 3639 032211 200 00 0 00 035442 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3640 032212 270 00 0 00 035442 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3641 032213 444 00 0 00 035443 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3642 032214 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3643 032215 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3644 STOP^ + 3645 032216 254 04 0 00 032217 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3646 032217 324 00 0 00 032220 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3647 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3648 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3649 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-28 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0098 + + 3650 ;********** + 3651 + 3652 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3653 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3654 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3655 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3656 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3657 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3658 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3659 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3660 ;BITS 1 THRU 35 OF BOTH AC AND E + 3661 011226 SN=SN+1 + 3662 000010 000000 ZZ=ZZ+ZZ + 3663 IFE ZZ, + 3664 032220 200 00 0 00 035443 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3665 032221 270 00 0 00 035443 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3666 032222 444 00 0 00 035444 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3667 032223 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3668 032224 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3669 STOP^ + 3670 032225 254 04 0 00 032226 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3671 032226 324 00 0 00 032227 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3672 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3673 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3674 + 3675 ;********** + 3676 + 3677 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3678 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3679 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3680 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3681 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3682 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3683 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3684 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3685 ;BITS 1 THRU 35 OF BOTH AC AND E + 3686 011227 SN=SN+1 + 3687 000020 000000 ZZ=ZZ+ZZ + 3688 IFE ZZ, + 3689 032227 200 00 0 00 035444 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3690 032230 270 00 0 00 035444 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3691 032231 444 00 0 00 035445 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3692 032232 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3693 032233 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3694 STOP^ + 3695 032234 254 04 0 00 032235 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3696 032235 324 00 0 00 032236 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3697 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3698 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3699 + 3700 ;********** + 3701 + 3702 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3703 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3704 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-29 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0099 + + 3705 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3706 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3707 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3708 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3709 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3710 ;BITS 1 THRU 35 OF BOTH AC AND E + 3711 011230 SN=SN+1 + 3712 000040 000000 ZZ=ZZ+ZZ + 3713 IFE ZZ, + 3714 032236 200 00 0 00 035445 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3715 032237 270 00 0 00 035445 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3716 032240 444 00 0 00 035446 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3717 032241 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3718 032242 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3719 STOP^ + 3720 032243 254 04 0 00 032244 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3721 032244 324 00 0 00 032245 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3722 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3723 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3724 + 3725 ;********** + 3726 + 3727 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3728 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3729 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3730 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3731 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3732 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3733 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3734 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3735 ;BITS 1 THRU 35 OF BOTH AC AND E + 3736 011231 SN=SN+1 + 3737 000100 000000 ZZ=ZZ+ZZ + 3738 IFE ZZ, + 3739 032245 200 00 0 00 035446 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3740 032246 270 00 0 00 035446 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3741 032247 444 00 0 00 035447 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3742 032250 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3743 032251 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3744 STOP^ + 3745 032252 254 04 0 00 032253 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3746 032253 324 00 0 00 032254 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 + 3750 ;********** + 3751 + 3752 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3753 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3754 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3755 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3756 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3757 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3758 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3759 ;SO THAT A ONE WILL BE FLOATED THROUGH +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-30 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0100 + + 3760 ;BITS 1 THRU 35 OF BOTH AC AND E + 3761 011232 SN=SN+1 + 3762 000200 000000 ZZ=ZZ+ZZ + 3763 IFE ZZ, + 3764 032254 200 00 0 00 035447 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3765 032255 270 00 0 00 035447 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3766 032256 444 00 0 00 035450 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3767 032257 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3768 032260 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3769 STOP^ + 3770 032261 254 04 0 00 032262 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3771 032262 324 00 0 00 032263 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3772 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3773 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3774 + 3775 ;********** + 3776 + 3777 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3778 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3779 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3780 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3781 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3782 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3783 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3784 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3785 ;BITS 1 THRU 35 OF BOTH AC AND E + 3786 011233 SN=SN+1 + 3787 000400 000000 ZZ=ZZ+ZZ + 3788 IFE ZZ, + 3789 032263 200 00 0 00 035450 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3790 032264 270 00 0 00 035450 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3791 032265 444 00 0 00 035451 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3792 032266 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3793 032267 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3794 STOP^ + 3795 032270 254 04 0 00 032271 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3796 032271 324 00 0 00 032272 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3797 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3798 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3799 + 3800 ;********** + 3801 + 3802 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3803 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3804 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3805 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3806 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3807 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3808 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3809 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3810 ;BITS 1 THRU 35 OF BOTH AC AND E + 3811 011234 SN=SN+1 + 3812 001000 000000 ZZ=ZZ+ZZ + 3813 IFE ZZ, + 3814 032272 200 00 0 00 035451 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-31 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0101 + + 3815 032273 270 00 0 00 035451 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3816 032274 444 00 0 00 035452 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3817 032275 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3818 032276 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3819 STOP^ + 3820 032277 254 04 0 00 032300 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3821 032300 324 00 0 00 032301 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3822 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3823 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3824 + 3825 ;********** + 3826 + 3827 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3828 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3829 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3830 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3831 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3832 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3833 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3834 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3835 ;BITS 1 THRU 35 OF BOTH AC AND E + 3836 011235 SN=SN+1 + 3837 002000 000000 ZZ=ZZ+ZZ + 3838 IFE ZZ, + 3839 032301 200 00 0 00 035452 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3840 032302 270 00 0 00 035452 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3841 032303 444 00 0 00 035453 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3842 032304 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3843 032305 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3844 STOP^ + 3845 032306 254 04 0 00 032307 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3846 032307 324 00 0 00 032310 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3847 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3848 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3849 + 3850 ;********** + 3851 + 3852 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3853 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3854 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3855 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3856 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3857 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3858 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3859 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3860 ;BITS 1 THRU 35 OF BOTH AC AND E + 3861 011236 SN=SN+1 + 3862 004000 000000 ZZ=ZZ+ZZ + 3863 IFE ZZ, + 3864 032310 200 00 0 00 035453 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3865 032311 270 00 0 00 035453 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3866 032312 444 00 0 00 035454 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3867 032313 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3868 032314 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3869 STOP^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-32 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0102 + + 3870 032315 254 04 0 00 032316 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3871 032316 324 00 0 00 032317 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3872 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3873 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3874 + 3875 ;********** + 3876 + 3877 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3878 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3879 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3880 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3881 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3882 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3883 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3884 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3885 ;BITS 1 THRU 35 OF BOTH AC AND E + 3886 011237 SN=SN+1 + 3887 010000 000000 ZZ=ZZ+ZZ + 3888 IFE ZZ, + 3889 032317 200 00 0 00 035454 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3890 032320 270 00 0 00 035454 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3891 032321 444 00 0 00 035455 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3892 032322 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3893 032323 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3894 STOP^ + 3895 032324 254 04 0 00 032325 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3896 032325 324 00 0 00 032326 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3897 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3898 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3899 + 3900 ;********** + 3901 + 3902 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3903 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3904 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3905 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3906 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3907 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3908 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3909 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3910 ;BITS 1 THRU 35 OF BOTH AC AND E + 3911 011240 SN=SN+1 + 3912 020000 000000 ZZ=ZZ+ZZ + 3913 IFE ZZ, + 3914 032326 200 00 0 00 035455 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3915 032327 270 00 0 00 035455 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3916 032330 444 00 0 00 035456 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3917 032331 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3918 032332 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3919 STOP^ + 3920 032333 254 04 0 00 032334 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3921 032334 324 00 0 00 032335 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3922 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3923 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3924 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-33 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0103 + + 3925 ;********** + 3926 + 3927 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3928 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3929 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3930 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3931 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3932 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3933 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3934 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3935 ;BITS 1 THRU 35 OF BOTH AC AND E + 3936 011241 SN=SN+1 + 3937 040000 000000 ZZ=ZZ+ZZ + 3938 IFE ZZ, + 3939 032335 200 00 0 00 035456 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3940 032336 270 00 0 00 035456 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3941 032337 444 00 0 00 035457 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3942 032340 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3943 032341 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3944 STOP^ + 3945 032342 254 04 0 00 032343 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3946 032343 324 00 0 00 032344 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3947 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3948 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3949 + 3950 ;********** + 3951 + 3952 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3953 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3954 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN + 3955 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3956 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3957 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3958 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3959 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3960 ;BITS 1 THRU 35 OF BOTH AC AND E + 3961 011242 SN=SN+1 + 3962 100000 000000 ZZ=ZZ+ZZ + 3963 IFE ZZ, + 3964 032344 200 00 0 00 035457 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3965 032345 270 00 0 00 035457 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3966 032346 444 00 0 00 035460 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3967 032347 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3968 032350 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3969 STOP^ + 3970 032351 254 04 0 00 032352 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3971 032352 324 00 0 00 032353 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3972 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3973 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3974 + 3975 ;********** + 3976 + 3977 ;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) + 3978 ;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= + 3979 ;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 7-34 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0104 + + 3980 ;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A + 3981 ;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE + 3982 ;RESULT IN THE AC WILL BE ZERO AND THE TEST + 3983 ;WILL FAIL. THIS TEST IS REPEATED 35 TIMES + 3984 ;SO THAT A ONE WILL BE FLOATED THROUGH + 3985 ;BITS 1 THRU 35 OF BOTH AC AND E + 3986 011243 SN=SN+1 + 3987 200000 000000 ZZ=ZZ+ZZ + 3988 IFE ZZ, + 3989 032353 200 00 0 00 035460 MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + 3990 032354 270 00 0 00 035460 ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + 3991 032355 444 00 0 00 035461 EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + 3992 032356 444 00 0 00 035412 EQV [0] ;RESULTS IN C(AC)=0 + 3993 032357 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 3994 STOP^ + 3995 032360 254 04 0 00 032361 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3996 032361 324 00 0 00 032362 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3997 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3998 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3999 + 4000 ;********** + 4001 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0105 + + 4002 011300 SN=11300 + 4003 000000 ZZ=0 + 4004 000000 YY=0 + 4005 + 4006 A11300: REPEAT ^D18, + 4007 <;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4008 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4009 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4010 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4011 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4012 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4013 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4014 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4015 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4016 SN=SN+1 + 4017 YY=YY/2 + 4018 ZZ=ZZ+YY + 4019 IFE YY, + 4020 IFE ZZ, + 4021 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4022 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4023 ;POWER SHOULD RESULT IN C(AC)=0. + 4024 SKIPE ;PASS TEST IF C(AC)=0 + 4025 STOP + 4026 + 4027 ;********** + 4028 > + 4029 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4030 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4031 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4032 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4033 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4034 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4035 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4036 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4037 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4038 011301 SN=SN+1 + 4039 000000 YY=YY/2 + 4040 000000 ZZ=ZZ+YY + 4041 400000 IFE YY, + 4042 400000 IFE ZZ, + 4043 032362 200 00 0 00 035461 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4044 032363 270 00 0 00 035461 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4045 ;POWER SHOULD RESULT IN C(AC)=0. + 4046 032364 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4047 STOP^ + 4048 032365 254 04 0 00 032366 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4049 032366 324 00 0 00 032367 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4050 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4051 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4052 + 4053 ;********** + 4054 + 4055 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4056 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0106 + + 4057 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4058 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4059 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4060 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4061 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4062 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4063 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4064 011302 SN=SN+1 + 4065 200000 YY=YY/2 + 4066 600000 ZZ=ZZ+YY + 4067 IFE YY, + 4068 IFE ZZ, + 4069 032367 200 00 0 00 035462 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4070 032370 270 00 0 00 035460 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4071 ;POWER SHOULD RESULT IN C(AC)=0. + 4072 032371 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4073 STOP^ + 4074 032372 254 04 0 00 032373 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4075 032373 324 00 0 00 032374 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4076 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4077 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4078 + 4079 ;********** + 4080 + 4081 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4082 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4083 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4084 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4085 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4086 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4087 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4088 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4089 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4090 011303 SN=SN+1 + 4091 100000 YY=YY/2 + 4092 700000 ZZ=ZZ+YY + 4093 IFE YY, + 4094 IFE ZZ, + 4095 032374 200 00 0 00 035463 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4096 032375 270 00 0 00 035457 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4097 ;POWER SHOULD RESULT IN C(AC)=0. + 4098 032376 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4099 STOP^ + 4100 032377 254 04 0 00 032400 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4101 032400 324 00 0 00 032401 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4102 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4103 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4104 + 4105 ;********** + 4106 + 4107 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4108 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4109 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4110 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4111 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0107 + + 4112 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4113 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4114 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4115 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4116 011304 SN=SN+1 + 4117 040000 YY=YY/2 + 4118 740000 ZZ=ZZ+YY + 4119 IFE YY, + 4120 IFE ZZ, + 4121 032401 200 00 0 00 035464 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4122 032402 270 00 0 00 035456 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4123 ;POWER SHOULD RESULT IN C(AC)=0. + 4124 032403 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4125 STOP^ + 4126 032404 254 04 0 00 032405 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4127 032405 324 00 0 00 032406 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4128 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4129 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4130 + 4131 ;********** + 4132 + 4133 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4134 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4135 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4136 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4137 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4138 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4139 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4140 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4141 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4142 011305 SN=SN+1 + 4143 020000 YY=YY/2 + 4144 760000 ZZ=ZZ+YY + 4145 IFE YY, + 4146 IFE ZZ, + 4147 032406 200 00 0 00 035465 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4148 032407 270 00 0 00 035455 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4149 ;POWER SHOULD RESULT IN C(AC)=0. + 4150 032410 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4151 STOP^ + 4152 032411 254 04 0 00 032412 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4153 032412 324 00 0 00 032413 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4154 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4155 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4156 + 4157 ;********** + 4158 + 4159 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4160 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4161 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4162 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4163 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4164 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4165 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4166 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0108 + + 4167 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4168 011306 SN=SN+1 + 4169 010000 YY=YY/2 + 4170 770000 ZZ=ZZ+YY + 4171 IFE YY, + 4172 IFE ZZ, + 4173 032413 200 00 0 00 035466 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4174 032414 270 00 0 00 035454 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4175 ;POWER SHOULD RESULT IN C(AC)=0. + 4176 032415 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4177 STOP^ + 4178 032416 254 04 0 00 032417 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4179 032417 324 00 0 00 032420 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4180 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4181 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4182 + 4183 ;********** + 4184 + 4185 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4186 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4187 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4188 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4189 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4190 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4191 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4192 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4193 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4194 011307 SN=SN+1 + 4195 004000 YY=YY/2 + 4196 774000 ZZ=ZZ+YY + 4197 IFE YY, + 4198 IFE ZZ, + 4199 032420 200 00 0 00 035467 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4200 032421 270 00 0 00 035453 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4201 ;POWER SHOULD RESULT IN C(AC)=0. + 4202 032422 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4203 STOP^ + 4204 032423 254 04 0 00 032424 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4205 032424 324 00 0 00 032425 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4206 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4207 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4208 + 4209 ;********** + 4210 + 4211 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4212 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4213 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4214 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4215 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4216 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4217 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4218 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4219 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4220 011310 SN=SN+1 + 4221 002000 YY=YY/2 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0109 + + 4222 776000 ZZ=ZZ+YY + 4223 IFE YY, + 4224 IFE ZZ, + 4225 032425 200 00 0 00 035470 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4226 032426 270 00 0 00 035452 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4227 ;POWER SHOULD RESULT IN C(AC)=0. + 4228 032427 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4229 STOP^ + 4230 032430 254 04 0 00 032431 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4231 032431 324 00 0 00 032432 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4232 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4233 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4234 + 4235 ;********** + 4236 + 4237 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4238 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4239 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4240 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4241 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4242 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4243 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4244 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4245 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4246 011311 SN=SN+1 + 4247 001000 YY=YY/2 + 4248 777000 ZZ=ZZ+YY + 4249 IFE YY, + 4250 IFE ZZ, + 4251 032432 200 00 0 00 035471 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4252 032433 270 00 0 00 035451 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4253 ;POWER SHOULD RESULT IN C(AC)=0. + 4254 032434 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4255 STOP^ + 4256 032435 254 04 0 00 032436 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4257 032436 324 00 0 00 032437 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4258 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4259 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4260 + 4261 ;********** + 4262 + 4263 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4264 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4265 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4266 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4267 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4268 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4269 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4270 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4271 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4272 011312 SN=SN+1 + 4273 000400 YY=YY/2 + 4274 777400 ZZ=ZZ+YY + 4275 IFE YY, + 4276 IFE ZZ, +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0110 + + 4277 032437 200 00 0 00 035472 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4278 032440 270 00 0 00 035450 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4279 ;POWER SHOULD RESULT IN C(AC)=0. + 4280 032441 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4281 STOP^ + 4282 032442 254 04 0 00 032443 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4283 032443 324 00 0 00 032444 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4284 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4285 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4286 + 4287 ;********** + 4288 + 4289 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4290 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4291 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4292 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4293 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4294 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4295 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4296 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4297 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4298 011313 SN=SN+1 + 4299 000200 YY=YY/2 + 4300 777600 ZZ=ZZ+YY + 4301 IFE YY, + 4302 IFE ZZ, + 4303 032444 200 00 0 00 035473 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4304 032445 270 00 0 00 035447 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4305 ;POWER SHOULD RESULT IN C(AC)=0. + 4306 032446 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4307 STOP^ + 4308 032447 254 04 0 00 032450 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4309 032450 324 00 0 00 032451 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4310 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4311 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4312 + 4313 ;********** + 4314 + 4315 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4316 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4317 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4318 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4319 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4320 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4321 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4322 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4323 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4324 011314 SN=SN+1 + 4325 000100 YY=YY/2 + 4326 777700 ZZ=ZZ+YY + 4327 IFE YY, + 4328 IFE ZZ, + 4329 032451 200 00 0 00 035474 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4330 032452 270 00 0 00 035446 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4331 ;POWER SHOULD RESULT IN C(AC)=0. +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0111 + + 4332 032453 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4333 STOP^ + 4334 032454 254 04 0 00 032455 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4335 032455 324 00 0 00 032456 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4336 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4337 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4338 + 4339 ;********** + 4340 + 4341 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4342 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4343 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4344 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4345 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4346 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4347 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4348 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4349 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4350 011315 SN=SN+1 + 4351 000040 YY=YY/2 + 4352 777740 ZZ=ZZ+YY + 4353 IFE YY, + 4354 IFE ZZ, + 4355 032456 200 00 0 00 035475 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4356 032457 270 00 0 00 035445 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4357 ;POWER SHOULD RESULT IN C(AC)=0. + 4358 032460 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4359 STOP^ + 4360 032461 254 04 0 00 032462 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4361 032462 324 00 0 00 032463 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4362 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4363 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4364 + 4365 ;********** + 4366 + 4367 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4368 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4369 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4370 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4371 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4372 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4373 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4374 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4375 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4376 011316 SN=SN+1 + 4377 000020 YY=YY/2 + 4378 777760 ZZ=ZZ+YY + 4379 IFE YY, + 4380 IFE ZZ, + 4381 032463 200 00 0 00 035476 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4382 032464 270 00 0 00 035444 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4383 ;POWER SHOULD RESULT IN C(AC)=0. + 4384 032465 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4385 STOP^ + 4386 032466 254 04 0 00 032467 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-7 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0112 + + 4387 032467 324 00 0 00 032470 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4388 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4389 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4390 + 4391 ;********** + 4392 + 4393 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4394 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4395 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4396 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4397 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4398 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4399 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4400 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4401 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4402 011317 SN=SN+1 + 4403 000010 YY=YY/2 + 4404 777770 ZZ=ZZ+YY + 4405 IFE YY, + 4406 IFE ZZ, + 4407 032470 200 00 0 00 035477 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4408 032471 270 00 0 00 035443 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4409 ;POWER SHOULD RESULT IN C(AC)=0. + 4410 032472 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4411 STOP^ + 4412 032473 254 04 0 00 032474 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4413 032474 324 00 0 00 032475 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4414 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4415 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4416 + 4417 ;********** + 4418 + 4419 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4420 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4421 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4422 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4423 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4424 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4425 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4426 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4427 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4428 011320 SN=SN+1 + 4429 000004 YY=YY/2 + 4430 777774 ZZ=ZZ+YY + 4431 IFE YY, + 4432 IFE ZZ, + 4433 032475 200 00 0 00 035500 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4434 032476 270 00 0 00 035442 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4435 ;POWER SHOULD RESULT IN C(AC)=0. + 4436 032477 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4437 STOP^ + 4438 032500 254 04 0 00 032501 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4439 032501 324 00 0 00 032502 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4440 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4441 ;IN THE SUBTEST) TO LOOP ON ERROR^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-8 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0113 + + 4442 + 4443 ;********** + 4444 + 4445 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4446 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4447 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4448 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4449 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4450 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4451 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4452 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4453 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4454 011321 SN=SN+1 + 4455 000002 YY=YY/2 + 4456 777776 ZZ=ZZ+YY + 4457 IFE YY, + 4458 IFE ZZ, + 4459 032502 200 00 0 00 035501 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4460 032503 270 00 0 00 035441 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4461 ;POWER SHOULD RESULT IN C(AC)=0. + 4462 032504 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4463 STOP^ + 4464 032505 254 04 0 00 032506 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4465 032506 324 00 0 00 032507 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4466 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4467 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4468 + 4469 ;********** + 4470 + 4471 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4472 ;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4473 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4474 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE + 4475 ;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4476 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4477 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4478 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS + 4479 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4480 011322 SN=SN+1 + 4481 000001 YY=YY/2 + 4482 777777 ZZ=ZZ+YY + 4483 IFE YY, + 4484 IFE ZZ, + 4485 032507 200 00 0 00 035502 MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4486 032510 270 00 0 00 035440 ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4487 ;POWER SHOULD RESULT IN C(AC)=0. + 4488 032511 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 4489 STOP^ + 4490 032512 254 04 0 00 032513 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4491 032513 324 00 0 00 032514 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4492 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4493 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4494 + 4495 ;********** + 4496 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-9 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0114 + + 4497 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-10 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0115 + + 4498 011400 SN=11400 + 4499 000000 ZZ=0 + 4500 000000 YY=0 + 4501 + 4502 A11400: REPEAT ^D18, + 4503 <;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4504 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4505 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4506 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4507 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4508 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4509 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4510 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4511 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4512 SN=SN+1 + 4513 YY=YY/2 + 4514 ZZ=ZZ+YY + 4515 IFE YY, + 4516 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4517 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4518 ;POWER SHOULD RESULT IN C(AC)=0. + 4519 ADD [YY] ;PASS TEST IF C(AC)=0 + 4520 SKIPE + 4521 STOP + 4522 + 4523 ;********** + 4524 > + 4525 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4526 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4527 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4528 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4529 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4530 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4531 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4532 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4533 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4534 011401 SN=SN+1 + 4535 000000 YY=YY/2 + 4536 000000 ZZ=ZZ+YY + 4537 400000 IFE YY, + 4538 400000 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4539 032514 200 00 0 00 035503 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4540 ;POWER SHOULD RESULT IN C(AC)=0. + 4541 032515 270 00 0 00 035437 ADD [YY] ;PASS TEST IF C(AC)=0 + 4542 032516 332 00 0 00 000000 SKIPE + 4543 STOP^ + 4544 032517 254 04 0 00 032520 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4545 032520 324 00 0 00 032521 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4546 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4547 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4548 + 4549 ;********** + 4550 + 4551 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4552 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-11 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0116 + + 4553 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4554 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4555 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4556 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4557 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4558 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4559 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4560 011402 SN=SN+1 + 4561 200000 YY=YY/2 + 4562 600000 ZZ=ZZ+YY + 4563 IFE YY, + 4564 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4565 032521 200 00 0 00 035504 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4566 ;POWER SHOULD RESULT IN C(AC)=0. + 4567 032522 270 00 0 00 035436 ADD [YY] ;PASS TEST IF C(AC)=0 + 4568 032523 332 00 0 00 000000 SKIPE + 4569 STOP^ + 4570 032524 254 04 0 00 032525 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4571 032525 324 00 0 00 032526 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4572 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4573 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4574 + 4575 ;********** + 4576 + 4577 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4578 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4579 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4580 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4581 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4582 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4583 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4584 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4585 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4586 011403 SN=SN+1 + 4587 100000 YY=YY/2 + 4588 700000 ZZ=ZZ+YY + 4589 IFE YY, + 4590 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4591 032526 200 00 0 00 035505 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4592 ;POWER SHOULD RESULT IN C(AC)=0. + 4593 032527 270 00 0 00 035435 ADD [YY] ;PASS TEST IF C(AC)=0 + 4594 032530 332 00 0 00 000000 SKIPE + 4595 STOP^ + 4596 032531 254 04 0 00 032532 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4597 032532 324 00 0 00 032533 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4598 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4599 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4600 + 4601 ;********** + 4602 + 4603 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4604 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4605 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4606 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4607 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-12 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0117 + + 4608 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4609 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4610 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4611 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4612 011404 SN=SN+1 + 4613 040000 YY=YY/2 + 4614 740000 ZZ=ZZ+YY + 4615 IFE YY, + 4616 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4617 032533 200 00 0 00 035506 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4618 ;POWER SHOULD RESULT IN C(AC)=0. + 4619 032534 270 00 0 00 035434 ADD [YY] ;PASS TEST IF C(AC)=0 + 4620 032535 332 00 0 00 000000 SKIPE + 4621 STOP^ + 4622 032536 254 04 0 00 032537 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4623 032537 324 00 0 00 032540 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4624 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4625 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4626 + 4627 ;********** + 4628 + 4629 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4630 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4631 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4632 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4633 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4634 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4635 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4636 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4637 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4638 011405 SN=SN+1 + 4639 020000 YY=YY/2 + 4640 760000 ZZ=ZZ+YY + 4641 IFE YY, + 4642 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4643 032540 200 00 0 00 035507 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4644 ;POWER SHOULD RESULT IN C(AC)=0. + 4645 032541 270 00 0 00 035433 ADD [YY] ;PASS TEST IF C(AC)=0 + 4646 032542 332 00 0 00 000000 SKIPE + 4647 STOP^ + 4648 032543 254 04 0 00 032544 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4649 032544 324 00 0 00 032545 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4650 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4651 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4652 + 4653 ;********** + 4654 + 4655 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4656 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4657 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4658 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4659 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4660 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4661 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4662 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-13 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0118 + + 4663 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4664 011406 SN=SN+1 + 4665 010000 YY=YY/2 + 4666 770000 ZZ=ZZ+YY + 4667 IFE YY, + 4668 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4669 032545 200 00 0 00 035510 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4670 ;POWER SHOULD RESULT IN C(AC)=0. + 4671 032546 270 00 0 00 035432 ADD [YY] ;PASS TEST IF C(AC)=0 + 4672 032547 332 00 0 00 000000 SKIPE + 4673 STOP^ + 4674 032550 254 04 0 00 032551 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4675 032551 324 00 0 00 032552 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4676 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4677 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4678 + 4679 ;********** + 4680 + 4681 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4682 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4683 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4684 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4685 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4686 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4687 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4688 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4689 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4690 011407 SN=SN+1 + 4691 004000 YY=YY/2 + 4692 774000 ZZ=ZZ+YY + 4693 IFE YY, + 4694 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4695 032552 200 00 0 00 035511 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4696 ;POWER SHOULD RESULT IN C(AC)=0. + 4697 032553 270 00 0 00 035431 ADD [YY] ;PASS TEST IF C(AC)=0 + 4698 032554 332 00 0 00 000000 SKIPE + 4699 STOP^ + 4700 032555 254 04 0 00 032556 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4701 032556 324 00 0 00 032557 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4702 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4703 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4704 + 4705 ;********** + 4706 + 4707 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4708 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4709 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4710 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4711 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4712 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4713 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4714 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4715 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4716 011410 SN=SN+1 + 4717 002000 YY=YY/2 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-14 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0119 + + 4718 776000 ZZ=ZZ+YY + 4719 IFE YY, + 4720 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4721 032557 200 00 0 00 035512 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4722 ;POWER SHOULD RESULT IN C(AC)=0. + 4723 032560 270 00 0 00 035430 ADD [YY] ;PASS TEST IF C(AC)=0 + 4724 032561 332 00 0 00 000000 SKIPE + 4725 STOP^ + 4726 032562 254 04 0 00 032563 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4727 032563 324 00 0 00 032564 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4728 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4729 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4730 + 4731 ;********** + 4732 + 4733 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4734 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4735 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4736 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4737 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4738 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4739 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4740 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4741 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4742 011411 SN=SN+1 + 4743 001000 YY=YY/2 + 4744 777000 ZZ=ZZ+YY + 4745 IFE YY, + 4746 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4747 032564 200 00 0 00 035513 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4748 ;POWER SHOULD RESULT IN C(AC)=0. + 4749 032565 270 00 0 00 035427 ADD [YY] ;PASS TEST IF C(AC)=0 + 4750 032566 332 00 0 00 000000 SKIPE + 4751 STOP^ + 4752 032567 254 04 0 00 032570 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4753 032570 324 00 0 00 032571 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4754 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4755 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4756 + 4757 ;********** + 4758 + 4759 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4760 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4761 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4762 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4763 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4764 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4765 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4766 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4767 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4768 011412 SN=SN+1 + 4769 000400 YY=YY/2 + 4770 777400 ZZ=ZZ+YY + 4771 IFE YY, + 4772 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-15 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0120 + + 4773 032571 200 00 0 00 035514 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4774 ;POWER SHOULD RESULT IN C(AC)=0. + 4775 032572 270 00 0 00 035426 ADD [YY] ;PASS TEST IF C(AC)=0 + 4776 032573 332 00 0 00 000000 SKIPE + 4777 STOP^ + 4778 032574 254 04 0 00 032575 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4779 032575 324 00 0 00 032576 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4780 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4781 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4782 + 4783 ;********** + 4784 + 4785 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4786 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4787 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4788 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4789 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4790 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4791 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4792 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4793 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4794 011413 SN=SN+1 + 4795 000200 YY=YY/2 + 4796 777600 ZZ=ZZ+YY + 4797 IFE YY, + 4798 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4799 032576 200 00 0 00 035515 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4800 ;POWER SHOULD RESULT IN C(AC)=0. + 4801 032577 270 00 0 00 035425 ADD [YY] ;PASS TEST IF C(AC)=0 + 4802 032600 332 00 0 00 000000 SKIPE + 4803 STOP^ + 4804 032601 254 04 0 00 032602 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4805 032602 324 00 0 00 032603 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4806 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4807 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4808 + 4809 ;********** + 4810 + 4811 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4812 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4813 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4814 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4815 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4816 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4817 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4818 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4819 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4820 011414 SN=SN+1 + 4821 000100 YY=YY/2 + 4822 777700 ZZ=ZZ+YY + 4823 IFE YY, + 4824 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4825 032603 200 00 0 00 035516 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4826 ;POWER SHOULD RESULT IN C(AC)=0. + 4827 032604 270 00 0 00 035424 ADD [YY] ;PASS TEST IF C(AC)=0 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-16 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0121 + + 4828 032605 332 00 0 00 000000 SKIPE + 4829 STOP^ + 4830 032606 254 04 0 00 032607 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4831 032607 324 00 0 00 032610 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4832 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4833 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4834 + 4835 ;********** + 4836 + 4837 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4838 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4839 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4840 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4841 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4842 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4843 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4844 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4845 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4846 011415 SN=SN+1 + 4847 000040 YY=YY/2 + 4848 777740 ZZ=ZZ+YY + 4849 IFE YY, + 4850 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4851 032610 200 00 0 00 035517 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4852 ;POWER SHOULD RESULT IN C(AC)=0. + 4853 032611 270 00 0 00 035423 ADD [YY] ;PASS TEST IF C(AC)=0 + 4854 032612 332 00 0 00 000000 SKIPE + 4855 STOP^ + 4856 032613 254 04 0 00 032614 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4857 032614 324 00 0 00 032615 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4858 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4859 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4860 + 4861 ;********** + 4862 + 4863 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4864 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4865 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4866 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4867 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4868 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4869 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4870 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4871 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4872 011416 SN=SN+1 + 4873 000020 YY=YY/2 + 4874 777760 ZZ=ZZ+YY + 4875 IFE YY, + 4876 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4877 032615 200 00 0 00 035520 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4878 ;POWER SHOULD RESULT IN C(AC)=0. + 4879 032616 270 00 0 00 035422 ADD [YY] ;PASS TEST IF C(AC)=0 + 4880 032617 332 00 0 00 000000 SKIPE + 4881 STOP^ + 4882 032620 254 04 0 00 032621 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-17 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0122 + + 4883 032621 324 00 0 00 032622 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4884 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4885 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4886 + 4887 ;********** + 4888 + 4889 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4890 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4891 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4892 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4893 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4894 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4895 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4896 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4897 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4898 011417 SN=SN+1 + 4899 000010 YY=YY/2 + 4900 777770 ZZ=ZZ+YY + 4901 IFE YY, + 4902 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4903 032622 200 00 0 00 035521 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4904 ;POWER SHOULD RESULT IN C(AC)=0. + 4905 032623 270 00 0 00 035421 ADD [YY] ;PASS TEST IF C(AC)=0 + 4906 032624 332 00 0 00 000000 SKIPE + 4907 STOP^ + 4908 032625 254 04 0 00 032626 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4909 032626 324 00 0 00 032627 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4910 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4911 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4912 + 4913 ;********** + 4914 + 4915 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4916 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4917 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4918 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4919 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4920 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4921 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4922 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4923 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4924 011420 SN=SN+1 + 4925 000004 YY=YY/2 + 4926 777774 ZZ=ZZ+YY + 4927 IFE YY, + 4928 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4929 032627 200 00 0 00 035522 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4930 ;POWER SHOULD RESULT IN C(AC)=0. + 4931 032630 270 00 0 00 035420 ADD [YY] ;PASS TEST IF C(AC)=0 + 4932 032631 332 00 0 00 000000 SKIPE + 4933 STOP^ + 4934 032632 254 04 0 00 032633 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4935 032633 324 00 0 00 032634 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4936 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4937 ;IN THE SUBTEST) TO LOOP ON ERROR^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 8-18 +DAKABM MAC 19-JAN-77 13:39 TEST OF THE ADD INSTRUCTION SEQ 0123 + + 4938 + 4939 ;********** + 4940 + 4941 ;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4942 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4943 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4944 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4945 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4946 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4947 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4948 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4949 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4950 011421 SN=SN+1 + 4951 000002 YY=YY/2 + 4952 777776 ZZ=ZZ+YY + 4953 IFE YY, + 4954 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4955 032634 200 00 0 00 035523 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4956 ;POWER SHOULD RESULT IN C(AC)=0. + 4957 032635 270 00 0 00 035417 ADD [YY] ;PASS TEST IF C(AC)=0 + 4958 032636 332 00 0 00 000000 SKIPE + 4959 STOP^ + 4960 032637 254 04 0 00 032640 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4961 032640 324 00 0 00 032641 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 ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE + 4968 ;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER + 4969 ;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST + 4970 ;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE + 4971 ;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE + 4972 ;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, + 4973 ;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER + 4974 ;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS + 4975 ;FORMER VALUE PLUS THE CURRENT C(AC) + 4976 011422 SN=SN+1 + 4977 000001 YY=YY/2 + 4978 777777 ZZ=ZZ+YY + 4979 IFE YY, + 4980 IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + 4981 032641 200 00 0 00 035524 MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + 4982 ;POWER SHOULD RESULT IN C(AC)=0. + 4983 032642 270 00 0 00 035416 ADD [YY] ;PASS TEST IF C(AC)=0 + 4984 032643 332 00 0 00 000000 SKIPE + 4985 STOP^ + 4986 032644 254 04 0 00 032645 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4987 032645 324 00 0 00 032646 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4988 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4989 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4990 + 4991 ;********** + 4992 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 9 +DAKABM MAC 19-JAN-77 13:39 SPECIAL KI10 FOUR BIT ADDER TEST SEQ 0124 + + 4993 SUBTTL SPECIAL KI10 FOUR BIT ADDER TEST + 4994 + 4995 ;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR + 4996 ;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. + 4997 ;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 33 TO BIT 32. + 4998 + 4999 032646 200 00 0 00 035525 A13500: MOVE [-1,,-5] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 33 + 5000 032647 270 00 0 00 035416 ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 33 TO BIT 32 + 5001 032650 444 00 0 00 035522 EQV [-1,,-4] ;RESULT IN AC=ALL ONES + 5002 032651 444 00 0 00 035412 EQV [0] ;RESULT IN AC=0 + 5003 032652 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5004 STOP^ + 5005 032653 254 04 0 00 032654 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5006 032654 324 00 0 00 032655 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5007 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5008 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5009 + 5010 ;********** + 5011 + 5012 ;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR + 5013 ;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. + 5014 ;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 29 TO BIT 28. + 5015 + 5016 032655 200 00 0 00 035526 A13600: MOVE [-1,,-101] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 29 + 5017 032656 270 00 0 00 035416 ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 29 TO BIT 28 + 5018 032657 444 00 0 00 035516 EQV [-1,,-100] ;RESULT IN AC=ALL ONES + 5019 032660 444 00 0 00 035412 EQV [0] ;RESULT IN AC=0 + 5020 032661 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5021 STOP^ + 5022 032662 254 04 0 00 032663 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5023 032663 324 00 0 00 032664 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5024 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5025 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5026 + 5027 ;********** + 5028 + 5029 ;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR + 5030 ;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. + 5031 ;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 25 TO BIT 24. + 5032 + 5033 032664 200 00 0 00 035527 A13700: MOVE [-1,,-2001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 25 + 5034 032665 270 00 0 00 035416 ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 25 TO BIT 24 + 5035 032666 444 00 0 00 035512 EQV [-1,,-2000] ;RESULT IN AC=ALL ONES + 5036 032667 444 00 0 00 035412 EQV [0] ;RESULT IN AC=0 + 5037 032670 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5038 STOP^ + 5039 032671 254 04 0 00 032672 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5040 032672 324 00 0 00 032673 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5041 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5042 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5043 + 5044 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 10 +DAKABM MAC 19-JAN-77 13:39 SPECIAL KI10 FOUR BIT ADDER TEST SEQ 0125 + + 5045 ;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR + 5046 ;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. + 5047 ;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 21 TO BIT 20. + 5048 + 5049 032673 200 00 0 00 035530 A14000: MOVE [-1,,-40001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 21 + 5050 032674 270 00 0 00 035416 ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 21 TO BIT 20 + 5051 032675 444 00 0 00 035506 EQV [-1,,-40000] ;RESULT IN AC=ALL ONES + 5052 032676 444 00 0 00 035412 EQV [0] ;RESULT IN AC=0 + 5053 032677 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5054 STOP^ + 5055 032700 254 04 0 00 032701 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5056 032701 324 00 0 00 032702 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5057 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5058 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5059 + 5060 ;********** + 5061 + 5062 ;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR + 5063 ;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. + 5064 ;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 18 TO BIT 17. + 5065 + 5066 032702 200 00 0 00 035531 A14100: MOVE [-1,,-400001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 18 + 5067 032703 270 00 0 00 035416 ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 18 TO BIT 17 + 5068 032704 444 00 0 00 035503 EQV [-1,,400000] ;RESULT IN AC=ALL ONES + 5069 032705 444 00 0 00 035412 EQV [0] ;RESULT IN AC=0 + 5070 032706 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5071 STOP^ + 5072 032707 254 04 0 00 032710 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5073 032710 324 00 0 00 032711 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5074 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5075 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5076 + 5077 ;********** + 5078 + 5079 ;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR + 5080 ;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. + 5081 ;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 14 TO BIT 13. + 5082 + 5083 032711 200 00 0 00 035532 A14200: MOVE [-11,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 14 + 5084 032712 270 00 0 00 035416 ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 14 TO BIT 13 + 5085 032713 444 00 0 00 035477 EQV [-10,,0] ;RESULT IN AC=ALL ONES + 5086 032714 444 00 0 00 035412 EQV [0] ;RESULT IN AC=0 + 5087 032715 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5088 STOP^ + 5089 032716 254 04 0 00 032717 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5090 032717 324 00 0 00 032720 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5091 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5092 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5093 + 5094 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 11 +DAKABM MAC 19-JAN-77 13:39 SPECIAL KI10 FOUR BIT ADDER TEST SEQ 0126 + + 5095 ;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR + 5096 ;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. + 5097 ;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 10 TO BIT 9. + 5098 + 5099 032720 200 00 0 00 035533 A14300: MOVE [-201,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 10 + 5100 032721 270 00 0 00 035416 ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 10 TO BIT 9 + 5101 032722 444 00 0 00 035473 EQV [-200,,0] ;RESULT IN AC=ALL ONES + 5102 032723 444 00 0 00 035412 EQV [0] ;RESULT IN AC=0 + 5103 032724 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5104 STOP^ + 5105 032725 254 04 0 00 032726 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5106 032726 324 00 0 00 032727 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5107 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5108 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5109 + 5110 ;********** + 5111 + 5112 ;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR + 5113 ;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. + 5114 ;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 6 TO BIT 5. + 5115 + 5116 032727 200 00 0 00 035534 A14400: MOVE [-4001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 6 + 5117 032730 270 00 0 00 035416 ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 6 TO BIT 5 + 5118 032731 444 00 0 00 035467 EQV [-4000,,0] ;RESULT IN AC=ALL ONES + 5119 032732 444 00 0 00 035412 EQV [0] ;RESULT IN AC=0 + 5120 032733 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5121 STOP^ + 5122 032734 254 04 0 00 032735 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5123 032735 324 00 0 00 032736 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5124 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5125 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5126 + 5127 ;********** + 5128 + 5129 ;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR + 5130 ;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. + 5131 ;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 2 TO BIT 1. + 5132 + 5133 032736 200 00 0 00 035535 A14500: MOVE [-100001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 2 + 5134 032737 270 00 0 00 035416 ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 2 TO BIT 1 + 5135 032740 444 00 0 00 035463 EQV [-100000,,0] ;RESULT IN AC=ALL ONES + 5136 032741 444 00 0 00 035412 EQV [0] ;RESULT IN AC=0 + 5137 032742 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5138 STOP^ + 5139 032743 254 04 0 00 032744 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5140 032744 324 00 0 00 032745 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5141 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5142 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5143 + 5144 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 12 +DAKABM MAC 19-JAN-77 13:39 SPECIAL KI10 FOUR BIT ADDER TEST SEQ 0127 + + 5145 ;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR + 5146 ;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. + 5147 ;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 1 TO BIT 0. + 5148 + 5149 032745 200 00 0 00 035536 A14600: MOVE [-200001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 1 + 5150 032746 270 00 0 00 035416 ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 1 TO BIT 0 + 5151 032747 444 00 0 00 035462 EQV [600000,,0] ;RESULT IN AC=ALL ONES + 5152 032750 444 00 0 00 035412 EQV [0] ;RESULT IN AC=0 + 5153 032751 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5154 STOP^ + 5155 032752 254 04 0 00 032753 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5156 032753 324 00 0 00 032754 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5157 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5158 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5159 + 5160 ;********** + 5161 + 5162 ;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR + 5163 ;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. + 5164 ;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT -1TO BIT 35. + 5165 + 5166 032754 200 00 0 00 035524 A14700: MOVE [-1,,-1] ;PRESET AC WITH ALL ONES + 5167 032755 270 00 0 00 035416 ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT -1 TO BIT 35 + 5168 032756 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5169 STOP^ + 5170 032757 254 04 0 00 032760 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5171 032760 324 00 0 00 032761 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5172 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5173 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5174 + 5175 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0128 + + 5176 SUBTTL TEST OF SUB AND COMPARE INSTRUCTIONS + 5177 + 5178 ;THIS TEST VERIFIES THAT IF A NON ZERO POSITIVE NUMBER IN E IS + 5179 ;SUBTRACTED FROM THE AC WHEN C(AC)=0, THE RESULT IN THE AC + 5180 ;IS NEGATIVE + 5181 + 5182 032761 200 00 0 00 035412 A11500: MOVE [0] ;PRESET AC TO ZERO + 5183 032762 274 00 0 00 035537 SUB [XWD 0,-1] ;*SUB OF POSITIVE NONZERO NUMBER FROM AC OF ALL ZEROS + 5184 ;SHOULD RESULT IN C(AC) NEGATIVE + 5185 032763 331 00 0 00 000000 SKIPL ;PASS TEST IF C(AC) IS NEGATIVE + 5186 STOP^ + 5187 032764 254 04 0 00 032765 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5188 032765 324 00 0 00 032766 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5189 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5190 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5191 + 5192 ;AD AR- EN D [ADAM], F CYC ACT ENB [F1], + 5193 ;IR SUBX[IR1], IR ADSUB[IR1] + 5194 + 5195 ;********** + 5196 + 5197 ;THIS TEST VERIFIES THAT IF A WORD OF ALL ZEROS IS + 5198 ;SUBTRACTED FROM AN AC OF ALL ZEROS, THE RESULT + 5199 ;IS AN AC OF ZEROS. + 5200 + 5201 032766 200 00 0 00 035412 A11600: MOVE [0] ;PRESET AC TO ZERO + 5202 032767 274 00 0 00 035412 SUB [0] ;*SUB OF 0 FROM 0 SHOULD RESULT IN C(AC)=0 + 5203 032770 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5204 STOP^ + 5205 032771 254 04 0 00 032772 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5206 032772 324 00 0 00 032773 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5207 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5208 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5209 ;AD CRY 36[ADCR], F CYC ACT EN D[F1], IF SUBX [IR1] + 5210 + 5211 ;********** + 5212 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0129 + + 5213 011700 SN=11700 + 5214 000000 ZZ=0 + 5215 + 5216 A11700: REPEAT ^D36, + 5217 <;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5218 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5219 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5220 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5221 SN=SN+1 + 5222 ZZ=ZZ+ZZ + 5223 IFE ZZ, + 5224 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5225 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5226 SKIPE ;PASS TEST IF C(AC)=0 + 5227 STOP + 5228 + 5229 ;********** + 5230 > + 5231 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5232 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5233 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5234 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5235 011701 SN=SN+1 + 5236 000000 ZZ=ZZ+ZZ + 5237 000001 IFE ZZ, + 5238 032773 200 00 0 00 035416 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5239 032774 274 00 0 00 035416 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5240 032775 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5241 STOP^ + 5242 032776 254 04 0 00 032777 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5243 032777 324 00 0 00 033000 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5244 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5245 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5246 + 5247 ;********** + 5248 + 5249 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5250 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5251 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5252 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5253 011702 SN=SN+1 + 5254 000002 ZZ=ZZ+ZZ + 5255 IFE ZZ, + 5256 033000 200 00 0 00 035417 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5257 033001 274 00 0 00 035417 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5258 033002 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5259 STOP^ + 5260 033003 254 04 0 00 033004 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5261 033004 324 00 0 00 033005 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5262 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5263 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5264 + 5265 ;********** + 5266 + 5267 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0130 + + 5268 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5269 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5270 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5271 011703 SN=SN+1 + 5272 000004 ZZ=ZZ+ZZ + 5273 IFE ZZ, + 5274 033005 200 00 0 00 035420 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5275 033006 274 00 0 00 035420 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5276 033007 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5277 STOP^ + 5278 033010 254 04 0 00 033011 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5279 033011 324 00 0 00 033012 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5280 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5281 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5282 + 5283 ;********** + 5284 + 5285 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5286 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5287 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5288 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5289 011704 SN=SN+1 + 5290 000010 ZZ=ZZ+ZZ + 5291 IFE ZZ, + 5292 033012 200 00 0 00 035421 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5293 033013 274 00 0 00 035421 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5294 033014 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5295 STOP^ + 5296 033015 254 04 0 00 033016 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5297 033016 324 00 0 00 033017 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5298 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5299 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5300 + 5301 ;********** + 5302 + 5303 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5304 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5305 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5306 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5307 011705 SN=SN+1 + 5308 000020 ZZ=ZZ+ZZ + 5309 IFE ZZ, + 5310 033017 200 00 0 00 035422 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5311 033020 274 00 0 00 035422 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5312 033021 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5313 STOP^ + 5314 033022 254 04 0 00 033023 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5315 033023 324 00 0 00 033024 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5316 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5317 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5318 + 5319 ;********** + 5320 + 5321 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5322 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0131 + + 5323 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5324 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5325 011706 SN=SN+1 + 5326 000040 ZZ=ZZ+ZZ + 5327 IFE ZZ, + 5328 033024 200 00 0 00 035423 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5329 033025 274 00 0 00 035423 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5330 033026 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5331 STOP^ + 5332 033027 254 04 0 00 033030 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5333 033030 324 00 0 00 033031 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5334 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5335 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5336 + 5337 ;********** + 5338 + 5339 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5340 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5341 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5342 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5343 011707 SN=SN+1 + 5344 000100 ZZ=ZZ+ZZ + 5345 IFE ZZ, + 5346 033031 200 00 0 00 035424 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5347 033032 274 00 0 00 035424 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5348 033033 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5349 STOP^ + 5350 033034 254 04 0 00 033035 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5351 033035 324 00 0 00 033036 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5352 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5353 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5354 + 5355 ;********** + 5356 + 5357 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5358 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5359 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5360 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5361 011710 SN=SN+1 + 5362 000200 ZZ=ZZ+ZZ + 5363 IFE ZZ, + 5364 033036 200 00 0 00 035425 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5365 033037 274 00 0 00 035425 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5366 033040 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5367 STOP^ + 5368 033041 254 04 0 00 033042 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5369 033042 324 00 0 00 033043 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5370 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5371 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5372 + 5373 ;********** + 5374 + 5375 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5376 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5377 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0132 + + 5378 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5379 011711 SN=SN+1 + 5380 000400 ZZ=ZZ+ZZ + 5381 IFE ZZ, + 5382 033043 200 00 0 00 035426 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5383 033044 274 00 0 00 035426 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5384 033045 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5385 STOP^ + 5386 033046 254 04 0 00 033047 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5387 033047 324 00 0 00 033050 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5388 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5389 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5390 + 5391 ;********** + 5392 + 5393 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5394 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5395 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5396 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5397 011712 SN=SN+1 + 5398 001000 ZZ=ZZ+ZZ + 5399 IFE ZZ, + 5400 033050 200 00 0 00 035427 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5401 033051 274 00 0 00 035427 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5402 033052 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5403 STOP^ + 5404 033053 254 04 0 00 033054 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5405 033054 324 00 0 00 033055 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5406 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5407 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5408 + 5409 ;********** + 5410 + 5411 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5412 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5413 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5414 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5415 011713 SN=SN+1 + 5416 002000 ZZ=ZZ+ZZ + 5417 IFE ZZ, + 5418 033055 200 00 0 00 035430 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5419 033056 274 00 0 00 035430 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5420 033057 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5421 STOP^ + 5422 033060 254 04 0 00 033061 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5423 033061 324 00 0 00 033062 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5424 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5425 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5426 + 5427 ;********** + 5428 + 5429 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5430 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5431 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5432 ;TIMES IN ORDER TO TEST ALL 36 BITS. +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0133 + + 5433 011714 SN=SN+1 + 5434 004000 ZZ=ZZ+ZZ + 5435 IFE ZZ, + 5436 033062 200 00 0 00 035431 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5437 033063 274 00 0 00 035431 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5438 033064 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5439 STOP^ + 5440 033065 254 04 0 00 033066 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5441 033066 324 00 0 00 033067 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5442 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5443 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5444 + 5445 ;********** + 5446 + 5447 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5448 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5449 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5450 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5451 011715 SN=SN+1 + 5452 010000 ZZ=ZZ+ZZ + 5453 IFE ZZ, + 5454 033067 200 00 0 00 035432 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5455 033070 274 00 0 00 035432 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5456 033071 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5457 STOP^ + 5458 033072 254 04 0 00 033073 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5459 033073 324 00 0 00 033074 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5460 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5461 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5462 + 5463 ;********** + 5464 + 5465 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5466 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5467 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5468 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5469 011716 SN=SN+1 + 5470 020000 ZZ=ZZ+ZZ + 5471 IFE ZZ, + 5472 033074 200 00 0 00 035433 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5473 033075 274 00 0 00 035433 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5474 033076 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5475 STOP^ + 5476 033077 254 04 0 00 033100 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5477 033100 324 00 0 00 033101 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5478 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5479 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5480 + 5481 ;********** + 5482 + 5483 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5484 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5485 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5486 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5487 011717 SN=SN+1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0134 + + 5488 040000 ZZ=ZZ+ZZ + 5489 IFE ZZ, + 5490 033101 200 00 0 00 035434 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5491 033102 274 00 0 00 035434 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5492 033103 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5493 STOP^ + 5494 033104 254 04 0 00 033105 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5495 033105 324 00 0 00 033106 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5496 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5497 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5498 + 5499 ;********** + 5500 + 5501 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5502 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5503 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5504 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5505 011720 SN=SN+1 + 5506 100000 ZZ=ZZ+ZZ + 5507 IFE ZZ, + 5508 033106 200 00 0 00 035435 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5509 033107 274 00 0 00 035435 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5510 033110 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5511 STOP^ + 5512 033111 254 04 0 00 033112 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5513 033112 324 00 0 00 033113 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5514 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5515 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5516 + 5517 ;********** + 5518 + 5519 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5520 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5521 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5522 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5523 011721 SN=SN+1 + 5524 200000 ZZ=ZZ+ZZ + 5525 IFE ZZ, + 5526 033113 200 00 0 00 035436 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5527 033114 274 00 0 00 035436 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5528 033115 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5529 STOP^ + 5530 033116 254 04 0 00 033117 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5531 033117 324 00 0 00 033120 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5532 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5533 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5534 + 5535 ;********** + 5536 + 5537 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5538 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5539 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5540 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5541 011722 SN=SN+1 + 5542 400000 ZZ=ZZ+ZZ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-7 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0135 + + 5543 IFE ZZ, + 5544 033120 200 00 0 00 035437 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5545 033121 274 00 0 00 035437 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5546 033122 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5547 STOP^ + 5548 033123 254 04 0 00 033124 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5549 033124 324 00 0 00 033125 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5550 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5551 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5552 + 5553 ;********** + 5554 + 5555 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5556 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5557 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5558 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5559 011723 SN=SN+1 + 5560 000001 000000 ZZ=ZZ+ZZ + 5561 IFE ZZ, + 5562 033125 200 00 0 00 035440 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5563 033126 274 00 0 00 035440 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5564 033127 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5565 STOP^ + 5566 033130 254 04 0 00 033131 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5567 033131 324 00 0 00 033132 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5568 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5569 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5570 + 5571 ;********** + 5572 + 5573 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5574 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5575 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5576 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5577 011724 SN=SN+1 + 5578 000002 000000 ZZ=ZZ+ZZ + 5579 IFE ZZ, + 5580 033132 200 00 0 00 035441 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5581 033133 274 00 0 00 035441 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5582 033134 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5583 STOP^ + 5584 033135 254 04 0 00 033136 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5585 033136 324 00 0 00 033137 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5586 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5587 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5588 + 5589 ;********** + 5590 + 5591 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5592 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5593 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5594 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5595 011725 SN=SN+1 + 5596 000004 000000 ZZ=ZZ+ZZ + 5597 IFE ZZ, +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-8 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0136 + + 5598 033137 200 00 0 00 035442 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5599 033140 274 00 0 00 035442 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5600 033141 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5601 STOP^ + 5602 033142 254 04 0 00 033143 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5603 033143 324 00 0 00 033144 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5604 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5605 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5606 + 5607 ;********** + 5608 + 5609 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5610 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5611 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5612 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5613 011726 SN=SN+1 + 5614 000010 000000 ZZ=ZZ+ZZ + 5615 IFE ZZ, + 5616 033144 200 00 0 00 035443 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5617 033145 274 00 0 00 035443 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5618 033146 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5619 STOP^ + 5620 033147 254 04 0 00 033150 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5621 033150 324 00 0 00 033151 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5622 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5623 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5624 + 5625 ;********** + 5626 + 5627 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5628 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5629 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5630 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5631 011727 SN=SN+1 + 5632 000020 000000 ZZ=ZZ+ZZ + 5633 IFE ZZ, + 5634 033151 200 00 0 00 035444 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5635 033152 274 00 0 00 035444 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5636 033153 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5637 STOP^ + 5638 033154 254 04 0 00 033155 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5639 033155 324 00 0 00 033156 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5640 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5641 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5642 + 5643 ;********** + 5644 + 5645 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5646 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5647 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5648 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5649 011730 SN=SN+1 + 5650 000040 000000 ZZ=ZZ+ZZ + 5651 IFE ZZ, + 5652 033156 200 00 0 00 035445 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-9 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0137 + + 5653 033157 274 00 0 00 035445 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5654 033160 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5655 STOP^ + 5656 033161 254 04 0 00 033162 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5657 033162 324 00 0 00 033163 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5658 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5659 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5660 + 5661 ;********** + 5662 + 5663 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5664 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5665 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5666 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5667 011731 SN=SN+1 + 5668 000100 000000 ZZ=ZZ+ZZ + 5669 IFE ZZ, + 5670 033163 200 00 0 00 035446 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5671 033164 274 00 0 00 035446 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5672 033165 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5673 STOP^ + 5674 033166 254 04 0 00 033167 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5675 033167 324 00 0 00 033170 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5676 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5677 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5678 + 5679 ;********** + 5680 + 5681 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5682 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5683 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5684 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5685 011732 SN=SN+1 + 5686 000200 000000 ZZ=ZZ+ZZ + 5687 IFE ZZ, + 5688 033170 200 00 0 00 035447 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5689 033171 274 00 0 00 035447 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5690 033172 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5691 STOP^ + 5692 033173 254 04 0 00 033174 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5693 033174 324 00 0 00 033175 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5694 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5695 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5696 + 5697 ;********** + 5698 + 5699 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5700 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5701 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5702 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5703 011733 SN=SN+1 + 5704 000400 000000 ZZ=ZZ+ZZ + 5705 IFE ZZ, + 5706 033175 200 00 0 00 035450 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5707 033176 274 00 0 00 035450 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-10 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0138 + + 5708 033177 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5709 STOP^ + 5710 033200 254 04 0 00 033201 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5711 033201 324 00 0 00 033202 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5712 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5713 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5714 + 5715 ;********** + 5716 + 5717 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5718 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5719 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5720 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5721 011734 SN=SN+1 + 5722 001000 000000 ZZ=ZZ+ZZ + 5723 IFE ZZ, + 5724 033202 200 00 0 00 035451 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5725 033203 274 00 0 00 035451 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5726 033204 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5727 STOP^ + 5728 033205 254 04 0 00 033206 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5729 033206 324 00 0 00 033207 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5730 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5731 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5732 + 5733 ;********** + 5734 + 5735 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5736 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5737 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5738 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5739 011735 SN=SN+1 + 5740 002000 000000 ZZ=ZZ+ZZ + 5741 IFE ZZ, + 5742 033207 200 00 0 00 035452 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5743 033210 274 00 0 00 035452 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5744 033211 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5745 STOP^ + 5746 033212 254 04 0 00 033213 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5747 033213 324 00 0 00 033214 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5748 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5749 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5750 + 5751 ;********** + 5752 + 5753 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5754 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5755 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5756 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5757 011736 SN=SN+1 + 5758 004000 000000 ZZ=ZZ+ZZ + 5759 IFE ZZ, + 5760 033214 200 00 0 00 035453 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5761 033215 274 00 0 00 035453 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5762 033216 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-11 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0139 + + 5763 STOP^ + 5764 033217 254 04 0 00 033220 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5765 033220 324 00 0 00 033221 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5766 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5767 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5768 + 5769 ;********** + 5770 + 5771 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5772 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5773 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5774 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5775 011737 SN=SN+1 + 5776 010000 000000 ZZ=ZZ+ZZ + 5777 IFE ZZ, + 5778 033221 200 00 0 00 035454 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5779 033222 274 00 0 00 035454 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5780 033223 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5781 STOP^ + 5782 033224 254 04 0 00 033225 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5783 033225 324 00 0 00 033226 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5784 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5785 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5786 + 5787 ;********** + 5788 + 5789 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5790 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5791 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5792 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5793 011740 SN=SN+1 + 5794 020000 000000 ZZ=ZZ+ZZ + 5795 IFE ZZ, + 5796 033226 200 00 0 00 035455 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5797 033227 274 00 0 00 035455 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5798 033230 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5799 STOP^ + 5800 033231 254 04 0 00 033232 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5801 033232 324 00 0 00 033233 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5802 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5803 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5804 + 5805 ;********** + 5806 + 5807 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5808 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5809 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5810 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5811 011741 SN=SN+1 + 5812 040000 000000 ZZ=ZZ+ZZ + 5813 IFE ZZ, + 5814 033233 200 00 0 00 035456 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5815 033234 274 00 0 00 035456 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5816 033235 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5817 STOP^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-12 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0140 + + 5818 033236 254 04 0 00 033237 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5819 033237 324 00 0 00 033240 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5820 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5821 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5822 + 5823 ;********** + 5824 + 5825 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5826 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5827 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5828 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5829 011742 SN=SN+1 + 5830 100000 000000 ZZ=ZZ+ZZ + 5831 IFE ZZ, + 5832 033240 200 00 0 00 035457 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5833 033241 274 00 0 00 035457 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5834 033242 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5835 STOP^ + 5836 033243 254 04 0 00 033244 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5837 033244 324 00 0 00 033245 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5838 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5839 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5840 + 5841 ;********** + 5842 + 5843 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5844 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5845 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5846 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5847 011743 SN=SN+1 + 5848 200000 000000 ZZ=ZZ+ZZ + 5849 IFE ZZ, + 5850 033245 200 00 0 00 035460 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5851 033246 274 00 0 00 035460 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5852 033247 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5853 STOP^ + 5854 033250 254 04 0 00 033251 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5855 033251 324 00 0 00 033252 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5856 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5857 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5858 + 5859 ;********** + 5860 + 5861 ;THIS TEST VERIFIES THAT IF A RIPPLED ONE + 5862 ;IS SUBTRACTED FROM ITSELF, THE RESULT IS + 5863 ;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 + 5864 ;TIMES IN ORDER TO TEST ALL 36 BITS. + 5865 011744 SN=SN+1 + 5866 400000 000000 ZZ=ZZ+ZZ + 5867 IFE ZZ, + 5868 033252 200 00 0 00 035461 MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + 5869 033253 274 00 0 00 035461 SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5870 033254 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5871 STOP^ + 5872 033255 254 04 0 00 033256 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-13 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0141 + + 5873 033256 324 00 0 00 033257 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5874 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5875 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5876 + 5877 ;********** + 5878 + 5879 PAGE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 13-14 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0142 + + 5880 ;THIS TEST VERIFIES THAT IF A WORD OF ALL + 5881 ;ONES IS SUBTRACTED FROM ITSELF, THE RESULT + 5882 ;IN THE AC IS ZERO. + 5883 + 5884 033257 200 00 0 00 035524 A12000: MOVE [-1] ;PRESET AC TO ALL ONES + 5885 033260 274 00 0 00 035524 SUB [-1] ;*SUB OF -1 FROM ITSELF SHOULD RESULT IN C(AC)=0 + 5886 033261 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 5887 STOP^ + 5888 033262 254 04 0 00 033263 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5889 033263 324 00 0 00 033264 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5890 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5891 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5892 + 5893 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 14 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0143 + + 5894 ;THIS TEST VERIFIES THAT CAMA ALWAYS SKIPS THE + 5895 ;NEXT INSTRUCTION INDEPENDENT OF THE DATA WITH AC + 5896 ;AND E. THIS TEST FAILS IF CAMA DOES NOT SKIP ALWAYS. + 5897 + 5898 033264 200 00 0 00 035412 A12100: MOVE [0] ;PRESET AC, E TO ZERO + 5899 033265 314 00 0 00 000000 CAMA ;*CAMA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION, + 5900 ;OTHERWISE THIS TEST FAILS + 5901 STOP^ + 5902 033266 254 04 0 00 033267 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5903 033267 324 00 0 00 033270 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5904 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5905 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5906 + 5907 ;ET0 [E], ET0 EN[E], IR CAXX[IR3], AD CRY 3C[ADCR], + 5908 ;FCYC ACT EN D [ADCR], AD CRY 36 F/F'S [ADCR], + 5909 ;PC CLOCK EN [PCC], ET0 C F/F[E], IR CAXX[IR3], + 5910 ;ADZ COND P[ADZ] AND ADZ COND Z[ADZ] + 5911 + 5912 ;********** + 5913 + 5914 ;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE. + 5915 ;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY + 5916 ;IF C(AC)=C(E). IN THIS TEST AC=E=0 AND + 5917 ;C(AC)=C(E)=0. HENCE, CAME MUST + 5918 ;SKIP THE NEXT INSTRUCTION + 5919 ;IN THIS TEST + 5920 + 5921 033270 200 00 0 00 035412 A12200: MOVE [0] ;PRESET AC, E TO ZERO + 5922 033271 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP SINCE E=AC + 5923 STOP^ + 5924 033272 254 04 0 00 033273 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5925 033273 324 00 0 00 033274 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5926 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5927 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5928 + 5929 ;AD FM + EN [ADFP], F CXC ACT ENC[F1], IRCAXX[IR3] + 5930 + 5931 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 15 +DAKABM MAC 19-JAN-77 13:39 TEST OF SUB AND COMPARE INSTRUCTIONS SEQ 0144 + + 5932 ;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE + 5933 ;IT SKIPS THE NEXT INSTRUCTION OF AND ONLY IF + 5934 ;C(AC)=C(E). IN THIS TEST C(AC)=C(E)=0; + 5935 ;BUT, E IS NOT WITHIN THE AC RANGE. + 5936 ;HENCE, CAME MUST SKIP + 5937 ;THE NEXT INSTRUCTION IN THIS TEST. + 5938 + 5939 033274 200 00 0 00 035412 A12300: MOVE [0] ;*CAME SHOULD SKIP WHEN C(AC)=C(E)=0 + 5940 033275 312 00 0 00 035412 CAME [0] + 5941 STOP^ + 5942 033276 254 04 0 00 033277 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5943 033277 324 00 0 00 033300 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5944 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5945 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5946 + 5947 ;CAMX: FCE[F1], IR CAMX[IR1] + 5948 + 5949 ;********** + 5950 + 5951 ;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE. + 5952 ;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY IF + 5953 ;C(AC)=C(E). IN THIS TEST C(AC)=0 AND + 5954 ;C(E)=-1. HENCE, CAME SHOULD NOT + 5955 ;SKIP THE NEXT INSTRUCTION IN THIS TEST. + 5956 + 5957 033300 200 00 0 00 035412 A12400: MOVE [0] ;PRESET AC TO ZERO + 5958 033301 312 00 0 00 035524 CAME [-1] ;*CAME SHOULD NOT SKIP BECAUSE C(AC)=0 ANDC(E)=- + 5959 033302 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF CAME PASSES TEST + 5960 STOP^ + 5961 033303 254 04 0 00 033304 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5962 033304 324 00 0 00 033305 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5963 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5964 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5965 + 5966 ;AD AR- EN [ADAM], IR CAXX [IR3], F CYC ACT EN B [F1], + 5967 ;AD AR- F/F'S [ADAM], AD ADD [ADC1], AD FM + FETCH EN A [ADFP], + 5968 ;F CYC ACT EN A [F1], AD ADD EN C [ADC1], AD ADD F/F'S [ADC1] + 5969 + 5970 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 16 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0145 + + 5971 SUBTTL TEST OF COMPARE (CAMX) INSTRUCTIONS + 5972 + 5973 ;********** + 5974 + 5975 ;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 5976 ;ONLY WHEN C(AC) IS LESS THAN C(E). + 5977 ;IN THIS TEST, C(AC)=-1 AND C(E)=0; HENCE, CAML SHOULD SKIP. OTHERWISE,THE + 5978 ;PROGRAM HALTS. + 5979 + 5980 033305 200 00 0 00 035524 B100: MOVE [-1] ;PRELOAD AC WITH -1 + 5981 033306 311 00 0 00 035412 CAML [0] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E) + 5982 STOP^ + 5983 033307 254 04 0 00 033310 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5984 033310 324 00 0 00 033311 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5985 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5986 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5987 + 5988 ;***** FAILURE ANALYSIS ***** + 5989 ;C(AC0) C(AC1) FAILING SIGNAL + 5990 + 5991 ; FC: AB PC EN + 5992 ; ET0: COND Q: PC CLK EN + 5993 + 5994 ;********** + 5995 + 5996 ;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 5997 ;ONLY WHEN C(AC) IS LESS THAN C(E). + 5998 ;IN THIS CASE, C(AC)=0 AND C(E)=-1; HENCE, CAML SHOULD NOT SKIP. OTHERWISE, + 5999 ;THE PROGRAM HALTS. + 6000 + 6001 033311 200 00 0 00 035412 B200: MOVE [0] ;PRELOAD AC WITH 0 + 6002 033312 311 00 0 00 035524 CAML [-1] ;*CAML SHOULD NOT SKIP BECAUSE + 6003 ;C(AC) IS GREATER THAN C(E) + 6004 033313 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + 6005 STOP^ + 6006 033314 254 04 0 00 033315 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6007 033315 324 00 0 00 033316 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6008 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6009 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6010 + 6011 ;***** FAILURE ANALYSIS ***** + 6012 ;C(AC0) C(AC1) FAILING SIGNAL + 6013 + 6014 ; SW: FCE + 6015 ; FC: PC CHANGE + 6016 + 6017 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 17 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0146 + + 6018 ;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 6019 ;ONLY WHEN C(AC) IS LESS THAN C(E). + 6020 ;IN THIS CASE, C(AC)=400000,,0 (THE MOST + 6021 ;NEGATIVE NUMBER) AND C(E)=377777,,-1 + 6022 ;(THE MOST POSITIVE NUMBER); HENCE, + 6023 ;CAML SHOULD SKIP. OTHERWISE, THE + 6024 ;PROGRAM HALTS + 6025 + 6026 033316 200 00 0 00 035461 B300: MOVE [XWD 400000,0] ;PRELOAD AC WITH 400000,,0 + 6027 033317 311 00 0 00 035540 CAML [XWD 377777,-1] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E) + 6028 STOP^ + 6029 033320 254 04 0 00 033321 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6030 033321 324 00 0 00 033322 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6031 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6032 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6033 + 6034 ;***** FAILURE ANALYSIS ***** + 6035 ;C(AC0) C(AC1) FAILING SIGNAL + 6036 + 6037 ; FC: AD ADD + 6038 + 6039 ;********** + 6040 + 6041 ;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 6042 ;ONLY WHEN C(AC) IS LESS THAN C(E). + 6043 ;IN THIS CASE, C(AC)=377777,,-1 (THE MOST POSITIVE NUMBER) AND C(E)=400000,,0 (THE MOST NEG + 6044 ATIVE NUMBER) + 6045 ;HENCE, CAML SHOULD NOT SKIP. OTHERWISE, THE PROGRAM HALTS. + 6046 + 6047 033322 200 00 0 00 035540 B400: MOVE [XWD 377777,-1] ;PRELOAD AC WITH 377777,,-1 + 6048 033323 311 00 0 00 035461 CAML [XWD 400000,0] ;*CAML SHOULD NOT SKIP BECAUSE + 6049 ;C(AC) IS GREATER THAN C(E) + 6050 033324 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + 6051 STOP^ + 6052 033325 254 04 0 00 033326 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6053 033326 324 00 0 00 033327 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6054 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6055 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6056 + 6057 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 18 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0147 + + 6058 ;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 6059 ;ONLY WHEN C(AC) IS LESS THAN C(E). + 6060 ;IN THIS CASE, C(AC)=400000,,0 (THE MOST NEGTIVE NUMBER) AND C(E)=-1; + 6061 ;HENCE, CAML SHOULD SKIP. OTHERWISE, THE PROGRAM HALTS + 6062 + 6063 033327 200 00 0 00 035461 B500: MOVE [XWD 400000,0] ;PRELOAD AC WITH 400000,,0 + 6064 033330 311 00 0 00 035524 CAML [-1] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E) + 6065 STOP^ + 6066 033331 254 04 0 00 033332 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6067 033332 324 00 0 00 033333 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6068 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6069 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6070 + 6071 ;***** FAILURE ANALYSIS ***** + 6072 ;C(AC0) C(AC1) FAILING SIGNAL + 6073 + 6074 ; FC: AD FM + EN + 6075 + 6076 ;********** + 6077 + 6078 ;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 6079 ;ONLY WHEN C(AC) IS LESS THAN C(E). + 6080 ;IN THIS CASE, C(AC)=0 AND C(E)=-1 ;HENCE, CAML SHOULD NOT SKIP. OTHERWISE, + 6081 ;THE PROGRAM HALTS. + 6082 + 6083 033333 400 00 0 00 000000 B600: SETZ ;PRELOAD AC WITH 0 + 6084 033334 311 00 0 00 035524 CAML [-1] ;*CAML SHOULD NOT SKIP BECAUSE + 6085 ;C(AC) IS GREATER THAN C(E) + 6086 033335 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES. + 6087 STOP^ + 6088 033336 254 04 0 00 033337 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6089 033337 324 00 0 00 033340 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6090 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6091 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6092 + 6093 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 19 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0148 + + 6094 ;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT INSTRUCTION WHEN AND + 6095 ;ONLY WHEN C(AC) IS LESS THAN C(E). + 6096 ;IN THIS CASE, C(AC)=0 AND C(E)=0 ;HENCE, CAML SHOULD NOT SKIP. OTHERWISE, + 6097 ;THE PROGRAM HALTS. + 6098 + 6099 033340 400 00 0 00 000000 B700: SETZ ;PRELOAD AS WITH 0 + 6100 033341 311 00 0 00 035412 CAML [0] ;*CAML SHOULD NOT SKIP BECAUSE C(AC)=C(E) + 6101 033342 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + 6102 STOP^ + 6103 033343 254 04 0 00 033344 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6104 033344 324 00 0 00 033345 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6105 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6106 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6107 + 6108 ;***** FAILURE ANALYSIS ***** + 6109 ;C(AC0) C(AC1) FAILING SIGNAL + 6110 + 6111 ; FC: AD CRY 36 + 6112 + 6113 ;********** + 6114 + 6115 ;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 6116 ;ONLY WHEN C(AC) IS LESS THAN C(E). + 6117 ;IN THIS CASE, C(AC)=0 AND C(E)=400000,,O (THE MOST NEGATIVE NUMBER); + 6118 ;HENCE CAML SHOULD NOT SKIP. OTHERWISE, THE PROGRAM HALTS. + 6119 + 6120 033345 400 00 0 00 000000 B1000: SETZ ;PRELOAD AC WITH 0 + 6121 033346 311 00 0 00 035461 CAML [XWD 400000,0] ;*CAML SHOULD NOT SKIP BECAUSE + 6122 ;C(AC) IS GREATER THAN C(E) + 6123 033347 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + 6124 STOP^ + 6125 033350 254 04 0 00 033351 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6126 033351 324 00 0 00 033352 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6127 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6128 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6129 + 6130 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 20 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0149 + + 6131 ;THIS TEST VERIFIES THAT CAM IS DATA INDEPENDENT. IT NEVER SKIPS + 6132 ;THE NEXT SEQUENTIAL INSTRUCTION + 6133 ;IN THIS CASE, C(AC)=-1 AND C(E)=0 + 6134 ;IF IT DOES SKIP THE NEXT INSTRUCTION, THE PROGRAM HALTS + 6135 + 6136 033352 200 00 0 00 035524 B1100: MOVE [-1] ;PRELOAD AC WITH -1 + 6137 033353 310 00 0 00 035412 CAM [0] ;*CAM SHOULD NEVER SKIP + 6138 033354 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF CAM PASSES + 6139 STOP^ + 6140 033355 254 04 0 00 033356 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6141 033356 324 00 0 00 033357 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6142 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6143 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6144 + 6145 ;********** + 6146 + 6147 ;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 6148 ;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E). + 6149 ;IN THIS CASE, C(AC)=-1 AND C(E)=0; HENCE, CAMGE SHOULD NOT SKIP. + 6150 ;OTHERWISE, THE PROGRAM HALTS. + 6151 + 6152 033357 200 00 0 00 035524 B1200: MOVE [-1] ;PRELOAD AC WITH-1 + 6153 033360 315 00 0 00 035412 CAMGE [0] ;*CAMGE SHOULD NOT SKIP BECAUSE C(AC) IS LESS THAN C(E) + 6154 033361 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF CAMGE PASSES. + 6155 STOP^ + 6156 033362 254 04 0 00 033363 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6157 033363 324 00 0 00 033364 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6158 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6159 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6160 + 6161 ;***** FAILURE ANALYSIS ***** + 6162 ;C(AC0) C(AC1) FAILING SIGNAL + 6163 + 6164 ; FC: PC CHANGE + 6165 ; FC: AB PC EN + 6166 + 6167 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 21 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0150 + + 6168 ;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 6169 ;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E) + 6170 ;IN THIS CASE, C(AC)=0 AND C(E)=-1; HENCE CAMGE SHOULD SKIP. + 6171 ;OTHEWISE, THE PROGRAM HALTS. + 6172 + 6173 033364 400 00 0 00 000000 B1300: SETZ ;PRELOAD AC WITH 0 + 6174 033365 315 00 0 00 035524 CAMGE [-1] ;*CAMGE SHOULD SKIP BECAUSE C(AC) IS GREATER THAN C(E) + 6175 STOP^ + 6176 033366 254 04 0 00 033367 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6177 033367 324 00 0 00 033370 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6178 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6179 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6180 + 6181 ;***** FAILURE ANALYSIS ***** + 6182 ;C(AC0) C(AC1) FAILING SIGNAL + 6183 + 6184 ; SW: FCE + 6185 ; ET0: COND Q: PC CLK EN + 6186 + 6187 ;********** + 6188 + 6189 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 6190 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E) + 6191 ;IN THIS CASE C(AC)=0 AND C(E)=-1; HENCE CAMN SHOULD SKIP. + 6192 ;OTHERWISE, THE PROGRAM HALTS + 6193 + 6194 033370 400 00 0 00 000000 B1400: SETZ ;PRELOAD AC WITH 0 + 6195 033371 316 00 0 00 035524 CAMN [-1] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 6196 STOP^ + 6197 033372 254 04 0 00 033373 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6198 033373 324 00 0 00 033374 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6199 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6200 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6201 + 6202 ;***** FAILURE ANALYSIS ***** + 6203 ;C(AC0) C(AC1) FAILING SIGNAL + 6204 + 6205 ; FC:AD FM + EN + 6206 ; FC: AD AR - EN + 6207 ; FC: AD CRY 36 + 6208 ; FC: AD ADD + 6209 ; FC: AB PC EN + 6210 ; ET0: PC CLK EN + 6211 + 6212 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 22 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0151 + + 6213 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 6214 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E) + 6215 ;IN THIS CASE, C(AC)=0 AND C(E)=0; HENCE CAMN SHOULD NOT SKIP. + 6216 ;OTHERWISE, THE PROGRAM HALTS + 6217 + 6218 033374 400 00 0 00 000000 B1500: SETZ ;PRELOAD AC WITH 0 + 6219 033375 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD NOT SKIP BECAUSE C(AC)=C(E). + 6220 033376 334 00 0 00 000000 SKIPA ;SKIP HALT INSTRUCTION IF CAMN PASSES + 6221 STOP^ + 6222 033377 254 04 0 00 033400 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6223 033400 324 00 0 00 033401 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6224 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6225 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6226 + 6227 ;***** FAILURE ANALYSIS ***** + 6228 ;C(AC0) C(AC1) FAILING SIGNAL + 6229 + 6230 ; SW: FCE + 6231 ; FC: PC CHANGE + 6232 + 6233 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 23 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0152 + + 6234 001600 SN=1600 + 6235 000000 ZZ=0 + 6236 + 6237 B1600: REPEAT ^D18,< + 6238 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6239 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6240 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6241 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6242 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6243 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6244 + 6245 SN=SN+1 + 6246 ZZ=ZZ+ZZ + 6247 IFE ZZ, + 6248 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6249 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6250 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6251 STOP + 6252 + 6253 ;***** FAILURE ANALYSIS ***** + 6254 ;C(AC0) C(AC1) FAILING SIGNAL + 6255 + 6256 ; ET0: COND P + 6257 + 6258 ;********** + 6259 > + 6260 + 6261 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6262 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6263 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6264 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6265 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6266 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6267 + 6268 001601 SN=SN+1 + 6269 000000 ZZ=ZZ+ZZ + 6270 000001 IFE ZZ, + 6271 033401 200 00 0 00 035416 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6272 033402 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6273 033403 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6274 STOP^ + 6275 033404 254 04 0 00 033405 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6276 033405 324 00 0 00 033406 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6277 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6278 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6279 + 6280 ;***** FAILURE ANALYSIS ***** + 6281 ;C(AC0) C(AC1) FAILING SIGNAL + 6282 + 6283 ; ET0: COND P + 6284 + 6285 ;********** + 6286 + 6287 + 6288 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 23-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0153 + + 6289 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6290 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6291 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6292 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6293 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6294 + 6295 001602 SN=SN+1 + 6296 000002 ZZ=ZZ+ZZ + 6297 IFE ZZ, + 6298 033406 200 00 0 00 035417 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6299 033407 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6300 033410 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6301 STOP^ + 6302 033411 254 04 0 00 033412 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6303 033412 324 00 0 00 033413 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6304 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6305 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6306 + 6307 ;***** FAILURE ANALYSIS ***** + 6308 ;C(AC0) C(AC1) FAILING SIGNAL + 6309 + 6310 ; ET0: COND P + 6311 + 6312 ;********** + 6313 + 6314 + 6315 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6316 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6317 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6318 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6319 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6320 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6321 + 6322 001603 SN=SN+1 + 6323 000004 ZZ=ZZ+ZZ + 6324 IFE ZZ, + 6325 033413 200 00 0 00 035420 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6326 033414 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6327 033415 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6328 STOP^ + 6329 033416 254 04 0 00 033417 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6330 033417 324 00 0 00 033420 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6331 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6332 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6333 + 6334 ;***** FAILURE ANALYSIS ***** + 6335 ;C(AC0) C(AC1) FAILING SIGNAL + 6336 + 6337 ; ET0: COND P + 6338 + 6339 ;********** + 6340 + 6341 + 6342 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6343 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 23-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0154 + + 6344 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6345 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6346 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6347 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6348 + 6349 001604 SN=SN+1 + 6350 000010 ZZ=ZZ+ZZ + 6351 IFE ZZ, + 6352 033420 200 00 0 00 035421 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6353 033421 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6354 033422 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6355 STOP^ + 6356 033423 254 04 0 00 033424 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6357 033424 324 00 0 00 033425 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6358 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6359 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6360 + 6361 ;***** FAILURE ANALYSIS ***** + 6362 ;C(AC0) C(AC1) FAILING SIGNAL + 6363 + 6364 ; ET0: COND P + 6365 + 6366 ;********** + 6367 + 6368 + 6369 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6370 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6371 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6372 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6373 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6374 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6375 + 6376 001605 SN=SN+1 + 6377 000020 ZZ=ZZ+ZZ + 6378 IFE ZZ, + 6379 033425 200 00 0 00 035422 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6380 033426 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6381 033427 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6382 STOP^ + 6383 033430 254 04 0 00 033431 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6384 033431 324 00 0 00 033432 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6385 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6386 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6387 + 6388 ;***** FAILURE ANALYSIS ***** + 6389 ;C(AC0) C(AC1) FAILING SIGNAL + 6390 + 6391 ; ET0: COND P + 6392 + 6393 ;********** + 6394 + 6395 + 6396 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6397 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6398 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 23-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0155 + + 6399 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6400 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6401 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6402 + 6403 001606 SN=SN+1 + 6404 000040 ZZ=ZZ+ZZ + 6405 IFE ZZ, + 6406 033432 200 00 0 00 035423 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6407 033433 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6408 033434 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6409 STOP^ + 6410 033435 254 04 0 00 033436 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6411 033436 324 00 0 00 033437 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6412 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6413 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6414 + 6415 ;***** FAILURE ANALYSIS ***** + 6416 ;C(AC0) C(AC1) FAILING SIGNAL + 6417 + 6418 ; ET0: COND P + 6419 + 6420 ;********** + 6421 + 6422 + 6423 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6424 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6425 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6426 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6427 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6428 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6429 + 6430 001607 SN=SN+1 + 6431 000100 ZZ=ZZ+ZZ + 6432 IFE ZZ, + 6433 033437 200 00 0 00 035424 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6434 033440 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6435 033441 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6436 STOP^ + 6437 033442 254 04 0 00 033443 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6438 033443 324 00 0 00 033444 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6439 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6440 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6441 + 6442 ;***** FAILURE ANALYSIS ***** + 6443 ;C(AC0) C(AC1) FAILING SIGNAL + 6444 + 6445 ; ET0: COND P + 6446 + 6447 ;********** + 6448 + 6449 + 6450 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6451 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6452 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6453 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 23-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0156 + + 6454 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6455 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6456 + 6457 001610 SN=SN+1 + 6458 000200 ZZ=ZZ+ZZ + 6459 IFE ZZ, + 6460 033444 200 00 0 00 035425 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6461 033445 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6462 033446 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6463 STOP^ + 6464 033447 254 04 0 00 033450 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6465 033450 324 00 0 00 033451 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6466 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6467 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6468 + 6469 ;***** FAILURE ANALYSIS ***** + 6470 ;C(AC0) C(AC1) FAILING SIGNAL + 6471 + 6472 ; ET0: COND P + 6473 + 6474 ;********** + 6475 + 6476 + 6477 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6478 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6479 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6480 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6481 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6482 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6483 + 6484 001611 SN=SN+1 + 6485 000400 ZZ=ZZ+ZZ + 6486 IFE ZZ, + 6487 033451 200 00 0 00 035426 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6488 033452 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6489 033453 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6490 STOP^ + 6491 033454 254 04 0 00 033455 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6492 033455 324 00 0 00 033456 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6493 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6494 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6495 + 6496 ;***** FAILURE ANALYSIS ***** + 6497 ;C(AC0) C(AC1) FAILING SIGNAL + 6498 + 6499 ; ET0: COND P + 6500 + 6501 ;********** + 6502 + 6503 + 6504 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6505 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6506 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6507 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6508 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 23-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0157 + + 6509 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6510 + 6511 001612 SN=SN+1 + 6512 001000 ZZ=ZZ+ZZ + 6513 IFE ZZ, + 6514 033456 200 00 0 00 035427 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6515 033457 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6516 033460 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6517 STOP^ + 6518 033461 254 04 0 00 033462 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6519 033462 324 00 0 00 033463 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6520 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6521 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6522 + 6523 ;***** FAILURE ANALYSIS ***** + 6524 ;C(AC0) C(AC1) FAILING SIGNAL + 6525 + 6526 ; ET0: COND P + 6527 + 6528 ;********** + 6529 + 6530 + 6531 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6532 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6533 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6534 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6535 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6536 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6537 + 6538 001613 SN=SN+1 + 6539 002000 ZZ=ZZ+ZZ + 6540 IFE ZZ, + 6541 033463 200 00 0 00 035430 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6542 033464 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6543 033465 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6544 STOP^ + 6545 033466 254 04 0 00 033467 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6546 033467 324 00 0 00 033470 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6547 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6548 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6549 + 6550 ;***** FAILURE ANALYSIS ***** + 6551 ;C(AC0) C(AC1) FAILING SIGNAL + 6552 + 6553 ; ET0: COND P + 6554 + 6555 ;********** + 6556 + 6557 + 6558 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6559 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6560 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6561 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6562 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6563 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 23-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0158 + + 6564 + 6565 001614 SN=SN+1 + 6566 004000 ZZ=ZZ+ZZ + 6567 IFE ZZ, + 6568 033470 200 00 0 00 035431 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6569 033471 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6570 033472 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6571 STOP^ + 6572 033473 254 04 0 00 033474 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6573 033474 324 00 0 00 033475 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6574 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6575 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6576 + 6577 ;***** FAILURE ANALYSIS ***** + 6578 ;C(AC0) C(AC1) FAILING SIGNAL + 6579 + 6580 ; ET0: COND P + 6581 + 6582 ;********** + 6583 + 6584 + 6585 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6586 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6587 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6588 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6589 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6590 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6591 + 6592 001615 SN=SN+1 + 6593 010000 ZZ=ZZ+ZZ + 6594 IFE ZZ, + 6595 033475 200 00 0 00 035432 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6596 033476 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6597 033477 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6598 STOP^ + 6599 033500 254 04 0 00 033501 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6600 033501 324 00 0 00 033502 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6601 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6602 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6603 + 6604 ;***** FAILURE ANALYSIS ***** + 6605 ;C(AC0) C(AC1) FAILING SIGNAL + 6606 + 6607 ; ET0: COND P + 6608 + 6609 ;********** + 6610 + 6611 + 6612 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6613 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6614 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6615 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6616 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6617 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6618 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 23-7 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0159 + + 6619 001616 SN=SN+1 + 6620 020000 ZZ=ZZ+ZZ + 6621 IFE ZZ, + 6622 033502 200 00 0 00 035433 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6623 033503 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6624 033504 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6625 STOP^ + 6626 033505 254 04 0 00 033506 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6627 033506 324 00 0 00 033507 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6628 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6629 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6630 + 6631 ;***** FAILURE ANALYSIS ***** + 6632 ;C(AC0) C(AC1) FAILING SIGNAL + 6633 + 6634 ; ET0: COND P + 6635 + 6636 ;********** + 6637 + 6638 + 6639 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6640 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6641 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6642 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6643 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6644 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6645 + 6646 001617 SN=SN+1 + 6647 040000 ZZ=ZZ+ZZ + 6648 IFE ZZ, + 6649 033507 200 00 0 00 035434 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6650 033510 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6651 033511 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6652 STOP^ + 6653 033512 254 04 0 00 033513 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6654 033513 324 00 0 00 033514 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6655 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6656 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6657 + 6658 ;***** FAILURE ANALYSIS ***** + 6659 ;C(AC0) C(AC1) FAILING SIGNAL + 6660 + 6661 ; ET0: COND P + 6662 + 6663 ;********** + 6664 + 6665 + 6666 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6667 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6668 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6669 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6670 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6671 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6672 + 6673 001620 SN=SN+1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 23-8 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0160 + + 6674 100000 ZZ=ZZ+ZZ + 6675 IFE ZZ, + 6676 033514 200 00 0 00 035435 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6677 033515 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6678 033516 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6679 STOP^ + 6680 033517 254 04 0 00 033520 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6681 033520 324 00 0 00 033521 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 ;***** FAILURE ANALYSIS ***** + 6686 ;C(AC0) C(AC1) FAILING SIGNAL + 6687 + 6688 ; ET0: COND P + 6689 + 6690 ;********** + 6691 + 6692 + 6693 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6694 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6695 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6696 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6697 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6698 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6699 + 6700 001621 SN=SN+1 + 6701 200000 ZZ=ZZ+ZZ + 6702 IFE ZZ, + 6703 033521 200 00 0 00 035436 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6704 033522 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6705 033523 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6706 STOP^ + 6707 033524 254 04 0 00 033525 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6708 033525 324 00 0 00 033526 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6709 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6710 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6711 + 6712 ;***** FAILURE ANALYSIS ***** + 6713 ;C(AC0) C(AC1) FAILING SIGNAL + 6714 + 6715 ; ET0: COND P + 6716 + 6717 ;********** + 6718 + 6719 + 6720 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6721 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6722 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6723 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6724 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6725 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6726 + 6727 001622 SN=SN+1 + 6728 400000 ZZ=ZZ+ZZ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 23-9 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0161 + + 6729 IFE ZZ, + 6730 033526 200 00 0 00 035437 MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + 6731 033527 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6732 033530 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6733 STOP^ + 6734 033531 254 04 0 00 033532 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6735 033532 324 00 0 00 033533 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6736 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6737 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6738 + 6739 ;***** FAILURE ANALYSIS ***** + 6740 ;C(AC0) C(AC1) FAILING SIGNAL + 6741 + 6742 ; ET0: COND P + 6743 + 6744 ;********** + 6745 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 24 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0162 + + 6746 000000 ZZ=0 + 6747 + 6748 REPEAT ^D18,< + 6749 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6750 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6751 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6752 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6753 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6754 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6755 + 6756 SN=SN+1 + 6757 ZZ=ZZ+ZZ + 6758 IFE ZZ, + 6759 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6760 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6761 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6762 STOP + 6763 + 6764 ;********** + 6765 > + 6766 + 6767 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6768 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6769 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6770 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6771 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6772 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6773 + 6774 001623 SN=SN+1 + 6775 000000 ZZ=ZZ+ZZ + 6776 000001 IFE ZZ, + 6777 033533 200 00 0 00 035440 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6778 033534 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6779 033535 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6780 STOP^ + 6781 033536 254 04 0 00 033537 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6782 033537 324 00 0 00 033540 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6783 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6784 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6785 + 6786 ;********** + 6787 + 6788 + 6789 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6790 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6791 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6792 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6793 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6794 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6795 + 6796 001624 SN=SN+1 + 6797 000002 ZZ=ZZ+ZZ + 6798 IFE ZZ, + 6799 033540 200 00 0 00 035441 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6800 033541 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 24-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0163 + + 6801 033542 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6802 STOP^ + 6803 033543 254 04 0 00 033544 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6804 033544 324 00 0 00 033545 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6805 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6806 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6807 + 6808 ;********** + 6809 + 6810 + 6811 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6812 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6813 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6814 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6815 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6816 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6817 + 6818 001625 SN=SN+1 + 6819 000004 ZZ=ZZ+ZZ + 6820 IFE ZZ, + 6821 033545 200 00 0 00 035442 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6822 033546 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6823 033547 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6824 STOP^ + 6825 033550 254 04 0 00 033551 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6826 033551 324 00 0 00 033552 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6827 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6828 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6829 + 6830 ;********** + 6831 + 6832 + 6833 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6834 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6835 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6836 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6837 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6838 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6839 + 6840 001626 SN=SN+1 + 6841 000010 ZZ=ZZ+ZZ + 6842 IFE ZZ, + 6843 033552 200 00 0 00 035443 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6844 033553 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6845 033554 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6846 STOP^ + 6847 033555 254 04 0 00 033556 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6848 033556 324 00 0 00 033557 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6849 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6850 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6851 + 6852 ;********** + 6853 + 6854 + 6855 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 24-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0164 + + 6856 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6857 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6858 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6859 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6860 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6861 + 6862 001627 SN=SN+1 + 6863 000020 ZZ=ZZ+ZZ + 6864 IFE ZZ, + 6865 033557 200 00 0 00 035444 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6866 033560 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6867 033561 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6868 STOP^ + 6869 033562 254 04 0 00 033563 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6870 033563 324 00 0 00 033564 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6871 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6872 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6873 + 6874 ;********** + 6875 + 6876 + 6877 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6878 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6879 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6880 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6881 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6882 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6883 + 6884 001630 SN=SN+1 + 6885 000040 ZZ=ZZ+ZZ + 6886 IFE ZZ, + 6887 033564 200 00 0 00 035445 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6888 033565 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6889 033566 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6890 STOP^ + 6891 033567 254 04 0 00 033570 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6892 033570 324 00 0 00 033571 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6893 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6894 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6895 + 6896 ;********** + 6897 + 6898 + 6899 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6900 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6901 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6902 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6903 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6904 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6905 + 6906 001631 SN=SN+1 + 6907 000100 ZZ=ZZ+ZZ + 6908 IFE ZZ, + 6909 033571 200 00 0 00 035446 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6910 033572 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 24-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0165 + + 6911 033573 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6912 STOP^ + 6913 033574 254 04 0 00 033575 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6914 033575 324 00 0 00 033576 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6915 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6916 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6917 + 6918 ;********** + 6919 + 6920 + 6921 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6922 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6923 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6924 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6925 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6926 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6927 + 6928 001632 SN=SN+1 + 6929 000200 ZZ=ZZ+ZZ + 6930 IFE ZZ, + 6931 033576 200 00 0 00 035447 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6932 033577 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6933 033600 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6934 STOP^ + 6935 033601 254 04 0 00 033602 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6936 033602 324 00 0 00 033603 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6937 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6938 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6939 + 6940 ;********** + 6941 + 6942 + 6943 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6944 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6945 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6946 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6947 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6948 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6949 + 6950 001633 SN=SN+1 + 6951 000400 ZZ=ZZ+ZZ + 6952 IFE ZZ, + 6953 033603 200 00 0 00 035450 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6954 033604 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6955 033605 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6956 STOP^ + 6957 033606 254 04 0 00 033607 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6958 033607 324 00 0 00 033610 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6959 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6960 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6961 + 6962 ;********** + 6963 + 6964 + 6965 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 24-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0166 + + 6966 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6967 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6968 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6969 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6970 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6971 + 6972 001634 SN=SN+1 + 6973 001000 ZZ=ZZ+ZZ + 6974 IFE ZZ, + 6975 033610 200 00 0 00 035451 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6976 033611 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6977 033612 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 6978 STOP^ + 6979 033613 254 04 0 00 033614 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6980 033614 324 00 0 00 033615 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6981 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6982 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6983 + 6984 ;********** + 6985 + 6986 + 6987 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 6988 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 6989 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 6990 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 6991 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 6992 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 6993 + 6994 001635 SN=SN+1 + 6995 002000 ZZ=ZZ+ZZ + 6996 IFE ZZ, + 6997 033615 200 00 0 00 035452 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 6998 033616 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 6999 033617 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 7000 STOP^ + 7001 033620 254 04 0 00 033621 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7002 033621 324 00 0 00 033622 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7003 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7004 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7005 + 7006 ;********** + 7007 + 7008 + 7009 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 7010 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 7011 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 7012 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 7013 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 7014 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 7015 + 7016 001636 SN=SN+1 + 7017 004000 ZZ=ZZ+ZZ + 7018 IFE ZZ, + 7019 033622 200 00 0 00 035453 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 7020 033623 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 24-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0167 + + 7021 033624 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 7022 STOP^ + 7023 033625 254 04 0 00 033626 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7024 033626 324 00 0 00 033627 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7025 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7026 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7027 + 7028 ;********** + 7029 + 7030 + 7031 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 7032 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 7033 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 7034 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 7035 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 7036 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 7037 + 7038 001637 SN=SN+1 + 7039 010000 ZZ=ZZ+ZZ + 7040 IFE ZZ, + 7041 033627 200 00 0 00 035454 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 7042 033630 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 7043 033631 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 7044 STOP^ + 7045 033632 254 04 0 00 033633 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7046 033633 324 00 0 00 033634 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7047 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7048 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7049 + 7050 ;********** + 7051 + 7052 + 7053 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 7054 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 7055 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 7056 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 7057 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 7058 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 7059 + 7060 001640 SN=SN+1 + 7061 020000 ZZ=ZZ+ZZ + 7062 IFE ZZ, + 7063 033634 200 00 0 00 035455 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 7064 033635 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 7065 033636 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 7066 STOP^ + 7067 033637 254 04 0 00 033640 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7068 033640 324 00 0 00 033641 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7069 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7070 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7071 + 7072 ;********** + 7073 + 7074 + 7075 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 24-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0168 + + 7076 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 7077 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 7078 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 7079 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 7080 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 7081 + 7082 001641 SN=SN+1 + 7083 040000 ZZ=ZZ+ZZ + 7084 IFE ZZ, + 7085 033641 200 00 0 00 035456 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 7086 033642 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 7087 033643 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 7088 STOP^ + 7089 033644 254 04 0 00 033645 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7090 033645 324 00 0 00 033646 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7091 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7092 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7093 + 7094 ;********** + 7095 + 7096 + 7097 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 7098 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 7099 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 7100 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 7101 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 7102 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 7103 + 7104 001642 SN=SN+1 + 7105 100000 ZZ=ZZ+ZZ + 7106 IFE ZZ, + 7107 033646 200 00 0 00 035457 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 7108 033647 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 7109 033650 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 7110 STOP^ + 7111 033651 254 04 0 00 033652 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7112 033652 324 00 0 00 033653 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7113 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7114 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7115 + 7116 ;********** + 7117 + 7118 + 7119 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 7120 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 7121 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 7122 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 7123 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 7124 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 7125 + 7126 001643 SN=SN+1 + 7127 200000 ZZ=ZZ+ZZ + 7128 IFE ZZ, + 7129 033653 200 00 0 00 035460 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 7130 033654 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 24-7 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0169 + + 7131 033655 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 7132 STOP^ + 7133 033656 254 04 0 00 033657 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7134 033657 324 00 0 00 033660 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 + 7141 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY + 7142 ;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME + 7143 ;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN + 7144 ;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) + 7145 ;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS + 7146 ;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + 7147 + 7148 001644 SN=SN+1 + 7149 400000 ZZ=ZZ+ZZ + 7150 IFE ZZ, + 7151 033660 200 00 0 00 035461 MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + 7152 033661 316 00 0 00 000000 CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + 7153 033662 312 00 0 00 000000 CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + 7154 STOP^ + 7155 033663 254 04 0 00 033664 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7156 033664 324 00 0 00 033665 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7157 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7158 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7159 + 7160 ;********** + 7161 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0170 + + 7162 001700 SN=1700 + 7163 000000 ZZ=0 + 7164 + 7165 B1700: REPEAT ^D36,< + 7166 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7167 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7168 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7169 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7170 SN=SN+1 + 7171 ZZ=ZZ+ZZ + 7172 IFE ZZ, + 7173 SETZ ;PRELOAD AC WITH 0 + 7174 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7175 STOP + 7176 + 7177 ;********** + 7178 > + 7179 + 7180 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7181 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7182 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7183 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7184 001701 SN=SN+1 + 7185 000000 ZZ=ZZ+ZZ + 7186 000001 IFE ZZ, + 7187 033665 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7188 033666 316 00 0 00 035416 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7189 STOP ^ + 7190 033667 254 04 0 00 033670 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7191 033670 324 00 0 00 033671 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7192 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7193 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7194 + 7195 ;********** + 7196 + 7197 + 7198 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7199 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7200 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7201 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7202 001702 SN=SN+1 + 7203 000002 ZZ=ZZ+ZZ + 7204 IFE ZZ, + 7205 033671 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7206 033672 316 00 0 00 035417 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7207 STOP ^ + 7208 033673 254 04 0 00 033674 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7209 033674 324 00 0 00 033675 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7210 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7211 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7212 + 7213 ;********** + 7214 + 7215 + 7216 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0171 + + 7217 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7218 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7219 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7220 001703 SN=SN+1 + 7221 000004 ZZ=ZZ+ZZ + 7222 IFE ZZ, + 7223 033675 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7224 033676 316 00 0 00 035420 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7225 STOP ^ + 7226 033677 254 04 0 00 033700 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7227 033700 324 00 0 00 033701 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7228 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7229 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7230 + 7231 ;********** + 7232 + 7233 + 7234 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7235 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7236 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7237 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7238 001704 SN=SN+1 + 7239 000010 ZZ=ZZ+ZZ + 7240 IFE ZZ, + 7241 033701 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7242 033702 316 00 0 00 035421 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7243 STOP ^ + 7244 033703 254 04 0 00 033704 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7245 033704 324 00 0 00 033705 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7246 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7247 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7248 + 7249 ;********** + 7250 + 7251 + 7252 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7253 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7254 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7255 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7256 001705 SN=SN+1 + 7257 000020 ZZ=ZZ+ZZ + 7258 IFE ZZ, + 7259 033705 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7260 033706 316 00 0 00 035422 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7261 STOP ^ + 7262 033707 254 04 0 00 033710 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7263 033710 324 00 0 00 033711 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7264 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7265 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7266 + 7267 ;********** + 7268 + 7269 + 7270 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7271 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0172 + + 7272 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7273 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7274 001706 SN=SN+1 + 7275 000040 ZZ=ZZ+ZZ + 7276 IFE ZZ, + 7277 033711 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7278 033712 316 00 0 00 035423 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7279 STOP ^ + 7280 033713 254 04 0 00 033714 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7281 033714 324 00 0 00 033715 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 + 7288 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7289 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7290 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7291 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7292 001707 SN=SN+1 + 7293 000100 ZZ=ZZ+ZZ + 7294 IFE ZZ, + 7295 033715 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7296 033716 316 00 0 00 035424 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7297 STOP ^ + 7298 033717 254 04 0 00 033720 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7299 033720 324 00 0 00 033721 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7300 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7301 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7302 + 7303 ;********** + 7304 + 7305 + 7306 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7307 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7308 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7309 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7310 001710 SN=SN+1 + 7311 000200 ZZ=ZZ+ZZ + 7312 IFE ZZ, + 7313 033721 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7314 033722 316 00 0 00 035425 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7315 STOP ^ + 7316 033723 254 04 0 00 033724 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7317 033724 324 00 0 00 033725 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7318 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7319 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7320 + 7321 ;********** + 7322 + 7323 + 7324 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7325 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7326 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0173 + + 7327 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7328 001711 SN=SN+1 + 7329 000400 ZZ=ZZ+ZZ + 7330 IFE ZZ, + 7331 033725 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7332 033726 316 00 0 00 035426 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7333 STOP ^ + 7334 033727 254 04 0 00 033730 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7335 033730 324 00 0 00 033731 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7336 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7337 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7338 + 7339 ;********** + 7340 + 7341 + 7342 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7343 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7344 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7345 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7346 001712 SN=SN+1 + 7347 001000 ZZ=ZZ+ZZ + 7348 IFE ZZ, + 7349 033731 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7350 033732 316 00 0 00 035427 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7351 STOP ^ + 7352 033733 254 04 0 00 033734 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7353 033734 324 00 0 00 033735 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7354 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7355 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7356 + 7357 ;********** + 7358 + 7359 + 7360 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7361 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7362 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7363 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7364 001713 SN=SN+1 + 7365 002000 ZZ=ZZ+ZZ + 7366 IFE ZZ, + 7367 033735 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7368 033736 316 00 0 00 035430 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7369 STOP ^ + 7370 033737 254 04 0 00 033740 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7371 033740 324 00 0 00 033741 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7372 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7373 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7374 + 7375 ;********** + 7376 + 7377 + 7378 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7379 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7380 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7381 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0174 + + 7382 001714 SN=SN+1 + 7383 004000 ZZ=ZZ+ZZ + 7384 IFE ZZ, + 7385 033741 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7386 033742 316 00 0 00 035431 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7387 STOP ^ + 7388 033743 254 04 0 00 033744 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7389 033744 324 00 0 00 033745 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7390 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7391 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7392 + 7393 ;********** + 7394 + 7395 + 7396 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7397 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7398 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7399 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7400 001715 SN=SN+1 + 7401 010000 ZZ=ZZ+ZZ + 7402 IFE ZZ, + 7403 033745 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7404 033746 316 00 0 00 035432 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7405 STOP ^ + 7406 033747 254 04 0 00 033750 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7407 033750 324 00 0 00 033751 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 + 7414 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7415 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7416 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7417 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7418 001716 SN=SN+1 + 7419 020000 ZZ=ZZ+ZZ + 7420 IFE ZZ, + 7421 033751 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7422 033752 316 00 0 00 035433 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7423 STOP ^ + 7424 033753 254 04 0 00 033754 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7425 033754 324 00 0 00 033755 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7426 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7427 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7428 + 7429 ;********** + 7430 + 7431 + 7432 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7433 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7434 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7435 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7436 001717 SN=SN+1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0175 + + 7437 040000 ZZ=ZZ+ZZ + 7438 IFE ZZ, + 7439 033755 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7440 033756 316 00 0 00 035434 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7441 STOP ^ + 7442 033757 254 04 0 00 033760 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7443 033760 324 00 0 00 033761 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7444 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7445 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7446 + 7447 ;********** + 7448 + 7449 + 7450 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7451 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7452 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7453 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7454 001720 SN=SN+1 + 7455 100000 ZZ=ZZ+ZZ + 7456 IFE ZZ, + 7457 033761 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7458 033762 316 00 0 00 035435 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7459 STOP ^ + 7460 033763 254 04 0 00 033764 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7461 033764 324 00 0 00 033765 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7462 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7463 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7464 + 7465 ;********** + 7466 + 7467 + 7468 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7469 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7470 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7471 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7472 001721 SN=SN+1 + 7473 200000 ZZ=ZZ+ZZ + 7474 IFE ZZ, + 7475 033765 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7476 033766 316 00 0 00 035436 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7477 STOP ^ + 7478 033767 254 04 0 00 033770 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7479 033770 324 00 0 00 033771 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7480 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7481 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7482 + 7483 ;********** + 7484 + 7485 + 7486 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7487 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7488 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7489 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7490 001722 SN=SN+1 + 7491 400000 ZZ=ZZ+ZZ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0176 + + 7492 IFE ZZ, + 7493 033771 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7494 033772 316 00 0 00 035437 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7495 STOP ^ + 7496 033773 254 04 0 00 033774 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7497 033774 324 00 0 00 033775 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7498 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7499 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7500 + 7501 ;********** + 7502 + 7503 + 7504 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7505 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7506 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7507 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7508 001723 SN=SN+1 + 7509 000001 000000 ZZ=ZZ+ZZ + 7510 IFE ZZ, + 7511 033775 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7512 033776 316 00 0 00 035440 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7513 STOP ^ + 7514 033777 254 04 0 00 034000 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7515 034000 324 00 0 00 034001 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7516 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7517 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7518 + 7519 ;********** + 7520 + 7521 + 7522 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7523 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7524 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7525 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7526 001724 SN=SN+1 + 7527 000002 000000 ZZ=ZZ+ZZ + 7528 IFE ZZ, + 7529 034001 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7530 034002 316 00 0 00 035441 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7531 STOP ^ + 7532 034003 254 04 0 00 034004 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7533 034004 324 00 0 00 034005 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 + 7540 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7541 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7542 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7543 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7544 001725 SN=SN+1 + 7545 000004 000000 ZZ=ZZ+ZZ + 7546 IFE ZZ, +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-7 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0177 + + 7547 034005 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7548 034006 316 00 0 00 035442 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7549 STOP ^ + 7550 034007 254 04 0 00 034010 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7551 034010 324 00 0 00 034011 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7552 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7553 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7554 + 7555 ;********** + 7556 + 7557 + 7558 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7559 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7560 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7561 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7562 001726 SN=SN+1 + 7563 000010 000000 ZZ=ZZ+ZZ + 7564 IFE ZZ, + 7565 034011 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7566 034012 316 00 0 00 035443 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7567 STOP ^ + 7568 034013 254 04 0 00 034014 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7569 034014 324 00 0 00 034015 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7570 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7571 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7572 + 7573 ;********** + 7574 + 7575 + 7576 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7577 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7578 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7579 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7580 001727 SN=SN+1 + 7581 000020 000000 ZZ=ZZ+ZZ + 7582 IFE ZZ, + 7583 034015 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7584 034016 316 00 0 00 035444 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7585 STOP ^ + 7586 034017 254 04 0 00 034020 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7587 034020 324 00 0 00 034021 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7588 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7589 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7590 + 7591 ;********** + 7592 + 7593 + 7594 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7595 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7596 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7597 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7598 001730 SN=SN+1 + 7599 000040 000000 ZZ=ZZ+ZZ + 7600 IFE ZZ, + 7601 034021 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-8 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0178 + + 7602 034022 316 00 0 00 035445 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7603 STOP ^ + 7604 034023 254 04 0 00 034024 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7605 034024 324 00 0 00 034025 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7606 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7607 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7608 + 7609 ;********** + 7610 + 7611 + 7612 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7613 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7614 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7615 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7616 001731 SN=SN+1 + 7617 000100 000000 ZZ=ZZ+ZZ + 7618 IFE ZZ, + 7619 034025 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7620 034026 316 00 0 00 035446 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7621 STOP ^ + 7622 034027 254 04 0 00 034030 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7623 034030 324 00 0 00 034031 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7624 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7625 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7626 + 7627 ;********** + 7628 + 7629 + 7630 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7631 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7632 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7633 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7634 001732 SN=SN+1 + 7635 000200 000000 ZZ=ZZ+ZZ + 7636 IFE ZZ, + 7637 034031 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7638 034032 316 00 0 00 035447 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7639 STOP ^ + 7640 034033 254 04 0 00 034034 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7641 034034 324 00 0 00 034035 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7642 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7643 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7644 + 7645 ;********** + 7646 + 7647 + 7648 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7649 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7650 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7651 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7652 001733 SN=SN+1 + 7653 000400 000000 ZZ=ZZ+ZZ + 7654 IFE ZZ, + 7655 034035 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7656 034036 316 00 0 00 035450 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-9 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0179 + + 7657 STOP ^ + 7658 034037 254 04 0 00 034040 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7659 034040 324 00 0 00 034041 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7660 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7661 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7662 + 7663 ;********** + 7664 + 7665 + 7666 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7667 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7668 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7669 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7670 001734 SN=SN+1 + 7671 001000 000000 ZZ=ZZ+ZZ + 7672 IFE ZZ, + 7673 034041 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7674 034042 316 00 0 00 035451 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7675 STOP ^ + 7676 034043 254 04 0 00 034044 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7677 034044 324 00 0 00 034045 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7678 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7679 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7680 + 7681 ;********** + 7682 + 7683 + 7684 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7685 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7686 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7687 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7688 001735 SN=SN+1 + 7689 002000 000000 ZZ=ZZ+ZZ + 7690 IFE ZZ, + 7691 034045 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7692 034046 316 00 0 00 035452 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7693 STOP ^ + 7694 034047 254 04 0 00 034050 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7695 034050 324 00 0 00 034051 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7696 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7697 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7698 + 7699 ;********** + 7700 + 7701 + 7702 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7703 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7704 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7705 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7706 001736 SN=SN+1 + 7707 004000 000000 ZZ=ZZ+ZZ + 7708 IFE ZZ, + 7709 034051 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7710 034052 316 00 0 00 035453 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7711 STOP ^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-10 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0180 + + 7712 034053 254 04 0 00 034054 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7713 034054 324 00 0 00 034055 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7714 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7715 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7716 + 7717 ;********** + 7718 + 7719 + 7720 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7721 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7722 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7723 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7724 001737 SN=SN+1 + 7725 010000 000000 ZZ=ZZ+ZZ + 7726 IFE ZZ, + 7727 034055 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7728 034056 316 00 0 00 035454 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7729 STOP ^ + 7730 034057 254 04 0 00 034060 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7731 034060 324 00 0 00 034061 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7732 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7733 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7734 + 7735 ;********** + 7736 + 7737 + 7738 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7739 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7740 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7741 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7742 001740 SN=SN+1 + 7743 020000 000000 ZZ=ZZ+ZZ + 7744 IFE ZZ, + 7745 034061 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7746 034062 316 00 0 00 035455 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7747 STOP ^ + 7748 034063 254 04 0 00 034064 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7749 034064 324 00 0 00 034065 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7750 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7751 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7752 + 7753 ;********** + 7754 + 7755 + 7756 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7757 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7758 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7759 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7760 001741 SN=SN+1 + 7761 040000 000000 ZZ=ZZ+ZZ + 7762 IFE ZZ, + 7763 034065 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7764 034066 316 00 0 00 035456 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7765 STOP ^ + 7766 034067 254 04 0 00 034070 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-11 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0181 + + 7767 034070 324 00 0 00 034071 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7768 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7769 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7770 + 7771 ;********** + 7772 + 7773 + 7774 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7775 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7776 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7777 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7778 001742 SN=SN+1 + 7779 100000 000000 ZZ=ZZ+ZZ + 7780 IFE ZZ, + 7781 034071 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7782 034072 316 00 0 00 035457 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7783 STOP ^ + 7784 034073 254 04 0 00 034074 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7785 034074 324 00 0 00 034075 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7786 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7787 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7788 + 7789 ;********** + 7790 + 7791 + 7792 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7793 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7794 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7795 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7796 001743 SN=SN+1 + 7797 200000 000000 ZZ=ZZ+ZZ + 7798 IFE ZZ, + 7799 034075 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7800 034076 316 00 0 00 035460 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7801 STOP ^ + 7802 034077 254 04 0 00 034100 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7803 034100 324 00 0 00 034101 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7804 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7805 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7806 + 7807 ;********** + 7808 + 7809 + 7810 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND + 7811 ;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, + 7812 ;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS + 7813 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E + 7814 001744 SN=SN+1 + 7815 400000 000000 ZZ=ZZ+ZZ + 7816 IFE ZZ, + 7817 034101 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 7818 034102 316 00 0 00 035461 CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7819 STOP ^ + 7820 034103 254 04 0 00 034104 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7821 034104 324 00 0 00 034105 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 25-12 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0182 + + 7822 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7823 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7824 + 7825 ;********** + 7826 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0183 + + 7827 002000 SN=2000 + 7828 000000 ZZ=0 + 7829 + 7830 B2000: REPEAT ^D36,< + 7831 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 7832 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 7833 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 7834 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 7835 SN=SN+1 + 7836 ZZ=ZZ+ZZ + 7837 IFE ZZ, + 7838 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 7839 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7840 STOP + 7841 + 7842 ;********** + 7843 > + 7844 + 7845 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 7846 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 7847 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 7848 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 7849 002001 SN=SN+1 + 7850 000000 ZZ=ZZ+ZZ + 7851 000001 IFE ZZ, + 7852 034105 200 00 0 00 035416 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 7853 034106 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7854 STOP^ + 7855 034107 254 04 0 00 034110 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7856 034110 324 00 0 00 034111 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7857 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7858 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7859 + 7860 ;********** + 7861 + 7862 + 7863 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 7864 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 7865 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 7866 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 7867 002002 SN=SN+1 + 7868 000002 ZZ=ZZ+ZZ + 7869 IFE ZZ, + 7870 034111 200 00 0 00 035417 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 7871 034112 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7872 STOP^ + 7873 034113 254 04 0 00 034114 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7874 034114 324 00 0 00 034115 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7875 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7876 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7877 + 7878 ;********** + 7879 + 7880 + 7881 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0184 + + 7882 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 7883 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 7884 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 7885 002003 SN=SN+1 + 7886 000004 ZZ=ZZ+ZZ + 7887 IFE ZZ, + 7888 034115 200 00 0 00 035420 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 7889 034116 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7890 STOP^ + 7891 034117 254 04 0 00 034120 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7892 034120 324 00 0 00 034121 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7893 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7894 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7895 + 7896 ;********** + 7897 + 7898 + 7899 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 7900 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 7901 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 7902 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 7903 002004 SN=SN+1 + 7904 000010 ZZ=ZZ+ZZ + 7905 IFE ZZ, + 7906 034121 200 00 0 00 035421 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 7907 034122 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7908 STOP^ + 7909 034123 254 04 0 00 034124 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7910 034124 324 00 0 00 034125 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7911 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7912 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7913 + 7914 ;********** + 7915 + 7916 + 7917 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 7918 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 7919 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 7920 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 7921 002005 SN=SN+1 + 7922 000020 ZZ=ZZ+ZZ + 7923 IFE ZZ, + 7924 034125 200 00 0 00 035422 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 7925 034126 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7926 STOP^ + 7927 034127 254 04 0 00 034130 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7928 034130 324 00 0 00 034131 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7929 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7930 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7931 + 7932 ;********** + 7933 + 7934 + 7935 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 7936 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0185 + + 7937 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 7938 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 7939 002006 SN=SN+1 + 7940 000040 ZZ=ZZ+ZZ + 7941 IFE ZZ, + 7942 034131 200 00 0 00 035423 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 7943 034132 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7944 STOP^ + 7945 034133 254 04 0 00 034134 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7946 034134 324 00 0 00 034135 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7947 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7948 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7949 + 7950 ;********** + 7951 + 7952 + 7953 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 7954 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 7955 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 7956 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 7957 002007 SN=SN+1 + 7958 000100 ZZ=ZZ+ZZ + 7959 IFE ZZ, + 7960 034135 200 00 0 00 035424 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 7961 034136 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7962 STOP^ + 7963 034137 254 04 0 00 034140 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7964 034140 324 00 0 00 034141 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7965 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7966 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7967 + 7968 ;********** + 7969 + 7970 + 7971 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 7972 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 7973 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 7974 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 7975 002010 SN=SN+1 + 7976 000200 ZZ=ZZ+ZZ + 7977 IFE ZZ, + 7978 034141 200 00 0 00 035425 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 7979 034142 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7980 STOP^ + 7981 034143 254 04 0 00 034144 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7982 034144 324 00 0 00 034145 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7983 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7984 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7985 + 7986 ;********** + 7987 + 7988 + 7989 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 7990 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 7991 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0186 + + 7992 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 7993 002011 SN=SN+1 + 7994 000400 ZZ=ZZ+ZZ + 7995 IFE ZZ, + 7996 034145 200 00 0 00 035426 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 7997 034146 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 7998 STOP^ + 7999 034147 254 04 0 00 034150 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8000 034150 324 00 0 00 034151 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 + 8006 + 8007 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8008 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8009 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8010 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8011 002012 SN=SN+1 + 8012 001000 ZZ=ZZ+ZZ + 8013 IFE ZZ, + 8014 034151 200 00 0 00 035427 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8015 034152 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8016 STOP^ + 8017 034153 254 04 0 00 034154 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8018 034154 324 00 0 00 034155 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8019 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8020 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8021 + 8022 ;********** + 8023 + 8024 + 8025 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8026 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8027 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8028 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8029 002013 SN=SN+1 + 8030 002000 ZZ=ZZ+ZZ + 8031 IFE ZZ, + 8032 034155 200 00 0 00 035430 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8033 034156 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8034 STOP^ + 8035 034157 254 04 0 00 034160 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8036 034160 324 00 0 00 034161 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8037 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8038 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8039 + 8040 ;********** + 8041 + 8042 + 8043 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8044 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8045 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8046 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0187 + + 8047 002014 SN=SN+1 + 8048 004000 ZZ=ZZ+ZZ + 8049 IFE ZZ, + 8050 034161 200 00 0 00 035431 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8051 034162 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8052 STOP^ + 8053 034163 254 04 0 00 034164 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8054 034164 324 00 0 00 034165 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8055 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8056 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8057 + 8058 ;********** + 8059 + 8060 + 8061 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8062 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8063 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8064 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8065 002015 SN=SN+1 + 8066 010000 ZZ=ZZ+ZZ + 8067 IFE ZZ, + 8068 034165 200 00 0 00 035432 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8069 034166 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8070 STOP^ + 8071 034167 254 04 0 00 034170 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8072 034170 324 00 0 00 034171 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8073 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8074 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8075 + 8076 ;********** + 8077 + 8078 + 8079 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8080 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8081 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8082 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8083 002016 SN=SN+1 + 8084 020000 ZZ=ZZ+ZZ + 8085 IFE ZZ, + 8086 034171 200 00 0 00 035433 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8087 034172 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8088 STOP^ + 8089 034173 254 04 0 00 034174 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8090 034174 324 00 0 00 034175 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8091 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8092 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8093 + 8094 ;********** + 8095 + 8096 + 8097 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8098 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8099 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8100 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8101 002017 SN=SN+1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0188 + + 8102 040000 ZZ=ZZ+ZZ + 8103 IFE ZZ, + 8104 034175 200 00 0 00 035434 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8105 034176 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8106 STOP^ + 8107 034177 254 04 0 00 034200 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8108 034200 324 00 0 00 034201 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8109 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8110 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8111 + 8112 ;********** + 8113 + 8114 + 8115 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8116 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8117 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8118 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8119 002020 SN=SN+1 + 8120 100000 ZZ=ZZ+ZZ + 8121 IFE ZZ, + 8122 034201 200 00 0 00 035435 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8123 034202 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8124 STOP^ + 8125 034203 254 04 0 00 034204 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8126 034204 324 00 0 00 034205 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8127 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8128 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8129 + 8130 ;********** + 8131 + 8132 + 8133 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8134 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8135 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8136 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8137 002021 SN=SN+1 + 8138 200000 ZZ=ZZ+ZZ + 8139 IFE ZZ, + 8140 034205 200 00 0 00 035436 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8141 034206 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8142 STOP^ + 8143 034207 254 04 0 00 034210 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8144 034210 324 00 0 00 034211 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8145 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8146 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8147 + 8148 ;********** + 8149 + 8150 + 8151 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8152 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8153 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8154 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8155 002022 SN=SN+1 + 8156 400000 ZZ=ZZ+ZZ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0189 + + 8157 IFE ZZ, + 8158 034211 200 00 0 00 035437 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8159 034212 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8160 STOP^ + 8161 034213 254 04 0 00 034214 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8162 034214 324 00 0 00 034215 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8163 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8164 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8165 + 8166 ;********** + 8167 + 8168 + 8169 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8170 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8171 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8172 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8173 002023 SN=SN+1 + 8174 000001 000000 ZZ=ZZ+ZZ + 8175 IFE ZZ, + 8176 034215 200 00 0 00 035440 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8177 034216 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8178 STOP^ + 8179 034217 254 04 0 00 034220 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8180 034220 324 00 0 00 034221 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8181 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8182 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8183 + 8184 ;********** + 8185 + 8186 + 8187 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8188 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8189 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8190 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8191 002024 SN=SN+1 + 8192 000002 000000 ZZ=ZZ+ZZ + 8193 IFE ZZ, + 8194 034221 200 00 0 00 035441 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8195 034222 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8196 STOP^ + 8197 034223 254 04 0 00 034224 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8198 034224 324 00 0 00 034225 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 + 8205 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8206 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8207 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8208 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8209 002025 SN=SN+1 + 8210 000004 000000 ZZ=ZZ+ZZ + 8211 IFE ZZ, +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-7 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0190 + + 8212 034225 200 00 0 00 035442 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8213 034226 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8214 STOP^ + 8215 034227 254 04 0 00 034230 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8216 034230 324 00 0 00 034231 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8217 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8218 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8219 + 8220 ;********** + 8221 + 8222 + 8223 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8224 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8225 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8226 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8227 002026 SN=SN+1 + 8228 000010 000000 ZZ=ZZ+ZZ + 8229 IFE ZZ, + 8230 034231 200 00 0 00 035443 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8231 034232 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8232 STOP^ + 8233 034233 254 04 0 00 034234 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8234 034234 324 00 0 00 034235 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8235 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8236 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8237 + 8238 ;********** + 8239 + 8240 + 8241 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8242 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8243 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8244 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8245 002027 SN=SN+1 + 8246 000020 000000 ZZ=ZZ+ZZ + 8247 IFE ZZ, + 8248 034235 200 00 0 00 035444 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8249 034236 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8250 STOP^ + 8251 034237 254 04 0 00 034240 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8252 034240 324 00 0 00 034241 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8253 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8254 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8255 + 8256 ;********** + 8257 + 8258 + 8259 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8260 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8261 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8262 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8263 002030 SN=SN+1 + 8264 000040 000000 ZZ=ZZ+ZZ + 8265 IFE ZZ, + 8266 034241 200 00 0 00 035445 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-8 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0191 + + 8267 034242 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8268 STOP^ + 8269 034243 254 04 0 00 034244 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8270 034244 324 00 0 00 034245 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8271 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8272 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8273 + 8274 ;********** + 8275 + 8276 + 8277 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8278 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8279 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8280 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8281 002031 SN=SN+1 + 8282 000100 000000 ZZ=ZZ+ZZ + 8283 IFE ZZ, + 8284 034245 200 00 0 00 035446 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8285 034246 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8286 STOP^ + 8287 034247 254 04 0 00 034250 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8288 034250 324 00 0 00 034251 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8289 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8290 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8291 + 8292 ;********** + 8293 + 8294 + 8295 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8296 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8297 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8298 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8299 002032 SN=SN+1 + 8300 000200 000000 ZZ=ZZ+ZZ + 8301 IFE ZZ, + 8302 034251 200 00 0 00 035447 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8303 034252 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8304 STOP^ + 8305 034253 254 04 0 00 034254 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8306 034254 324 00 0 00 034255 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8307 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8308 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8309 + 8310 ;********** + 8311 + 8312 + 8313 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8314 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8315 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8316 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8317 002033 SN=SN+1 + 8318 000400 000000 ZZ=ZZ+ZZ + 8319 IFE ZZ, + 8320 034255 200 00 0 00 035450 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8321 034256 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-9 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0192 + + 8322 STOP^ + 8323 034257 254 04 0 00 034260 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8324 034260 324 00 0 00 034261 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8325 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8326 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8327 + 8328 ;********** + 8329 + 8330 + 8331 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8332 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8333 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8334 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8335 002034 SN=SN+1 + 8336 001000 000000 ZZ=ZZ+ZZ + 8337 IFE ZZ, + 8338 034261 200 00 0 00 035451 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8339 034262 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8340 STOP^ + 8341 034263 254 04 0 00 034264 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8342 034264 324 00 0 00 034265 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8343 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8344 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8345 + 8346 ;********** + 8347 + 8348 + 8349 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8350 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8351 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8352 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8353 002035 SN=SN+1 + 8354 002000 000000 ZZ=ZZ+ZZ + 8355 IFE ZZ, + 8356 034265 200 00 0 00 035452 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8357 034266 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8358 STOP^ + 8359 034267 254 04 0 00 034270 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8360 034270 324 00 0 00 034271 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8361 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8362 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8363 + 8364 ;********** + 8365 + 8366 + 8367 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8368 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8369 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8370 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8371 002036 SN=SN+1 + 8372 004000 000000 ZZ=ZZ+ZZ + 8373 IFE ZZ, + 8374 034271 200 00 0 00 035453 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8375 034272 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8376 STOP^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-10 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0193 + + 8377 034273 254 04 0 00 034274 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8378 034274 324 00 0 00 034275 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8379 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8380 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8381 + 8382 ;********** + 8383 + 8384 + 8385 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8386 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8387 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8388 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8389 002037 SN=SN+1 + 8390 010000 000000 ZZ=ZZ+ZZ + 8391 IFE ZZ, + 8392 034275 200 00 0 00 035454 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8393 034276 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8394 STOP^ + 8395 034277 254 04 0 00 034300 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8396 034300 324 00 0 00 034301 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 + 8403 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8404 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8405 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8406 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8407 002040 SN=SN+1 + 8408 020000 000000 ZZ=ZZ+ZZ + 8409 IFE ZZ, + 8410 034301 200 00 0 00 035455 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8411 034302 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8412 STOP^ + 8413 034303 254 04 0 00 034304 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8414 034304 324 00 0 00 034305 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8415 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8416 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8417 + 8418 ;********** + 8419 + 8420 + 8421 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8422 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8423 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8424 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8425 002041 SN=SN+1 + 8426 040000 000000 ZZ=ZZ+ZZ + 8427 IFE ZZ, + 8428 034305 200 00 0 00 035456 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8429 034306 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8430 STOP^ + 8431 034307 254 04 0 00 034310 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-11 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0194 + + 8432 034310 324 00 0 00 034311 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8433 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8434 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8435 + 8436 ;********** + 8437 + 8438 + 8439 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8440 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8441 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8442 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8443 002042 SN=SN+1 + 8444 100000 000000 ZZ=ZZ+ZZ + 8445 IFE ZZ, + 8446 034311 200 00 0 00 035457 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8447 034312 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8448 STOP^ + 8449 034313 254 04 0 00 034314 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8450 034314 324 00 0 00 034315 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8451 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8452 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8453 + 8454 ;********** + 8455 + 8456 + 8457 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8458 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8459 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8460 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8461 002043 SN=SN+1 + 8462 200000 000000 ZZ=ZZ+ZZ + 8463 IFE ZZ, + 8464 034315 200 00 0 00 035460 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8465 034316 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8466 STOP^ + 8467 034317 254 04 0 00 034320 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8468 034320 324 00 0 00 034321 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8469 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8470 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8471 + 8472 ;********** + 8473 + 8474 + 8475 ;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND + 8476 ;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, + 8477 ;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. + 8478 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC + 8479 002044 SN=SN+1 + 8480 400000 000000 ZZ=ZZ+ZZ + 8481 IFE ZZ, + 8482 034321 200 00 0 00 035461 MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + 8483 034322 316 00 0 00 035412 CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + 8484 STOP^ + 8485 034323 254 04 0 00 034324 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8486 034324 324 00 0 00 034325 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 26-12 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAMX) INSTRUCTIONS SEQ 0195 + + 8487 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8488 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8489 + 8490 ;********** + 8491 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 27 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0196 + + 8492 SUBTTL TEST OF MOVS INSTRUCTION + 8493 + 8494 ;********** + 8495 + 8496 002100 SN=2100 + 8497 000000 ZZ=0 + 8498 + 8499 B2100: REPEAT ^D18,< + 8500 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8501 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8502 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8503 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8504 + 8505 SN=SN+1 + 8506 ZZ=ZZ+ZZ + 8507 IFE ZZ, + 8508 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8509 ;AND MOVE RESULT INTO AC + 8510 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8511 STOP + 8512 + 8513 ;********** + 8514 > + 8515 + 8516 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8517 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8518 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8519 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8520 + 8521 002101 SN=SN+1 + 8522 000000 ZZ=ZZ+ZZ + 8523 000001 IFE ZZ, + 8524 034325 204 00 0 00 035410 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8525 ;AND MOVE RESULT INTO AC + 8526 034326 312 00 0 00 035410 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8527 STOP ^ + 8528 034327 254 04 0 00 034330 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8529 034330 324 00 0 00 034331 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8530 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8531 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8532 + 8533 ;********** + 8534 + 8535 + 8536 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8537 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8538 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8539 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8540 + 8541 002102 SN=SN+1 + 8542 000002 ZZ=ZZ+ZZ + 8543 IFE ZZ, + 8544 034331 204 00 0 00 035541 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8545 ;AND MOVE RESULT INTO AC + 8546 034332 312 00 0 00 035541 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 27-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0197 + + 8547 STOP ^ + 8548 034333 254 04 0 00 034334 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8549 034334 324 00 0 00 034335 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8550 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8551 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8552 + 8553 ;********** + 8554 + 8555 + 8556 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8557 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8558 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8559 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8560 + 8561 002103 SN=SN+1 + 8562 000004 ZZ=ZZ+ZZ + 8563 IFE ZZ, + 8564 034335 204 00 0 00 035542 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8565 ;AND MOVE RESULT INTO AC + 8566 034336 312 00 0 00 035542 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8567 STOP ^ + 8568 034337 254 04 0 00 034340 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8569 034340 324 00 0 00 034341 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8570 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8571 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8572 + 8573 ;********** + 8574 + 8575 + 8576 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8577 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8578 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8579 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8580 + 8581 002104 SN=SN+1 + 8582 000010 ZZ=ZZ+ZZ + 8583 IFE ZZ, + 8584 034341 204 00 0 00 035543 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8585 ;AND MOVE RESULT INTO AC + 8586 034342 312 00 0 00 035543 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8587 STOP ^ + 8588 034343 254 04 0 00 034344 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8589 034344 324 00 0 00 034345 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8590 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8591 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8592 + 8593 ;********** + 8594 + 8595 + 8596 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8597 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8598 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8599 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8600 + 8601 002105 SN=SN+1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 27-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0198 + + 8602 000020 ZZ=ZZ+ZZ + 8603 IFE ZZ, + 8604 034345 204 00 0 00 035544 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8605 ;AND MOVE RESULT INTO AC + 8606 034346 312 00 0 00 035544 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8607 STOP ^ + 8608 034347 254 04 0 00 034350 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8609 034350 324 00 0 00 034351 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8610 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8611 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8612 + 8613 ;********** + 8614 + 8615 + 8616 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8617 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8618 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8619 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8620 + 8621 002106 SN=SN+1 + 8622 000040 ZZ=ZZ+ZZ + 8623 IFE ZZ, + 8624 034351 204 00 0 00 035545 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8625 ;AND MOVE RESULT INTO AC + 8626 034352 312 00 0 00 035545 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8627 STOP ^ + 8628 034353 254 04 0 00 034354 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8629 034354 324 00 0 00 034355 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8630 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8631 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8632 + 8633 ;********** + 8634 + 8635 + 8636 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8637 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8638 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8639 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8640 + 8641 002107 SN=SN+1 + 8642 000100 ZZ=ZZ+ZZ + 8643 IFE ZZ, + 8644 034355 204 00 0 00 035546 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8645 ;AND MOVE RESULT INTO AC + 8646 034356 312 00 0 00 035546 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8647 STOP ^ + 8648 034357 254 04 0 00 034360 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8649 034360 324 00 0 00 034361 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8650 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8651 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8652 + 8653 ;********** + 8654 + 8655 + 8656 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 27-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0199 + + 8657 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8658 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8659 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8660 + 8661 002110 SN=SN+1 + 8662 000200 ZZ=ZZ+ZZ + 8663 IFE ZZ, + 8664 034361 204 00 0 00 035547 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8665 ;AND MOVE RESULT INTO AC + 8666 034362 312 00 0 00 035547 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8667 STOP ^ + 8668 034363 254 04 0 00 034364 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8669 034364 324 00 0 00 034365 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8670 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8671 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8672 + 8673 ;********** + 8674 + 8675 + 8676 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8677 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8678 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8679 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8680 + 8681 002111 SN=SN+1 + 8682 000400 ZZ=ZZ+ZZ + 8683 IFE ZZ, + 8684 034365 204 00 0 00 035550 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8685 ;AND MOVE RESULT INTO AC + 8686 034366 312 00 0 00 035550 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8687 STOP ^ + 8688 034367 254 04 0 00 034370 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8689 034370 324 00 0 00 034371 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 + 8696 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8697 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8698 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8699 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8700 + 8701 002112 SN=SN+1 + 8702 001000 ZZ=ZZ+ZZ + 8703 IFE ZZ, + 8704 034371 204 00 0 00 035551 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8705 ;AND MOVE RESULT INTO AC + 8706 034372 312 00 0 00 035551 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8707 STOP ^ + 8708 034373 254 04 0 00 034374 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8709 034374 324 00 0 00 034375 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8710 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8711 ;IN THE SUBTEST) TO LOOP ON ERROR^ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 27-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0200 + + 8712 + 8713 ;********** + 8714 + 8715 + 8716 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8717 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8718 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8719 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8720 + 8721 002113 SN=SN+1 + 8722 002000 ZZ=ZZ+ZZ + 8723 IFE ZZ, + 8724 034375 204 00 0 00 035552 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8725 ;AND MOVE RESULT INTO AC + 8726 034376 312 00 0 00 035552 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8727 STOP ^ + 8728 034377 254 04 0 00 034400 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8729 034400 324 00 0 00 034401 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8730 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8731 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8732 + 8733 ;********** + 8734 + 8735 + 8736 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8737 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8738 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8739 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8740 + 8741 002114 SN=SN+1 + 8742 004000 ZZ=ZZ+ZZ + 8743 IFE ZZ, + 8744 034401 204 00 0 00 035553 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8745 ;AND MOVE RESULT INTO AC + 8746 034402 312 00 0 00 035553 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8747 STOP ^ + 8748 034403 254 04 0 00 034404 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8749 034404 324 00 0 00 034405 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8750 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8751 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8752 + 8753 ;********** + 8754 + 8755 + 8756 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8757 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8758 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8759 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8760 + 8761 002115 SN=SN+1 + 8762 010000 ZZ=ZZ+ZZ + 8763 IFE ZZ, + 8764 034405 204 00 0 00 035554 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8765 ;AND MOVE RESULT INTO AC + 8766 034406 312 00 0 00 035554 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 27-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0201 + + 8767 STOP ^ + 8768 034407 254 04 0 00 034410 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8769 034410 324 00 0 00 034411 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8770 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8771 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8772 + 8773 ;********** + 8774 + 8775 + 8776 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8777 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8778 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8779 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8780 + 8781 002116 SN=SN+1 + 8782 020000 ZZ=ZZ+ZZ + 8783 IFE ZZ, + 8784 034411 204 00 0 00 035555 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8785 ;AND MOVE RESULT INTO AC + 8786 034412 312 00 0 00 035555 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8787 STOP ^ + 8788 034413 254 04 0 00 034414 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8789 034414 324 00 0 00 034415 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8790 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8791 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8792 + 8793 ;********** + 8794 + 8795 + 8796 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8797 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8798 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8799 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8800 + 8801 002117 SN=SN+1 + 8802 040000 ZZ=ZZ+ZZ + 8803 IFE ZZ, + 8804 034415 204 00 0 00 035556 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8805 ;AND MOVE RESULT INTO AC + 8806 034416 312 00 0 00 035556 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8807 STOP ^ + 8808 034417 254 04 0 00 034420 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8809 034420 324 00 0 00 034421 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 + 8816 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8817 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8818 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8819 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8820 + 8821 002120 SN=SN+1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 27-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0202 + + 8822 100000 ZZ=ZZ+ZZ + 8823 IFE ZZ, + 8824 034421 204 00 0 00 035557 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8825 ;AND MOVE RESULT INTO AC + 8826 034422 312 00 0 00 035557 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8827 STOP ^ + 8828 034423 254 04 0 00 034424 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8829 034424 324 00 0 00 034425 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8830 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8831 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8832 + 8833 ;********** + 8834 + 8835 + 8836 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8837 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8838 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8839 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8840 + 8841 002121 SN=SN+1 + 8842 200000 ZZ=ZZ+ZZ + 8843 IFE ZZ, + 8844 034425 204 00 0 00 035560 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8845 ;AND MOVE RESULT INTO AC + 8846 034426 312 00 0 00 035560 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8847 STOP ^ + 8848 034427 254 04 0 00 034430 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8849 034430 324 00 0 00 034431 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8850 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8851 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8852 + 8853 ;********** + 8854 + 8855 + 8856 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8857 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES + 8858 ;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. + 8859 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + 8860 + 8861 002122 SN=SN+1 + 8862 400000 ZZ=ZZ+ZZ + 8863 IFE ZZ, + 8864 034431 204 00 0 00 035561 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8865 ;AND MOVE RESULT INTO AC + 8866 034432 312 00 0 00 035561 CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + 8867 STOP ^ + 8868 034433 254 04 0 00 034434 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8869 034434 324 00 0 00 034435 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8870 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8871 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8872 + 8873 ;********** + 8874 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 28 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0203 + + 8875 002200 SN=2200 + 8876 000000 ZZ=0 + 8877 + 8878 B2200: REPEAT ^D18,< + 8879 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8880 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 8881 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 8882 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 8883 + 8884 SN=SN+1 + 8885 ZZ=ZZ+ZZ+1 + 8886 IFE , + 8887 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8888 ;AND MOVE RESULT INTO AC + 8889 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 8890 STOP + 8891 + 8892 ;********** + 8893 > + 8894 + 8895 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8896 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 8897 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 8898 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 8899 + 8900 002201 SN=SN+1 + 8901 000001 ZZ=ZZ+ZZ+1 + 8902 777777 777776 IFE , + 8903 034435 204 00 0 00 035562 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8904 ;AND MOVE RESULT INTO AC + 8905 034436 312 00 0 00 035562 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 8906 STOP ^ + 8907 034437 254 04 0 00 034440 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8908 034440 324 00 0 00 034441 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8909 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8910 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8911 + 8912 ;********** + 8913 + 8914 + 8915 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8916 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 8917 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 8918 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 8919 + 8920 002202 SN=SN+1 + 8921 777777 777775 ZZ=ZZ+ZZ+1 + 8922 IFE , + 8923 034441 204 00 0 00 035563 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8924 ;AND MOVE RESULT INTO AC + 8925 034442 312 00 0 00 035563 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 8926 STOP ^ + 8927 034443 254 04 0 00 034444 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8928 034444 324 00 0 00 034445 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8929 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 28-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0204 + + 8930 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8931 + 8932 ;********** + 8933 + 8934 + 8935 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8936 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 8937 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 8938 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 8939 + 8940 002203 SN=SN+1 + 8941 777777 777773 ZZ=ZZ+ZZ+1 + 8942 IFE , + 8943 034445 204 00 0 00 035564 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8944 ;AND MOVE RESULT INTO AC + 8945 034446 312 00 0 00 035564 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 8946 STOP ^ + 8947 034447 254 04 0 00 034450 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8948 034450 324 00 0 00 034451 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8949 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8950 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8951 + 8952 ;********** + 8953 + 8954 + 8955 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8956 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 8957 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 8958 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 8959 + 8960 002204 SN=SN+1 + 8961 777777 777767 ZZ=ZZ+ZZ+1 + 8962 IFE , + 8963 034451 204 00 0 00 035565 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8964 ;AND MOVE RESULT INTO AC + 8965 034452 312 00 0 00 035565 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 8966 STOP ^ + 8967 034453 254 04 0 00 034454 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8968 034454 324 00 0 00 034455 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8969 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8970 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8971 + 8972 ;********** + 8973 + 8974 + 8975 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8976 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 8977 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 8978 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 8979 + 8980 002205 SN=SN+1 + 8981 777777 777757 ZZ=ZZ+ZZ+1 + 8982 IFE , + 8983 034455 204 00 0 00 035566 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 8984 ;AND MOVE RESULT INTO AC +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 28-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0205 + + 8985 034456 312 00 0 00 035566 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 8986 STOP ^ + 8987 034457 254 04 0 00 034460 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 8988 034460 324 00 0 00 034461 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 8989 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 8990 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 8991 + 8992 ;********** + 8993 + 8994 + 8995 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 8996 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 8997 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 8998 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 8999 + 9000 002206 SN=SN+1 + 9001 777777 777737 ZZ=ZZ+ZZ+1 + 9002 IFE , + 9003 034461 204 00 0 00 035567 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9004 ;AND MOVE RESULT INTO AC + 9005 034462 312 00 0 00 035567 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9006 STOP ^ + 9007 034463 254 04 0 00 034464 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9008 034464 324 00 0 00 034465 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9009 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9010 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9011 + 9012 ;********** + 9013 + 9014 + 9015 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9016 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9017 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9018 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9019 + 9020 002207 SN=SN+1 + 9021 777777 777677 ZZ=ZZ+ZZ+1 + 9022 IFE , + 9023 034465 204 00 0 00 035570 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9024 ;AND MOVE RESULT INTO AC + 9025 034466 312 00 0 00 035570 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9026 STOP ^ + 9027 034467 254 04 0 00 034470 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9028 034470 324 00 0 00 034471 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9029 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9030 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9031 + 9032 ;********** + 9033 + 9034 + 9035 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9036 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9037 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9038 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9039 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 28-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0206 + + 9040 002210 SN=SN+1 + 9041 777777 777577 ZZ=ZZ+ZZ+1 + 9042 IFE , + 9043 034471 204 00 0 00 035571 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9044 ;AND MOVE RESULT INTO AC + 9045 034472 312 00 0 00 035571 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9046 STOP ^ + 9047 034473 254 04 0 00 034474 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9048 034474 324 00 0 00 034475 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9049 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9050 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9051 + 9052 ;********** + 9053 + 9054 + 9055 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9056 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9057 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9058 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9059 + 9060 002211 SN=SN+1 + 9061 777777 777377 ZZ=ZZ+ZZ+1 + 9062 IFE , + 9063 034475 204 00 0 00 035572 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9064 ;AND MOVE RESULT INTO AC + 9065 034476 312 00 0 00 035572 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9066 STOP ^ + 9067 034477 254 04 0 00 034500 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9068 034500 324 00 0 00 034501 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9069 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9070 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9071 + 9072 ;********** + 9073 + 9074 + 9075 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9076 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9077 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9078 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9079 + 9080 002212 SN=SN+1 + 9081 777777 776777 ZZ=ZZ+ZZ+1 + 9082 IFE , + 9083 034501 204 00 0 00 035573 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9084 ;AND MOVE RESULT INTO AC + 9085 034502 312 00 0 00 035573 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9086 STOP ^ + 9087 034503 254 04 0 00 034504 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9088 034504 324 00 0 00 034505 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9089 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9090 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9091 + 9092 ;********** + 9093 + 9094 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 28-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0207 + + 9095 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9096 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9097 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9098 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9099 + 9100 002213 SN=SN+1 + 9101 777777 775777 ZZ=ZZ+ZZ+1 + 9102 IFE , + 9103 034505 204 00 0 00 035574 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9104 ;AND MOVE RESULT INTO AC + 9105 034506 312 00 0 00 035574 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9106 STOP ^ + 9107 034507 254 04 0 00 034510 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9108 034510 324 00 0 00 034511 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9109 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9110 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9111 + 9112 ;********** + 9113 + 9114 + 9115 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9116 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9117 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9118 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9119 + 9120 002214 SN=SN+1 + 9121 777777 773777 ZZ=ZZ+ZZ+1 + 9122 IFE , + 9123 034511 204 00 0 00 035575 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9124 ;AND MOVE RESULT INTO AC + 9125 034512 312 00 0 00 035575 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9126 STOP ^ + 9127 034513 254 04 0 00 034514 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9128 034514 324 00 0 00 034515 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9129 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9130 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9131 + 9132 ;********** + 9133 + 9134 + 9135 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9136 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9137 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9138 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9139 + 9140 002215 SN=SN+1 + 9141 777777 767777 ZZ=ZZ+ZZ+1 + 9142 IFE , + 9143 034515 204 00 0 00 035576 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9144 ;AND MOVE RESULT INTO AC + 9145 034516 312 00 0 00 035576 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9146 STOP ^ + 9147 034517 254 04 0 00 034520 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9148 034520 324 00 0 00 034521 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9149 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 28-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0208 + + 9150 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9151 + 9152 ;********** + 9153 + 9154 + 9155 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9156 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9157 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9158 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9159 + 9160 002216 SN=SN+1 + 9161 777777 757777 ZZ=ZZ+ZZ+1 + 9162 IFE , + 9163 034521 204 00 0 00 035577 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9164 ;AND MOVE RESULT INTO AC + 9165 034522 312 00 0 00 035577 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9166 STOP ^ + 9167 034523 254 04 0 00 034524 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9168 034524 324 00 0 00 034525 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9169 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9170 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9171 + 9172 ;********** + 9173 + 9174 + 9175 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9176 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9177 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9178 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9179 + 9180 002217 SN=SN+1 + 9181 777777 737777 ZZ=ZZ+ZZ+1 + 9182 IFE , + 9183 034525 204 00 0 00 035600 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9184 ;AND MOVE RESULT INTO AC + 9185 034526 312 00 0 00 035600 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9186 STOP ^ + 9187 034527 254 04 0 00 034530 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9188 034530 324 00 0 00 034531 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9189 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9190 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9191 + 9192 ;********** + 9193 + 9194 + 9195 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9196 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9197 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9198 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9199 + 9200 002220 SN=SN+1 + 9201 777777 677777 ZZ=ZZ+ZZ+1 + 9202 IFE , + 9203 034531 204 00 0 00 035601 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9204 ;AND MOVE RESULT INTO AC +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 28-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0209 + + 9205 034532 312 00 0 00 035601 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9206 STOP ^ + 9207 034533 254 04 0 00 034534 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9208 034534 324 00 0 00 034535 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9209 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9210 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9211 + 9212 ;********** + 9213 + 9214 + 9215 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9216 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9217 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9218 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9219 + 9220 002221 SN=SN+1 + 9221 777777 577777 ZZ=ZZ+ZZ+1 + 9222 IFE , + 9223 034535 204 00 0 00 035602 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9224 ;AND MOVE RESULT INTO AC + 9225 034536 312 00 0 00 035602 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9226 STOP ^ + 9227 034537 254 04 0 00 034540 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9228 034540 324 00 0 00 034541 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9229 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9230 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9231 + 9232 ;********** + 9233 + 9234 + 9235 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9236 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES + 9237 ;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. + 9238 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + 9239 + 9240 002222 SN=SN+1 + 9241 777777 377777 ZZ=ZZ+ZZ+1 + 9242 IFE , + 9243 034541 204 00 0 00 035603 MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9244 ;AND MOVE RESULT INTO AC + 9245 034542 312 00 0 00 035603 CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + 9246 STOP ^ + 9247 034543 254 04 0 00 034544 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9248 034544 324 00 0 00 034545 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9249 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9250 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9251 + 9252 ;********** + 9253 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 29 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0210 + + 9254 002300 SN=2300 + 9255 000000 ZZ=0 + 9256 000000 YY=0 + 9257 + 9258 B2300: REPEAT ^D18,< + 9259 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9260 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9261 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9262 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9263 ;THEN, C(AC) IS CHECKED. + 9264 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9265 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9266 + 9267 SN=SN+1 + 9268 ZZ=ZZ+ZZ + 9269 YY=YY+YY+1 + 9270 IFE ZZ, + 9271 IFE , + 9272 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9273 ;AND MOVE RESULT INTO AC + 9274 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9275 STOP + 9276 + 9277 ;********** + 9278 > + 9279 + 9280 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9281 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9282 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9283 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9284 ;THEN, C(AC) IS CHECKED. + 9285 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9286 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9287 + 9288 002301 SN=SN+1 + 9289 000000 ZZ=ZZ+ZZ + 9290 000001 YY=YY+YY+1 + 9291 000001 IFE ZZ, + 9292 777777 777776 IFE , + 9293 034545 204 00 0 00 035604 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9294 ;AND MOVE RESULT INTO AC + 9295 034546 312 00 0 00 035605 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9296 STOP ^ + 9297 034547 254 04 0 00 034550 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9298 034550 324 00 0 00 034551 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9299 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9300 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9301 + 9302 ;********** + 9303 + 9304 + 9305 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9306 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9307 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9308 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 29-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0211 + + 9309 ;THEN, C(AC) IS CHECKED. + 9310 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9311 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9312 + 9313 002302 SN=SN+1 + 9314 000002 ZZ=ZZ+ZZ + 9315 777777 777775 YY=YY+YY+1 + 9316 IFE ZZ, + 9317 IFE , + 9318 034551 204 00 0 00 035606 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9319 ;AND MOVE RESULT INTO AC + 9320 034552 312 00 0 00 035607 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9321 STOP ^ + 9322 034553 254 04 0 00 034554 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9323 034554 324 00 0 00 034555 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9324 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9325 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9326 + 9327 ;********** + 9328 + 9329 + 9330 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9331 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9332 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9333 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9334 ;THEN, C(AC) IS CHECKED. + 9335 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9336 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9337 + 9338 002303 SN=SN+1 + 9339 000004 ZZ=ZZ+ZZ + 9340 777777 777773 YY=YY+YY+1 + 9341 IFE ZZ, + 9342 IFE , + 9343 034555 204 00 0 00 035610 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9344 ;AND MOVE RESULT INTO AC + 9345 034556 312 00 0 00 035611 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9346 STOP ^ + 9347 034557 254 04 0 00 034560 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9348 034560 324 00 0 00 034561 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9349 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9350 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9351 + 9352 ;********** + 9353 + 9354 + 9355 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9356 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9357 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9358 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9359 ;THEN, C(AC) IS CHECKED. + 9360 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9361 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9362 + 9363 002304 SN=SN+1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 29-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0212 + + 9364 000010 ZZ=ZZ+ZZ + 9365 777777 777767 YY=YY+YY+1 + 9366 IFE ZZ, + 9367 IFE , + 9368 034561 204 00 0 00 035612 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9369 ;AND MOVE RESULT INTO AC + 9370 034562 312 00 0 00 035613 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9371 STOP ^ + 9372 034563 254 04 0 00 034564 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9373 034564 324 00 0 00 034565 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9374 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9375 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9376 + 9377 ;********** + 9378 + 9379 + 9380 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9381 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9382 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9383 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9384 ;THEN, C(AC) IS CHECKED. + 9385 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9386 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9387 + 9388 002305 SN=SN+1 + 9389 000020 ZZ=ZZ+ZZ + 9390 777777 777757 YY=YY+YY+1 + 9391 IFE ZZ, + 9392 IFE , + 9393 034565 204 00 0 00 035614 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9394 ;AND MOVE RESULT INTO AC + 9395 034566 312 00 0 00 035615 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9396 STOP ^ + 9397 034567 254 04 0 00 034570 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9398 034570 324 00 0 00 034571 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9399 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9400 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9401 + 9402 ;********** + 9403 + 9404 + 9405 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9406 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9407 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9408 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9409 ;THEN, C(AC) IS CHECKED. + 9410 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9411 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9412 + 9413 002306 SN=SN+1 + 9414 000040 ZZ=ZZ+ZZ + 9415 777777 777737 YY=YY+YY+1 + 9416 IFE ZZ, + 9417 IFE , + 9418 034571 204 00 0 00 035616 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 29-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0213 + + 9419 ;AND MOVE RESULT INTO AC + 9420 034572 312 00 0 00 035617 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9421 STOP ^ + 9422 034573 254 04 0 00 034574 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9423 034574 324 00 0 00 034575 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9424 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9425 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9426 + 9427 ;********** + 9428 + 9429 + 9430 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9431 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9432 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9433 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9434 ;THEN, C(AC) IS CHECKED. + 9435 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9436 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9437 + 9438 002307 SN=SN+1 + 9439 000100 ZZ=ZZ+ZZ + 9440 777777 777677 YY=YY+YY+1 + 9441 IFE ZZ, + 9442 IFE , + 9443 034575 204 00 0 00 035620 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9444 ;AND MOVE RESULT INTO AC + 9445 034576 312 00 0 00 035621 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9446 STOP ^ + 9447 034577 254 04 0 00 034600 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9448 034600 324 00 0 00 034601 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9449 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9450 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9451 + 9452 ;********** + 9453 + 9454 + 9455 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9456 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9457 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9458 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9459 ;THEN, C(AC) IS CHECKED. + 9460 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9461 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9462 + 9463 002310 SN=SN+1 + 9464 000200 ZZ=ZZ+ZZ + 9465 777777 777577 YY=YY+YY+1 + 9466 IFE ZZ, + 9467 IFE , + 9468 034601 204 00 0 00 035622 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9469 ;AND MOVE RESULT INTO AC + 9470 034602 312 00 0 00 035623 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9471 STOP ^ + 9472 034603 254 04 0 00 034604 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9473 034604 324 00 0 00 034605 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 29-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0214 + + 9474 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9475 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9476 + 9477 ;********** + 9478 + 9479 + 9480 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9481 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9482 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9483 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9484 ;THEN, C(AC) IS CHECKED. + 9485 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9486 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9487 + 9488 002311 SN=SN+1 + 9489 000400 ZZ=ZZ+ZZ + 9490 777777 777377 YY=YY+YY+1 + 9491 IFE ZZ, + 9492 IFE , + 9493 034605 204 00 0 00 035624 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9494 ;AND MOVE RESULT INTO AC + 9495 034606 312 00 0 00 035625 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9496 STOP ^ + 9497 034607 254 04 0 00 034610 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9498 034610 324 00 0 00 034611 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9499 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9500 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9501 + 9502 ;********** + 9503 + 9504 + 9505 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9506 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9507 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9508 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9509 ;THEN, C(AC) IS CHECKED. + 9510 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9511 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9512 + 9513 002312 SN=SN+1 + 9514 001000 ZZ=ZZ+ZZ + 9515 777777 776777 YY=YY+YY+1 + 9516 IFE ZZ, + 9517 IFE , + 9518 034611 204 00 0 00 035626 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9519 ;AND MOVE RESULT INTO AC + 9520 034612 312 00 0 00 035627 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9521 STOP ^ + 9522 034613 254 04 0 00 034614 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9523 034614 324 00 0 00 034615 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9524 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9525 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9526 + 9527 ;********** + 9528 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 29-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0215 + + 9529 + 9530 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9531 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9532 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9533 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9534 ;THEN, C(AC) IS CHECKED. + 9535 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9536 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9537 + 9538 002313 SN=SN+1 + 9539 002000 ZZ=ZZ+ZZ + 9540 777777 775777 YY=YY+YY+1 + 9541 IFE ZZ, + 9542 IFE , + 9543 034615 204 00 0 00 035630 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9544 ;AND MOVE RESULT INTO AC + 9545 034616 312 00 0 00 035631 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9546 STOP ^ + 9547 034617 254 04 0 00 034620 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9548 034620 324 00 0 00 034621 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9549 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9550 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9551 + 9552 ;********** + 9553 + 9554 + 9555 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9556 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9557 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9558 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9559 ;THEN, C(AC) IS CHECKED. + 9560 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9561 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9562 + 9563 002314 SN=SN+1 + 9564 004000 ZZ=ZZ+ZZ + 9565 777777 773777 YY=YY+YY+1 + 9566 IFE ZZ, + 9567 IFE , + 9568 034621 204 00 0 00 035632 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9569 ;AND MOVE RESULT INTO AC + 9570 034622 312 00 0 00 035633 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9571 STOP ^ + 9572 034623 254 04 0 00 034624 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9573 034624 324 00 0 00 034625 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9574 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9575 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9576 + 9577 ;********** + 9578 + 9579 + 9580 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9581 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9582 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9583 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 29-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0216 + + 9584 ;THEN, C(AC) IS CHECKED. + 9585 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9586 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9587 + 9588 002315 SN=SN+1 + 9589 010000 ZZ=ZZ+ZZ + 9590 777777 767777 YY=YY+YY+1 + 9591 IFE ZZ, + 9592 IFE , + 9593 034625 204 00 0 00 035634 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9594 ;AND MOVE RESULT INTO AC + 9595 034626 312 00 0 00 035635 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9596 STOP ^ + 9597 034627 254 04 0 00 034630 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9598 034630 324 00 0 00 034631 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9599 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9600 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9601 + 9602 ;********** + 9603 + 9604 + 9605 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9606 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9607 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9608 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9609 ;THEN, C(AC) IS CHECKED. + 9610 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9611 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9612 + 9613 002316 SN=SN+1 + 9614 020000 ZZ=ZZ+ZZ + 9615 777777 757777 YY=YY+YY+1 + 9616 IFE ZZ, + 9617 IFE , + 9618 034631 204 00 0 00 035636 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9619 ;AND MOVE RESULT INTO AC + 9620 034632 312 00 0 00 035637 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9621 STOP ^ + 9622 034633 254 04 0 00 034634 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9623 034634 324 00 0 00 034635 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9624 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9625 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9626 + 9627 ;********** + 9628 + 9629 + 9630 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9631 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9632 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9633 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9634 ;THEN, C(AC) IS CHECKED. + 9635 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9636 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9637 + 9638 002317 SN=SN+1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 29-7 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0217 + + 9639 040000 ZZ=ZZ+ZZ + 9640 777777 737777 YY=YY+YY+1 + 9641 IFE ZZ, + 9642 IFE , + 9643 034635 204 00 0 00 035640 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9644 ;AND MOVE RESULT INTO AC + 9645 034636 312 00 0 00 035641 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9646 STOP ^ + 9647 034637 254 04 0 00 034640 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9648 034640 324 00 0 00 034641 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9649 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9650 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9651 + 9652 ;********** + 9653 + 9654 + 9655 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9656 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9657 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9658 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9659 ;THEN, C(AC) IS CHECKED. + 9660 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9661 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9662 + 9663 002320 SN=SN+1 + 9664 100000 ZZ=ZZ+ZZ + 9665 777777 677777 YY=YY+YY+1 + 9666 IFE ZZ, + 9667 IFE , + 9668 034641 204 00 0 00 035642 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9669 ;AND MOVE RESULT INTO AC + 9670 034642 312 00 0 00 035643 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9671 STOP ^ + 9672 034643 254 04 0 00 034644 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9673 034644 324 00 0 00 034645 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9674 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9675 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9676 + 9677 ;********** + 9678 + 9679 + 9680 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9681 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9682 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9683 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9684 ;THEN, C(AC) IS CHECKED. + 9685 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9686 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9687 + 9688 002321 SN=SN+1 + 9689 200000 ZZ=ZZ+ZZ + 9690 777777 577777 YY=YY+YY+1 + 9691 IFE ZZ, + 9692 IFE , + 9693 034645 204 00 0 00 035644 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 29-8 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0218 + + 9694 ;AND MOVE RESULT INTO AC + 9695 034646 312 00 0 00 035645 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9696 STOP ^ + 9697 034647 254 04 0 00 034650 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9698 034650 324 00 0 00 034651 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9699 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9700 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9701 + 9702 ;********** + 9703 + 9704 + 9705 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9706 ;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E + 9707 ;AND A 0 IS RIPPLED THRU THE RIGHT HALF + 9708 ;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9709 ;THEN, C(AC) IS CHECKED. + 9710 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9711 ;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9712 + 9713 002322 SN=SN+1 + 9714 400000 ZZ=ZZ+ZZ + 9715 777777 377777 YY=YY+YY+1 + 9716 IFE ZZ, + 9717 IFE , + 9718 034651 204 00 0 00 035646 MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9719 ;AND MOVE RESULT INTO AC + 9720 034652 312 00 0 00 035647 CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + 9721 STOP ^ + 9722 034653 254 04 0 00 034654 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9723 034654 324 00 0 00 034655 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9724 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9725 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9726 + 9727 ;********** + 9728 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 30 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0219 + + 9729 002400 SN=2400 + 9730 000000 ZZ=0 + 9731 000000 YY=0 + 9732 + 9733 B2400: REPEAT ^D18,< + 9734 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9735 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 9736 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 9737 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9738 ;THEN, C(AC) IS CHECKED. + 9739 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9740 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9741 + 9742 SN=SN+1 + 9743 ZZ=ZZ+ZZ + 9744 YY=YY+YY+1 + 9745 IFE ZZ, + 9746 IFE , + 9747 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9748 ;AND MOVE RESULT INTO AC + 9749 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 9750 STOP + 9751 + 9752 ;********** + 9753 > + 9754 + 9755 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9756 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 9757 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 9758 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9759 ;THEN, C(AC) IS CHECKED. + 9760 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9761 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9762 + 9763 002401 SN=SN+1 + 9764 000000 ZZ=ZZ+ZZ + 9765 000001 YY=YY+YY+1 + 9766 000001 IFE ZZ, + 9767 777777 777776 IFE , + 9768 034655 204 00 0 00 035605 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9769 ;AND MOVE RESULT INTO AC + 9770 034656 312 00 0 00 035604 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 9771 STOP ^ + 9772 034657 254 04 0 00 034660 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9773 034660 324 00 0 00 034661 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9774 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9775 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9776 + 9777 ;********** + 9778 + 9779 + 9780 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9781 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 9782 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 9783 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 30-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0220 + + 9784 ;THEN, C(AC) IS CHECKED. + 9785 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9786 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9787 + 9788 002402 SN=SN+1 + 9789 000002 ZZ=ZZ+ZZ + 9790 777777 777775 YY=YY+YY+1 + 9791 IFE ZZ, + 9792 IFE , + 9793 034661 204 00 0 00 035607 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9794 ;AND MOVE RESULT INTO AC + 9795 034662 312 00 0 00 035606 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 9796 STOP ^ + 9797 034663 254 04 0 00 034664 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9798 034664 324 00 0 00 034665 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9799 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9800 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9801 + 9802 ;********** + 9803 + 9804 + 9805 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9806 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 9807 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 9808 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9809 ;THEN, C(AC) IS CHECKED. + 9810 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9811 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9812 + 9813 002403 SN=SN+1 + 9814 000004 ZZ=ZZ+ZZ + 9815 777777 777773 YY=YY+YY+1 + 9816 IFE ZZ, + 9817 IFE , + 9818 034665 204 00 0 00 035611 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9819 ;AND MOVE RESULT INTO AC + 9820 034666 312 00 0 00 035610 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 9821 STOP ^ + 9822 034667 254 04 0 00 034670 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9823 034670 324 00 0 00 034671 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9824 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9825 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9826 + 9827 ;********** + 9828 + 9829 + 9830 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9831 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 9832 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 9833 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9834 ;THEN, C(AC) IS CHECKED. + 9835 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9836 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9837 + 9838 002404 SN=SN+1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 30-2 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0221 + + 9839 000010 ZZ=ZZ+ZZ + 9840 777777 777767 YY=YY+YY+1 + 9841 IFE ZZ, + 9842 IFE , + 9843 034671 204 00 0 00 035613 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9844 ;AND MOVE RESULT INTO AC + 9845 034672 312 00 0 00 035612 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 9846 STOP ^ + 9847 034673 254 04 0 00 034674 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9848 034674 324 00 0 00 034675 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9849 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9850 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9851 + 9852 ;********** + 9853 + 9854 + 9855 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9856 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 9857 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 9858 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9859 ;THEN, C(AC) IS CHECKED. + 9860 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9861 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9862 + 9863 002405 SN=SN+1 + 9864 000020 ZZ=ZZ+ZZ + 9865 777777 777757 YY=YY+YY+1 + 9866 IFE ZZ, + 9867 IFE , + 9868 034675 204 00 0 00 035615 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9869 ;AND MOVE RESULT INTO AC + 9870 034676 312 00 0 00 035614 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 9871 STOP ^ + 9872 034677 254 04 0 00 034700 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9873 034700 324 00 0 00 034701 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9874 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9875 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9876 + 9877 ;********** + 9878 + 9879 + 9880 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9881 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 9882 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 9883 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9884 ;THEN, C(AC) IS CHECKED. + 9885 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9886 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9887 + 9888 002406 SN=SN+1 + 9889 000040 ZZ=ZZ+ZZ + 9890 777777 777737 YY=YY+YY+1 + 9891 IFE ZZ, + 9892 IFE , + 9893 034701 204 00 0 00 035617 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 30-3 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0222 + + 9894 ;AND MOVE RESULT INTO AC + 9895 034702 312 00 0 00 035616 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 9896 STOP ^ + 9897 034703 254 04 0 00 034704 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9898 034704 324 00 0 00 034705 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9899 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9900 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9901 + 9902 ;********** + 9903 + 9904 + 9905 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9906 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 9907 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 9908 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9909 ;THEN, C(AC) IS CHECKED. + 9910 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9911 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9912 + 9913 002407 SN=SN+1 + 9914 000100 ZZ=ZZ+ZZ + 9915 777777 777677 YY=YY+YY+1 + 9916 IFE ZZ, + 9917 IFE , + 9918 034705 204 00 0 00 035621 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9919 ;AND MOVE RESULT INTO AC + 9920 034706 312 00 0 00 035620 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 9921 STOP ^ + 9922 034707 254 04 0 00 034710 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9923 034710 324 00 0 00 034711 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9924 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9925 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9926 + 9927 ;********** + 9928 + 9929 + 9930 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9931 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 9932 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 9933 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9934 ;THEN, C(AC) IS CHECKED. + 9935 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9936 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9937 + 9938 002410 SN=SN+1 + 9939 000200 ZZ=ZZ+ZZ + 9940 777777 777577 YY=YY+YY+1 + 9941 IFE ZZ, + 9942 IFE , + 9943 034711 204 00 0 00 035623 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9944 ;AND MOVE RESULT INTO AC + 9945 034712 312 00 0 00 035622 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 9946 STOP ^ + 9947 034713 254 04 0 00 034714 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9948 034714 324 00 0 00 034715 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 30-4 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0223 + + 9949 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9950 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9951 + 9952 ;********** + 9953 + 9954 + 9955 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9956 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 9957 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 9958 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9959 ;THEN, C(AC) IS CHECKED. + 9960 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9961 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9962 + 9963 002411 SN=SN+1 + 9964 000400 ZZ=ZZ+ZZ + 9965 777777 777377 YY=YY+YY+1 + 9966 IFE ZZ, + 9967 IFE , + 9968 034715 204 00 0 00 035625 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9969 ;AND MOVE RESULT INTO AC + 9970 034716 312 00 0 00 035624 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 9971 STOP ^ + 9972 034717 254 04 0 00 034720 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9973 034720 324 00 0 00 034721 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9974 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 9975 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 9976 + 9977 ;********** + 9978 + 9979 + 9980 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 9981 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 9982 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 9983 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 9984 ;THEN, C(AC) IS CHECKED. + 9985 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 9986 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 9987 + 9988 002412 SN=SN+1 + 9989 001000 ZZ=ZZ+ZZ + 9990 777777 776777 YY=YY+YY+1 + 9991 IFE ZZ, + 9992 IFE , + 9993 034721 204 00 0 00 035627 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 9994 ;AND MOVE RESULT INTO AC + 9995 034722 312 00 0 00 035626 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 9996 STOP ^ + 9997 034723 254 04 0 00 034724 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 9998 034724 324 00 0 00 034725 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 9999 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10000 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10001 + 10002 ;********** + 10003 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 30-5 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0224 + + 10004 + 10005 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 10006 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 10007 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 10008 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 10009 ;THEN, C(AC) IS CHECKED. + 10010 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 10011 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 10012 + 10013 002413 SN=SN+1 + 10014 002000 ZZ=ZZ+ZZ + 10015 777777 775777 YY=YY+YY+1 + 10016 IFE ZZ, + 10017 IFE , + 10018 034725 204 00 0 00 035631 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 10019 ;AND MOVE RESULT INTO AC + 10020 034726 312 00 0 00 035630 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 10021 STOP ^ + 10022 034727 254 04 0 00 034730 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10023 034730 324 00 0 00 034731 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10024 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10025 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10026 + 10027 ;********** + 10028 + 10029 + 10030 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 10031 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 10032 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 10033 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 10034 ;THEN, C(AC) IS CHECKED. + 10035 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 10036 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 10037 + 10038 002414 SN=SN+1 + 10039 004000 ZZ=ZZ+ZZ + 10040 777777 773777 YY=YY+YY+1 + 10041 IFE ZZ, + 10042 IFE , + 10043 034731 204 00 0 00 035633 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 10044 ;AND MOVE RESULT INTO AC + 10045 034732 312 00 0 00 035632 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 10046 STOP ^ + 10047 034733 254 04 0 00 034734 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10048 034734 324 00 0 00 034735 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10049 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10050 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10051 + 10052 ;********** + 10053 + 10054 + 10055 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 10056 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 10057 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 10058 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 30-6 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0225 + + 10059 ;THEN, C(AC) IS CHECKED. + 10060 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 10061 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 10062 + 10063 002415 SN=SN+1 + 10064 010000 ZZ=ZZ+ZZ + 10065 777777 767777 YY=YY+YY+1 + 10066 IFE ZZ, + 10067 IFE , + 10068 034735 204 00 0 00 035635 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 10069 ;AND MOVE RESULT INTO AC + 10070 034736 312 00 0 00 035634 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 10071 STOP ^ + 10072 034737 254 04 0 00 034740 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10073 034740 324 00 0 00 034741 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10074 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10075 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10076 + 10077 ;********** + 10078 + 10079 + 10080 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 10081 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 10082 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 10083 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 10084 ;THEN, C(AC) IS CHECKED. + 10085 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 10086 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 10087 + 10088 002416 SN=SN+1 + 10089 020000 ZZ=ZZ+ZZ + 10090 777777 757777 YY=YY+YY+1 + 10091 IFE ZZ, + 10092 IFE , + 10093 034741 204 00 0 00 035637 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 10094 ;AND MOVE RESULT INTO AC + 10095 034742 312 00 0 00 035636 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 10096 STOP ^ + 10097 034743 254 04 0 00 034744 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10098 034744 324 00 0 00 034745 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10099 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10100 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10101 + 10102 ;********** + 10103 + 10104 + 10105 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 10106 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 10107 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 10108 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 10109 ;THEN, C(AC) IS CHECKED. + 10110 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 10111 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 10112 + 10113 002417 SN=SN+1 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 30-7 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0226 + + 10114 040000 ZZ=ZZ+ZZ + 10115 777777 737777 YY=YY+YY+1 + 10116 IFE ZZ, + 10117 IFE , + 10118 034745 204 00 0 00 035641 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 10119 ;AND MOVE RESULT INTO AC + 10120 034746 312 00 0 00 035640 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 10121 STOP ^ + 10122 034747 254 04 0 00 034750 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10123 034750 324 00 0 00 034751 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10124 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10125 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10126 + 10127 ;********** + 10128 + 10129 + 10130 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 10131 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 10132 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 10133 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 10134 ;THEN, C(AC) IS CHECKED. + 10135 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 10136 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 10137 + 10138 002420 SN=SN+1 + 10139 100000 ZZ=ZZ+ZZ + 10140 777777 677777 YY=YY+YY+1 + 10141 IFE ZZ, + 10142 IFE , + 10143 034751 204 00 0 00 035643 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 10144 ;AND MOVE RESULT INTO AC + 10145 034752 312 00 0 00 035642 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 10146 STOP ^ + 10147 034753 254 04 0 00 034754 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10148 034754 324 00 0 00 034755 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10149 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10150 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10151 + 10152 ;********** + 10153 + 10154 + 10155 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 10156 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 10157 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 10158 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 10159 ;THEN, C(AC) IS CHECKED. + 10160 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 10161 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 10162 + 10163 002421 SN=SN+1 + 10164 200000 ZZ=ZZ+ZZ + 10165 777777 577777 YY=YY+YY+1 + 10166 IFE ZZ, + 10167 IFE , + 10168 034755 204 00 0 00 035645 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 30-8 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVS INSTRUCTION SEQ 0227 + + 10169 ;AND MOVE RESULT INTO AC + 10170 034756 312 00 0 00 035644 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 10171 STOP ^ + 10172 034757 254 04 0 00 034760 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10173 034760 324 00 0 00 034761 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10174 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10175 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10176 + 10177 ;********** + 10178 + 10179 + 10180 ;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND + 10181 ;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E + 10182 ;AND A 1 IS RIPPLED THRU THE RIGHT HALF + 10183 ;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. + 10184 ;THEN, C(AC) IS CHECKED. + 10185 ;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF + 10186 ;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + 10187 + 10188 002422 SN=SN+1 + 10189 400000 ZZ=ZZ+ZZ + 10190 777777 377777 YY=YY+YY+1 + 10191 IFE ZZ, + 10192 IFE , + 10193 034761 204 00 0 00 035647 MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + 10194 ;AND MOVE RESULT INTO AC + 10195 034762 312 00 0 00 035646 CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + 10196 STOP ^ + 10197 034763 254 04 0 00 034764 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10198 034764 324 00 0 00 034765 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10199 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10200 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10201 + 10202 ;********** + 10203 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 31 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAXX) INSTRUCTIONS SEQ 0228 + + 10204 SUBTTL TEST OF COMPARE (CAXX) INSTRUCTIONS + 10205 + 10206 ;********** + 10207 + 10208 ;THIS TEST VERIFIES THAT CAIE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 10209 ;AND ONLY WHEN C(AC)=E + 10210 ;IN THIS CASE C(AC)=E=0; HENCE, CAIE SHOULD SKIP + 10211 ;OTHERWISE THE PROGRAM HALTS + 10212 + 10213 034765 400 00 0 00 000000 B2500: SETZ ;PRELOAD AC TO 0 + 10214 034766 302 00 0 00 000000 CAIE ;*CAIE SHOULD SKIP BECAUSE C(AC)=E + 10215 STOP^ + 10216 034767 254 04 0 00 034770 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10217 034770 324 00 0 00 034771 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10218 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10219 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10220 + 10221 ;***** FAILURE ANALYSIS ***** + 10222 ;C(AC0) C(AC1) FAILING SIGNAL + 10223 + 10224 ; SW: PC CHANGE + 10225 ; FC: AD FM ; EN + 10226 ; FC: AD CRY 36 + 10227 ; FC: AB PC EN + 10228 ; ET0: COND P: PC CLK EN + 10229 + 10230 ;********** + 10231 + 10232 ;THIS TEST VERIFIES THAT CAIE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 10233 ;AND ONLY WHEN C(AC)=E + 10234 ;IN THIS CASE C(AC)=E=1. HENCE, CAIE SHOULD SKIP + 10235 ;OTHERWISE THE PROGRAM HALTS + 10236 + 10237 034771 200 00 0 00 035416 B2600: MOVE [1] ;PRELOAD AC TO 1 + 10238 034772 302 00 0 00 000001 CAIE 1 ;*CAIE SHOULD SKIP BECAUSE C(AC)=E + 10239 STOP^ + 10240 034773 254 04 0 00 034774 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10241 034774 324 00 0 00 034775 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10242 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10243 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10244 + 10245 ;***** FAILURE ANALYSIS ***** + 10246 ;C(AC0) C(AC1) FAILING SIGNAL + 10247 + 10248 ; FC: AD AR - EN + 10249 + 10250 ;********** + 10251 + 10252 ;THIS TEST VERIFIES THAT CAME SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 10253 ;AND ONLY WHEN C(AC)=C(E) + 10254 ;IN THIS CASE C(AC)=C(E)=1; HENCE, CAME SHOULD SKIP + 10255 ;OTHERWISE THE PROGRAM HALTS + 10256 + 10257 034775 201 00 0 00 000001 B2700: MOVEI 1 ;PRELOAD AC TO 1 + 10258 034776 312 00 0 00 035416 CAME [1] ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 31-1 +DAKABM MAC 19-JAN-77 13:39 TEST OF COMPARE (CAXX) INSTRUCTIONS SEQ 0229 + + 10259 STOP^ + 10260 034777 254 04 0 00 035000 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10261 035000 324 00 0 00 035001 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10262 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10263 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10264 + 10265 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 32 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0230 + + 10266 SUBTTL TEST OF BOOLEAN INSTRUCTIONS + 10267 + 10268 ;********** + 10269 + 10270 ;THIS TEST VERIFIES THAT SETCA IGNORES THE ADDRESS FIELD OF THE INSTUCTION WORD. + 10271 ;IN THIS CASE C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 + 10272 ;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES. + 10273 + 10274 035001 201 00 0 00 777777 B3000: MOVEI -1 ;PRELOAD AC TO 0,,-1 + 10275 035002 450 00 0 00 035524 SETCA [-1] ;*SETCA SHOULD PUT -1,,0 INTO THE AC + 10276 035003 312 00 0 00 035502 CAME [-1,,0] ;PASS TEST IF C(AC)=-1,,0 + 10277 STOP^ + 10278 035004 254 04 0 00 035005 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10279 035005 324 00 0 00 035006 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10280 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10281 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10282 + 10283 ;********** + 10284 + 10285 ;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE + 10286 ;RESULT IN THE AC. + 10287 ;IN THIS CASE C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 + 10288 ;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES + 10289 + 10290 035006 201 00 0 00 777777 B3100: MOVEI -1 ;PRELOAD AC TO 0,,-1 + 10291 035007 450 00 0 00 000000 SETCA ;*SETCA SHOULD PUT -1,,0 INTO THE AC + 10292 035010 312 00 0 00 035502 CAME [-1,,0] ;PASS TEST IF C(AC) =-1,,0 + 10293 STOP^ + 10294 035011 254 04 0 00 035012 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10295 035012 324 00 0 00 035013 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10296 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10297 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10298 + 10299 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 33 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0231 + + 10300 ;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE + 10301 ;RESULT IN THE AC, + 10302 ;IN THIS CASE C(AC)=0,,0 HENCE, THE RESULT IN THE AC SHOULD BE,-1 + 10303 ;IF THE RESULT IN THE AC IS -1,,-1, THE TEST PASSES + 10304 + 10305 035013 201 00 0 00 000000 B3200: MOVEI 0 ;PRELOAD AC TO 0,,0 + 10306 035014 450 00 0 00 000000 SETCA ;*SETCA SHOULD PUT -1,,-1 INTO THE AC + 10307 035015 312 00 0 00 035524 CAME [-1] ;PASS TEST IF C(AC) =-1,,-1 + 10308 STOP^ + 10309 035016 254 04 0 00 035017 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10310 035017 324 00 0 00 035020 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10311 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10312 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10313 + 10314 ;***** FAILURE ANALYSIS ***** + 10315 ;C(AC0) C(AC1) FAILING SIGNAL + 10316 + 10317 ;0 ET2: AR AD EN + 10318 + 10319 ;********** + 10320 + 10321 ;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE + 10322 ;RESULT IN THE AC, + 10323 ;IN THIS CASE C(AC)=-1,,-1; HENCE, THE RESULT IN THE AC SHOULD BE 0,,0 + 10324 ;IF THE RESULT IN THE AC IS ZERO, THE TEST PASSES + 10325 + 10326 035020 200 00 0 00 035524 B3300: MOVE [-1] ;PRELOAD AC TO -1,,-1 + 10327 035021 450 00 0 00 000000 SETCA ;*SETCA SHOULD PUT 0,,0 INTO THE AC + 10328 035022 312 00 0 00 035412 CAME [0] ;PASS TEST IF C(AC) IS ZERO + 10329 STOP^ + 10330 035023 254 04 0 00 035024 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10331 035024 324 00 0 00 035025 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10332 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10333 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10334 + 10335 ;***** FAILURE ANALYSIS ***** + 10336 ;C(AC0) C(AC1) FAILING SIGNAL + 10337 + 10338 ;-1,,-1 FC: AD FM - EN + 10339 + 10340 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 34 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0232 + + 10341 ;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE + 10342 ;RESULT IN THE AC. + 10343 ;IN THIS CASE AC=E AND C(E)=C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 + 10344 ;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES + 10345 + 10346 035025 201 00 0 00 777777 B3500: MOVEI -1 ;PRELOAD AC TO 0,,-1 + 10347 035026 460 00 0 00 000000 SETCM ;*SETCM SHOULD PUT -1,,0 INTO THE AC + 10348 035027 312 00 0 00 035502 CAME [-1,,0] ;PASS TEST IF C(AC) =-1,,0 + 10349 STOP^ + 10350 035030 254 04 0 00 035031 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10351 035031 324 00 0 00 035032 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10352 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10353 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10354 + 10355 ;***** FAILURE ANALYSIS ***** + 10356 ;C(AC0) C(AC1) FAILING SIGNAL + 10357 + 10358 ;-1,,-1 SW: FCE + 10359 ;-1,,-1 FC: AD AR - EN + 10360 ;0,,-1 ET2: AR AD EN + 10361 + 10362 ;********** + 10363 + 10364 ;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE + 10365 ;RESULT IN THE AC. + 10366 ;IN THIS CASE C(E)=-1,,-1; HENCE, THE RESULT IN THE AC SHOULD BE 0,,0 + 10367 ;IF THE RESULT IN THE AC IS ZERO,THE TEST PASSES + 10368 + 10369 035032 460 00 0 00 035524 B3600: SETCM [-1] ;*SETCM SHOULD PUT 0 INTO THE AC + 10370 035033 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC0)=0 + 10371 STOP^ + 10372 035034 254 04 0 00 035035 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10373 035035 324 00 0 00 035036 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10374 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10375 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10376 + 10377 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 35 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0233 + + 10378 ;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE + 10379 ;RESULT IN THE AC. + 10380 ;IN THIS CASE C(E)=0,,0; HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 + 10381 ;IF THE RESULT IN THE AC IS -1,,-1,THE TEST PASSES + 10382 + 10383 035036 460 00 0 00 035412 B3700: SETCM [0] ;*SETCM SHOULD PUT -1,,-1 INTO THE AC + 10384 035037 312 00 0 00 035524 CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + 10385 STOP^ + 10386 035040 254 04 0 00 035041 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10387 035041 324 00 0 00 035042 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10388 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10389 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10390 + 10391 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 36 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0234 + + 10392 ;THIS TEST VERIFIES THAT SETO SETS C(AC) TO -1,,-1. SETO IGNORES + 10393 ;THE ADDRESS FIELD OF THE INSTRUCTION WORD. + 10394 ;FIRST C(AC) IS SET TO 0,,0; THEN SETO IS EXECUTED. + 10395 ;THE AC IS THEN CHECKED FOR ALL ONES. IF C(AC) IS ALL ONES, + 10396 ;THE TEST PASSES + 10397 + 10398 035042 201 00 0 00 000000 B4300: MOVEI 0 ;PRELOAD AC WITH 0,,0 + 10399 035043 474 00 0 00 000000 SETO ;*SETO SHOULD LOAD THE AC WITH -1,,-1 + 10400 035044 312 00 0 00 035524 CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + 10401 STOP^ + 10402 035045 254 04 0 00 035046 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10403 035046 324 00 0 00 035047 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10404 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10405 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10406 + 10407 ;***** FAILURE ANALYSIS ***** + 10408 ;C(AC0) C(AC1) FAILING SIGNAL + 10409 + 10410 ;0 ET2: AR AD EN + 10411 + 10412 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 37 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0235 + + 10413 ;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL + 10414 ;INCLUSIVE OR OF C(AC) WITH THE COMPLEMENT OF C(MEMORY). + 10415 ;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=0. + 10416 ;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES. + 10417 ;THE AC IS CHECKED FOR ITS FINAL CONTENTS NON-ZERO. + 10418 ;IF C(AC) IS NOT=0, THE TEST PASSES + 10419 + 10420 035047 201 00 0 00 000000 B4400: MOVEI 0 ;PRELOAD AC,E WITH 0 + 10421 035050 464 00 0 00 000000 ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0 + 10422 035051 336 00 0 00 000000 SKIPN ;PASS IF C(AC) IS NON-ZERO + 10423 STOP^ + 10424 035052 254 04 0 00 035053 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10425 035053 324 00 0 00 035054 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10426 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10427 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10428 + 10429 ;********** + 10430 + 10431 ;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL + 10432 ;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY). + 10433 ;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=0 + 10434 ;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES. + 10435 ;THE AC IS CHECKED FOR ITS FINAL CONTENTS EQUAL TO -1,,-1 + 10436 ;IF C(AC0)=-1,,-1, THE TEST PASSES + 10437 + 10438 035054 201 00 0 00 000000 B4500: MOVEI 0 ;PRELOAD AC,E WITH 0 + 10439 035055 464 00 0 00 000000 ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0 + 10440 035056 312 00 0 00 035524 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 10441 STOP^ + 10442 035057 254 04 0 00 035060 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10443 035060 324 00 0 00 035061 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10444 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10445 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10446 + 10447 ;***** FAILURE ANALYSIS ***** + 10448 ;C(AC0) C(AC1) FAILING SIGNAL + 10449 + 10450 ;0 SW: ET0 + 10451 ;0 FC: AD AR + EN + 10452 ;0 ET2: AR AD EN + 10453 + 10454 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 38 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0236 + + 10455 ;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL + 10456 ;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY). + 10457 ;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=-1,,-1 + 10458 ;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES. + 10459 ;THE AC IS CHECKED FOR ITS FINAL CONTENTS EQUAL TO -1,,-1 + 10460 ;IF C(AC0)=-1,,-1, THE TEST PASSES + 10461 + 10462 035061 200 00 0 00 035524 B4600: MOVE [-1] ;PRELOAD AC,E WITH -1,,-1 + 10463 035062 464 00 0 00 000000 ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0 + 10464 035063 312 00 0 00 035524 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 10465 STOP^ + 10466 035064 254 04 0 00 035065 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10467 035065 324 00 0 00 035066 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10468 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10469 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10470 + 10471 ;***** FAILURE ANALYSIS ***** + 10472 ;C(AC0) C(AC1) FAILING SIGNAL + 10473 + 10474 ;0 FC: AD FM - EN + 10475 ;0 ET0: AR AD EN + 10476 + 10477 ;********** + 10478 + 10479 ;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL + 10480 ;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY). + 10481 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1; HENCE, THE RESULT + 10482 ;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR ITS INAL CONTENTS=0. + 10483 ;IF C(AC)=0, THE TEST PASSES + 10484 + 10485 035066 201 00 0 00 000000 B4700: MOVEI 0 ;PRELOAD AC WITH 0 + 10486 035067 464 00 0 00 035524 ORCM [-1] ;*ORCM SHOULD PLACE ALL ZEROS INTO THE AC + 10487 035070 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0,,0 + 10488 STOP^ + 10489 035071 254 04 0 00 035072 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10490 035072 324 00 0 00 035073 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10491 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10492 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10493 + 10494 ;***** FAILURE ANALYSIS ***** + 10495 ;C(AC0) C(AC1) FAILING SIGNAL + 10496 + 10497 ;-E SW: FCE + 10498 + 10499 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 39 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0237 + + 10500 ;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL + 10501 ;INCLUSIVE OR OF C(AC) WITH C(E). + 10502 ;IN THIS CASE AC=E AND C(AC)=C(E)=0,,0. HENCE THE + 10503 ;RESULT IN THE AC SHOULD BE 0,,0. + 10504 ;THE AC IS CHECKED FOR 0,,0. IF C(AC)=0,,0, THIS TEST PASSES + 10505 + 10506 035073 201 00 0 00 000000 B5000: MOVEI 0 ;PRELOAD AC,E WITH 0,,0 + 10507 035074 434 00 0 00 000000 IOR ;*IOR SHOULD PUT 0 INTO AC + 10508 035075 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0,,0 + 10509 STOP^ + 10510 035076 254 04 0 00 035077 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10511 035077 324 00 0 00 035100 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10512 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10513 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10514 + 10515 ;***** FAILURE ANALYSIS ***** + 10516 ;C(AC0) C(AC1) FAILING SIGNAL + 10517 + 10518 ;-1,,-1 SW: ET0 + 10519 ;-1,,-1 ET0: AR AD EN + 10520 ;-1,,-1 ET0: AD AR - EN + 10521 ;-1,,-1 ET2: AR AD EN + 10522 + 10523 ;********** + 10524 + 10525 ;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL + 10526 ;INCLUSIVE OR OF C(AC) WITH C(E). + 10527 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE + 10528 ;RESULT IN THE AC SHOULD BE -1,,-1. + 10529 ;THE AC IS CHECKED FOR -1,,-1 + 10530 ;IF C(AC) =-1,,-1 THE TEST PASSES. + 10531 + 10532 035100 201 00 0 00 000000 B5100: MOVEI 0 ;PRELOAD AC WITH 0 + 10533 035101 434 00 0 00 035524 IOR [-1] ;*IOR SHOULD PUT -1,,-1 INTO AC + 10534 035102 312 00 0 00 035524 CAME [-1] ;PASS TEST IF C(AC) =-1,,-1 + 10535 STOP^ + 10536 035103 254 04 0 00 035104 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10537 035104 324 00 0 00 035105 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10538 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10539 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10540 + 10541 ;***** FAILURE ANALYSIS ***** + 10542 ;C(AC0) C(AC1) FAILING SIGNAL + 10543 + 10544 ;E SW: FCE + 10545 ;0 FC: AD AR - EN + 10546 + 10547 ;***** FAILURE ANALYSIS ***** + 10548 ;C(AC0) C(AC1) FAILING SIGNAL + 10549 + 10550 ;0 FC: AD FM - EN + 10551 + 10552 035105 NB5300:;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 40 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0238 + + 10553 ;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL + 10554 ;INCLUSIVE OR OF C(AC) WITH C(E). + 10555 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE + 10556 ;RESULT IN THE AC SHOULD BE -1,,-1 + 10557 ;THE AC IS CHECKED FOR ITS CONTENTS = ALL ONES + 10558 ;IF C(AC)=-1, THE TEST PASSES + 10559 + 10560 035105 474 00 0 00 000000 B5200: SETO ;PRELOAD AC WITH -1,,-1 + 10561 035106 434 00 0 00 035524 IOR [-1] ;*IOR SHOULD PUT -1,,-1 INTO AC + 10562 035107 312 00 0 00 035524 CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + 10563 STOP^ + 10564 035110 254 04 0 00 035111 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10565 035111 324 00 0 00 035112 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10566 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10567 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10568 + 10569 ;********** + 10570 + 10571 ;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL + 10572 ;INCLUSIVE OR OF C(AC) WITH C(E). + 10573 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE + 10574 ;RESULT IN THE AC SHOULD BE -1,,-1 + 10575 ;THE AC IS CHECKED FOR ITS CONTENTS = ALL ONES + 10576 ;IF C(AC)=-1,,-1, THE TEST PASSES + 10577 + 10578 035112 474 00 0 00 000000 B5300: SETO ;PRELOAD AC WITH -1,,-1 + 10579 035113 434 00 0 00 035412 IOR [0] ;*IOR SHOULD PUT -1,,-1 INTO AC + 10580 035114 312 00 0 00 035524 CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + 10581 STOP^ + 10582 035115 254 04 0 00 035116 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10583 035116 324 00 0 00 035117 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10584 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10585 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10586 + 10587 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 41 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0239 + + 10588 ;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND + 10589 ;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). + 10590 ;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT + 10591 ;IN THE AC SHOULD BE 0,,-1 + 10592 ;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THE TEST PASSES + 10593 + 10594 035117 474 00 0 00 000000 B5500: SETO ;PRELOAD AC WITH ALL ONES + 10595 035120 420 00 0 00 035502 ANDCM [XWD -1,0] ;*ANDCM SHOULD PLACE 0,,-1 IN THE AC + 10596 035121 312 00 0 00 035537 CAME [0,,-1] ;IF C(AC)=0,,-1, THE TEST PASSES + 10597 STOP^ + 10598 035122 254 04 0 00 035123 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10599 035123 324 00 0 00 035124 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10600 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10601 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10602 + 10603 ;***** FAILURE ANALYSIS ***** + 10604 ;C(AC0) C(AC1) FAILING SIGNAL + 10605 + 10606 ;-E SW: FCE + 10607 ;-1,,-1 FC: AD AR - EN + 10608 ;-1,,0 ET2: AR AD EN + 10609 + 10610 ;********** + 10611 + 10612 ;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND + 10613 ;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). + 10614 ;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=0. HENCE, + 10615 ;THE RESULT IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0. + 10616 ;IF C(AC)=0, THE TEST PASSES. + 10617 + 10618 035124 474 00 0 00 000000 B5600: SETO ;PRELOAD AC WITH ALL ONES + 10619 035125 420 00 0 00 000000 ANDCM ;*ANDCM SHOULD PLACE 0 IN THE AC + 10620 035126 332 00 0 00 000000 SKIPE ;IF C(AC)=0, THE TEST PASSES. + 10621 STOP^ + 10622 035127 254 04 0 00 035130 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10623 035130 324 00 0 00 035131 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10624 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10625 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10626 + 10627 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 42 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0240 + + 10628 ;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND + 10629 ;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). + 10630 ;IN THIS CASE C(AC)=-1,,-1, AND C(E)=0. HENCE, THE RESULT IN THE AC + 10631 ;SHOULD BE ALL ONES. THE AC IS CHECKED FOR -1,,-1. + 10632 ;IF C(AC)=-1,,-1, THE TEST PASSES + 10633 + 10634 035131 474 00 0 00 000000 B5700: SETO ;PRELOAD AC WITH 0 + 10635 035132 420 00 0 00 035412 ANDCM [0] ;*ANDCM SHOULD PLACE -1,,-1 IN THE AC + 10636 035133 312 00 0 00 035524 CAME [-1] ;IF C(AC)=-1,,-1, THE TEST PASSES + 10637 STOP^ + 10638 035134 254 04 0 00 035135 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10639 035135 324 00 0 00 035136 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10640 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10641 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10642 + 10643 ;********** + 10644 + 10645 ;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND + 10646 ;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). + 10647 ;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC + 10648 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. + 10649 ;IF C(AC)=0, THE TEST PASSES + 10650 + 10651 035136 201 00 0 00 000000 B6000: MOVEI 0 ;PRELOAD AC WITH 0 + 10652 035137 420 00 0 00 000000 ANDCM ;*ANDCM SHOULD PLACE 0 IN THE AC + 10653 035140 332 00 0 00 000000 SKIPE ;IF C(AC)=0, THE TEST PASSES. + 10654 STOP^ + 10655 035141 254 04 0 00 035142 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10656 035142 324 00 0 00 035143 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10657 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10658 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10659 + 10660 ;***** FAILURE ANALYSIS ***** + 10661 ;C(AC0) C(AC1) FAILING SIGNAL + 10662 + 10663 ;-1,,-1 FC: AD FM + EN + 10664 + 10665 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 43 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0241 + + 10666 ;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND + 10667 ;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). + 10668 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 10669 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. + 10670 ;IF C(AC)=0, THE TEST PASSES + 10671 + 10672 035143 400 00 0 00 000000 B6100: SETZ ;PRELOAD AC WITH 0 + 10673 035144 420 00 0 00 035524 ANDCM [-1] ;*ANDCM SHOULD PLACE 0 IN THE AC + 10674 035145 332 00 0 00 000000 SKIPE ;IF C(AC)=0, THE TEST PASSES + 10675 STOP^ + 10676 035146 254 04 0 00 035147 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10677 035147 324 00 0 00 035150 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10678 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10679 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10680 + 10681 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 44 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0242 + + 10682 ;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION + 10683 ;OF THE COMPLEMENT OF C(AC) AND C(E). + 10684 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC + 10685 ;SHOULD BE 0. THE AC IS CHECKED FOR ZERO. IF C(AC) IS + 10686 ;EQUAL TO ZERO, THE TEST PASSES. + 10687 + 10688 035150 200 00 0 00 035502 B6200: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + 10689 035151 410 00 0 00 035412 ANDCA [0] ;*ANDCA SHOULD PLACE 0 IN THE AC + 10690 035152 332 00 0 00 000000 SKIPE ;IF C(AC)=0, THE TEST PASSES. + 10691 STOP^ + 10692 035153 254 04 0 00 035154 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10693 035154 324 00 0 00 035155 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10694 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10695 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10696 + 10697 ;***** FAILURE ANALYSIS ***** + 10698 ;C(AC0) C(AC1) FAILING SIGNAL + 10699 + 10700 ;E SW: FCE + 10701 ;0,,-1 FC: AD AR + EN + 10702 + 10703 ;********** + 10704 + 10705 ;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION + 10706 ;OF THE COMPLEMENT OF C(AC) AND C(E). + 10707 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE, THE + 10708 ;RESULT IN THE AC SHOULD BE 0,,707070. THE AC IS CHECKED + 10709 ;FOR 0,,707070. IF C(AC)=0,,707070, THE TEST PASSES. + 10710 + 10711 035155 200 00 0 00 035502 B6300: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + 10712 035156 410 00 0 00 035650 ANDCA [707070707070] ;*ANDCA SHOULD PLACE 0,,707070 IN THE AC + 10713 035157 312 00 0 00 035651 CAME [XWD 0,707070] ;IF C(AC)=0,,707070, THE TEST PASSES + 10714 STOP^ + 10715 035160 254 04 0 00 035161 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10716 035161 324 00 0 00 035162 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10717 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10718 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10719 + 10720 ;***** FAILURE ANALYSIS ***** + 10721 ;C(AC0) C(AC1) FAILING SIGNAL + 10722 + 10723 ;707070,,707070 FC: AD FM - EN + 10724 ;707070,,707070 ET2: AR AD EN + 10725 + 10726 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 45 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0243 + + 10727 ;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION + 10728 ;OF THE COMPLEMENT OF C(AC) AND C(E). + 10729 ;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=0. HENCE, THE RESULT + 10730 ;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC=0, + 10731 ;THE TEST PASSES. + 10732 + 10733 035162 400 00 0 00 000000 B6400: SETZ ;CLEAR THE AC AND E + 10734 035163 410 00 0 00 000000 ANDCA ;*ANDCA SHOULD PLACE 0 IN THE AC + 10735 035164 332 00 0 00 000000 SKIPE ;IF C(AC)=0, THE TEST PASSES + 10736 STOP^ + 10737 035165 254 04 0 00 035166 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10738 035166 324 00 0 00 035167 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10739 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10740 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10741 + 10742 ;********** + 10743 + 10744 ;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION + 10745 ;OF THE COMPLEMENT OF C(AC) AND C(E). + 10746 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 10747 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR ALL ONES. + 10748 ;IF C(AC)=-1,,-1, THE TEST PASSES. + 10749 + 10750 035167 400 00 0 00 000000 B6500: SETZ ;CLEAR THE AC + 10751 035170 410 00 0 00 035524 ANDCA [-1] ;*ANDCA SHOULD PLACE ALL ONES IN THE AC + 10752 035171 312 00 0 00 035524 CAME [-1] ;IF C(AC)=ALL ONES, THE TEST PASSES. + 10753 STOP^ + 10754 035172 254 04 0 00 035173 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10755 035173 324 00 0 00 035174 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10756 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10757 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10758 + 10759 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 46 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0244 + + 10760 ;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION + 10761 ;OF THE COMPLEMENT OF C(AC) AND C(E). + 10762 ;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT + 10763 ;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, + 10764 ;THE TEST PASSES. + 10765 + 10766 035174 474 00 0 00 000000 B6600: SETO ;PRESET AC TO ALL ONES + 10767 035175 410 00 0 00 000000 ANDCA ;*ANDCA SHOULD PLACE 0 IN THE AC + 10768 035176 332 00 0 00 000000 SKIPE ;IF C(AC)=0, THE TEST PASSES + 10769 STOP^ + 10770 035177 254 04 0 00 035200 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10771 035200 324 00 0 00 035201 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10772 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10773 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10774 + 10775 ;********** + 10776 + 10777 ;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION + 10778 ;OF THE COMPLEMENT OF C(AC) AND C(E). + 10779 ;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 10780 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, + 10781 ;THE TEST PASSES. + 10782 + 10783 035201 474 00 0 00 000000 B6700: SETO ;PRESET AC TO ALL ONES + 10784 035202 410 00 0 00 035412 ANDCA [0] ;*ANDCA SHOULD PLACE 0 IN THE AC + 10785 035203 332 00 0 00 000000 SKIPE ;IF C(AC)=0, THE TEST PASSES. + 10786 STOP^ + 10787 035204 254 04 0 00 035205 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10788 035205 324 00 0 00 035206 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10789 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10790 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10791 + 10792 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 47 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0245 + + 10793 ;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION + 10794 ;OF THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). + 10795 ;IN THIS CASE C(AC)=-1,,0 AND C(E)=0; HENCE, THE RESULT IN THE AC + 10796 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, + 10797 ;THIS TEST PASSES. + 10798 + 10799 035206 200 00 0 00 035502 B7000: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + 10800 035207 440 00 0 00 035412 ANDCB [0] ;*ANDCB SHOULD PLACE 0,,-1 IN THE AC + 10801 035210 312 00 0 00 035537 CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + 10802 STOP^ + 10803 035211 254 04 0 00 035212 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10804 035212 324 00 0 00 035213 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10805 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10806 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10807 + 10808 ;***** FAILURE ANALYSIS ***** + 10809 ;C(AC0) C(AC1) FAILING SIGNAL + 10810 + 10811 ;0,,-E SW: FCE + 10812 ;-1,,-1 FC: AD FM - EN + 10813 ;0 ET2: AR AD EN + 10814 + 10815 ;********** + 10816 + 10817 ;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION + 10818 ;OF THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). + 10819 ;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,-1; HENCE, THE RESULT IN THE AC + 10820 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, + 10821 ;THIS TEST PASSES. + 10822 + 10823 035213 200 00 0 00 035502 B7100: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + 10824 035214 440 00 0 00 035524 ANDCB [-1] ;*ANDCB SHOULD PLACE 0 IN AC + 10825 035215 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 10826 STOP^ + 10827 035216 254 04 0 00 035217 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10828 035217 324 00 0 00 035220 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10829 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10830 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10831 + 10832 ;***** FAILURE ANALYSIS ***** + 10833 ;C(AC0) C(AC1) FAILING SIGNAL + 10834 + 10835 ;0,,-1 FC: AD AR - EN + 10836 + 10837 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 48 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0246 + + 10838 + 10839 ;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF + 10840 ;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). + 10841 ;IN THIS CASE AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC + 10842 ;SHOULD BE ALL ONES. THE AC IS CHECKED FOR ALL ONES. IF C(AC)=-1,,-1, + 10843 ;THE TEST PASSES. + 10844 + 10845 035220 400 00 0 00 000000 B7200: SETZ ;PRELOAD AC,E WITH ZEROES + 10846 035221 440 00 0 00 000000 ANDCB ;*ANDCB SHOULD PLACE ALL ONES IN THE AC + 10847 035222 312 00 0 00 035524 CAME [-1] ;PASS IF C(AC) IS ALL ONES + 10848 STOP^ + 10849 035223 254 04 0 00 035224 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10850 035224 324 00 0 00 035225 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10851 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10852 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10853 + 10854 ;********** + 10855 + 10856 ;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF + 10857 ;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). + 10858 ;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1. HENCE THE RESULT IN THE AC + 10859 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + 10860 + 10861 035225 474 00 0 00 000000 B7300: SETO ;PRELOAD AC,E WITH ONES + 10862 035226 440 00 0 00 000000 ANDCB ;*ANDCB SHOULD PLACE ALL ZEROS IN THE AC + 10863 035227 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 10864 STOP^ + 10865 035230 254 04 0 00 035231 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10866 035231 324 00 0 00 035232 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10867 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10868 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10869 + 10870 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 49 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0247 + + 10871 ;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF + 10872 ;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). + 10873 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 10874 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + 10875 + 10876 035232 400 00 0 00 000000 B7400: SETZ ;PRELOAD AC WITH 0 + 10877 035233 440 00 0 00 035524 ANDCB [-1] ;*ANDCB SHOULD PLACE 0 IN THE AC + 10878 035234 302 00 0 00 000000 CAIE ;PASS IF C(AC)=0 + 10879 STOP^ + 10880 035235 254 04 0 00 035236 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10881 035236 324 00 0 00 035237 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10882 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10883 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10884 + 10885 ;********** + 10886 + 10887 ;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF + 10888 ;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). + 10889 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 10890 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + 10891 + 10892 035237 474 00 0 00 000000 B7500: SETO ;PRELOAD AC WITH -1,,-1 + 10893 035240 440 00 0 00 035412 ANDCB [0] ;*ANDCB SHOULD PLACE 0 IN THE AC + 10894 035241 302 00 0 00 000000 CAIE ;PASS IF C(AC)=0 + 10895 STOP^ + 10896 035242 254 04 0 00 035243 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10897 035243 324 00 0 00 035244 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10898 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10899 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10900 + 10901 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 50 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0248 + + 10902 ;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF + 10903 ;THE COMPLEMENT OF C(AC) AND C(E). + 10904 ;IN THIS CASE C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC + 10905 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, + 10906 ;THIS TEST FAILS. + 10907 + 10908 035244 200 00 0 00 035502 B7600: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + 10909 035245 454 00 0 00 035412 ORCA [0] ;*ORCA SHOULD PLACE 0,,-1 IN THE AC + 10910 035246 312 00 0 00 035537 CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + 10911 STOP^ + 10912 035247 254 04 0 00 035250 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10913 035250 324 00 0 00 035251 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10914 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10915 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10916 + 10917 ;***** FAILURE ANALYSIS ***** + 10918 ;C(AC0) C(AC1) FAILING SIGNAL + 10919 + 10920 ;-1,,0 SW: ET0 + 10921 ;-1,,0 FC: AD AR - EN + 10922 ;0 FC: AD FM + EN + 10923 ;-1,,-1 ET0: AR AD EN + 10924 ;-1,,-1 ET0: AD AR - EN + 10925 ;-1,,0 ET2: AR AD EN + 10926 + 10927 ;********** + 10928 + 10929 ;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF + 10930 ;THE COMPLEMENT OF C(AC) AND C(E). + 10931 ;IN THIS CASE C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE, THE RESULT IN THE AC + 10932 ;SHOULD BE 707070,,-1. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, + 10933 ;THIS TEST FAILS. + 10934 + 10935 035251 200 00 0 00 035502 B10000: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + 10936 035252 454 00 0 00 035650 ORCA [707070707070] ;*ORCA SHOULD PLACE 707070,,-1 IN THE AC + 10937 035253 312 00 0 00 035652 CAME [XWD 707070,-1] ;PASS IF C(AC)=707070,,-1 + 10938 STOP^ + 10939 035254 254 04 0 00 035255 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10940 035255 324 00 0 00 035256 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10941 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10942 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10943 + 10944 ;***** FAILURE ANALYSIS ***** + 10945 ;C(AC0) C(AC1) FAILING SIGNAL + 10946 + 10947 ;0,,-1 SW: FCE + 10948 + 10949 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 51 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0249 + + 10950 ;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF + 10951 ;THE COMPLEMENT OF C(AC) AND C(E). + 10952 ;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC + 10953 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + 10954 + 10955 035256 400 00 0 00 000000 B10100: SETZ ;PRELOAD AC,E WITH 0 + 10956 035257 454 00 0 00 000000 ORCA ;*ORCA SHOULD PLACE -1,,-1 IN THE AC + 10957 035260 312 00 0 00 035524 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 10958 STOP^ + 10959 035261 254 04 0 00 035262 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10960 035262 324 00 0 00 035263 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10961 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10962 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10963 + 10964 ;********** + 10965 + 10966 ;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OF FUNCTION OF + 10967 ;THE COMPLEMENT OF C(AC) AND C(E). + 10968 ;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 10969 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + 10970 + 10971 035263 474 00 0 00 000000 B10200: SETO ;PRELOAD AC,E WITH 0 + 10972 035264 454 00 0 00 000000 ORCA ;*ORCA SHOULD PLACE -1,,-1 IN THE AC + 10973 035265 312 00 0 00 035524 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 10974 STOP^ + 10975 035266 254 04 0 00 035267 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10976 035267 324 00 0 00 035270 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10977 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10978 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10979 + 10980 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 52 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0250 + + 10981 ;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF + 10982 ;THE COMPLEMENT OF C(AC) AND C(E). + 10983 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESUTL IN THE AC + 10984 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + 10985 + 10986 035270 400 00 0 00 000000 B10300: SETZ ;PRELOAD AC WITH 0 + 10987 035271 454 00 0 00 035524 ORCA [-1] ;*ORCA SHOULD PLACE -1,,-1 IN THE AC + 10988 035272 312 00 0 00 035524 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 10989 STOP^ + 10990 035273 254 04 0 00 035274 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 10991 035274 324 00 0 00 035275 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 10992 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 10993 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 10994 + 10995 ;********** + 10996 + 10997 ;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF + 10998 ;THE COMPLEMENT OF C(AC) AND C(E). + 10999 ;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 11000 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + 11001 + 11002 035275 474 00 0 00 000000 B10400: SETO ;PRELOAD AC WITH -1,,-1 + 11003 035276 454 00 0 00 035412 ORCA [0] ;*ORCA SHOULD PLACE 0 IN THE AC + 11004 035277 302 00 0 00 000000 CAIE ;PASS IF C(AC)=0 + 11005 STOP^ + 11006 035300 254 04 0 00 035301 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11007 035301 324 00 0 00 035302 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11008 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11009 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11010 + 11011 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 53 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0251 + + 11012 ;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF + 11013 ;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E) + 11014 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE THE RESULT + 11015 ;IN THE AC 070707,,-1. THE AC IS CHECKED FOR 070707,,-1. IF C(AC)=070707,,-1, + 11016 ;THIS TEST PASSES + 11017 + 11018 035302 200 00 0 00 035502 B10500: MOVE [XWD -1,0] ;PRELOAD THE AC WITH -1,,0 + 11019 035303 470 00 0 00 035650 ORCB [707070707070] ;*ORCB SHOULD PLACE 070707,,-1 IN THE AC + 11020 035304 312 00 0 00 035653 CAME [XWD 070707,-1] ;PASS IF C(AC)=070707,,-1 + 11021 STOP^ + 11022 035305 254 04 0 00 035306 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11023 035306 324 00 0 00 035307 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11024 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11025 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11026 + 11027 ;***** FAILURE ANALYSIS ***** + 11028 ;C(AC0) C(AC1) FAILING SIGNAL + 11029 + 11030 ;-1,,-1 SW: FCE + 11031 ;707070,,0 SW: ET0 + 11032 ;0,,-1 FC: AD AR + EN + 11033 ;070707,,070707 FC: AD FM + EN + 11034 ;070707,,070707 ET0: AR AD EN + 11035 ;-1,,-1 ET0: AD AR - EN + 11036 ;707070,,0 ET2: AR AD EN + 11037 + 11038 ;********** + 11039 + 11040 ;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF + 11041 ;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E) + 11042 ;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE THE RESULT + 11043 ;IN THE AC -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, + 11044 ;THIS TEST PASSES + 11045 + 11046 035307 200 00 0 00 035537 B10700: MOVE [XWD 0,-1] ;PRELOAD THE AC WITH 0,,-1 + 11047 035310 470 00 0 00 035524 ORCB [-1] ;*ORCB SHOULD PLACE -1,,0 IN THE AC + 11048 035311 312 00 0 00 035502 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 11049 STOP^ + 11050 035312 254 04 0 00 035313 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11051 035313 324 00 0 00 035314 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11052 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11053 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11054 + 11055 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 54 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0252 + + 11056 ;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF + 11057 ;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). + 11058 ;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC + 11059 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)-1,,-1, THE TEST PASSES + 11060 + 11061 035314 400 00 0 00 000000 B11000: SETZ ;PRELOAD AC WITH 0 + 11062 035315 470 00 0 00 035412 ORCB [0] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC + 11063 035316 312 00 0 00 035524 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 11064 STOP^ + 11065 035317 254 04 0 00 035320 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11066 035320 324 00 0 00 035321 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11067 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11068 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11069 + 11070 ;********** + 11071 + 11072 ;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF + 11073 ;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). + 11074 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 11075 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES + 11076 + 11077 035321 474 00 0 00 000000 B11100: SETO ;PRELOAD AC WITH -1,,-1 + 11078 035322 470 00 0 00 035524 ORCB [-1] ;*ORCB SHOULD PLACE 0 IN THE AC + 11079 035323 302 00 0 00 000000 CAIE ;PASS IF C(AC)=0 + 11080 STOP^ + 11081 035324 254 04 0 00 035325 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11082 035325 324 00 0 00 035326 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11083 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11084 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11085 + 11086 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 55 +DAKABM MAC 19-JAN-77 13:39 TEST OF BOOLEAN INSTRUCTIONS SEQ 0253 + + 11087 ;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF + 11088 ;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E) + 11089 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 11090 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES + 11091 + 11092 035326 400 00 0 00 000000 B11200: SETZ ;PRELOAD AC WITH 0 + 11093 035327 470 00 0 00 035524 ORCB [-1] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC + 11094 035330 312 00 0 00 035524 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 11095 STOP^ + 11096 035331 254 04 0 00 035332 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11097 035332 324 00 0 00 035333 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11098 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11099 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11100 + 11101 ;********** + 11102 + 11103 ;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF + 11104 ;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). + 11105 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 11106 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES + 11107 + 11108 035333 474 00 0 00 000000 B11300: SETO ;PRELOAD AC WITH -1,,-1 + 11109 035334 470 00 0 00 035412 ORCB [0] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC + 11110 035335 312 00 0 00 035524 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 11111 STOP^ + 11112 035336 254 04 0 00 035337 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11113 035337 324 00 0 00 035340 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11114 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11115 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11116 + 11117 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 56 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVN INSTRUCTION SEQ 0254 + + 11118 SUBTTL TEST OF MOVN INSTRUCTION + 11119 + 11120 ;********** + 11121 + 11122 ;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC + 11123 ;IN THIS CASE C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 11124 ;THE AC IS CHECKED FOR 0, THE NEGATIVE OF 0. IF C(AC)=0, THIS TEST PASSES + 11125 + 11126 035340 474 00 0 00 000000 B11500: SETO ;PRELOAD AC WITH -1,,-1 + 11127 035341 210 00 0 00 035412 MOVN [0] ;*MOVN SHOULD PLACE 0 INTO THE AC + 11128 035342 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 11129 STOP^ + 11130 035343 254 04 0 00 035344 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11131 035344 324 00 0 00 035345 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11132 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11133 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11134 + 11135 ;***** FAILURE ANALYSIS ***** + 11136 ;C(AC0) C(AC1) FAILING SIGNAL + 11137 + 11138 ;E SW: FCE + 11139 ;-1,,-1 FC: AD FM + EN + 11140 ;-1,,-1 FC: AD CRY 36 + 11141 + 11142 ;********** + 11143 + 11144 ;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC. + 11145 ;IN THIS CASE C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE 1,,0 + 11146 ;THE AC IS CHECKED FOR 1,,0. IF C(AC)=1,,0, THE TEST PASSES + 11147 + 11148 035345 200 00 0 00 035502 B11600: MOVE [XWD -1,0] ;PRELOAD AC,E WITH -1,,0 + 11149 035346 210 00 0 00 000000 MOVN ;*MOVN SHOULD PLACE 1,,0 INTO THE AC + 11150 035347 312 00 0 00 035440 CAME [XWD 1,0] ;PASS IF C(AC)=1,,0 + 11151 STOP^ + 11152 035350 254 04 0 00 035351 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11153 035351 324 00 0 00 035352 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11154 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11155 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11156 + 11157 ;***** FAILURE ANALYSIS ***** + 11158 ;C(AC0) C(AC1) FAILING SIGNAL + 11159 + 11160 ;0 FC: AD ADD + 11161 ;0 FC: AD FM - EN + 11162 ;0 FC: AD AR - EN + 11163 ;-1,,0 ET2: AR AD EN + 11164 + 11165 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 57 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVN INSTRUCTION SEQ 0255 + + 11166 ;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC. + 11167 ;IN THIS CASE C(E) =707070,,707070. HENCE, THE RESULT IN THE AC SHOULD BE + 11168 ;070707,,070710. THE AC IS CHECKED FOR 070707,,070710. IF C(AC)= + 11169 ;070707,,070710, THE TEST PASSES + 11170 + 11171 035352 400 00 0 00 000000 B11700: SETZ ;PRELOAD AC WITH 0 + 11172 035353 210 00 0 00 035650 MOVN [707070707070] ;*MOVN SHOULD PLACE 070707,,070710 INTO THE AC + 11173 035354 312 00 0 00 035654 CAME [070707070710] ;PASS IF C(AC) 070707,,070710 + 11174 STOP^ + 11175 035355 254 04 0 00 035356 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11176 035356 324 00 0 00 035357 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11177 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11178 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11179 + 11180 ;********** + 11181 + 11182 ;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC + 11183 ;IN THIS CASE C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0,,1. + 11184 ;THE AC IS CHECKED FOR 0,,1, THE NEGATIVE OF -1,,-1. IF C(AC)=1, THIS TEST PASSES + 11185 + 11186 035357 210 00 0 00 035524 B12100: MOVN [-1] ;*MOVN SHOULD PLACE 0,,1 INTO THE AC + 11187 035360 302 00 0 00 000001 CAIE 1 ;PASS OF C(AC)=0,,1 + 11188 STOP^ + 11189 035361 254 04 0 00 035362 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11190 035362 324 00 0 00 035363 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11191 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11192 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11193 + 11194 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 58 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVM INSTRUCTION SEQ 0256 + + 11195 SUBTTL TEST OF MOVM INSTRUCTION + 11196 + 11197 ;********** + 11198 + 11199 ;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC. + 11200 ;IN THIS CASE, C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 11201 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 11202 + 11203 035363 474 00 0 00 000000 B12200: SETO ;PRELOAD AC WITH -1,,-1 + 11204 035364 214 00 0 00 035412 MOVM [0] ;*MOVM SHOULD PLACE 0 INTO THE AC + 11205 035365 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 11206 STOP^ + 11207 035366 254 04 0 00 035367 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11208 035367 324 00 0 00 035370 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11209 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11210 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11211 + 11212 ;***** FAILURE ANALYSIS ***** + 11213 ;C(AC0) C(AC1) FAILING SIGNAL + 11214 + 11215 ;E SW: FCE + 11216 + 11217 ;********** + 11218 + 11219 ;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC + 11220 ;IN THIS CASE, C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0,,1. + 11221 ;THE AC IS CHECKED FOR 0,,1. IF C(AC)=0,,1, THIS TEST PASSES + 11222 + 11223 035370 400 00 0 00 000000 B12300: SETZ ;PRELOAD AC WITH 0 + 11224 035371 214 00 0 00 035524 MOVM [-1] ;*MOVM SHOULD PLACE 0,,1 INTO THE AC + 11225 035372 302 00 0 00 000001 CAIE 1 ;PASS IF C(AC)=0,,1 + 11226 STOP^ + 11227 035373 254 04 0 00 035374 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11228 035374 324 00 0 00 035375 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11229 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11230 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11231 + 11232 ;***** FAILURE ANALYSIS ***** + 11233 ;C(AC0) C(AC1) FAILING SIGNAL + 11234 + 11235 ;0 FC: AD FM + EN + 11236 ;0 FC: AD ADD + 11237 ;0 FC: AD CRY 36 + 11238 ;0 FC: AD AR - EN + 11239 ;-1,,-1 ET2: AR AD EN + 11240 + 11241 ;********** +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 59 +DAKABM MAC 19-JAN-77 13:39 TEST OF MOVM INSTRUCTION SEQ 0257 + + 11242 ;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC + 11243 ;IN THIS CASE, C(E)=400000,,0. HENCE, THE RESULT IN THE AC SHOULD BE + 11244 ;400000,,0. THE AC IS CHECKED FOR 400000,,0. + 11245 ;IF C(AC)=400000,,0, THIS TEST PASSES. + 11246 + 11247 035375 400 00 0 00 000000 B12400: SETZ + 11248 035376 214 00 0 00 035461 MOVM [XWD 400000,0] ;*MOVM SHOULD PLACE 400000,,0 INTO THE AC + 11249 035377 312 00 0 00 035461 CAME [XWD 400000,0] ;PASS IF C(AC)=400000,,0 + 11250 STOP^ + 11251 035400 254 04 0 00 035401 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11252 035401 324 00 0 00 035402 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11253 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11254 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11255 + 11256 ;********** + 11257 + 11258 ;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC + 11259 ;IN THIS CASE, C(E)=377777,,-1. HENCE, THE RESULT IN THE AC SHOULD BE + 11260 ;377777,,-1. THE AC IS CHECKED FOR 377777,,-1. + 11261 ;IF C(AC)=377777,,-1, THIS TEST PASSES. + 11262 + 11263 035402 400 00 0 00 000000 B12500: SETZ ;PRELOAD AC WITH 0 + 11264 035403 214 00 0 00 035540 MOVM [XWD 377777,-1] ;*MOVM SHOULD PLACE 377777,,-1 INTO THE AC + 11265 035404 312 00 0 00 035540 CAME [XWD 377777,-1] ;PASS IF C(AC)=377777,,-1 + 11266 STOP^ + 11267 035405 254 04 0 00 035406 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 11268 035406 324 00 0 00 035407 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 11269 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 11270 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 11271 + 11272 ;********** + 11273 035407 254 00 0 00 030057 JRST BEGEND +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 1 +STOR KLM 18-JAN-77 11:42 *STOR* RESERVED STORAGE, JAN 18,1977 SEQ 0258 + + 11274 SUBTTL *STOR* RESERVED STORAGE, JAN 18,1977 + 11275 + 11276 ;PROGRAM LITERALS + 11277 + 11278 XLIST + 11279 IFNDEF $LPAPER, + 11280 035410 LIT + 11281 035410 000001 000001 + 11282 035411 254 00 0 00 030741 + 11283 035412 000000 000000 + 11284 035413 123456 765432 + 11285 035414 123456 000000 + 11286 035415 000000 123456 + 11287 035416 000000 000001 + 11288 035417 000000 000002 + 11289 035420 000000 000004 + 11290 035421 000000 000010 + 11291 035422 000000 000020 + 11292 035423 000000 000040 + 11293 035424 000000 000100 + 11294 035425 000000 000200 + 11295 035426 000000 000400 + 11296 035427 000000 001000 + 11297 035430 000000 002000 + 11298 035431 000000 004000 + 11299 035432 000000 010000 + 11300 035433 000000 020000 + 11301 035434 000000 040000 + 11302 035435 000000 100000 + 11303 035436 000000 200000 + 11304 035437 000000 400000 + 11305 035440 000001 000000 + 11306 035441 000002 000000 + 11307 035442 000004 000000 + 11308 035443 000010 000000 + 11309 035444 000020 000000 + 11310 035445 000040 000000 + 11311 035446 000100 000000 + 11312 035447 000200 000000 + 11313 035450 000400 000000 + 11314 035451 001000 000000 + 11315 035452 002000 000000 + 11316 035453 004000 000000 + 11317 035454 010000 000000 + 11318 035455 020000 000000 + 11319 035456 040000 000000 + 11320 035457 100000 000000 + 11321 035460 200000 000000 + 11322 035461 400000 000000 + 11323 035462 600000 000000 + 11324 035463 700000 000000 + 11325 035464 740000 000000 + 11326 035465 760000 000000 + 11327 035466 770000 000000 + 11328 035467 774000 000000 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 1-1 +STOR KLM 18-JAN-77 11:42 *STOR* RESERVED STORAGE, JAN 18,1977 SEQ 0259 + + 11329 035470 776000 000000 + 11330 035471 777000 000000 + 11331 035472 777400 000000 + 11332 035473 777600 000000 + 11333 035474 777700 000000 + 11334 035475 777740 000000 + 11335 035476 777760 000000 + 11336 035477 777770 000000 + 11337 035500 777774 000000 + 11338 035501 777776 000000 + 11339 035502 777777 000000 + 11340 035503 777777 400000 + 11341 035504 777777 600000 + 11342 035505 777777 700000 + 11343 035506 777777 740000 + 11344 035507 777777 760000 + 11345 035510 777777 770000 + 11346 035511 777777 774000 + 11347 035512 777777 776000 + 11348 035513 777777 777000 + 11349 035514 777777 777400 + 11350 035515 777777 777600 + 11351 035516 777777 777700 + 11352 035517 777777 777740 + 11353 035520 777777 777760 + 11354 035521 777777 777770 + 11355 035522 777777 777774 + 11356 035523 777777 777776 + 11357 035524 777777 777777 + 11358 035525 777777 777773 + 11359 035526 777777 777677 + 11360 035527 777777 775777 + 11361 035530 777777 737777 + 11362 035531 777777 377777 + 11363 035532 777767 777777 + 11364 035533 777577 777777 + 11365 035534 773777 777777 + 11366 035535 677777 777777 + 11367 035536 577777 777777 + 11368 035537 000000 777777 + 11369 035540 377777 777777 + 11370 035541 000002 000002 + 11371 035542 000004 000004 + 11372 035543 000010 000010 + 11373 035544 000020 000020 + 11374 035545 000040 000040 + 11375 035546 000100 000100 + 11376 035547 000200 000200 + 11377 035550 000400 000400 + 11378 035551 001000 001000 + 11379 035552 002000 002000 + 11380 035553 004000 004000 + 11381 035554 010000 010000 + 11382 035555 020000 020000 + 11383 035556 040000 040000 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 1-2 +STOR KLM 18-JAN-77 11:42 *STOR* RESERVED STORAGE, JAN 18,1977 SEQ 0260 + + 11384 035557 100000 100000 + 11385 035560 200000 200000 + 11386 035561 400000 400000 + 11387 035562 777776 777776 + 11388 035563 777775 777775 + 11389 035564 777773 777773 + 11390 035565 777767 777767 + 11391 035566 777757 777757 + 11392 035567 777737 777737 + 11393 035570 777677 777677 + 11394 035571 777577 777577 + 11395 035572 777377 777377 + 11396 035573 776777 776777 + 11397 035574 775777 775777 + 11398 035575 773777 773777 + 11399 035576 767777 767777 + 11400 035577 757777 757777 + 11401 035600 737777 737777 + 11402 035601 677777 677777 + 11403 035602 577777 577777 + 11404 035603 377777 377777 + 11405 035604 000001 777776 + 11406 035605 777776 000001 + 11407 035606 000002 777775 + 11408 035607 777775 000002 + 11409 035610 000004 777773 + 11410 035611 777773 000004 + 11411 035612 000010 777767 + 11412 035613 777767 000010 + 11413 035614 000020 777757 + 11414 035615 777757 000020 + 11415 035616 000040 777737 + 11416 035617 777737 000040 + 11417 035620 000100 777677 + 11418 035621 777677 000100 + 11419 035622 000200 777577 + 11420 035623 777577 000200 + 11421 035624 000400 777377 + 11422 035625 777377 000400 + 11423 035626 001000 776777 + 11424 035627 776777 001000 + 11425 035630 002000 775777 + 11426 035631 775777 002000 + 11427 035632 004000 773777 + 11428 035633 773777 004000 + 11429 035634 010000 767777 + 11430 035635 767777 010000 + 11431 035636 020000 757777 + 11432 035637 757777 020000 + 11433 035640 040000 737777 + 11434 035641 737777 040000 + 11435 035642 100000 677777 + 11436 035643 677777 100000 + 11437 035644 200000 577777 + 11438 035645 577777 200000 +DAKAB PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) 0,2 MACRO %52(537) 14:08 19-JAN-77 PAGE 1-3 +STOR KLM 18-JAN-77 11:42 *STOR* RESERVED STORAGE, JAN 18,1977 SEQ 0261 + + 11439 035646 400000 377777 + 11440 035647 377777 400000 + 11441 035650 707070 707070 + 11442 035651 000000 707070 + 11443 035652 707070 777777 + 11444 035653 070707 777777 + 11445 035654 070707 070710 + 11446 LIST + 11447 035655 000000 000000 ENDSLD: 0 + 11448 + 11449 IFDEF DEBUG,< + 11450 PATCH: BLOCK DEBUG ;PATCHING AREA + 11451 > + 11452 + 11453 ;PROGRAM VARIABLES + 11454 035656 VAR + 11455 + 11456 IFDEF PGMEND,< + 11457 035656 000000 000000 END: 0 + 11458 030000 END BEGIN > + +NO ERRORS DETECTED + +PROGRAM BREAK IS 000000 +ABSLUTE BREAK IS 035657 +CPU TIME USED 00:41.977 + +11K CORE USED diff --git a/apps/pdp10/diags/klad/dakab/DAKAB.MAC.txt b/apps/pdp10/diags/klad/dakab/DAKAB.MAC.txt new file mode 100644 index 000000000..b7842de14 --- /dev/null +++ b/apps/pdp10/diags/klad/dakab/DAKAB.MAC.txt @@ -0,0 +1,1782 @@ +;MACROS + +; STOP - USED FOR SCOPE LOOP, IF INSTRUCTION FAILS, CHANGE (JUMPA .+1) +; TO A (JUMPA X) TO CYCLE ON FAILING INSTRUCTION + +DEFINE STOP (A)< + HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1> + +SUBTTL DIAGNOSTIC SECTION + LALL + +START: ;SETZM USER# ;CLEAR USER CONTROL WORD + ;JSP 0,.+1 ;GET FLAGS + ;TLNE USERF ;IN USER MODE? + ;SETOM USER ;YES, SET USER CONTROL WORD + ;SKIPN MONFLG ;SPECIAL USER MODE? + ;SETZM USER ;YES, CLEAR USER CONTROL WORD + ;SKIPN USER + ;JRST B00 + ;SKIPL MONCTL + ;TTCALL 3,PGMNAM ;MENTION OUR NAME + JRST STARTA ; GO START + +PGMNAM: ASCIZ/ +PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) [DAKAB] +/ + +;BASIC INSTRUCTION TEST (2) +;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF +;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES +;IN THE FIELD + + +STARTA: JRST .+1 + +B00: +SUBTTL TEST OF THE ADD INSTRUCTION + +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED +;TO ADD A NON-ZERO NUMBER CONTAINED IN E TO AN AC CONTAINING ALL ZEROS, +;THE RESULT IS A NON-ZERO NUMBER IN THE AC. FIRST, THE AC IS CLEARED; +;THEN, ANON-ZERO POSITIVE NUMBER IS ADDED TO THE AC USING THE ADD +;INSTRUCTION. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + + A10400: MOVE [0] ;PRESET AC TO ALL ZEROS + ADD [123456765432] ;*ADD OF A NON-ZERO NUMBER TO AN AC OF ALL + ;ZEROS SHOULD RESULT + ;IN AN AC CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + STOP + +;AD ADD [ADC1], AD ADD EN [ADC1], +;F CYC ACT EN A [F1], AD FM + FETCH EN A [ADFP], +;F CYC ACT EN C[F1], IR ADSUB [IR1], IRXX [IR1] + +;********** + +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD +;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE +;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS +;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS +; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + +A10500: MOVE [123456765432] ;PRESET AC WITH A NON-ZERO NUMBER + ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC + ;CONTAINING A NON-ZERO NUMBER + ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + STOP + +;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F [E], +;AR AD ET2 EN [ARMA], IR ADSUB [IR1] + +;********** +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD +;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE +;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS +;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS +; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + +A10600: MOVE [XWD 123456,0] ;PRESET AC WITH A NON-ZERO NUMBER + ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING + ;A NON-ZERO NUMBER SHOULD RESULT IN AN AC + ;CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + STOP + +;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F[E], +;AR AD ET2 EN [ARMA], IR AD SUB [IR1] + +;********* + +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD +;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE +;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS +;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS +; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + +A10700: MOVE [123456] ;PRESET AC WITH A NON-ZERO NUMBER + ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING + ;A NON-ZERO NUMBER + ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IS C(AC) IS NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD +;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE +;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS +;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER +;IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + +A13300: MOVE [0] ;PRESET AC WITH ALL ZEROS + ADD [123456,,0] ;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS + ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD +;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE +;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS +;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER +;IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + +A13400: MOVE [0] ;PRESET AC WITH ALL ZEROS + ADD [123456] ;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS + ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + STOP + +;********** +;ADD ZERO TO A RIPPLED ONE + +SN=11000 + ZZ=0 + +A11000: REPEAT ^D36, +<;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. +;A WORD OF ALL ZEROS IS ADDED TO AN +;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, +;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. +;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD +;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. +;THE FINAL RESULT SHOULD BE C(AC)=0. THIS +;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH +;EVERY BIT OF THE AC. +;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + ADD [0] ;*ADD OF ZERO TO FLOATING ONE + EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + EQV [0] ;RESULTS IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], +;IR ADDX [IR1], IR ADSUB [IR1] + +;********** +PAGE +> +;THIS TEST VERIFIES THAT THE ADDITION OF A WORD OF +;ALL ZEROS TO AN AC OF ALL ZEROS RESULTS IN +;C(AC)=0. FIRST THE AC IS CLEARED; THEN, A WORD +;OF ALL ZEROS IS ADDED TO THE AC. THE RESULT IN +;THE AC IS THEN CHECKED TO INSURE THAT C(AC)=0 + +A11100: MOVE [0] ;PRESET AC TO ZERO + ADD [0] ;*ADD OF ZERO TO ZERO SHOULD RESULT IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;FCE[F1], IR AD SUB [IR1] +;AD FM + EN [ADFP], AD FM + EN A [ADFP], +;F CYC ACT EN C[F1], IR ADSUB [IR1] + +;********** +;ADD ZERO TO A RIPPLED ONE + +SN=13200 + ZZ=0 + +A13200: REPEAT ^D36, +<;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. +;TO AN AC OF ALL ZEROS IS ADDED A +;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, +;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. +;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD +;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. +;THE FINAL RESULT SHOULD BE C(AC)=0. THIS +;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH +;EVERY BIT OF THE AC. +;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [0] ;LOAD AC WITH ALL ZEROS + ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + EQV [0] ;RESULTS IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +> +PAGE +;ADD A RIPPLED ONE TO A RIPPLED ONE + +SN=11200 + ZZ=0 + +A11200: REPEAT ^D35, +<;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) +;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= +;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN +;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A +;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE +;RESULT IN THE AC WILL BE ZERO AND THE TEST +;WILL FAIL. THIS TEST IS REPEATED 35 TIMES +;SO THAT A ONE WILL BE FLOATED THROUGH +;BITS 1 THRU 35 OF BOTH AC AND E +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + EQV [0] ;RESULTS IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +> +SN=11300 + ZZ=0 + YY=0 + +A11300: REPEAT ^D18, +<;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE +;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER +;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST +;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE +;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE +;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, +;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER +;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS +;FORMER VALUE PLUS THE CURRENT C(AC) +SN=SN+1 + YY=YY/2 + ZZ=ZZ+YY + IFE YY, + IFE ZZ, + MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + ;POWER SHOULD RESULT IN C(AC)=0. + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +> +PAGE +SN=11400 + ZZ=0 + YY=0 + +A11400: REPEAT ^D18, +<;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE +;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER +;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST +;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE +;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE +;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, +;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER +;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS +;FORMER VALUE PLUS THE CURRENT C(AC) +SN=SN+1 + YY=YY/2 + ZZ=ZZ+YY + IFE YY, + IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + ;POWER SHOULD RESULT IN C(AC)=0. + ADD [YY] ;PASS TEST IF C(AC)=0 + SKIPE + STOP + +;********** +> +SUBTTL SPECIAL KI10 FOUR BIT ADDER TEST + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 33 TO BIT 32. + +A13500: MOVE [-1,,-5] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 33 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 33 TO BIT 32 + EQV [-1,,-4] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 29 TO BIT 28. + +A13600: MOVE [-1,,-101] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 29 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 29 TO BIT 28 + EQV [-1,,-100] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 25 TO BIT 24. + +A13700: MOVE [-1,,-2001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 25 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 25 TO BIT 24 + EQV [-1,,-2000] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 21 TO BIT 20. + +A14000: MOVE [-1,,-40001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 21 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 21 TO BIT 20 + EQV [-1,,-40000] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 18 TO BIT 17. + +A14100: MOVE [-1,,-400001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 18 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 18 TO BIT 17 + EQV [-1,,400000] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 14 TO BIT 13. + +A14200: MOVE [-11,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 14 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 14 TO BIT 13 + EQV [-10,,0] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 10 TO BIT 9. + +A14300: MOVE [-201,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 10 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 10 TO BIT 9 + EQV [-200,,0] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 6 TO BIT 5. + +A14400: MOVE [-4001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 6 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 6 TO BIT 5 + EQV [-4000,,0] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 2 TO BIT 1. + +A14500: MOVE [-100001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 2 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 2 TO BIT 1 + EQV [-100000,,0] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 1 TO BIT 0. + +A14600: MOVE [-200001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 1 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 1 TO BIT 0 + EQV [600000,,0] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT -1TO BIT 35. + +A14700: MOVE [-1,,-1] ;PRESET AC WITH ALL ONES + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT -1 TO BIT 35 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +SUBTTL TEST OF SUB AND COMPARE INSTRUCTIONS + +;THIS TEST VERIFIES THAT IF A NON ZERO POSITIVE NUMBER IN E IS +;SUBTRACTED FROM THE AC WHEN C(AC)=0, THE RESULT IN THE AC +;IS NEGATIVE + +A11500: MOVE [0] ;PRESET AC TO ZERO + SUB [XWD 0,-1] ;*SUB OF POSITIVE NONZERO NUMBER FROM AC OF ALL ZEROS + ;SHOULD RESULT IN C(AC) NEGATIVE + SKIPL ;PASS TEST IF C(AC) IS NEGATIVE + STOP + +;AD AR- EN D [ADAM], F CYC ACT ENB [F1], +;IR SUBX[IR1], IR ADSUB[IR1] + +;********** + +;THIS TEST VERIFIES THAT IF A WORD OF ALL ZEROS IS +;SUBTRACTED FROM AN AC OF ALL ZEROS, THE RESULT +;IS AN AC OF ZEROS. + +A11600: MOVE [0] ;PRESET AC TO ZERO + SUB [0] ;*SUB OF 0 FROM 0 SHOULD RESULT IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP +;AD CRY 36[ADCR], F CYC ACT EN D[F1], IF SUBX [IR1] + +;********** +PAGE +SN=11700 + ZZ=0 + +A11700: REPEAT ^D36, +<;THIS TEST VERIFIES THAT IF A RIPPLED ONE +;IS SUBTRACTED FROM ITSELF, THE RESULT IS +;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 +;TIMES IN ORDER TO TEST ALL 36 BITS. +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +> +PAGE +;THIS TEST VERIFIES THAT IF A WORD OF ALL +;ONES IS SUBTRACTED FROM ITSELF, THE RESULT +;IN THE AC IS ZERO. + +A12000: MOVE [-1] ;PRESET AC TO ALL ONES + SUB [-1] ;*SUB OF -1 FROM ITSELF SHOULD RESULT IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT CAMA ALWAYS SKIPS THE +;NEXT INSTRUCTION INDEPENDENT OF THE DATA WITH AC +;AND E. THIS TEST FAILS IF CAMA DOES NOT SKIP ALWAYS. + +A12100: MOVE [0] ;PRESET AC, E TO ZERO + CAMA ;*CAMA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION, + ;OTHERWISE THIS TEST FAILS + STOP + +;ET0 [E], ET0 EN[E], IR CAXX[IR3], AD CRY 3C[ADCR], +;FCYC ACT EN D [ADCR], AD CRY 36 F/F'S [ADCR], +;PC CLOCK EN [PCC], ET0 C F/F[E], IR CAXX[IR3], +;ADZ COND P[ADZ] AND ADZ COND Z[ADZ] + +;********** + +;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE. +;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY +;IF C(AC)=C(E). IN THIS TEST AC=E=0 AND +;C(AC)=C(E)=0. HENCE, CAME MUST +;SKIP THE NEXT INSTRUCTION +;IN THIS TEST + +A12200: MOVE [0] ;PRESET AC, E TO ZERO + CAME ;*CAME SHOULD SKIP SINCE E=AC + STOP + +;AD FM + EN [ADFP], F CXC ACT ENC[F1], IRCAXX[IR3] + +;********** +;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE +;IT SKIPS THE NEXT INSTRUCTION OF AND ONLY IF +;C(AC)=C(E). IN THIS TEST C(AC)=C(E)=0; +;BUT, E IS NOT WITHIN THE AC RANGE. +;HENCE, CAME MUST SKIP +;THE NEXT INSTRUCTION IN THIS TEST. + +A12300: MOVE [0] ;*CAME SHOULD SKIP WHEN C(AC)=C(E)=0 + CAME [0] + STOP + +;CAMX: FCE[F1], IR CAMX[IR1] + +;********** + +;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE. +;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY IF +;C(AC)=C(E). IN THIS TEST C(AC)=0 AND +;C(E)=-1. HENCE, CAME SHOULD NOT +;SKIP THE NEXT INSTRUCTION IN THIS TEST. + +A12400: MOVE [0] ;PRESET AC TO ZERO + CAME [-1] ;*CAME SHOULD NOT SKIP BECAUSE C(AC)=0 ANDC(E)=- + SKIPA ;SKIP HALT INSTRUCTION IF CAME PASSES TEST + STOP + +;AD AR- EN [ADAM], IR CAXX [IR3], F CYC ACT EN B [F1], +;AD AR- F/F'S [ADAM], AD ADD [ADC1], AD FM + FETCH EN A [ADFP], +;F CYC ACT EN A [F1], AD ADD EN C [ADC1], AD ADD F/F'S [ADC1] + +;********** +SUBTTL TEST OF COMPARE (CAMX) INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS TEST, C(AC)=-1 AND C(E)=0; HENCE, CAML SHOULD SKIP. OTHERWISE,THE +;PROGRAM HALTS. + +B100: MOVE [-1] ;PRELOAD AC WITH -1 + CAML [0] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: AB PC EN +; ET0: COND Q: PC CLK EN + +;********** + +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=-1; HENCE, CAML SHOULD NOT SKIP. OTHERWISE, +;THE PROGRAM HALTS. + +B200: MOVE [0] ;PRELOAD AC WITH 0 + CAML [-1] ;*CAML SHOULD NOT SKIP BECAUSE + ;C(AC) IS GREATER THAN C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; SW: FCE +; FC: PC CHANGE + +;********** +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=400000,,0 (THE MOST +;NEGATIVE NUMBER) AND C(E)=377777,,-1 +;(THE MOST POSITIVE NUMBER); HENCE, +;CAML SHOULD SKIP. OTHERWISE, THE +;PROGRAM HALTS + +B300: MOVE [XWD 400000,0] ;PRELOAD AC WITH 400000,,0 + CAML [XWD 377777,-1] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: AD ADD + +;********** + +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=377777,,-1 (THE MOST POSITIVE NUMBER) AND C(E)=400000,,0 (THE MOST NEGATIVE NUMBER) +;HENCE, CAML SHOULD NOT SKIP. OTHERWISE, THE PROGRAM HALTS. + +B400: MOVE [XWD 377777,-1] ;PRELOAD AC WITH 377777,,-1 + CAML [XWD 400000,0] ;*CAML SHOULD NOT SKIP BECAUSE + ;C(AC) IS GREATER THAN C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=400000,,0 (THE MOST NEGTIVE NUMBER) AND C(E)=-1; +;HENCE, CAML SHOULD SKIP. OTHERWISE, THE PROGRAM HALTS + +B500: MOVE [XWD 400000,0] ;PRELOAD AC WITH 400000,,0 + CAML [-1] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: AD FM + EN + +;********** + +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=-1 ;HENCE, CAML SHOULD NOT SKIP. OTHERWISE, +;THE PROGRAM HALTS. + +B600: SETZ ;PRELOAD AC WITH 0 + CAML [-1] ;*CAML SHOULD NOT SKIP BECAUSE + ;C(AC) IS GREATER THAN C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES. + STOP + +;********** +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=0 ;HENCE, CAML SHOULD NOT SKIP. OTHERWISE, +;THE PROGRAM HALTS. + +B700: SETZ ;PRELOAD AS WITH 0 + CAML [0] ;*CAML SHOULD NOT SKIP BECAUSE C(AC)=C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: AD CRY 36 + +;********** + +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=400000,,O (THE MOST NEGATIVE NUMBER); +;HENCE CAML SHOULD NOT SKIP. OTHERWISE, THE PROGRAM HALTS. + +B1000: SETZ ;PRELOAD AC WITH 0 + CAML [XWD 400000,0] ;*CAML SHOULD NOT SKIP BECAUSE + ;C(AC) IS GREATER THAN C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT CAM IS DATA INDEPENDENT. IT NEVER SKIPS +;THE NEXT SEQUENTIAL INSTRUCTION +;IN THIS CASE, C(AC)=-1 AND C(E)=0 +;IF IT DOES SKIP THE NEXT INSTRUCTION, THE PROGRAM HALTS + +B1100: MOVE [-1] ;PRELOAD AC WITH -1 + CAM [0] ;*CAM SHOULD NEVER SKIP + SKIPA ;SKIP HALT INSTRUCTION IF CAM PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E). +;IN THIS CASE, C(AC)=-1 AND C(E)=0; HENCE, CAMGE SHOULD NOT SKIP. +;OTHERWISE, THE PROGRAM HALTS. + +B1200: MOVE [-1] ;PRELOAD AC WITH-1 + CAMGE [0] ;*CAMGE SHOULD NOT SKIP BECAUSE C(AC) IS LESS THAN C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAMGE PASSES. + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: PC CHANGE +; FC: AB PC EN + +;********** +;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E) +;IN THIS CASE, C(AC)=0 AND C(E)=-1; HENCE CAMGE SHOULD SKIP. +;OTHEWISE, THE PROGRAM HALTS. + +B1300: SETZ ;PRELOAD AC WITH 0 + CAMGE [-1] ;*CAMGE SHOULD SKIP BECAUSE C(AC) IS GREATER THAN C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; SW: FCE +; ET0: COND Q: PC CLK EN + +;********** + +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS NOT EQUAL TO C(E) +;IN THIS CASE C(AC)=0 AND C(E)=-1; HENCE CAMN SHOULD SKIP. +;OTHERWISE, THE PROGRAM HALTS + +B1400: SETZ ;PRELOAD AC WITH 0 + CAMN [-1] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC:AD FM + EN +; FC: AD AR - EN +; FC: AD CRY 36 +; FC: AD ADD +; FC: AB PC EN +; ET0: PC CLK EN + +;********** +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS NOT EQUAL TO C(E) +;IN THIS CASE, C(AC)=0 AND C(E)=0; HENCE CAMN SHOULD NOT SKIP. +;OTHERWISE, THE PROGRAM HALTS + +B1500: SETZ ;PRELOAD AC WITH 0 + CAMN [0] ;*CAMN SHOULD NOT SKIP BECAUSE C(AC)=C(E). + SKIPA ;SKIP HALT INSTRUCTION IF CAMN PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; SW: FCE +; FC: PC CHANGE + +;********** +SN=1600 + ZZ=0 + +B1600: REPEAT ^D18,< +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY +;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME +;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN +;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) +;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS +;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; ET0: COND P + +;********** +> + ZZ=0 + + REPEAT ^D18,< +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY +;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME +;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN +;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) +;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS +;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + STOP + +;********** +> +SN=1700 + ZZ=0 + +B1700: REPEAT ^D36,< +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND +;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, +;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + SETZ ;PRELOAD AC WITH 0 + CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + STOP + +;********** +> +SN=2000 + ZZ=0 + +B2000: REPEAT ^D36,< +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, +;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + STOP + +;********** +> +SUBTTL TEST OF MOVS INSTRUCTION + +;********** + +SN=2100 + ZZ=0 + +B2100: REPEAT ^D18,< +;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND +;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES +;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. +;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + ;AND MOVE RESULT INTO AC + CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + STOP + +;********** +> +SN=2200 + ZZ=0 + +B2200: REPEAT ^D18,< +;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND +;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES +;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. +;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + +SN=SN+1 + ZZ=ZZ+ZZ+1 + IFE , + MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + ;AND MOVE RESULT INTO AC + CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + STOP + +;********** +> +SN=2300 + ZZ=0 + YY=0 + +B2300: REPEAT ^D18,< +;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND +;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E +;AND A 0 IS RIPPLED THRU THE RIGHT HALF +;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. +;THEN, C(AC) IS CHECKED. +;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF +;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + +SN=SN+1 + ZZ=ZZ+ZZ + YY=YY+YY+1 + IFE ZZ, + IFE , + MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + ;AND MOVE RESULT INTO AC + CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + STOP + +;********** +> +SN=2400 + ZZ=0 + YY=0 + +B2400: REPEAT ^D18,< +;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND +;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E +;AND A 1 IS RIPPLED THRU THE RIGHT HALF +;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. +;THEN, C(AC) IS CHECKED. +;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF +;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + +SN=SN+1 + ZZ=ZZ+ZZ + YY=YY+YY+1 + IFE ZZ, + IFE , + MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + ;AND MOVE RESULT INTO AC + CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + STOP + +;********** +> +SUBTTL TEST OF COMPARE (CAXX) INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT CAIE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN C(AC)=E +;IN THIS CASE C(AC)=E=0; HENCE, CAIE SHOULD SKIP +;OTHERWISE THE PROGRAM HALTS + +B2500: SETZ ;PRELOAD AC TO 0 + CAIE ;*CAIE SHOULD SKIP BECAUSE C(AC)=E + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; SW: PC CHANGE +; FC: AD FM ; EN +; FC: AD CRY 36 +; FC: AB PC EN +; ET0: COND P: PC CLK EN + +;********** + +;THIS TEST VERIFIES THAT CAIE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN C(AC)=E +;IN THIS CASE C(AC)=E=1. HENCE, CAIE SHOULD SKIP +;OTHERWISE THE PROGRAM HALTS + +B2600: MOVE [1] ;PRELOAD AC TO 1 + CAIE 1 ;*CAIE SHOULD SKIP BECAUSE C(AC)=E + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: AD AR - EN + +;********** + +;THIS TEST VERIFIES THAT CAME SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN C(AC)=C(E) +;IN THIS CASE C(AC)=C(E)=1; HENCE, CAME SHOULD SKIP +;OTHERWISE THE PROGRAM HALTS + +B2700: MOVEI 1 ;PRELOAD AC TO 1 + CAME [1] ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + STOP + +;********** +SUBTTL TEST OF BOOLEAN INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT SETCA IGNORES THE ADDRESS FIELD OF THE INSTUCTION WORD. +;IN THIS CASE C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 +;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES. + +B3000: MOVEI -1 ;PRELOAD AC TO 0,,-1 + SETCA [-1] ;*SETCA SHOULD PUT -1,,0 INTO THE AC + CAME [-1,,0] ;PASS TEST IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE +;RESULT IN THE AC. +;IN THIS CASE C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 +;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES + +B3100: MOVEI -1 ;PRELOAD AC TO 0,,-1 + SETCA ;*SETCA SHOULD PUT -1,,0 INTO THE AC + CAME [-1,,0] ;PASS TEST IF C(AC) =-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE +;RESULT IN THE AC, +;IN THIS CASE C(AC)=0,,0 HENCE, THE RESULT IN THE AC SHOULD BE,-1 +;IF THE RESULT IN THE AC IS -1,,-1, THE TEST PASSES + +B3200: MOVEI 0 ;PRELOAD AC TO 0,,0 + SETCA ;*SETCA SHOULD PUT -1,,-1 INTO THE AC + CAME [-1] ;PASS TEST IF C(AC) =-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE +;RESULT IN THE AC, +;IN THIS CASE C(AC)=-1,,-1; HENCE, THE RESULT IN THE AC SHOULD BE 0,,0 +;IF THE RESULT IN THE AC IS ZERO, THE TEST PASSES + +B3300: MOVE [-1] ;PRELOAD AC TO -1,,-1 + SETCA ;*SETCA SHOULD PUT 0,,0 INTO THE AC + CAME [0] ;PASS TEST IF C(AC) IS ZERO + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD FM - EN + +;********** +;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE +;RESULT IN THE AC. +;IN THIS CASE AC=E AND C(E)=C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 +;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES + +B3500: MOVEI -1 ;PRELOAD AC TO 0,,-1 + SETCM ;*SETCM SHOULD PUT -1,,0 INTO THE AC + CAME [-1,,0] ;PASS TEST IF C(AC) =-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 SW: FCE +;-1,,-1 FC: AD AR - EN +;0,,-1 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE +;RESULT IN THE AC. +;IN THIS CASE C(E)=-1,,-1; HENCE, THE RESULT IN THE AC SHOULD BE 0,,0 +;IF THE RESULT IN THE AC IS ZERO,THE TEST PASSES + +B3600: SETCM [-1] ;*SETCM SHOULD PUT 0 INTO THE AC + SKIPE ;PASS TEST IF C(AC0)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE +;RESULT IN THE AC. +;IN THIS CASE C(E)=0,,0; HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 +;IF THE RESULT IN THE AC IS -1,,-1,THE TEST PASSES + +B3700: SETCM [0] ;*SETCM SHOULD PUT -1,,-1 INTO THE AC + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT SETO SETS C(AC) TO -1,,-1. SETO IGNORES +;THE ADDRESS FIELD OF THE INSTRUCTION WORD. +;FIRST C(AC) IS SET TO 0,,0; THEN SETO IS EXECUTED. +;THE AC IS THEN CHECKED FOR ALL ONES. IF C(AC) IS ALL ONES, +;THE TEST PASSES + +B4300: MOVEI 0 ;PRELOAD AC WITH 0,,0 + SETO ;*SETO SHOULD LOAD THE AC WITH -1,,-1 + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=0. +;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES. +;THE AC IS CHECKED FOR ITS FINAL CONTENTS NON-ZERO. +;IF C(AC) IS NOT=0, THE TEST PASSES + +B4400: MOVEI 0 ;PRELOAD AC,E WITH 0 + ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0 + SKIPN ;PASS IF C(AC) IS NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY). +;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=0 +;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES. +;THE AC IS CHECKED FOR ITS FINAL CONTENTS EQUAL TO -1,,-1 +;IF C(AC0)=-1,,-1, THE TEST PASSES + +B4500: MOVEI 0 ;PRELOAD AC,E WITH 0 + ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0 + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: ET0 +;0 FC: AD AR + EN +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY). +;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=-1,,-1 +;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES. +;THE AC IS CHECKED FOR ITS FINAL CONTENTS EQUAL TO -1,,-1 +;IF C(AC0)=-1,,-1, THE TEST PASSES + +B4600: MOVE [-1] ;PRELOAD AC,E WITH -1,,-1 + ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0 + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD FM - EN +;0 ET0: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1; HENCE, THE RESULT +;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR ITS INAL CONTENTS=0. +;IF C(AC)=0, THE TEST PASSES + +B4700: MOVEI 0 ;PRELOAD AC WITH 0 + ORCM [-1] ;*ORCM SHOULD PLACE ALL ZEROS INTO THE AC + SKIPE ;PASS IF C(AC)=0,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-E SW: FCE + +;********** +;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH C(E). +;IN THIS CASE AC=E AND C(AC)=C(E)=0,,0. HENCE THE +;RESULT IN THE AC SHOULD BE 0,,0. +;THE AC IS CHECKED FOR 0,,0. IF C(AC)=0,,0, THIS TEST PASSES + +B5000: MOVEI 0 ;PRELOAD AC,E WITH 0,,0 + IOR ;*IOR SHOULD PUT 0 INTO AC + SKIPE ;PASS TEST IF C(AC)=0,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 SW: ET0 +;-1,,-1 ET0: AR AD EN +;-1,,-1 ET0: AD AR - EN +;-1,,-1 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH C(E). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE +;RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1 +;IF C(AC) =-1,,-1 THE TEST PASSES. + +B5100: MOVEI 0 ;PRELOAD AC WITH 0 + IOR [-1] ;*IOR SHOULD PUT -1,,-1 INTO AC + CAME [-1] ;PASS TEST IF C(AC) =-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;0 FC: AD AR - EN + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD FM - EN + +NB5300:;********** +;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH C(E). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE +;RESULT IN THE AC SHOULD BE -1,,-1 +;THE AC IS CHECKED FOR ITS CONTENTS = ALL ONES +;IF C(AC)=-1, THE TEST PASSES + +B5200: SETO ;PRELOAD AC WITH -1,,-1 + IOR [-1] ;*IOR SHOULD PUT -1,,-1 INTO AC + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH C(E). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE +;RESULT IN THE AC SHOULD BE -1,,-1 +;THE AC IS CHECKED FOR ITS CONTENTS = ALL ONES +;IF C(AC)=-1,,-1, THE TEST PASSES + +B5300: SETO ;PRELOAD AC WITH -1,,-1 + IOR [0] ;*IOR SHOULD PUT -1,,-1 INTO AC + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND +;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT +;IN THE AC SHOULD BE 0,,-1 +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THE TEST PASSES + +B5500: SETO ;PRELOAD AC WITH ALL ONES + ANDCM [XWD -1,0] ;*ANDCM SHOULD PLACE 0,,-1 IN THE AC + CAME [0,,-1] ;IF C(AC)=0,,-1, THE TEST PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-E SW: FCE +;-1,,-1 FC: AD AR - EN +;-1,,0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND +;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=0. HENCE, +;THE RESULT IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0. +;IF C(AC)=0, THE TEST PASSES. + +B5600: SETO ;PRELOAD AC WITH ALL ONES + ANDCM ;*ANDCM SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES. + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND +;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE C(AC)=-1,,-1, AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE ALL ONES. THE AC IS CHECKED FOR -1,,-1. +;IF C(AC)=-1,,-1, THE TEST PASSES + +B5700: SETO ;PRELOAD AC WITH 0 + ANDCM [0] ;*ANDCM SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;IF C(AC)=-1,,-1, THE TEST PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND +;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. +;IF C(AC)=0, THE TEST PASSES + +B6000: MOVEI 0 ;PRELOAD AC WITH 0 + ANDCM ;*ANDCM SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES. + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD FM + EN + +;********** +;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND +;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. +;IF C(AC)=0, THE TEST PASSES + +B6100: SETZ ;PRELOAD AC WITH 0 + ANDCM [-1] ;*ANDCM SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR ZERO. IF C(AC) IS +;EQUAL TO ZERO, THE TEST PASSES. + +B6200: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ANDCA [0] ;*ANDCA SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES. + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;0,,-1 FC: AD AR + EN + +;********** + +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE, THE +;RESULT IN THE AC SHOULD BE 0,,707070. THE AC IS CHECKED +;FOR 0,,707070. IF C(AC)=0,,707070, THE TEST PASSES. + +B6300: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ANDCA [707070707070] ;*ANDCA SHOULD PLACE 0,,707070 IN THE AC + CAME [XWD 0,707070] ;IF C(AC)=0,,707070, THE TEST PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;707070,,707070 FC: AD FM - EN +;707070,,707070 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=0. HENCE, THE RESULT +;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC=0, +;THE TEST PASSES. + +B6400: SETZ ;CLEAR THE AC AND E + ANDCA ;*ANDCA SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR ALL ONES. +;IF C(AC)=-1,,-1, THE TEST PASSES. + +B6500: SETZ ;CLEAR THE AC + ANDCA [-1] ;*ANDCA SHOULD PLACE ALL ONES IN THE AC + CAME [-1] ;IF C(AC)=ALL ONES, THE TEST PASSES. + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT +;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, +;THE TEST PASSES. + +B6600: SETO ;PRESET AC TO ALL ONES + ANDCA ;*ANDCA SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, +;THE TEST PASSES. + +B6700: SETO ;PRESET AC TO ALL ONES + ANDCA [0] ;*ANDCA SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES. + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE C(AC)=-1,,0 AND C(E)=0; HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, +;THIS TEST PASSES. + +B7000: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ANDCB [0] ;*ANDCB SHOULD PLACE 0,,-1 IN THE AC + CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-E SW: FCE +;-1,,-1 FC: AD FM - EN +;0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,-1; HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, +;THIS TEST PASSES. + +B7100: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ANDCB [-1] ;*ANDCB SHOULD PLACE 0 IN AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 FC: AD AR - EN + +;********** + +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE ALL ONES. THE AC IS CHECKED FOR ALL ONES. IF C(AC)=-1,,-1, +;THE TEST PASSES. + +B7200: SETZ ;PRELOAD AC,E WITH ZEROES + ANDCB ;*ANDCB SHOULD PLACE ALL ONES IN THE AC + CAME [-1] ;PASS IF C(AC) IS ALL ONES + STOP + +;********** + +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B7300: SETO ;PRELOAD AC,E WITH ONES + ANDCB ;*ANDCB SHOULD PLACE ALL ZEROS IN THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B7400: SETZ ;PRELOAD AC WITH 0 + ANDCB [-1] ;*ANDCB SHOULD PLACE 0 IN THE AC + CAIE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B7500: SETO ;PRELOAD AC WITH -1,,-1 + ANDCB [0] ;*ANDCB SHOULD PLACE 0 IN THE AC + CAIE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, +;THIS TEST FAILS. + +B7600: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ORCA [0] ;*ORCA SHOULD PLACE 0,,-1 IN THE AC + CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 SW: ET0 +;-1,,0 FC: AD AR - EN +;0 FC: AD FM + EN +;-1,,-1 ET0: AR AD EN +;-1,,-1 ET0: AD AR - EN +;-1,,0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE, THE RESULT IN THE AC +;SHOULD BE 707070,,-1. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, +;THIS TEST FAILS. + +B10000: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ORCA [707070707070] ;*ORCA SHOULD PLACE 707070,,-1 IN THE AC + CAME [XWD 707070,-1] ;PASS IF C(AC)=707070,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 SW: FCE + +;********** +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B10100: SETZ ;PRELOAD AC,E WITH 0 + ORCA ;*ORCA SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OF FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B10200: SETO ;PRELOAD AC,E WITH 0 + ORCA ;*ORCA SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESUTL IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B10300: SETZ ;PRELOAD AC WITH 0 + ORCA [-1] ;*ORCA SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B10400: SETO ;PRELOAD AC WITH -1,,-1 + ORCA [0] ;*ORCA SHOULD PLACE 0 IN THE AC + CAIE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E) +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE THE RESULT +;IN THE AC 070707,,-1. THE AC IS CHECKED FOR 070707,,-1. IF C(AC)=070707,,-1, +;THIS TEST PASSES + +B10500: MOVE [XWD -1,0] ;PRELOAD THE AC WITH -1,,0 + ORCB [707070707070] ;*ORCB SHOULD PLACE 070707,,-1 IN THE AC + CAME [XWD 070707,-1] ;PASS IF C(AC)=070707,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 SW: FCE +;707070,,0 SW: ET0 +;0,,-1 FC: AD AR + EN +;070707,,070707 FC: AD FM + EN +;070707,,070707 ET0: AR AD EN +;-1,,-1 ET0: AD AR - EN +;707070,,0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E) +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE THE RESULT +;IN THE AC -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, +;THIS TEST PASSES + +B10700: MOVE [XWD 0,-1] ;PRELOAD THE AC WITH 0,,-1 + ORCB [-1] ;*ORCB SHOULD PLACE -1,,0 IN THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)-1,,-1, THE TEST PASSES + +B11000: SETZ ;PRELOAD AC WITH 0 + ORCB [0] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES + +B11100: SETO ;PRELOAD AC WITH -1,,-1 + ORCB [-1] ;*ORCB SHOULD PLACE 0 IN THE AC + CAIE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E) +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES + +B11200: SETZ ;PRELOAD AC WITH 0 + ORCB [-1] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES + +B11300: SETO ;PRELOAD AC WITH -1,,-1 + ORCB [0] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +SUBTTL TEST OF MOVN INSTRUCTION + +;********** + +;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC +;IN THIS CASE C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0, THE NEGATIVE OF 0. IF C(AC)=0, THIS TEST PASSES + +B11500: SETO ;PRELOAD AC WITH -1,,-1 + MOVN [0] ;*MOVN SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;-1,,-1 FC: AD FM + EN +;-1,,-1 FC: AD CRY 36 + +;********** + +;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC. +;IN THIS CASE C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE 1,,0 +;THE AC IS CHECKED FOR 1,,0. IF C(AC)=1,,0, THE TEST PASSES + +B11600: MOVE [XWD -1,0] ;PRELOAD AC,E WITH -1,,0 + MOVN ;*MOVN SHOULD PLACE 1,,0 INTO THE AC + CAME [XWD 1,0] ;PASS IF C(AC)=1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD ADD +;0 FC: AD FM - EN +;0 FC: AD AR - EN +;-1,,0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC. +;IN THIS CASE C(E) =707070,,707070. HENCE, THE RESULT IN THE AC SHOULD BE +;070707,,070710. THE AC IS CHECKED FOR 070707,,070710. IF C(AC)= +;070707,,070710, THE TEST PASSES + +B11700: SETZ ;PRELOAD AC WITH 0 + MOVN [707070707070] ;*MOVN SHOULD PLACE 070707,,070710 INTO THE AC + CAME [070707070710] ;PASS IF C(AC) 070707,,070710 + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC +;IN THIS CASE C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0,,1. +;THE AC IS CHECKED FOR 0,,1, THE NEGATIVE OF -1,,-1. IF C(AC)=1, THIS TEST PASSES + +B12100: MOVN [-1] ;*MOVN SHOULD PLACE 0,,1 INTO THE AC + CAIE 1 ;PASS OF C(AC)=0,,1 + STOP + +;********** +SUBTTL TEST OF MOVM INSTRUCTION + +;********** + +;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC. +;IN THIS CASE, C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B12200: SETO ;PRELOAD AC WITH -1,,-1 + MOVM [0] ;*MOVM SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE + +;********** + +;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC +;IN THIS CASE, C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0,,1. +;THE AC IS CHECKED FOR 0,,1. IF C(AC)=0,,1, THIS TEST PASSES + +B12300: SETZ ;PRELOAD AC WITH 0 + MOVM [-1] ;*MOVM SHOULD PLACE 0,,1 INTO THE AC + CAIE 1 ;PASS IF C(AC)=0,,1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD FM + EN +;0 FC: AD ADD +;0 FC: AD CRY 36 +;0 FC: AD AR - EN +;-1,,-1 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC +;IN THIS CASE, C(E)=400000,,0. HENCE, THE RESULT IN THE AC SHOULD BE +;400000,,0. THE AC IS CHECKED FOR 400000,,0. +;IF C(AC)=400000,,0, THIS TEST PASSES. + +B12400: SETZ + MOVM [XWD 400000,0] ;*MOVM SHOULD PLACE 400000,,0 INTO THE AC + CAME [XWD 400000,0] ;PASS IF C(AC)=400000,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC +;IN THIS CASE, C(E)=377777,,-1. HENCE, THE RESULT IN THE AC SHOULD BE +;377777,,-1. THE AC IS CHECKED FOR 377777,,-1. +;IF C(AC)=377777,,-1, THIS TEST PASSES. + +B12500: SETZ ;PRELOAD AC WITH 0 + MOVM [XWD 377777,-1] ;*MOVM SHOULD PLACE 377777,,-1 INTO THE AC + CAME [XWD 377777,-1] ;PASS IF C(AC)=377777,,-1 + STOP + +;********** + ;JRST BEGEND diff --git a/apps/pdp10/diags/klad/dakab/DAKABM.MAC.txt b/apps/pdp10/diags/klad/dakab/DAKABM.MAC.txt new file mode 100644 index 000000000..5a6bb7611 --- /dev/null +++ b/apps/pdp10/diags/klad/dakab/DAKABM.MAC.txt @@ -0,0 +1,1770 @@ +SUBTTL DIAGNOSTIC SECTION + LALL + +START: SETZM USER# ;CLEAR USER CONTROL WORD + JSP 0,.+1 ;GET FLAGS + TLNE USERF ;IN USER MODE? + SETOM USER ;YES, SET USER CONTROL WORD + SKIPN MONFLG ;SPECIAL USER MODE? + SETZM USER ;YES, CLEAR USER CONTROL WORD + SKIPN USER + JRST B00 + SKIPL MONCTL + TTCALL 3,PGMNAM ;MENTION OUR NAME + JRST STARTA ; GO START + +PGMNAM: ASCIZ/ +PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) [DAKAB] +/ + +;BASIC INSTRUCTION TEST (2) +;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF +;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES +;IN THE FIELD + + +STARTA: JRST .+1 + +B00: +SUBTTL TEST OF THE ADD INSTRUCTION + +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED +;TO ADD A NON-ZERO NUMBER CONTAINED IN E TO AN AC CONTAINING ALL ZEROS, +;THE RESULT IS A NON-ZERO NUMBER IN THE AC. FIRST, THE AC IS CLEARED; +;THEN, ANON-ZERO POSITIVE NUMBER IS ADDED TO THE AC USING THE ADD +;INSTRUCTION. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + + A10400: MOVE [0] ;PRESET AC TO ALL ZEROS + ADD [123456765432] ;*ADD OF A NON-ZERO NUMBER TO AN AC OF ALL + ;ZEROS SHOULD RESULT + ;IN AN AC CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + STOP + +;AD ADD [ADC1], AD ADD EN [ADC1], +;F CYC ACT EN A [F1], AD FM + FETCH EN A [ADFP], +;F CYC ACT EN C[F1], IR ADSUB [IR1], IRXX [IR1] + +;********** + +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD +;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE +;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS +;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS +; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + +A10500: MOVE [123456765432] ;PRESET AC WITH A NON-ZERO NUMBER + ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC + ;CONTAINING A NON-ZERO NUMBER + ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + STOP + +;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F [E], +;AR AD ET2 EN [ARMA], IR ADSUB [IR1] + +;********** +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD +;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE +;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS +;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS +; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + +A10600: MOVE [XWD 123456,0] ;PRESET AC WITH A NON-ZERO NUMBER + ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING + ;A NON-ZERO NUMBER SHOULD RESULT IN AN AC + ;CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + STOP + +;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F[E], +;AR AD ET2 EN [ARMA], IR AD SUB [IR1] + +;********* + +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD +;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE +;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS +;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS +; IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + +A10700: MOVE [123456] ;PRESET AC WITH A NON-ZERO NUMBER + ADD [0] ;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING + ;A NON-ZERO NUMBER + ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IS C(AC) IS NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD +;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE +;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS +;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER +;IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + +A13300: MOVE [0] ;PRESET AC WITH ALL ZEROS + ADD [123456,,0] ;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS + ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD +;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE +;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC. FIRST, THE AC IS +;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER +;IS ADDED TO THE AC. THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO + +A13400: MOVE [0] ;PRESET AC WITH ALL ZEROS + ADD [123456] ;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS + ;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER + SKIPN ;PASS TEST IF C(AC) IS NON-ZERO + STOP + +;********** +;ADD ZERO TO A RIPPLED ONE + +SN=11000 + ZZ=0 + +A11000: REPEAT ^D36, +<;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. +;A WORD OF ALL ZEROS IS ADDED TO AN +;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, +;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY. +;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD +;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. +;THE FINAL RESULT SHOULD BE C(AC)=0. THIS +;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH +;EVERY BIT OF THE AC. +;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + ADD [0] ;*ADD OF ZERO TO FLOATING ONE + EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + EQV [0] ;RESULTS IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1], +;IR ADDX [IR1], IR ADSUB [IR1] + +;********** +PAGE +> +;THIS TEST VERIFIES THAT THE ADDITION OF A WORD OF +;ALL ZEROS TO AN AC OF ALL ZEROS RESULTS IN +;C(AC)=0. FIRST THE AC IS CLEARED; THEN, A WORD +;OF ALL ZEROS IS ADDED TO THE AC. THE RESULT IN +;THE AC IS THEN CHECKED TO INSURE THAT C(AC)=0 + +A11100: MOVE [0] ;PRESET AC TO ZERO + ADD [0] ;*ADD OF ZERO TO ZERO SHOULD RESULT IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;FCE[F1], IR AD SUB [IR1] +;AD FM + EN [ADFP], AD FM + EN A [ADFP], +;F CYC ACT EN C[F1], IR ADSUB [IR1] + +;********** +;ADD ZERO TO A RIPPLED ONE + +SN=13200 + ZZ=0 + +A13200: REPEAT ^D36, +<;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS. +;TO AN AC OF ALL ZEROS IS ADDED A +;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT, +;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT. +;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC). THIS RESULT SHOULD +;BE ALL ONES. NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS. +;THE FINAL RESULT SHOULD BE C(AC)=0. THIS +;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH +;EVERY BIT OF THE AC. +;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS. +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [0] ;LOAD AC WITH ALL ZEROS + ADD [ZZ] ;*ADD OF FLOATING ONE TO ZERO + EQV [ZZ] ;RESULTS IN C(AC)=ALL ONES + EQV [0] ;RESULTS IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +> +PAGE +;ADD A RIPPLED ONE TO A RIPPLED ONE + +SN=11200 + ZZ=0 + +A11200: REPEAT ^D35, +<;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC) +;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)= +;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN +;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A +;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE +;RESULT IN THE AC WILL BE ZERO AND THE TEST +;WILL FAIL. THIS TEST IS REPEATED 35 TIMES +;SO THAT A ONE WILL BE FLOATED THROUGH +;BITS 1 THRU 35 OF BOTH AC AND E +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [ZZ] ;PRESET AC WITH A FLOATING ONE + ADD [ZZ] ;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO + EQV [ZZ+ZZ] ;RESULTS IN C(AC)=ALL ONES + EQV [0] ;RESULTS IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +> +SN=11300 + ZZ=0 + YY=0 + +A11300: REPEAT ^D18, +<;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE +;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER +;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST +;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE +;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE +;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, +;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER +;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS +;FORMER VALUE PLUS THE CURRENT C(AC) +SN=SN+1 + YY=YY/2 + ZZ=ZZ+YY + IFE YY, + IFE ZZ, + MOVE [XWD ZZ,0] ;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + ADD [XWD YY,0] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + ;POWER SHOULD RESULT IN C(AC)=0. + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +> +PAGE +SN=11400 + ZZ=0 + YY=0 + +A11400: REPEAT ^D18, +<;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE +;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER +;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST +;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE +;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE +;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN, +;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER +;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS +;FORMER VALUE PLUS THE CURRENT C(AC) +SN=SN+1 + YY=YY/2 + ZZ=ZZ+YY + IFE YY, + IFE ZZ, ;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0 + MOVE [XWD -1,ZZ] ;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH + ;POWER SHOULD RESULT IN C(AC)=0. + ADD [YY] ;PASS TEST IF C(AC)=0 + SKIPE + STOP + +;********** +> +SUBTTL SPECIAL KI10 FOUR BIT ADDER TEST + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 33 TO BIT 32. + +A13500: MOVE [-1,,-5] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 33 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 33 TO BIT 32 + EQV [-1,,-4] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 29 TO BIT 28. + +A13600: MOVE [-1,,-101] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 29 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 29 TO BIT 28 + EQV [-1,,-100] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 25 TO BIT 24. + +A13700: MOVE [-1,,-2001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 25 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 25 TO BIT 24 + EQV [-1,,-2000] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 21 TO BIT 20. + +A14000: MOVE [-1,,-40001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 21 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 21 TO BIT 20 + EQV [-1,,-40000] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 18 TO BIT 17. + +A14100: MOVE [-1,,-400001] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 18 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 18 TO BIT 17 + EQV [-1,,400000] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 14 TO BIT 13. + +A14200: MOVE [-11,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 14 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 14 TO BIT 13 + EQV [-10,,0] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 10 TO BIT 9. + +A14300: MOVE [-201,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 10 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 10 TO BIT 9 + EQV [-200,,0] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 6 TO BIT 5. + +A14400: MOVE [-4001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 6 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 6 TO BIT 5 + EQV [-4000,,0] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 2 TO BIT 1. + +A14500: MOVE [-100001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 2 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 2 TO BIT 1 + EQV [-100000,,0] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 1 TO BIT 0. + +A14600: MOVE [-200001,,-1] ;PRESET AC WITH ALL ONES EXCEPT FOR BIT 1 + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT 1 TO BIT 0 + EQV [600000,,0] ;RESULT IN AC=ALL ONES + EQV [0] ;RESULT IN AC=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR +;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER. +;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT -1TO BIT 35. + +A14700: MOVE [-1,,-1] ;PRESET AC WITH ALL ONES + ADD [1] ;*ADD SHOULD NOT CAUSE CARRY FROM BIT -1 TO BIT 35 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +SUBTTL TEST OF SUB AND COMPARE INSTRUCTIONS + +;THIS TEST VERIFIES THAT IF A NON ZERO POSITIVE NUMBER IN E IS +;SUBTRACTED FROM THE AC WHEN C(AC)=0, THE RESULT IN THE AC +;IS NEGATIVE + +A11500: MOVE [0] ;PRESET AC TO ZERO + SUB [XWD 0,-1] ;*SUB OF POSITIVE NONZERO NUMBER FROM AC OF ALL ZEROS + ;SHOULD RESULT IN C(AC) NEGATIVE + SKIPL ;PASS TEST IF C(AC) IS NEGATIVE + STOP + +;AD AR- EN D [ADAM], F CYC ACT ENB [F1], +;IR SUBX[IR1], IR ADSUB[IR1] + +;********** + +;THIS TEST VERIFIES THAT IF A WORD OF ALL ZEROS IS +;SUBTRACTED FROM AN AC OF ALL ZEROS, THE RESULT +;IS AN AC OF ZEROS. + +A11600: MOVE [0] ;PRESET AC TO ZERO + SUB [0] ;*SUB OF 0 FROM 0 SHOULD RESULT IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP +;AD CRY 36[ADCR], F CYC ACT EN D[F1], IF SUBX [IR1] + +;********** +PAGE +SN=11700 + ZZ=0 + +A11700: REPEAT ^D36, +<;THIS TEST VERIFIES THAT IF A RIPPLED ONE +;IS SUBTRACTED FROM ITSELF, THE RESULT IS +;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36 +;TIMES IN ORDER TO TEST ALL 36 BITS. +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [ZZ] ;LOAD AC WITH A FLOATING ONE + SUB [ZZ] ;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +> +PAGE +;THIS TEST VERIFIES THAT IF A WORD OF ALL +;ONES IS SUBTRACTED FROM ITSELF, THE RESULT +;IN THE AC IS ZERO. + +A12000: MOVE [-1] ;PRESET AC TO ALL ONES + SUB [-1] ;*SUB OF -1 FROM ITSELF SHOULD RESULT IN C(AC)=0 + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT CAMA ALWAYS SKIPS THE +;NEXT INSTRUCTION INDEPENDENT OF THE DATA WITH AC +;AND E. THIS TEST FAILS IF CAMA DOES NOT SKIP ALWAYS. + +A12100: MOVE [0] ;PRESET AC, E TO ZERO + CAMA ;*CAMA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION, + ;OTHERWISE THIS TEST FAILS + STOP + +;ET0 [E], ET0 EN[E], IR CAXX[IR3], AD CRY 3C[ADCR], +;FCYC ACT EN D [ADCR], AD CRY 36 F/F'S [ADCR], +;PC CLOCK EN [PCC], ET0 C F/F[E], IR CAXX[IR3], +;ADZ COND P[ADZ] AND ADZ COND Z[ADZ] + +;********** + +;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE. +;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY +;IF C(AC)=C(E). IN THIS TEST AC=E=0 AND +;C(AC)=C(E)=0. HENCE, CAME MUST +;SKIP THE NEXT INSTRUCTION +;IN THIS TEST + +A12200: MOVE [0] ;PRESET AC, E TO ZERO + CAME ;*CAME SHOULD SKIP SINCE E=AC + STOP + +;AD FM + EN [ADFP], F CXC ACT ENC[F1], IRCAXX[IR3] + +;********** +;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE +;IT SKIPS THE NEXT INSTRUCTION OF AND ONLY IF +;C(AC)=C(E). IN THIS TEST C(AC)=C(E)=0; +;BUT, E IS NOT WITHIN THE AC RANGE. +;HENCE, CAME MUST SKIP +;THE NEXT INSTRUCTION IN THIS TEST. + +A12300: MOVE [0] ;*CAME SHOULD SKIP WHEN C(AC)=C(E)=0 + CAME [0] + STOP + +;CAMX: FCE[F1], IR CAMX[IR1] + +;********** + +;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE. +;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY IF +;C(AC)=C(E). IN THIS TEST C(AC)=0 AND +;C(E)=-1. HENCE, CAME SHOULD NOT +;SKIP THE NEXT INSTRUCTION IN THIS TEST. + +A12400: MOVE [0] ;PRESET AC TO ZERO + CAME [-1] ;*CAME SHOULD NOT SKIP BECAUSE C(AC)=0 ANDC(E)=- + SKIPA ;SKIP HALT INSTRUCTION IF CAME PASSES TEST + STOP + +;AD AR- EN [ADAM], IR CAXX [IR3], F CYC ACT EN B [F1], +;AD AR- F/F'S [ADAM], AD ADD [ADC1], AD FM + FETCH EN A [ADFP], +;F CYC ACT EN A [F1], AD ADD EN C [ADC1], AD ADD F/F'S [ADC1] + +;********** +SUBTTL TEST OF COMPARE (CAMX) INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS TEST, C(AC)=-1 AND C(E)=0; HENCE, CAML SHOULD SKIP. OTHERWISE,THE +;PROGRAM HALTS. + +B100: MOVE [-1] ;PRELOAD AC WITH -1 + CAML [0] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: AB PC EN +; ET0: COND Q: PC CLK EN + +;********** + +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=-1; HENCE, CAML SHOULD NOT SKIP. OTHERWISE, +;THE PROGRAM HALTS. + +B200: MOVE [0] ;PRELOAD AC WITH 0 + CAML [-1] ;*CAML SHOULD NOT SKIP BECAUSE + ;C(AC) IS GREATER THAN C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; SW: FCE +; FC: PC CHANGE + +;********** +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=400000,,0 (THE MOST +;NEGATIVE NUMBER) AND C(E)=377777,,-1 +;(THE MOST POSITIVE NUMBER); HENCE, +;CAML SHOULD SKIP. OTHERWISE, THE +;PROGRAM HALTS + +B300: MOVE [XWD 400000,0] ;PRELOAD AC WITH 400000,,0 + CAML [XWD 377777,-1] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: AD ADD + +;********** + +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=377777,,-1 (THE MOST POSITIVE NUMBER) AND C(E)=400000,,0 (THE MOST NEGATIVE NUMBER) +;HENCE, CAML SHOULD NOT SKIP. OTHERWISE, THE PROGRAM HALTS. + +B400: MOVE [XWD 377777,-1] ;PRELOAD AC WITH 377777,,-1 + CAML [XWD 400000,0] ;*CAML SHOULD NOT SKIP BECAUSE + ;C(AC) IS GREATER THAN C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=400000,,0 (THE MOST NEGTIVE NUMBER) AND C(E)=-1; +;HENCE, CAML SHOULD SKIP. OTHERWISE, THE PROGRAM HALTS + +B500: MOVE [XWD 400000,0] ;PRELOAD AC WITH 400000,,0 + CAML [-1] ;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: AD FM + EN + +;********** + +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=-1 ;HENCE, CAML SHOULD NOT SKIP. OTHERWISE, +;THE PROGRAM HALTS. + +B600: SETZ ;PRELOAD AC WITH 0 + CAML [-1] ;*CAML SHOULD NOT SKIP BECAUSE + ;C(AC) IS GREATER THAN C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES. + STOP + +;********** +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=0 ;HENCE, CAML SHOULD NOT SKIP. OTHERWISE, +;THE PROGRAM HALTS. + +B700: SETZ ;PRELOAD AS WITH 0 + CAML [0] ;*CAML SHOULD NOT SKIP BECAUSE C(AC)=C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: AD CRY 36 + +;********** + +;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS LESS THAN C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=400000,,O (THE MOST NEGATIVE NUMBER); +;HENCE CAML SHOULD NOT SKIP. OTHERWISE, THE PROGRAM HALTS. + +B1000: SETZ ;PRELOAD AC WITH 0 + CAML [XWD 400000,0] ;*CAML SHOULD NOT SKIP BECAUSE + ;C(AC) IS GREATER THAN C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAML PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT CAM IS DATA INDEPENDENT. IT NEVER SKIPS +;THE NEXT SEQUENTIAL INSTRUCTION +;IN THIS CASE, C(AC)=-1 AND C(E)=0 +;IF IT DOES SKIP THE NEXT INSTRUCTION, THE PROGRAM HALTS + +B1100: MOVE [-1] ;PRELOAD AC WITH -1 + CAM [0] ;*CAM SHOULD NEVER SKIP + SKIPA ;SKIP HALT INSTRUCTION IF CAM PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E). +;IN THIS CASE, C(AC)=-1 AND C(E)=0; HENCE, CAMGE SHOULD NOT SKIP. +;OTHERWISE, THE PROGRAM HALTS. + +B1200: MOVE [-1] ;PRELOAD AC WITH-1 + CAMGE [0] ;*CAMGE SHOULD NOT SKIP BECAUSE C(AC) IS LESS THAN C(E) + SKIPA ;SKIP HALT INSTRUCTION IF CAMGE PASSES. + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: PC CHANGE +; FC: AB PC EN + +;********** +;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E) +;IN THIS CASE, C(AC)=0 AND C(E)=-1; HENCE CAMGE SHOULD SKIP. +;OTHEWISE, THE PROGRAM HALTS. + +B1300: SETZ ;PRELOAD AC WITH 0 + CAMGE [-1] ;*CAMGE SHOULD SKIP BECAUSE C(AC) IS GREATER THAN C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; SW: FCE +; ET0: COND Q: PC CLK EN + +;********** + +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS NOT EQUAL TO C(E) +;IN THIS CASE C(AC)=0 AND C(E)=-1; HENCE CAMN SHOULD SKIP. +;OTHERWISE, THE PROGRAM HALTS + +B1400: SETZ ;PRELOAD AC WITH 0 + CAMN [-1] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC:AD FM + EN +; FC: AD AR - EN +; FC: AD CRY 36 +; FC: AD ADD +; FC: AB PC EN +; ET0: PC CLK EN + +;********** +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS NOT EQUAL TO C(E) +;IN THIS CASE, C(AC)=0 AND C(E)=0; HENCE CAMN SHOULD NOT SKIP. +;OTHERWISE, THE PROGRAM HALTS + +B1500: SETZ ;PRELOAD AC WITH 0 + CAMN [0] ;*CAMN SHOULD NOT SKIP BECAUSE C(AC)=C(E). + SKIPA ;SKIP HALT INSTRUCTION IF CAMN PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; SW: FCE +; FC: PC CHANGE + +;********** +SN=1600 + ZZ=0 + +B1600: REPEAT ^D18,< +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY +;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME +;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN +;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) +;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS +;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [XWD ZZ] ;PRELOAD AC,E WITH A FLOATING 1 + CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; ET0: COND P + +;********** +> + ZZ=0 + + REPEAT ^D18,< +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY +;WHEN C(AC) IS NOT EQUAL TO C(E). IT ALSO VERIFIES THAT CAME +;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN +;C(AC)=C(E). IN BOTH CASES AC=E; HENCE, C(AC)=C(E) +;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS +;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS + +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [XWD ZZ,0] ;PRELOAD AC,E WITH A FLOATING 1 + CAMN ;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E) + CAME ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + STOP + +;********** +> +SN=1700 + ZZ=0 + +B1700: REPEAT ^D36,< +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND +;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1. HENCE, +;CAMN SHOULD SKIP; OTHERWISE, THE PROGRAM HALTS +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + SETZ ;PRELOAD AC WITH 0 + CAMN [ZZ] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + STOP + +;********** +> +SN=2000 + ZZ=0 + +B2000: REPEAT ^D36,< +;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND +;ONLY WHEN C(AC) IS NOT EQUAL TO C(E). HENCE, +;CAMN SHOULD SKIP; OTHERWISE THE PROGRAM HALTS. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVE [ZZ] ;PRELOAD AC WITH A FLOATING 1 + CAMN [0] ;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E) + STOP + +;********** +> +SUBTTL TEST OF MOVS INSTRUCTION + +;********** + +SN=2100 + ZZ=0 + +B2100: REPEAT ^D18,< +;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND +;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES +;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1]. THEN, C(AC) IS CHECKED. +;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF + +SN=SN+1 + ZZ=ZZ+ZZ + IFE ZZ, + MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + ;AND MOVE RESULT INTO AC + CAME [XWD ZZ,ZZ] ;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ + STOP + +;********** +> +SN=2200 + ZZ=0 + +B2200: REPEAT ^D18,< +;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND +;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES +;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0]. THEN, C(AC) IS CHECKED. +;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF + +SN=SN+1 + ZZ=ZZ+ZZ+1 + IFE , + MOVS [XWD ZZ,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + ;AND MOVE RESULT INTO AC + CAME [XWD ZZ,ZZ] ;PASS TEST IF AC CONTAINS ZZ,,ZZ + STOP + +;********** +> +SN=2300 + ZZ=0 + YY=0 + +B2300: REPEAT ^D18,< +;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND +;MOVES IT INTO AC. IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E +;AND A 0 IS RIPPLED THRU THE RIGHT HALF +;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. +;THEN, C(AC) IS CHECKED. +;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF +;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + +SN=SN+1 + ZZ=ZZ+ZZ + YY=YY+YY+1 + IFE ZZ, + IFE , + MOVS [XWD ZZ,YY] ;*MOVS SHOULD SWAP HALVES OF C(E) + ;AND MOVE RESULT INTO AC + CAME [XWD YY,ZZ] ;PASS TEST IF AC CONTAINS YY,,ZZ + STOP + +;********** +> +SN=2400 + ZZ=0 + YY=0 + +B2400: REPEAT ^D18,< +;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND +;MOVES IT INTO AC. IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E +;AND A 1 IS RIPPLED THRU THE RIGHT HALF +;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0]. +;THEN, C(AC) IS CHECKED. +;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF +;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E + +SN=SN+1 + ZZ=ZZ+ZZ + YY=YY+YY+1 + IFE ZZ, + IFE , + MOVS [XWD YY,ZZ] ;*MOVS SHOULD SWAP HALVES OF C(E) + ;AND MOVE RESULT INTO AC + CAME [XWD ZZ,YY] ;PASS TEST IF C(AC)=ZZ,,YY + STOP + +;********** +> +SUBTTL TEST OF COMPARE (CAXX) INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT CAIE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN C(AC)=E +;IN THIS CASE C(AC)=E=0; HENCE, CAIE SHOULD SKIP +;OTHERWISE THE PROGRAM HALTS + +B2500: SETZ ;PRELOAD AC TO 0 + CAIE ;*CAIE SHOULD SKIP BECAUSE C(AC)=E + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; SW: PC CHANGE +; FC: AD FM ; EN +; FC: AD CRY 36 +; FC: AB PC EN +; ET0: COND P: PC CLK EN + +;********** + +;THIS TEST VERIFIES THAT CAIE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN C(AC)=E +;IN THIS CASE C(AC)=E=1. HENCE, CAIE SHOULD SKIP +;OTHERWISE THE PROGRAM HALTS + +B2600: MOVE [1] ;PRELOAD AC TO 1 + CAIE 1 ;*CAIE SHOULD SKIP BECAUSE C(AC)=E + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +; FC: AD AR - EN + +;********** + +;THIS TEST VERIFIES THAT CAME SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN C(AC)=C(E) +;IN THIS CASE C(AC)=C(E)=1; HENCE, CAME SHOULD SKIP +;OTHERWISE THE PROGRAM HALTS + +B2700: MOVEI 1 ;PRELOAD AC TO 1 + CAME [1] ;*CAME SHOULD SKIP BECAUSE C(AC)=C(E) + STOP + +;********** +SUBTTL TEST OF BOOLEAN INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT SETCA IGNORES THE ADDRESS FIELD OF THE INSTUCTION WORD. +;IN THIS CASE C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 +;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES. + +B3000: MOVEI -1 ;PRELOAD AC TO 0,,-1 + SETCA [-1] ;*SETCA SHOULD PUT -1,,0 INTO THE AC + CAME [-1,,0] ;PASS TEST IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE +;RESULT IN THE AC. +;IN THIS CASE C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 +;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES + +B3100: MOVEI -1 ;PRELOAD AC TO 0,,-1 + SETCA ;*SETCA SHOULD PUT -1,,0 INTO THE AC + CAME [-1,,0] ;PASS TEST IF C(AC) =-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE +;RESULT IN THE AC, +;IN THIS CASE C(AC)=0,,0 HENCE, THE RESULT IN THE AC SHOULD BE,-1 +;IF THE RESULT IN THE AC IS -1,,-1, THE TEST PASSES + +B3200: MOVEI 0 ;PRELOAD AC TO 0,,0 + SETCA ;*SETCA SHOULD PUT -1,,-1 INTO THE AC + CAME [-1] ;PASS TEST IF C(AC) =-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE +;RESULT IN THE AC, +;IN THIS CASE C(AC)=-1,,-1; HENCE, THE RESULT IN THE AC SHOULD BE 0,,0 +;IF THE RESULT IN THE AC IS ZERO, THE TEST PASSES + +B3300: MOVE [-1] ;PRELOAD AC TO -1,,-1 + SETCA ;*SETCA SHOULD PUT 0,,0 INTO THE AC + CAME [0] ;PASS TEST IF C(AC) IS ZERO + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD FM - EN + +;********** +;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE +;RESULT IN THE AC. +;IN THIS CASE AC=E AND C(E)=C(AC)=0,,-1; HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 +;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES + +B3500: MOVEI -1 ;PRELOAD AC TO 0,,-1 + SETCM ;*SETCM SHOULD PUT -1,,0 INTO THE AC + CAME [-1,,0] ;PASS TEST IF C(AC) =-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 SW: FCE +;-1,,-1 FC: AD AR - EN +;0,,-1 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE +;RESULT IN THE AC. +;IN THIS CASE C(E)=-1,,-1; HENCE, THE RESULT IN THE AC SHOULD BE 0,,0 +;IF THE RESULT IN THE AC IS ZERO,THE TEST PASSES + +B3600: SETCM [-1] ;*SETCM SHOULD PUT 0 INTO THE AC + SKIPE ;PASS TEST IF C(AC0)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE +;RESULT IN THE AC. +;IN THIS CASE C(E)=0,,0; HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 +;IF THE RESULT IN THE AC IS -1,,-1,THE TEST PASSES + +B3700: SETCM [0] ;*SETCM SHOULD PUT -1,,-1 INTO THE AC + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT SETO SETS C(AC) TO -1,,-1. SETO IGNORES +;THE ADDRESS FIELD OF THE INSTRUCTION WORD. +;FIRST C(AC) IS SET TO 0,,0; THEN SETO IS EXECUTED. +;THE AC IS THEN CHECKED FOR ALL ONES. IF C(AC) IS ALL ONES, +;THE TEST PASSES + +B4300: MOVEI 0 ;PRELOAD AC WITH 0,,0 + SETO ;*SETO SHOULD LOAD THE AC WITH -1,,-1 + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=0. +;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES. +;THE AC IS CHECKED FOR ITS FINAL CONTENTS NON-ZERO. +;IF C(AC) IS NOT=0, THE TEST PASSES + +B4400: MOVEI 0 ;PRELOAD AC,E WITH 0 + ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0 + SKIPN ;PASS IF C(AC) IS NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY). +;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=0 +;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES. +;THE AC IS CHECKED FOR ITS FINAL CONTENTS EQUAL TO -1,,-1 +;IF C(AC0)=-1,,-1, THE TEST PASSES + +B4500: MOVEI 0 ;PRELOAD AC,E WITH 0 + ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0 + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: ET0 +;0 FC: AD AR + EN +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY). +;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=-1,,-1 +;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES. +;THE AC IS CHECKED FOR ITS FINAL CONTENTS EQUAL TO -1,,-1 +;IF C(AC0)=-1,,-1, THE TEST PASSES + +B4600: MOVE [-1] ;PRELOAD AC,E WITH -1,,-1 + ORCM ;*ORCM SHOULD PUT ALL ONES INTO AC0 + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD FM - EN +;0 ET0: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1; HENCE, THE RESULT +;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR ITS INAL CONTENTS=0. +;IF C(AC)=0, THE TEST PASSES + +B4700: MOVEI 0 ;PRELOAD AC WITH 0 + ORCM [-1] ;*ORCM SHOULD PLACE ALL ZEROS INTO THE AC + SKIPE ;PASS IF C(AC)=0,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-E SW: FCE + +;********** +;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH C(E). +;IN THIS CASE AC=E AND C(AC)=C(E)=0,,0. HENCE THE +;RESULT IN THE AC SHOULD BE 0,,0. +;THE AC IS CHECKED FOR 0,,0. IF C(AC)=0,,0, THIS TEST PASSES + +B5000: MOVEI 0 ;PRELOAD AC,E WITH 0,,0 + IOR ;*IOR SHOULD PUT 0 INTO AC + SKIPE ;PASS TEST IF C(AC)=0,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 SW: ET0 +;-1,,-1 ET0: AR AD EN +;-1,,-1 ET0: AD AR - EN +;-1,,-1 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH C(E). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE +;RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1 +;IF C(AC) =-1,,-1 THE TEST PASSES. + +B5100: MOVEI 0 ;PRELOAD AC WITH 0 + IOR [-1] ;*IOR SHOULD PUT -1,,-1 INTO AC + CAME [-1] ;PASS TEST IF C(AC) =-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;0 FC: AD AR - EN + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD FM - EN + +NB5300:;********** +;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH C(E). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE +;RESULT IN THE AC SHOULD BE -1,,-1 +;THE AC IS CHECKED FOR ITS CONTENTS = ALL ONES +;IF C(AC)=-1, THE TEST PASSES + +B5200: SETO ;PRELOAD AC WITH -1,,-1 + IOR [-1] ;*IOR SHOULD PUT -1,,-1 INTO AC + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL +;INCLUSIVE OR OF C(AC) WITH C(E). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE +;RESULT IN THE AC SHOULD BE -1,,-1 +;THE AC IS CHECKED FOR ITS CONTENTS = ALL ONES +;IF C(AC)=-1,,-1, THE TEST PASSES + +B5300: SETO ;PRELOAD AC WITH -1,,-1 + IOR [0] ;*IOR SHOULD PUT -1,,-1 INTO AC + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND +;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT +;IN THE AC SHOULD BE 0,,-1 +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THE TEST PASSES + +B5500: SETO ;PRELOAD AC WITH ALL ONES + ANDCM [XWD -1,0] ;*ANDCM SHOULD PLACE 0,,-1 IN THE AC + CAME [0,,-1] ;IF C(AC)=0,,-1, THE TEST PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-E SW: FCE +;-1,,-1 FC: AD AR - EN +;-1,,0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND +;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=0. HENCE, +;THE RESULT IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0. +;IF C(AC)=0, THE TEST PASSES. + +B5600: SETO ;PRELOAD AC WITH ALL ONES + ANDCM ;*ANDCM SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES. + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND +;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE C(AC)=-1,,-1, AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE ALL ONES. THE AC IS CHECKED FOR -1,,-1. +;IF C(AC)=-1,,-1, THE TEST PASSES + +B5700: SETO ;PRELOAD AC WITH 0 + ANDCM [0] ;*ANDCM SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;IF C(AC)=-1,,-1, THE TEST PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND +;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. +;IF C(AC)=0, THE TEST PASSES + +B6000: MOVEI 0 ;PRELOAD AC WITH 0 + ANDCM ;*ANDCM SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES. + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD FM + EN + +;********** +;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND +;OF C(AC) AND THE COMPLEMENT OF C(MEMORY). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. +;IF C(AC)=0, THE TEST PASSES + +B6100: SETZ ;PRELOAD AC WITH 0 + ANDCM [-1] ;*ANDCM SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR ZERO. IF C(AC) IS +;EQUAL TO ZERO, THE TEST PASSES. + +B6200: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ANDCA [0] ;*ANDCA SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES. + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;0,,-1 FC: AD AR + EN + +;********** + +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE, THE +;RESULT IN THE AC SHOULD BE 0,,707070. THE AC IS CHECKED +;FOR 0,,707070. IF C(AC)=0,,707070, THE TEST PASSES. + +B6300: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ANDCA [707070707070] ;*ANDCA SHOULD PLACE 0,,707070 IN THE AC + CAME [XWD 0,707070] ;IF C(AC)=0,,707070, THE TEST PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;707070,,707070 FC: AD FM - EN +;707070,,707070 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=0. HENCE, THE RESULT +;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC=0, +;THE TEST PASSES. + +B6400: SETZ ;CLEAR THE AC AND E + ANDCA ;*ANDCA SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR ALL ONES. +;IF C(AC)=-1,,-1, THE TEST PASSES. + +B6500: SETZ ;CLEAR THE AC + ANDCA [-1] ;*ANDCA SHOULD PLACE ALL ONES IN THE AC + CAME [-1] ;IF C(AC)=ALL ONES, THE TEST PASSES. + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT +;IN THE AC SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, +;THE TEST PASSES. + +B6600: SETO ;PRESET AC TO ALL ONES + ANDCA ;*ANDCA SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, +;THE TEST PASSES. + +B6700: SETO ;PRESET AC TO ALL ONES + ANDCA [0] ;*ANDCA SHOULD PLACE 0 IN THE AC + SKIPE ;IF C(AC)=0, THE TEST PASSES. + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE C(AC)=-1,,0 AND C(E)=0; HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, +;THIS TEST PASSES. + +B7000: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ANDCB [0] ;*ANDCB SHOULD PLACE 0,,-1 IN THE AC + CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-E SW: FCE +;-1,,-1 FC: AD FM - EN +;0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION +;OF THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,-1; HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, +;THIS TEST PASSES. + +B7100: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ANDCB [-1] ;*ANDCB SHOULD PLACE 0 IN AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 FC: AD AR - EN + +;********** + +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE ALL ONES. THE AC IS CHECKED FOR ALL ONES. IF C(AC)=-1,,-1, +;THE TEST PASSES. + +B7200: SETZ ;PRELOAD AC,E WITH ZEROES + ANDCB ;*ANDCB SHOULD PLACE ALL ONES IN THE AC + CAME [-1] ;PASS IF C(AC) IS ALL ONES + STOP + +;********** + +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B7300: SETO ;PRELOAD AC,E WITH ONES + ANDCB ;*ANDCB SHOULD PLACE ALL ZEROS IN THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B7400: SETZ ;PRELOAD AC WITH 0 + ANDCB [-1] ;*ANDCB SHOULD PLACE 0 IN THE AC + CAIE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B7500: SETO ;PRELOAD AC WITH -1,,-1 + ANDCB [0] ;*ANDCB SHOULD PLACE 0 IN THE AC + CAIE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, +;THIS TEST FAILS. + +B7600: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ORCA [0] ;*ORCA SHOULD PLACE 0,,-1 IN THE AC + CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 SW: ET0 +;-1,,0 FC: AD AR - EN +;0 FC: AD FM + EN +;-1,,-1 ET0: AR AD EN +;-1,,-1 ET0: AD AR - EN +;-1,,0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE, THE RESULT IN THE AC +;SHOULD BE 707070,,-1. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, +;THIS TEST FAILS. + +B10000: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + ORCA [707070707070] ;*ORCA SHOULD PLACE 707070,,-1 IN THE AC + CAME [XWD 707070,-1] ;PASS IF C(AC)=707070,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 SW: FCE + +;********** +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B10100: SETZ ;PRELOAD AC,E WITH 0 + ORCA ;*ORCA SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OF FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B10200: SETO ;PRELOAD AC,E WITH 0 + ORCA ;*ORCA SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESUTL IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B10300: SETZ ;PRELOAD AC WITH 0 + ORCA [-1] ;*ORCA SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND C(E). +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B10400: SETO ;PRELOAD AC WITH -1,,-1 + ORCA [0] ;*ORCA SHOULD PLACE 0 IN THE AC + CAIE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E) +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE THE RESULT +;IN THE AC 070707,,-1. THE AC IS CHECKED FOR 070707,,-1. IF C(AC)=070707,,-1, +;THIS TEST PASSES + +B10500: MOVE [XWD -1,0] ;PRELOAD THE AC WITH -1,,0 + ORCB [707070707070] ;*ORCB SHOULD PLACE 070707,,-1 IN THE AC + CAME [XWD 070707,-1] ;PASS IF C(AC)=070707,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 SW: FCE +;707070,,0 SW: ET0 +;0,,-1 FC: AD AR + EN +;070707,,070707 FC: AD FM + EN +;070707,,070707 ET0: AR AD EN +;-1,,-1 ET0: AD AR - EN +;707070,,0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E) +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE THE RESULT +;IN THE AC -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, +;THIS TEST PASSES + +B10700: MOVE [XWD 0,-1] ;PRELOAD THE AC WITH 0,,-1 + ORCB [-1] ;*ORCB SHOULD PLACE -1,,0 IN THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)-1,,-1, THE TEST PASSES + +B11000: SETZ ;PRELOAD AC WITH 0 + ORCB [0] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES + +B11100: SETO ;PRELOAD AC WITH -1,,-1 + ORCB [-1] ;*ORCB SHOULD PLACE 0 IN THE AC + CAIE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E) +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES + +B11200: SETZ ;PRELOAD AC WITH 0 + ORCB [-1] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF +;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES + +B11300: SETO ;PRELOAD AC WITH -1,,-1 + ORCB [0] ;*ORCB SHOULD PLACE -1,,-1 IN THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +SUBTTL TEST OF MOVN INSTRUCTION + +;********** + +;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC +;IN THIS CASE C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0, THE NEGATIVE OF 0. IF C(AC)=0, THIS TEST PASSES + +B11500: SETO ;PRELOAD AC WITH -1,,-1 + MOVN [0] ;*MOVN SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;-1,,-1 FC: AD FM + EN +;-1,,-1 FC: AD CRY 36 + +;********** + +;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC. +;IN THIS CASE C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE 1,,0 +;THE AC IS CHECKED FOR 1,,0. IF C(AC)=1,,0, THE TEST PASSES + +B11600: MOVE [XWD -1,0] ;PRELOAD AC,E WITH -1,,0 + MOVN ;*MOVN SHOULD PLACE 1,,0 INTO THE AC + CAME [XWD 1,0] ;PASS IF C(AC)=1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD ADD +;0 FC: AD FM - EN +;0 FC: AD AR - EN +;-1,,0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC. +;IN THIS CASE C(E) =707070,,707070. HENCE, THE RESULT IN THE AC SHOULD BE +;070707,,070710. THE AC IS CHECKED FOR 070707,,070710. IF C(AC)= +;070707,,070710, THE TEST PASSES + +B11700: SETZ ;PRELOAD AC WITH 0 + MOVN [707070707070] ;*MOVN SHOULD PLACE 070707,,070710 INTO THE AC + CAME [070707070710] ;PASS IF C(AC) 070707,,070710 + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC +;IN THIS CASE C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0,,1. +;THE AC IS CHECKED FOR 0,,1, THE NEGATIVE OF -1,,-1. IF C(AC)=1, THIS TEST PASSES + +B12100: MOVN [-1] ;*MOVN SHOULD PLACE 0,,1 INTO THE AC + CAIE 1 ;PASS OF C(AC)=0,,1 + STOP + +;********** +SUBTTL TEST OF MOVM INSTRUCTION + +;********** + +;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC. +;IN THIS CASE, C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B12200: SETO ;PRELOAD AC WITH -1,,-1 + MOVM [0] ;*MOVM SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE + +;********** + +;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC +;IN THIS CASE, C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0,,1. +;THE AC IS CHECKED FOR 0,,1. IF C(AC)=0,,1, THIS TEST PASSES + +B12300: SETZ ;PRELOAD AC WITH 0 + MOVM [-1] ;*MOVM SHOULD PLACE 0,,1 INTO THE AC + CAIE 1 ;PASS IF C(AC)=0,,1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD FM + EN +;0 FC: AD ADD +;0 FC: AD CRY 36 +;0 FC: AD AR - EN +;-1,,-1 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC +;IN THIS CASE, C(E)=400000,,0. HENCE, THE RESULT IN THE AC SHOULD BE +;400000,,0. THE AC IS CHECKED FOR 400000,,0. +;IF C(AC)=400000,,0, THIS TEST PASSES. + +B12400: SETZ + MOVM [XWD 400000,0] ;*MOVM SHOULD PLACE 400000,,0 INTO THE AC + CAME [XWD 400000,0] ;PASS IF C(AC)=400000,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC +;IN THIS CASE, C(E)=377777,,-1. HENCE, THE RESULT IN THE AC SHOULD BE +;377777,,-1. THE AC IS CHECKED FOR 377777,,-1. +;IF C(AC)=377777,,-1, THIS TEST PASSES. + +B12500: SETZ ;PRELOAD AC WITH 0 + MOVM [XWD 377777,-1] ;*MOVM SHOULD PLACE 377777,,-1 INTO THE AC + CAME [XWD 377777,-1] ;PASS IF C(AC)=377777,,-1 + STOP + +;********** + JRST BEGEND diff --git a/apps/pdp10/diags/klad/dakab/README.md b/apps/pdp10/diags/klad/dakab/README.md new file mode 100644 index 000000000..73922a3cd --- /dev/null +++ b/apps/pdp10/diags/klad/dakab/README.md @@ -0,0 +1,274 @@ +--- +layout: page +title: PDP-10 KA10 Basic Instruction Diagnostic #2 +permalink: /apps/pdp10/diags/klad/dakab/ +machines: + - id: testka10 + type: pdp10 + config: /devices/pdp10/machine/ka10/test/debugger/machine.xml + debugger: true + commands: a 30724 DAKAB.MAC +--- + +PDP-10 KA10 Basic Instruction Diagnostic #2 +------------------------------------------- + +The *PDP-10 KA10 Basic Instruction Diagnostic #2* (MAINDEC-10-DAKAB-B-D) test code has been extracted from +[DAKABM.MAC](DAKABM.MAC.txt) [[original](http://pdp-10.trailing-edge.com/klad_sources/01/klad.sources/dakabm.mac.html)] +for use with the [PDP-10 Test Machine with Debugger](/devices/pdp10/machine/ka10/test/debugger/) below. + +Resources for this test include: + +- [Instructions](#dakabtxt) +- [History](#dakabhst) +- [Source Code](#dakabmac) +- [MACRO-10 Listing](DAKAB.LST.txt) +- [Additional Information](http://archive.pcjs.org/apps/pdp10/diags/klad/dakab/DAKAB.SEQ.txt) + +{% include machine.html id="testka10" %} + +The Debugger's assemble ("a") command can be used to test the new built-in +[MACRO-10 Mini-Assembler](/modules/pdp10/lib/macro10.js), which supports a subset +of the [MACRO-10](http://archive.pcjs.org/pubs/dec/pdp10/tops10/02_1973AsmRef_macro.pdf) assembly language. +This command: + + a 30724 DAKAB.MAC + +will automatically read the [DAKAB.MAC](DAKAB.MAC.txt) source file (a slightly modified copy of [DAKABM.MAC](DAKABM.MAC.txt)), +assemble it, and then load the binary output at the specified address. + +--- + +DAKAB.TXT +--------- + +``` +MAINDEC-10-DAKAB.TXT + + + + + + IDENTIFICATION + -------------- + + PRODUCT CODE: MAINDEC-10-DAKAB-B-D + + PRODUCT NAME: DECSYSTEM10 PDP-10 KA10 BASIC + INSTRUCTION DIAGNOSTIC (2) + + FUNCTION: BASIC INSTRUCTIONS 2 + + VERSION: 0.2 + + DATE RELEASED: JANUARY 1977 + + MAINTAINED BY: DIAGNOSTIC ENGINEERING GROUP + + AUTHOR: JOHN R. KIRCHOFF + +COPYRIGHT(C) 1976,1977 +DIGITAL EQUIPMENT CORPORATION +MARLBORO, MASS. 01752 + +THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY +ON A SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH +THE INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE, +OR ANY OTHER COPIES THEREOF, MAY NOT BE PROVIDED OR OTHERWISE +MADE AVAILABLE TO ANY OTHER PERSON EXECPT FOR USE ON SUCH SYSTEM +AND TO ONE WHO AGREES TO THESE LICENSE TERMS. TITLE TO AND +OWNERSHIP OF THE SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC. + +THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE WITHOUT +NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL +EQUIPMENT CORPORATION. + +DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS +SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC. + MAINDEC-10-DAKAB.TXT + PAGE 2 + + + TABLE OF CONTENTS + ----------------- + +1.0 ABSTRACT + +2.0 REQUIREMENTS + +2.1 EQUIPMENT + +2.2 STORAGE + +2.3 PRELIMINARY PROGRAMS + +3.0 PROGRAM PROCEDURES + +3.1 LOADING PROCEDURE + +3.2 STARTING PROCEDURE + +3.3 OPERATING PROCEDURE + +4.0 ERRORS + +5.0 ITERATION COUNTER + +6.0 CYCLE TIME + +7.0 OPERATIONAL VARIATIONS + +8.0 MISCELLANEOUS + +9.0 LISTING + MAINDEC-10-DAKAB.TXT + PAGE 3 + + +1.0 ABSTRACT + + THIS PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC IS THE + SECOND IN A SERIES OF PDP-10 KA10 PROCESSOR DIAGNOSTICS. + THE DIAGNOSTIC TESTS SOME FOLLOWING INSTRUCTIONS. + MOVE, COMPARE, TEST, HALF WORD AND BOOLE. + IT ALSO TESTS THE ADDERS USING ADD AND COMPARE INSTRUCTIONS. + +2.0 REQUIREMENTS + +2.1 EQUIPMENT + + A PDP-10 KA10 WITH A MINIMUM OF 32K OF MEMORY + + PAPER TAPE READER + DECTAPE (OPTIONAL) + CONSOLE TELETYPE + +2.2 STORAGE + + THE PROGRAM RUNS WITHIN 32K OF MEMORY. + +2.3 PRELIMINARY PROGRAMS + + CONSOLE FUNCTIONS WORKING PROPERLY + PAPER TAPE OR DECTAPE READ-IN WORKING PROPERLY + PREVIOUS PROCESSOR DIAGNOSTICS + MAINDEC-10-DAKAB.TXT + PAGE 4 + + +3.0 PROGRAM PROCEDURES + +3.1 LOADING PROCEDURE + + PAPER TAPE - HARDWARE READ-IN (READER DEVICE CODE 104) + DECTAPE - LOAD WITH DIAMON (DECTAPE DEVICE CODE 320) + +3.2 STARTING PROCEDURE + + STAND-ALONE STARTING ADDRESS IS 30000. + + IF THE DIAGNOSTIC FAILS TO START CORRECTLY TRY STARTING AT THE + FIRST TEST INSTEAD OF AT THE BEGINNING OF THE CONTROL SEQUENCE. + (SEE LISTING). + +3.3 OPERATING PROCEDURE + + ONCE STARTED THE PROGRAM WILL CYCLE CONTINUALLY UNTIL STOPPED + OR AN ERROR OCCURS. + +4.0 ERRORS + + ERRORS ARE IN THE FORM OF HALT INSTRUCTIONS. THE LISTING + SHOULD BE CONSULTED TO DETERMINE THE CAUSE OF THE ERROR. A + NO OPERATION (JUMP) INSTRUCTION FOLLOWS EACH HALT. THIS + MAY BE USEFUL IN CONSTRUCTING A SCOPE LOOP TO CYCLE ON THE + FAILING INSTRUCTION. + +5.0 ITERATION COUNTER + + THE ITERATION COUNT OF THE PROGRAM IS DISPLAYED IN THE MEM- + ORY INDICATORS (MI). THIS COUNT IS A DECREMENTING COUNT AND + INITIALLY STARTS AT -1 IN STAND-ALONE OPERATION. + +6.0 CYCLE TIME + + THE CYCLE TIME OF THE PROGRAM IS IN THE MILLISECOND RANGE AND + IS THEREFORE SUITABLE FOR TAKING MARGINS, VIBRATION TESTS, ETC. + + MAINDEC-10-DAKAB.TXT + PAGE 5 + + +7.0 OPERATIONAL VARIATIONS + + A. DIAGNOSTIC MONITOR + + THE PROGRAM IS USABLE WITH THE DIAGNOSTIC MONITOR TO PRO- + VIDE RELIABILITY TESTS, ACCEPTANCE TESTS, AND/OR TO PRO- + VIDE A QUICK METHOD OF ISOLATION OF A FAULT TO A PARTICULAR + AREA OF THE PROCESSOR. CERTAIN PROCEDURES ARE USED WHEN + THE PROGRAM IS USED IN THIS MANNER. THEY ARE: + + 1. THE DIAGNOSTIC MONITOR TRANSFERS CONTROL TO THE PRO- + GRAM AND STARTS IT AT LOCATION 30002. + + 2. MONCTL - LOCATION 30043 IS USED AS THE DIAGNOSTIC MON- + ITOR CONTROL FLAG WORD. + + B. USER MODE + + THE PROGRAM WILL OPERATE IN USER MODE AND AS SUCH PROVIDES + ASSURANCE THAT THE PROCESSOR IS PERFORMING ALL FUNCTIONS + CORRECTLY. USER MODE STARTING ADDRESS IS 30000. + + C. SYSTEM EXERCISER + + STARTING ADDRESS IS 30003. NO DATA SWITCHES ARE USED BY + THIS PROGRAM. + +8.0 MISCELLANEOUS + + NONE + +9.0 LISTING +``` + +DAKAB.HST +--------- + + THIS IS A HISTORY OF THE DEVELOPMENT OF MAINDEC-10-DAKAB + + ************************************************************************ + + PRODUCT CODE: MAINDEC-10-DAKAB + + PRODUCT NAME: BASIC INSTRUCTION DIAGNOSTIC #2 + + DATE RELEASED: JANUARY 1977 + + VERSION: 0.2 + + UPDATE AUTHOR: JOHN R. KIRCHOFF + + CHANGES MADE: + + 1. UPGRADE TO ALLOW COMPATABILITY WITH THE SUBROUTINE PACKAGE. + + ************************************************************************ + + ORIGINAL VERSION: 0.1 + + ORIGINAL AUTHOR: RICHARD MALISKA + + ORIGINAL RELEASE: 16-MAR-72 + + ************************************************************************ + +DAKAB.MAC +--------- + +[[Download](DAKAB.MAC.txt)] + +{% highlight text %} +{% include_relative DAKAB.MAC.txt %} +{% endhighlight %} diff --git a/apps/pdp10/diags/klad/dakac/DAKAC.LST.txt b/apps/pdp10/diags/klad/dakac/DAKAC.LST.txt new file mode 100644 index 000000000..918bf80ac --- /dev/null +++ b/apps/pdp10/diags/klad/dakac/DAKAC.LST.txt @@ -0,0 +1,7750 @@ +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 1 +DAKACT MAC 19-JAN-77 13:36 DIAGNOSTIC PARAMETERS SEQ 0007 + + 1 ;DAKAC + 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 DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 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 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 2 +DAKACT MAC 19-JAN-77 13:36 DIAGNOSTIC PARAMETERS SEQ 0008 + + 30 SUBTTL DIAGNOSTIC PARAMETERS + 31 ;PARAMETER DEFINITIONS + 32 000001 EXCASB==1 + 33 000001 USRASB==1 + 34 000001 PGMEND==1 + 35 000100 DEBUG==100 + 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 030741 SADR1=STARTA + 55 030741 SADR2=STARTA + 56 030741 SADR3=STARTA + 57 030741 SADR4=STARTA + 58 254000 030741 SADR5=JRST STARTA + 59 254000 030741 SADR6=JRST STARTA + 60 254000 030741 SADR7=JRST STARTA + 61 254000 030741 SADR8=JRST STARTA + 62 254000 030741 SADR9=JRST STARTA + 63 254000 030741 SADR10=JRST STARTA + 64 254000 030741 SADR11=JRST STARTA + 65 + 66 000000 PAREA0=0 + 67 000000 PAREA1=0 + 68 000000 PAREA2=0 + 69 444153 414300 PAREA3=SIXBIT/DAKAC/ + 70 645560 000000 PAREA4=SIXBIT/TMP/ + 71 000000 PAREA5=0 + 72 000000 PAREA6=0 + 73 001000 ITERAT==1000 + 74 000001 PGMEND==1 + 75 .DIRECTIVE .OKOVL +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 1 +PARAM KLM 18-JAN-77 11:38 *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, JAN 18,1977 SEQ 0009 + + 76 SUBTTL *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, JAN 18,1977 + 77 + 78 DEFINE S,<;*********************************************************************> + 79 + 80 S^;*********************************************************************^ + 81 ;*DATA SWITCHES (READ FROM CONSOLE IN EXEC MODE OR TYPED IN IN USER MODE) + 82 ;*LEFT HALF SWITCHES ARE PRE-ASSIGNED FOR SUBROUTINE PACKAGE USE + 83 ;*AND CONTROL LOOPING, PRINTING (TTY OR OTHER DEVICE) AND MISC. FUNCTIONS + 84 S^;*********************************************************************^ + 85 + 86 400000 ABORT== 400000 ;ABORT PROGRAM ON PASS COMPLETION + 87 200000 RSTART==200000 ;RESTART TEST, PRINT TOTALS + 88 100000 TOTALS==100000 ;PRINT TOTALS, CONTINUE + 89 + 90 040000 NOPNT== 040000 ;INHIBIT ALL PRINT/TYPE OUT (EXCEPT FORCED) + 91 020000 PNTLPT==020000 ;PRINT ALL DATA ON LPT (LOGICAL DEVICE, USER MODE) + 92 010000 DING== 010000 ;RING BELL ON ERROR + 93 + 94 004000 LOOPER==004000 ;ENTER EXERCISE/CHECK LOOP ON ERROR + 95 002000 ERSTOP==002000 ;HALT ON TEST ERROR + 96 001000 PALERS==001000 ;PRINT ALL ERRORS + 97 + 98 000400 RELIAB==000400 ;RELIABILITY MODE + 99 000200 TXTINH==000200 ;INHIBIT ERROR TEXT + 100 000100 INHPAG==000100 ;INHIBIT PAGING + 101 + 102 000040 MODDVC==000040 ;MODIFY DEVICE CODE + 103 000020 INHCSH==000020 ;INHIBIT CACHE + 104 000010 OPRSEL==000010 ;OPERATOR SELECTION + 105 + 106 000004 CHAIN== 000004 ;CHAIN CONTROL SWITCH + 107 + 108 000002 KAHZ50==000002 ;KA10 50 HERTZ POWER + 109 + 110 ;SWITCH 17 RESERVED !!! +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 2 +PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0010 + + 111 SUBTTL *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 + 112 + 113 S^;*********************************************************************^ + 114 ;*SPECIAL SUBPROGRAM LINKAGES + 115 S^;*********************************************************************^ + 116 + 117 027772 FSELNK= 27772 ;FILE SELECT LINK + 118 027773 FRDLNK= 27773 ;FILE READ LINK + 119 027774 LDLNK= 27774 ;LOAD LINKAGE ADDRESS + 120 027775 DDTLNK= 27775 ;DDT LINKAGE ADDRESS + 121 027776 MODLNK= 27776 ;OPERATIONAL MODE CHECK LINKAGE ADDRESS + 122 027777 SUBLNK= 27777 ;SUBROUTINE LINKAGE ADDRESS + 123 + 124 S^;*********************************************************************^ + 125 ;*SPECIAL SUBROUTINE FATAL HALTS + 126 ;*USED TO REPORT ERRORS THAT CAUSE THE SUBROUTINES TO BE UNUSABLE + 127 S^;*********************************************************************^ + 128 + 129 ;ADDRESS TAG REASON + 130 ;--------------------- + 131 + 132 ; 1010 NOEXEC ;PROGRAM NOT CODED FOR EXEC MODE OPERATION + 133 ; 1011 PLERR ;FATAL PUSH LIST POINTER ERROR + 134 ; 1012 PLERR1 ;INITIAL PUSH LIST POINTER ERROR + 135 ; 1013 MUOERR ;MUUO WITH LUUO HANDLER WIPED OUT + 136 ; 1014 DTEBER ;DTE20 INTERRUPT WITHOUT DOORBELL + 137 ; 1015 DTECER ;DTE20 CLOCK INTERRUPT WITHOUT FLAG SET + 138 ; 1016 CPIERR ;CPU INITIALIZATION ERROR + 139 ; 1017 EOPERR ;END OF PROGRAM ERROR + 140 ; 1020 LUOERR ;INTERRUPT WITH LUUO HANDLER WIPED OUT + 141 + 142 S^;*********************************************************************^ +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 3 +PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0011 + + 143 S^;*********************************************************************^ + 144 ;OPERATOR DEFINITIONS (NON-UUO'S) + 145 S^;*********************************************************************^ + 146 + 147 260740 000000 OPDEF GO [PUSHJ P,] ;SUBROUTINE CALL + 148 263740 000000 OPDEF RTN [POPJ P,] ;SUBROUTINE RETURN + 149 261740 000000 OPDEF PUT [PUSH P,] ;PUT DATA ON PUSH LIST + 150 262740 000000 OPDEF GET [POP P,] ;GET DATA FROM PUSH LIST + 151 254000 000000 OPDEF PJRST [JRST ] ;JRST TO ROUTINE THAT RTN'S + 152 254200 000000 OPDEF HALT [JRST 4,] ;DEFINITION FOR DDT + 153 254100 000000 OPDEF JRSTF [JRST 2,] ;DEFINITION FOR DDT + 154 254500 000000 OPDEF JEN [JRST 12,] ;DEFINITION FOR DDT + 155 + 156 S^;*********************************************************************^ + 157 ;*SUBROUTINE INITIALIZATION CALL + 158 S^;*********************************************************************^ + 159 + 160 265000 030011 OPDEF PGMINT [JSP 0,SBINIT] ;SUBROUTINE INITIALIZATION + 161 + 162 S^;*********************************************************************^ + 163 ;*HALTING UUO'S (A MORE GRACEFUL HALT THAN SIMPLY USING THE HALT INSTRUCTION). + 164 S^;*********************************************************************^ + 165 + 166 037640 000004 OPDEF FATAL [37B8!15B12!4] ;FATAL PROGRAMMING HALT + 167 037600 000004 OPDEF ERRHLT [37B8!14B12!4] ;PROGRAM ERROR HALT + 168 + 169 S^;*********************************************************************^ + 170 ;*TERMINAL INPUT UUO'S + 171 ;*ALWAYS COME FROM THE CONSOLE TERMINAL IN EXEC MODE OR THE + 172 ;*CONTROLLING TERMINAL (REAL TERMINAL OR PTY) IN USER MODE. + 173 S^;*********************************************************************^ + 174 + 175 037000 000003 OPDEF TTICHR [37B8!0B12!3] ;TTY, INPUT ANY CHARACTER + 176 037040 000003 OPDEF TTIYES [37B8!1B12!3] ;TTY, NORMAL RETURN Y + 177 037100 000003 OPDEF TTINO [37B8!2B12!3] ;TTY, NORMAL RETURN N + 178 037140 000003 OPDEF TTIOCT [37B8!3B12!3] ;TTY, INPUT OCTAL WORD + 179 037200 000003 OPDEF TTIDEC [37B8!4B12!3] ;TTY, INPUT DECIMAL WORD + 180 037240 000003 OPDEF TTICNV [37B8!5B12!3] ;TTY, INPUT CONVERTABLE WORD + 181 037300 000003 OPDEF TTLOOK [37B8!6B12!3] ;TTY, KEYBOARD CHECK + 182 037340 000003 OPDEF TTALTM [37B8!7B12!3] ;TTY, ALT-MODE CHECK + 183 037400 000003 OPDEF TTSIXB [37B8!10B12!3] ;TTY, INPUT SIXBIT WORD + 184 037440 000003 OPDEF TTYINP [37B8!11B12!3] ;TTY, IMAGE MODE INPUT +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 4 +PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0012 + + 185 ;*TERMINAL OUTPUT UUO'S. + 186 + 187 037000 000000 OPDEF PNTA [37B8!0B12!0] ;PRINT ASCII WORD + 188 037000 000001 OPDEF PNTAF [37B8!0B12!1] ;PRINT ASCII WORD FORCED + 189 037740 000000 OPDEF PNTAL [37B8!17B12!0] ;PRINT ASCIZ LINE + 190 037740 000001 OPDEF PNTALF [37B8!17B12!1] ;PRINT ASCIZ LINE FORCED + 191 037600 000003 OPDEF PSIXL [37B8!14B12!3] ;PRINT SIXBIT'Z LINE + 192 037640 000003 OPDEF PSIXLF [37B8!15B12!3] ;PRINT SIXBIT'Z LINE FORCED + 193 037000 000000 OPDEF PNTMSG [37B8!0B12!0] ;PRINT MESSAGE IMMEDIATE + 194 037040 000000 OPDEF PNTMSF [37B8!1B12!0] ;PRINT MESSAGE IMMEDIATE FORCED + 195 037100 000000 OPDEF PSIXM [37B8!2B12!0] ;PRINT SIXBIT'Z MSG IMMEDIATE + 196 037200 000000 OPDEF PSIXMF [37B8!4B12!0] ;PRINT SIXBIT'Z MSG IMM FORCED + 197 037000 000000 OPDEF PNTCI [37B8!0B12!0] ;PRINT CHARACTER IMMEDIATE + 198 037040 000000 OPDEF PNTCIF [37B8!1B12!0] ;PRINT CHARACTER IMMEDIATE FORCED + 199 037500 000000 OPDEF PNTCHR [37B8!12B12!0] ;PRINT CHARACTER + 200 037500 000001 OPDEF PNTCHF [37B8!12B12!1] ;PRINT CHARACTER FORCED + 201 037040 000000 OPDEF PNT1 [37B8!1B12!0] ;PRINT ONE OCTAL DIGIT + 202 037040 000001 OPDEF PNT1F [37B8!1B12!1] ;PRINT 1 OCTAL DIGIT FORCED + 203 037100 000000 OPDEF PNT2 [37B8!2B12!0] ;PRINT TWO OCTAL DIGITS + 204 037100 000001 OPDEF PNT2F [37B8!2B12!1] ;PRINT 2 OCTAL DIGITS FORCED + 205 037140 000000 OPDEF PNT3 [37B8!3B12!0] ;PRINT THREE OCTAL DIGITS + 206 037140 000001 OPDEF PNT3F [37B8!3B12!1] ;PRINT THREE OCTAL DIGITS FORCED + 207 037200 000000 OPDEF PNT4 [37B8!4B12!0] ;PRINT FOUR OCTAL DIGITS + 208 037200 000001 OPDEF PNT4F [37B8!4B12!1] ;PRINT FOUR OCTAL DIGITS FORCED + 209 037240 000000 OPDEF PNT5 [37B8!5B12!0] ;PRINT FIVE OCTAL DIGITS + 210 037240 000001 OPDEF PNT5F [37B8!5B12!1] ;PRINT FIVE OCTAL DIGITS FORCED + 211 037300 000000 OPDEF PNT6 [37B8!6B12!0] ;PRINT SIX OCTAL DIGITS + 212 037300 000001 OPDEF PNT6F [37B8!6B12!1] ;PRINT SIX OCTAL DIGITS FORCED + 213 037340 000000 OPDEF PNT7 [37B8!7B12!0] ;PRINT 7 OCTAL DIGITS + 214 037340 000001 OPDEF PNT7F [37B8!7B12!1] ;PRINT 7 OCTAL DIGITS FORCED + 215 037440 000000 OPDEF PNT11 [37B8!11B12!0] ;PRINT 11 OCTAL DIGITS + 216 037440 000001 OPDEF PNT11F [37B8!11B12!1] ;PRINT 11 OCTAL DIGITS FORCED. + 217 037400 000000 OPDEF PNTADR [37B8!10B12!0] ;PRINT PHYSICAL ADDRESS + 218 037400 000001 OPDEF PNTADF [37B8!10B12!1] ;PRINT PHYSICAL ADDRESS FORCED + 219 037600 000000 OPDEF PNTOCT [37B8!14B12!0] ;PRINT FULL WORD OCTAL + 220 037600 000001 OPDEF PNTOTF [37B8!14B12!1] ;PRINT FULL WORD OCTAL FORCED + 221 037540 000000 OPDEF PNTHW [37B8!13B12!0] ;PRINT OCTAL HALF WORDS, 6 SP 6 + 222 037540 000001 OPDEF PNTHWF [37B8!13B12!1] ;PRINT OCTAL HALF WORDS, 6 SP 6 FORCED + 223 037700 000003 OPDEF PNTOCS [37B8!16B12!3] ;PRINT OCTAL, SUPPRESS LEADING 0'S + 224 037740 000003 OPDEF PNTOCF [37B8!17B12!3] ;PRINT OCTAL, SUPPRESS LEADING 0'S FORCED + 225 037640 000000 OPDEF PNTDEC [37B8!15B12!0] ;PRINT DECIMAL, SUPRESS LEADING 0'S + 226 037640 000001 OPDEF PNTDCF [37B8!15B12!1] ;PRINT DECIMAL, SUPRESS LEADING 0'S FORCED + 227 037700 000000 OPDEF PNTDS [37B8!16B12!0] ;PRINT DECIMAL, SPACES FOR LD 0'S + 228 037700 000001 OPDEF PNTDSF [37B8!16B12!1] ;PRINT DECIMAL, SPACES FOR LD 0'S FORCED + 229 037200 000002 OPDEF PNTNM [37B8!4B12!2] ;PRINT PROGRAM NAME + 230 037000 000002 OPDEF PNTSIX [37B8!0B12!2] ;PRINT SIXBIT WORD + 231 037040 000002 OPDEF PNTSXF [37B8!1B12!2] ;PRINT SIXBIT WORD FORCED + 232 037240 000002 OPDEF DROPDV [37B8!5B12!2] ;CLOSE LOGICAL FILE, USER MODE + 233 037100 000002 OPDEF PNTCW [37B8!2B12!2] ;PRINT DF10 CONTROL WORD + 234 037140 000002 OPDEF PNTCWF [37B8!3B12!2] ;PRINT DF10 CONTROL WORD FORCED + 235 037000 030242 OPDEF PCRL [37B8!0B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED + 236 037040 030242 OPDEF PCRLF [37B8!1B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED FORCED + 237 037000 000040 OPDEF PSP [37B8!0B12!40] ;PRINT SPACE + 238 037040 000040 OPDEF PSPF [37B8!1B12!40] ;PRINT SPACE FORCED + 239 037000 030243 OPDEF PCRL2 [37B8!0B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE) +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 4-1 +PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0013 + + 240 037040 030243 OPDEF PCRL2F [37B8!1B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE) FORCED + 241 037040 000007 OPDEF PBELL [37B8!1B12!7] ;PRINT TTY BELL + 242 + 243 037040 000026 OPDEF PFORCE [37B8!1B12!26] ;PRINT FORCE, CONTROL O OVERRIDE + 244 + 245 DEFINE PMSG (ARG),< + 246 PSIXM [SIXBIT\ARG'_\]> + 247 + 248 DEFINE PMSGF (ARG),< + 249 PSIXMF [SIXBIT\ARG'_\]> + 250 + 251 ;*SIXBTZ -- MACRO TO GENERATE SIXBIT DATA FOR PRINTING + 252 ;* CONSERVES CORE OVER ASCIZ + 253 + 254 DEFINE SIXBTZ (ARG),< [SIXBIT\ARG'_\]> + 255 + 256 ;*CONSOLE SWITCH INPUT UUO. + 257 ;*READS CONSOLE SWITCHES IF IN EXEC MODE OR ASKS FOR THEM IF + 258 ;* USER MODE. + 259 + 260 037400 000002 OPDEF SWITCH [37B8!10B12!2] ;INPUT CONSOLE SWITCHES + 261 + 262 ;*CLOCK INITIALIZATION UUO - TO SET DESIRED CLOCK OPERATION + 263 ;*EITHER IGNORE CLOCK, ONLY LET IT TICK OR CAUSE INTERRUPT TO OCCUR. + 264 + 265 037540 000004 OPDEF CLOKOP [37B8!13B12!4] ;CLOCK OPERATION UUO - PDP-11 CLOCK + 266 037200 000004 OPDEF MTROP [37B8!4B12!4] ;CLOCK OPERATION UUO - DK20 METER + 267 + 268 ;*KL10 ONLY CACHE OPERATION UUO'S + 269 + 270 037040 000004 OPDEF CINVAL [37B8!1B12!4] ;CACHE INVALIDATE + 271 037100 000004 OPDEF CFLUSH [37B8!2B12!4] ;CACHE FLUSH + 272 037140 000004 OPDEF CWRTBI [37B8!3B12!4] ;CACHE WRITE-BACK & INVALIDATE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 5 +PARAM KLM 18-JAN-77 11:38 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977 SEQ 0014 + + 273 ;*END OF PASS/PROGRAM UUOS + 274 + 275 ;PERFORMS THE END OF PASS FUNCTIONS. INCREMENT PASS COUNT, + 276 ;*DECREMENT ITERATION COUNT, CHECK IF FINISHED WITH THIS PROGRAM ETC. + 277 + 278 037500 000004 OPDEF ENDUUO [37B8!12B12!4] ;UUO TO DISPLAY LIGHTS + 279 037700 000004 OPDEF EOPUUO [37B8!16B12!4] ;END OF PROGRAM UUO + 280 + 281 ;*MEMORY MANAGEMENT UUO'S + 282 ;*UUO'S TO PERFORM VARIOUS MEMORY FUNCTIONS. MAPPING, ZEROING, PAGING, + 283 ;*ADDRESS CONVERSION, ETC... + 284 + 285 037000 000004 OPDEF MAPMEM [37B8!0B12!4] ;MAP MEMORY + 286 037500 000002 OPDEF MEMZRO [37B8!12B12!2] ;ZERO MEMORY + 287 037440 000002 OPDEF MEMSEG [37B8!11B12!2] ;SETUP MEMORY SEGMENT + 288 037540 000002 OPDEF MAPADR [37B8!13B12!2] ;VIRTUAL TO PHYSICAL ADR CONVERT + 289 037640 000002 OPDEF MAPCNK [37B8!15B12!2] ;MAP MEMORY CHUNK + 290 037600 000002 OPDEF MAPSET [37B8!14B12!2] ;SET KI10 EXEC PAGE MAP + 291 037740 000002 OPDEF MAPPNT [37B8!17B12!2] ;PRINT MEMORY MAP + 292 + 293 ;*DEVICE CODE MODIFICATION UUO + 294 ;*ALLOWS THE MODIFICATION OF IOT'S TO ONE DEVICE TO BE CHANGED TO + 295 ;*IOT'S TO A DIFFERENT DEVICE CODE. + 296 + 297 037340 000002 OPDEF MODPCU [37B8!7B12!2] ;MODIFY PERHIPERAL CODE, USER + 298 037300 000002 OPDEF MODPCP [37B8!6B12!2] ;MODIFY PERHIPERAL CODE, PROGRAM + 299 + 300 030000 IFNDEF MODDVL, + 301 030000 IFNDEF MODDVU, + 302 + 303 ;*"DIAMON" FILE SELECTION AND READ UUOS + 304 + 305 037240 000004 OPDEF FSELECT [37B8!5B12!4] ;FILE SELECTION + 306 037300 000004 OPDEF FREAD [37B8!6B12!4] ;FILE READ - ASCII DATA + 307 037340 000004 OPDEF FRD36 [37B8!7B12!4] ;FILE READ - 36 BIT DATA + 308 037400 000004 OPDEF FRD8 [37B8!10B12!4] ;FILE READ - 8 BIT DATA + 309 + 310 ;*KI10 ONLY UUO FOR PRINTING MARGIN VALUES + 311 + 312 037700 000002 OPDEF PNTMGN [37B8!16B12!2] ;PRINT MARGIN VALUE + 313 + 314 XLIST + 315 IFNDEF KLOLD, + 341 + 342 ;*A MACRO TO REPORT AN ERROR AND NOT LOOP + 343 + 344 DEFINE ERROR1 (FORMAT,CORECT,ACTUAL,F,D,ERR)< + 345 SALL + 346 ERUUO FORMAT,[T,,[SIXBIT\F'_\] + 347 CORECT,,ACTUAL + 348 [SIXBIT\D'_\],,ERR] + 349 XALL > + 350 + 351 >;END OF KLOLD CONDITIONAL + 352 + 353 XLIST + 354 LIST +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 1 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0016 + + 355 SUBTTL *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 + 356 + 357 030000 LOC 30000 + 358 + 359 S^;*********************************************************************^ + 360 ;*PROGRAM STARTING ADDRESSES + 361 ;*THESE ADDRESSES CALL VARIOUS SPECIAL START ROUTINES AND OR OPTIONS + 362 ;*NORMAL START ADDRESS IS 30000 ALL OTHERS ARE SPECIAL. INVOKED BECAUSE + 363 ;*OF END OF PASS, POWER FAILURE, DDT START, RE-ENTERING(TYPICALLY USER + 364 ;*MODE), OR ANY NUMBER OF SPECIAL FEATURE TESTS. + 365 S^;*********************************************************************^ + 366 + 367 030000 254 00 1 00 027776 BEGIN: JRST @MODLNK ;STAND-ALONE START + 368 030001 254 00 0 00 030712 $START: JRST START ;MODE CHECK STARTING ADDRESS + 369 + 370 030002 254 00 1 00 027774 DIAGMN: JRST @LDLNK ;DIAGNOSTIC MONITOR START + 371 + 372 030003 254 00 1 00 027774 SYSEXR: JRST @LDLNK ;SYSTEM EXERCISER START + 373 + 374 030004 254 00 0 00 030741 SFSTRT: JRST SADR1 ;SPECIAL FEATURE START + 375 + 376 030005 254 00 0 00 030741 PFSTRT: JRST SADR2 ;POWER FAIL RESTART + 377 + 378 030006 254 00 0 00 030741 REENTR: JRST SADR3 ;REENTER START(USUALLY USER MODE ONLY) + 379 + 380 030007 SRTDDT: ;COMMONLY MISTAKEN NAME FOR "DDTSRT" + 381 030007 254 00 1 00 027775 DDTSRT: JRST @DDTLNK ;DDT START + 382 + 383 030010 254 00 0 00 030741 BEGIN1: JRST STARTA ;LOOP START(END OF PASS COMES HERE) + 384 030011 254 00 1 00 027777 SBINIT: JRST @SUBLNK ;PMGINT LINKAGE + 385 030012 000000 000000 RETURN: 0 ;RETURN ADDRESS STORAGE + 386 + 387 030013 254000 030741 START1: SADR7 ;OPTIONAL STARTING ADR/INSTRUCTIONS + 388 030014 254000 030741 START2: SADR8 ; " + 389 030015 254000 030741 START3: SADR9 ; " + 390 030016 254000 030741 START4: SADR10 ; " + 391 030017 254000 030741 START5: SADR11 ; " +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 2 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0017 + + 392 S^;*********************************************************************^ + 393 ;*PROGRAM FIXED PARAMETER AREA + 394 S^;*********************************************************************^ + 395 + 396 030020 444153 414300 PNTNAM: PAREA3 ;SIXBIT PROGRAM NAME + 397 030021 645560 000000 PNTEXT: PAREA4 ;SIXBIT PROGRAM EXTENSION + 398 030022 000000 000000 RANDBS: PAREA1 ;RANDOM BASE NUMBER + 399 030023 000000 000000 SWTEXR: PAREA2 ;SYSTEM EXERCISER SWITCHES + 400 030024 000000 001000 ITRCNT: ITERAT ;PROGRAM ITERATIONS + 401 030025 000000 030725 $PNAME: PGMNAM ;POINTER TO PROGRAMS NAME + 402 030026 000000 000002 $PVER: MCNVER,,DECVER ;MCN & DEC VERSION LEVEL + 403 030027 000000 030000 $MODVL: MODDVL ;DEVICE CODE CHANGE LOWER LIMIT + 404 030030 000000 030000 $MODVU: MODDVU ;DEVICE CODE CHANGE UPPER LIMIT + 405 030031 777777 777777 $EMODE: IFNDEF EXCASB,<0> IFDEF EXCASB,<-1> ;EXEC ALLOWED + 406 030032 777777 777777 $UMODE: IFNDEF USRASB,<0> IFDEF USRASB,<-1> ;USER ALLOWED + 407 030033 000000 000000 $DSKUP: IFNDEF DSKUPD,<0> IFDEF DSKUPD,<-1> ;DISK UPDATE MODE + 408 030034 000000 000000 $MMAP: IFNDEF MEMMAP,<0> IFDEF MEMMAP,<-1> ;ALLOW MEMORY RTNS + 409 030035 000000 000000 PAREA7: PAREA5 ;OPTIONAL PARAMETER + 410 030036 000000 000000 PAREA8: PAREA6 ;OPTIONAL PARAMETER + 411 + 412 S^;*********************************************************************^ + 413 ;*PROGRAM VARIABLE PARAMETER AREA + 414 S^;*********************************************************************^ + 415 + 416 030037 000000 000000 USER: 0 ; 0 = EXEC, -1 = USER MODE FLAG + 417 030040 000000 000000 KAIFLG: 0 ;PROCESSOR TYPE, 0 = KA10, -1 = KI10 + 418 030041 000000 000000 KLFLG: 0 ;PROCESSOR TYPE, 0 = KA/KI, -1 = KL10 + 419 030042 777777 777777 MONFLG: -1 ;DIAG MONITOR SPECIAL USER FLAG + 420 030043 000000 000000 MONCTL: 0 ;DIAG MON/SYS EXR FLAG + 421 030044 000000 000000 MONTEN: 0 ;-1= LOADED BY 10 + 422 030045 000000 000000 CLOCKF: 0 ;CLOCK TICKED FLAG + 423 030046 000000 000000 CONSW: 0 ;CONSOLE SWITCH SETTINGS + 424 030047 000000 000000 PASCNT: 0 ;PROGRAM PASS COUNT + 425 030050 000000 000000 RUNFLG: 0 ;PROGRAM RUN FLAG + 426 030051 000000 000000 TESTPC: 0 ;SUBTEST PC + 427 030052 000000 000000 ERRPC: 0 ;ERROR PC + 428 030053 000000 000000 ERRTLS: 0 ;ERROR TOTALS + 429 030054 000000 000000 TICKS: 0 ;PROGRAM RUNNING TIME + 430 030055 000000 000000 MARGIN: 0 ;KI10 MARGIN WORD VALUE + 431 030056 000000 000000 $ONETM: 0 ;SUBROUTINE INITIALIZATION FLAG +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 3 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0018 + + 432 S^;*********************************************************************^ + 433 ;*SPECIAL PROGRAM DISPATCH ADDRESSES + 434 S^;*********************************************************************^ + 435 + 436 030057 037 12 0 00 000004 BEGEND: ENDUUO ;END OF PASS + 437 030060 254 00 0 00 030010 $BEND1: JRST BEGIN1 ;KEEP RUNNING PROGRAM + 438 030061 037 16 0 00 000004 $BEND2: EOPUUO ;END OF PROGRAM - NO RETURN + 439 030062 254000 030741 CNTLC: SADR5 ;CONTROL C XFER ADDRESS + 440 030063 254000 030741 ALTMGO: SADR6 ;ALTMODE XFER ADDRESS + 441 030064 CPOPJ1: ;SKIP RETURN + 442 030064 350 00 0 17 000000 UUOSKP: AOS (P) ;SKIP RETURN FROM UUO + 443 030065 CPOPJ: ;NON-SKIP REGULAR RETURN + 444 030065 263 17 0 00 000000 UUOEXT: RTN ;UUO RETURN + 445 030066 255 00 0 00 000000 UUORTN: JFCL ;ADDITIONAL USERS UUO ROUTINE + 446 030067 255 00 0 00 000000 $UORTX: JFCL ;ADDITIONAL UUO LINKAGE + 447 030070 255 00 0 00 000000 $UUOER: JFCL ;INITED AS (JRST $UOERX) + 448 030071 255 00 0 00 000000 $ITRHL: JFCL ;ADDITIONAL INTERRUPT LINKAGE + 449 030072 255 00 0 00 000000 $ITRX1: JFCL ; " + 450 030073 255 00 0 00 000000 $USRHL: JFCL ; " + 451 030074 255 00 0 00 000000 $RSRTX: JFCL ;ADDITIONAL POWER FAIL LINKAGE + 452 030075 255 00 0 00 000000 $RSRTY: JFCL ; " + 453 030076 255 00 0 00 000000 RESRT1: JFCL ; INITED AS (JRST RESRTX) + 454 030077 255 00 0 00 000000 RESRT2: JFCL ; " + 455 030100 255 00 0 00 000000 $PARER: JFCL ;ADDITIONAL PARITY ERROR LINKAGE + 456 030101 255 00 0 00 000000 ERMORE: JFCL ;ADDITIONAL ERROR HANDLER LINKAGE + 457 030102 254 04 0 00 030102 HALT . ;IMPROPER TRANSFER HALT + 458 + 459 030103 000000 000000 $PSHER: 0 ;INITED AS (JRST PSHERR) + 460 030104 000000 000000 ITRCH1: 0 ;PC & FLAGS OF CURRENT INTERRUPT + 461 030105 000000 000000 0 ;INITED AS (JRST $ITRC1) + 462 + 463 S^;*********************************************************************^ + 464 ;*PROCESSOR CONTROL STORAGE + 465 S^;*********************************************************************^ + 466 + 467 030106 000000 000000 $ACC0: 0 ;INTERRUPT SAVED AC0 + 468 030107 000000 000000 $SVPI: 0 ;INTERRUPT SAVED PI + 469 030110 000000 000000 $SVAPR: 0 ;INTERRUPT SAVED APR + 470 030111 000000 000000 $SVPAG: 0 ;INTERRUPT SAVED PAG (DATAI) + 471 030112 000000 000000 $SPAG1: 0 ;INTERRUPT SAVED PAG (CONI) + 472 + 473 030113 000000 000000 $SVUUO: 0 ;CURRENT USERS UUO + 474 030114 000000 000000 $SVUPC: 0 ;PC OF CURRENT USERS UUO + 475 + 476 030115 000000 000000 REPTU: 0 ;REPEAT UUO ITERATIONS + 477 030116 000000 000000 SCOPE: 0 ;ERROR HANDLER SCOPE LOOP FLAG + 478 030117 000000 000000 %CORFLG:0 ; " CORRECT FLAG + 479 030120 000000 000000 %COREC: 0 ; " CORRECT DATA + 480 030121 000000 000000 %ACTFL: 0 ; " ACTUAL FLAG + 481 030122 000000 000000 %ACTUL: 0 ; " ACTUAL DATA + 482 030123 000000 000000 %DISCR: 0 ; " DISCREPENCY DATA +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 4 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0019 + + 483 S^;*********************************************************************^ + 484 ;*UUO DISPATCH TABLE + 485 S^;*********************************************************************^ + 486 XLIST + 487 LIST + 488 030124 030070 030070 UUODIS: LUUO1,,$UUOER + 489 030125 030070 030070 LUUO3,,LUUO2 + 490 030126 030070 030070 LUUO5,,LUUO4 + 491 030127 030070 030070 LUUO7,,LUUO6 + 492 030130 030070 030070 LUUO11,,LUUO10 + 493 030131 030070 030070 LUUO13,,LUUO12 + 494 030132 030070 030070 LUUO15,,LUUO14 + 495 030133 030070 030070 LUUO17,,LUUO16 + 496 030134 030070 030070 LUUO21,,LUUO20 + 497 030135 030070 030070 LUUO23,,LUUO22 + 498 030136 030070 030070 LUUO25,,LUUO24 + 499 030137 030070 030070 LUUO27,,LUUO26 + 500 030140 030070 030070 LUUO31,,LUUO30 + 501 030141 030070 030070 LUUO33,,LUUO32 + 502 + 503 S^;*********************************************************************^ + 504 ;*MEMORY MANAGMENT STORAGE + 505 S^;*********************************************************************^ + 506 + 507 030142 000000 000000 DF22F: 0 ;DF10 CONTROL FLAG, 0 = 18, -1 = 22 BIT + 508 030143 000000 000000 MAPNEW: 0 ;MEMORY MAPPING CONTROL FLAG, -1 = 4096K MAPPING + 509 030144 000000 000000 MEMTOT: 0 ;TOTAL MEMORY SIZE IN K (1024.) + 510 030145 000000 000000 MEMLOW: 0 ;LOWEST USABLE MEMORY + 511 030146 MEMSIZ: BLOCK ^D41 ;MEMORY SEGMENT POINTER TABLE + 512 + 513 S^;*********************************************************************^ + 514 ;*PRINT CONTROL STORAGE + 515 S^;*********************************************************************^ + 516 + 517 030217 000000 000000 PNTFLG: 0 ;PRINT FLAG, -1 WHILE IN PRINT ROUTINE + 518 030220 000000 000000 PNTENB: 0 ;PRINT ENABLE + 519 030221 000000 000000 PDISF: 0 ;PRINT DISABLED FLAG + 520 030222 000000 000000 PNTINH: 0 ;INHIBIT PRINT INPUT CHECKS + 521 030223 000000 000000 PNTSPC: 0 ;PRINT SPACE CONTROL + 522 030224 000000 000000 OPTIME: 0 ;TYPE-IN WAIT TIME + 523 030225 000000 000000 $TWCNT: 0 ;TIME WAITED + 524 030226 000000 000000 $DVOFF: 0 ;LOGICAL DEVICE INITED FLAG + 525 030227 000000 000000 TTYFIL: 0 ;TTY EXEC FILLERS FLAG + 526 030230 000000 000000 TTYSPD: 0 ;TTY EXEC BAUD RATE + 527 030231 000000 000000 $TTCHR: 0 ;ACTUAL TYPED IN CHAR + 528 030232 000000 000000 $CHRIN: 0 ;UPPER CASED & PARITY STRIPPED CHAR + 529 030233 000000 000000 $TYPNB: 0 ;TYPED IN NUMBER + 530 030234 000000 000000 $CRLF: 0 ;FREE CR/LF FLAG + 531 030235 000000 000000 $TABF: 0 ;TAB CONVERSION FLAG + 532 030236 000000 000000 $FFF: 0 ;FORM FEED CONVERSION FLAG + 533 030237 000000 000000 $VTF: 0 ;VERTICAL TAB CONVERSION FLAG + 534 030240 000000 000000 USRLFF: 0 ;USER LF FILLERS + 535 030241 000000 000000 USRCRF: 0 ;USER CR FILLERS +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 5 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0020 + + 536 S^;*********************************************************************^ + 537 ;*THE FOLLOWING MISCELLANEOUS PRINT CHARACTERS ARE INCLUDED + 538 ;*TO FACILITATE PRINTING AND ARE CALLED AS FOLLOWS: + 539 ;* MOVEI NAME + 540 ;* PNTA ;OR PNTAF + 541 S^;*********************************************************************^ + 542 + 543 030242 CRLF: ASCII/ + 544 030242 015 012 000 000 000 / + 545 030243 CRLF2: ASCII/ + 546 + 547 030243 015 012 015 012 000 / + 548 030244 054 000 000 000 000 COMMA: ASCII/,/ + 549 030245 056 000 000 000 000 PERIOD: ASCII/./ + 550 030246 040 000 000 000 000 SPACE: ASCII/ / + 551 030247 011 000 000 000 000 TAB: ASCII/ / + 552 030250 MINUS: + 553 030250 055 000 000 000 000 HYPEN: ASCII/-/ + 554 030251 053 000 000 000 000 PLUS: ASCII/+/ + 555 030252 052 000 000 000 000 AST: ASCII/*/ + 556 030253 100 000 000 000 000 ATSIN: ASCII/@/ + 557 030254 050 000 000 000 000 LFP: ASCII/(/ + 558 030255 051 000 000 000 000 RTP: ASCII/)/ + 559 030256 007 0000000000 BELL: BYTE (7) 007 + 560 030257 077 000 000 000 000 QUEST: ASCII/?/ + 561 030260 057 000 000 000 000 SLASH: ASCII!/! + 562 030261 044 000 000 000 000 DOLLAR: ASCII/$/ + 563 030262 000000 000012 RADIX: ^D10 ;DECIMAL PRINT RADIX + 564 030263 000000 000040 RADLSP: 40 ;DECIMAL PRINT LEADING CHAR + 565 030264 000000 000012 RADLSC: ^D10 ;DECIMAL PRINT LEADING CHAR COUNT + 566 + 567 S^;*********************************************************************^ + 568 ;*USER MODE OUTPUT FILE INFORMATION + 569 S^;*********************************************************************^ + 570 + 571 030265 $OBUF: BLOCK 3 ;LOGICAL FILE OUTPUT BUFFER HEADER + 572 030270 60 62 51 56 64 00 $OUTNM: SIXBIT /PRINT/ ;FILE NAME + 573 030271 60 56 64 00 00 00 $OUTEX: SIXBIT /PNT/ ;FILE NAME EXTENSION + 574 030272 BLOCK 2 + 575 + 576 S^;*********************************************************************^ + 577 ;*DISK UPDATE MODE FILE INFORMATION + 578 S^;*********************************************************************^ + 579 + 580 030274 $IBUF: BLOCK 3 + 581 030277 60 62 51 56 64 00 $INNM: SIXBIT /PRINT/ + 582 030300 60 56 64 00 00 00 $INEXT: SIXBIT /PNT/ + 583 030301 BLOCK 2 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 6 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0021 + + 584 S^;*********************************************************************^ + 585 ;*PUSHDOWN LIST CONTROL INFORMATION + 586 S^;*********************************************************************^ + 587 + 588 030303 777577 030303 PLIST: PLIST-PLISTE,,PLIST + 589 030304 PLISTS: BLOCK 200 + 590 030504 000000 000000 PLISTE: 0 ;END OF PUSHDOWN LIST + 591 + 592 S^;*********************************************************************^ + 593 ;*POWER LINE CLOCK FREQUENCY FLAG + 594 S^;*********************************************************************^ + 595 + 596 030505 000000 000000 CYCL60: 0 ;0 = 60, -1 = 50 CYCLE + 597 + 598 S^;*********************************************************************^ + 599 ;*KL10 CACHE CONTROL FLAGS + 600 S^;*********************************************************************^ + 601 + 602 030506 000000 000000 CSHFLG: 0 ;ALLOW CACHE IF 0 + 603 030507 000000 000000 CSHMEM: 0 ;CACHE MEMORY SEGMENTS IF 0 + 604 + 605 S^;*********************************************************************^ + 606 ;*NUMBER INPUT DIGIT FLAG + 607 S^;*********************************************************************^ + 608 + 609 030510 000000 000000 TTNBRF: 0 ;-1 IF ANY DIGIT TYPED + 610 + 611 S^;*********************************************************************^ + 612 ;*KL10 & KI10 "INHPAG" SWITCH PAGING PREVENTION + 613 S^;*********************************************************************^ + 614 + 615 030511 000000 000000 PVPAGI: 0 ;IF NON-ZERO, OVERRIDE "INHPAG" SWITCH ACTION + 616 + 617 S^;*********************************************************************^ + 618 ;*ERROR REPORTING ROUTINE ADDITIONAL USERS CONTROL INSTRUCTIONS + 619 S^;*********************************************************************^ + 620 + 621 030512 000000 000000 %ERHI1: 0 ;IF NON-ZERO, XCT'D AT START OF %ERUUO + 622 030513 000000 000000 %ERHI2: 0 ;IF NON-ZERO, XCT'D AT END OF %ERUUO + 623 030514 000000 000000 %ERHI3: 0 ;IF NON-ZERO, XCT'D AFTER "PC" OF %ERUUO + 624 + 625 S^;*********************************************************************^ + 626 ;*SPECIAL USERS UUO INTERCEPT INSTRUCTION + 627 S^;*********************************************************************^ + 628 + 629 030515 000000 000000 $$UUO: 0 ;IF NON-ZERO, XCT'D AT START OF $UORTN +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 7 +FIXED KLM 18-JAN-77 11:39 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977 SEQ 0022 + + 630 S^;*********************************************************************^ + 631 ;*KL10 PROCESSOR TYPE FLAG, 0=P0, 1=BBD NEW, 2=BBD OLD + 632 S^;*********************************************************************^ + 633 + 634 030516 000000 000000 KLTYP: 0 + 635 + 636 S^;*********************************************************************^ + 637 ;*SPECIAL USERS MUUO INTERCEPT INSTRUCTION + 638 S^;*********************************************************************^ + 639 + 640 030517 000000 000000 $$MUUO: 0 ;IF NON-ZERO, XCT'D AT START OF MUUOER + 641 + 642 S^;*********************************************************************^ + 643 ;*SPECIAL USERS USER MODE OUTPUT ERROR INTERCEPT INSTUCTION + 644 S^;*********************************************************************^ + 645 + 646 030520 000000 000000 $$OUTER:0 ;IF NON-ZERO, XCT'D AT END OF USER MODE ERROR + 647 + 648 S^;*********************************************************************^ + 649 ;*"SWITCH" CALL USAGE CONTROL + 650 S^;*********************************************************************^ + 651 + 652 030521 000000 000000 $$TOGGLE:0 ;IF NON-ZERO, USE C(CONSW) FOR SWITCHES + 653 + 654 S^;*********************************************************************^ + 655 ;*SPECIAL USERS ALTMODE SWITCH CALL INTERCEPT INSTRUCTIONS + 656 S^;*********************************************************************^ + 657 + 658 030522 000000 000000 $$TAX1: 0 ;IF NON-ZERO, XCT'D AT START OF ALTMODE SWITCH CALL + 659 030523 000000 000000 $$TAX2: 0 ;IF NON-ZERO, XCT'D AT END OF ALTMODE SWITCH CALL + 660 + 661 S^;*********************************************************************^ + 662 ;*SPECIAL FUTURE EXPANSION ROOM + 663 ;*IF ANY FIXED AREA TAGS ARE ADDED, REDUCE THE SIZE OF + 664 ;*THIS BLOCK STATEMENT ACCORDINGLY. THIS MUST BE DONE + 665 ;*SO THAT PREVIOUS FIXED ASSIGNMENTS DO NOT CHANGE. + 666 S^;*********************************************************************^ + 667 + 668 030524 BLOCK 53 ;HOPEFULLY THIS IS ENOUGH FOREVER + 669 + 670 S^;*********************************************************************^ + 671 ;*END OF FIXED STORAGE + 672 S^;*********************************************************************^ + 673 + 674 030577 $ENDFX=&<777700>-1 + 675 030577 LOC $ENDFX + 676 030577 000000 000000 ENDFIX: 0 ;END OF FIXED STORAGE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 1 +SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0023 + + 677 SUBTTL *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 + 678 + 679 ;NEW DEFINITIONS USED BY THE KL10 SUBROUTINE PACKAGE + 680 + 681 000000 AC0= 0 + 682 030000 DIAGNOS=30000 ;PDP-10 DIAGNOSTIC START ADDRESS + 683 010000 DDT= 10000 ;PDP-10 DDT START ADDRESS + 684 020000 DIAMON= 20000 ;PDP-10 DIAMON LOADER START ADDRESS + 685 020000 DONG11= 1B22 ;11 DOORBELL (FROM THE 10) + 686 + 687 ;DTE20 DEVICE CODES + 688 + 689 000200 DTE== 200 ;DTE0 + 690 000204 DTE0== 204 + 691 000204 DTE1== 204 + 692 000210 DTE2== 210 + 693 000214 DTE3== 214 + 694 + 695 ;KL10 EPT COMMUNICATION AREA + 696 + 697 000440 $STD= 440 ;PDP-10 DIAGNOSTIC START ADDRESS + 698 000441 $DDT= 441 ;PDP-10 DDT START ADDRESS + 699 000442 $STL= 442 ;PDP-10 LOADER START ADDRESS + 700 000443 $STM= 443 ;PDP-10 MONITOR START ADDRESS + 701 + 702 000444 $DTFLG= 444 ;DTE20 OPERATION COMPLETE FLAG + 703 000445 $DTCLK= 445 ;DTE20 CLOCK INTERRUPT FLAG + 704 000446 $DTCI= 446 ;DTE20 CLOCK INTERRUPT INSTRUCTION + 705 000447 $DTT11= 447 ;DTE20 10 TO 11 ARGUMENT + 706 000450 $DTF11= 450 ;DTE20 11 TO 10 ARGUMENT + 707 000451 $DTCMD= 451 ;DTE20 TO 11 COMMAND WORD + 708 000452 $DTSEQ= 452 ;DTE20 OPERATION SEQUENCE NUMBER + 709 000453 $DTOPR= 453 ;DTE20 OPERATIONAL DTE # + 710 000454 $DTCHR= 454 ;DTE20 LAST TYPED CHARACTER + 711 000455 $DTMTD= 455 ;DTE20 MONITOR TTY OUTPUT COMPLETE FLAG + 712 000456 $DTMTI= 456 ;DTE20 MONITOR TTY INPUT FLAG + 713 + 714 000457 $DTSWR= 457 ;DTE20 CONSOLE SWITCH REGISTER +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 2 +SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0024 + + 715 ;SPECIAL "FIXED" REASSIGNMENTS + 716 + 717 030600 $$LOC=. ;SAVE CURRENT LOCATION + 718 + 719 030000 LOC 30000 + 720 030000 254 00 0 00 030600 $$BEGIN:JRST $$START ;SETUP SPECIAL START + 721 030001 254 00 0 00 030600 JRST $$START ;"DIAMON" CHAIN START ADDRESS + 722 + 723 000440 LOC 440 + 724 000440 254 00 0 00 030000 $STD: JRST BEGIN ;SETUP FOR "STD" + 725 000443 LOC 443 + 726 000443 254 00 0 00 030636 $STM: JRST $SPEC ;SIMPLE RUN CONTROL + 727 + 728 030057 LOC 30057 + 729 030057 254 00 0 00 030641 $BEGEND:JRST $SPBEND ;SETUP SPECIAL "BEGEND" + 730 + 731 ;SPECIAL MUUO, TRAP & PAGE FAIL SETUP + 732 + 733 000420 LOC 420 + 734 000420 254 04 0 00 000420 $$420: HALT . ;KI10 PAGE FAIL + 735 000421 255 00 0 00 000000 $$421: JFCL ;OVERFLOW + 736 000422 254 04 0 00 000422 $$422: HALT . ;PUSHDOWN OVERFLOW + 737 000423 254 04 0 00 000423 $$423: HALT . ;TRAP 3 + 738 000424 000000 000000 $$424: 0 ;MMUO + 739 000425 000000 000000 $$425: 0 ;MMUO PC + 740 000426 000000 000000 $$426: 0 ;KI10-PAGE FAIL, KL10-PROCESS CONTEXT + 741 000427 254 04 0 00 000427 $$427: HALT . + 742 000430 000000 000427 $$430: 427 ;MMUO NEW PC'S + 743 000431 000000 000427 $$431: 427 + 744 000432 000000 000427 $$432: 427 + 745 000433 000000 000427 $$433: 427 + 746 000434 000000 000427 $$434: 427 + 747 000435 000000 000427 $$435: 427 + 748 000436 000000 000427 $$436: 427 + 749 000437 000000 000427 $$437: 427 + 750 + 751 000500 LOC 500 + 752 000500 000000 000000 $$500: 0 ;KL10 PAGE FAIL WORD + 753 000501 000000 000000 $$501: 0 ;KL10 PAGE FAIL PC + 754 000502 000000 000503 $$502: 503 ;KL10 PAGE FAIL NEW PC + 755 000503 254 04 0 00 000503 $$503: HALT . +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 3 +SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0025 + + 756 030600 LOC $$LOC ;RESET CURRENT LOCATION + 757 + 758 ;SPECIAL STARTUP SEQUENCE + 759 + 760 030600 402 00 0 00 030037 $$START:SETZM USER + 761 030601 265 00 0 00 030602 JSP 0,.+1 ;IN USER MODE ? + 762 030602 603 00 0 00 010000 TLNE 0,USERF + 763 030603 476 00 0 00 030037 SETOM USER ;YES, SET CONTROL WORD + 764 030604 336 00 0 00 030042 SKIPN MONFLG ;SPECIAL USER MODE ? + 765 030605 402 00 0 00 030037 SETZM USER ;YES, RUN AS EXEC + 766 030606 332 00 0 00 030037 SKIPE USER + 767 030607 254 00 0 00 030712 JRST START ;USER MODE, DON'T NEED CPU TYPE + 768 + 769 030610 336 00 0 00 030044 $STKIL: SKIPN MONTEN ;LOADED BY "DIAMON" ? + 770 030611 476 00 0 00 030024 SETOM ITRCNT ;NO, RUN FOREVER + 771 030612 402 00 0 00 030516 SETZM KLTYP + 772 030613 402 00 0 00 030041 SETZM KLFLG ;ASSUME KI10 + 773 030614 200 01 0 00 034010 MOVE 1,[1,,1] + 774 030615 251 01 0 00 000001 BLT 1,1 ;HOPE THIS WORKS + 775 030616 316 01 0 00 034010 CAMN 1,[1,,1] ;IF AC NE 1,,1 AFTER BLT, KL10 + 776 030617 254 00 0 00 030712 JRST START ;KI10, NO ADDITIONAL SETUP + 777 + 778 030620 7 000 20 0 00 010040 $STKL: CONO APR,10040 ;SET BBD NOT BIT + 779 030621 7 000 24 0 00 000000 CONI APR,0 + 780 030622 7 000 20 0 00 020040 CONO APR,20040 ;CLEAR BBD NOT BIT + 781 030623 606 00 0 00 000040 TRNN 0,40 ;IF SET, KL10 + 782 030624 350 00 0 00 030516 AOS KLTYP ;IF NOT, BBD + 783 030625 402 00 0 00 000444 SETZM $DTFLG + 784 030626 402 00 0 00 000445 SETZM $DTCLK + 785 030627 200 00 0 00 000453 MOVE $DTOPR ;GET DTE # + 786 030630 436 00 0 00 030670 ORM $$DTE0 ;INSERT IN DTE I/O INSTS + 787 030631 436 00 0 00 030672 ORM $$DTE1 + 788 030632 436 00 0 00 030704 ORM $$DTE2 + 789 030633 436 00 0 00 030706 ORM $$DTE3 + 790 030634 476 00 0 00 030041 SETOM KLFLG ;SET KL10 CONTROL FLAG + 791 030635 254 00 0 00 030712 JRST START + 792 + 793 030636 200 00 0 00 034011 $SPEC: MOVE [JRST STARTA] ;SIMPLE RUN CONTROL + 794 030637 202 00 0 00 030643 MOVEM $SPB1 + 795 030640 254 00 0 00 030712 JRST START +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 4 +SPCCPU KLM 26-FEB-76 05:50 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0026 + + 796 ;SPECIAL "BEGEND" ROUTINE + 797 + 798 030641 350 00 0 00 030047 $SPBEND:AOS PASCNT ;INCREMENT PASS COUNT + 799 030642 370 00 0 00 030024 SOS ITRCNT ;DECREMENT ITERATION COUNT + 800 030643 336 00 0 00 030037 $SPB1: SKIPN USER + 801 030644 254 00 0 00 030652 JRST $SPBEX ;EXEC MODE + 802 + 803 030645 332 00 0 00 030024 $SPBUS: SKIPE ITRCNT ;USER MODE, COMPLETED ? + 804 030646 254 00 0 00 030741 JRST STARTA ;NO, KEEP RUNNING + 805 030647 336 00 0 00 030044 SKIPN MONTEN ;DONE, LOADED BY "DIAMON" ? + 806 030650 047 00 0 00 000012 EXIT ;NO, RETURN TO MONITOR + 807 030651 254 00 1 00 030012 JRST @RETURN ;YES, RETURN TO "DIAMON" + 808 + 809 030652 332 00 0 00 030041 $SPBEX: SKIPE KLFLG + 810 030653 254 00 0 00 030660 JRST $SPBKL ;KL10 & EXEC + 811 030654 7 004 14 0 00 030024 DATAO PI,ITRCNT ;KI10 & EXEC, DISPLAY ITER COUNT + 812 030655 332 00 0 00 030024 SKIPE ITRCNT + 813 030656 254 00 0 00 030741 JRST STARTA ;NOT COMPLETED YET + 814 030657 254 00 1 00 030012 JRST @RETURN ;DONE + 815 + 816 030660 336 00 0 00 030024 $SPBKL: SKIPN ITRCNT + 817 030661 254 00 0 00 030676 JRST $SPKLD ;KL10, EXEC & COMPLETED + 818 + 819 030662 335 00 0 00 030043 SKIPGE MONCTL + 820 030663 254 00 0 00 030741 JRST STARTA ;"DIAMON" CONTROL + 821 030664 201 00 0 00 000404 MOVEI 0,404 ;NOTIFY PDP-11 OF END OF PASS + 822 030665 202 00 0 00 000451 MOVEM 0,$DTCMD + 823 030666 402 00 0 00 000444 SETZM $DTFLG + 824 030667 336 00 0 00 030516 SKIPN KLTYP + 825 030670 7 200 20 0 00 020000 $$DTE0: CONO DTE,DONG11 + 826 030671 332 00 0 00 030516 SKIPE KLTYP + 827 030672 7 200 20 0 00 010000 $$DTE1: CONO DTE,10000 + 828 030673 336 00 0 00 000444 SKIPN $DTFLG ;WAIT TILL 11 RESPONDS + 829 030674 254 00 0 00 030673 JRST .-1 + 830 030675 254 00 0 00 030741 JRST STARTA ;KEEP RUNNING + 831 + 832 ;SPECIAL KL10 COMPLETED ROUTINE + 833 + 834 030676 332 00 0 00 030044 $SPKLD: SKIPE MONTEN + 835 030677 254 00 1 00 030012 JRST @RETURN ;LOADED BY "DIAMON" + 836 + 837 030700 201 00 0 00 000403 MOVEI 0,403 ;NOTIFY PDP-11 OF COMPLETION + 838 030701 202 00 0 00 000451 MOVEM 0,$DTCMD + 839 030702 402 00 0 00 000444 SETZM $DTFLG + 840 030703 336 00 0 00 030516 SKIPN KLTYP + 841 030704 7 200 20 0 00 020000 $$DTE2: CONO DTE,DONG11 + 842 030705 332 00 0 00 030516 SKIPE KLTYP + 843 030706 7 200 20 0 00 010000 $$DTE3: CONO DTE,10000 + 844 030707 336 00 0 00 000444 SKIPN $DTFLG ;SHOULD NEVER HAPPEN + 845 030710 254 00 0 00 030707 JRST .-1 ;11 NEVER RETURNS ON END OF PROGRAM + 846 030711 254 04 0 00 030000 HALT BEGIN ;IF IT DOES, HALT. +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 1 +DAKACM MAC 19-JAN-77 13:40 DIAGNOSTIC SECTION SEQ 0027 + + 847 SUBTTL DIAGNOSTIC SECTION + 848 + 849 LALL + 850 + 851 030712 402 00 0 00 030037 START: SETZM USER# + 852 030713 265 00 0 00 030714 JSP 0,.+1 ;GET FLAGS + 853 030714 603 00 0 00 010000 TLNE USERF ;IN USER MODE + 854 030715 476 00 0 00 030037 SETOM USER ;YES SET USER CONTROLL WORD + 855 030716 336 00 0 00 030042 SKIPN MONFLG ;SPECIAL USER MODE + 856 030717 402 00 0 00 030037 SETZM USER ;YES CLEAR USER CONTROLL WORD + 857 030720 336 00 0 00 030037 SKIPN USER + 858 030721 254 00 0 00 030741 JRST STARTA + 859 030722 331 00 0 00 030043 SKIPL MONCTL + 860 030723 051 03 0 00 030725 TTCALL 3,PGMNAM ;MENTION OUR NAME + 861 030724 254 00 0 00 030741 JRST STARTA + 862 + 863 030725 PGMNAM: ASCIZ/ + 864 030725 015 012 120 104 120 PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) [DAKAC] + 865 030726 055 061 060 040 113 + 866 030727 101 061 060 040 102 + 867 030730 101 123 111 103 040 + 868 030731 111 116 123 124 122 + 869 030732 125 103 124 111 117 + 870 030733 116 040 104 111 101 + 871 030734 107 116 117 123 124 + 872 030735 111 103 040 050 063 + 873 030736 051 040 133 104 101 + 874 030737 113 101 103 135 015 + 875 030740 012 000 000 000 000 / + 876 030741 254 00 0 00 030742 STARTA: JRST .+1 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 2 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0028 + + 877 SUBTTL TEST OF LOGICAL TEST INSTRUCTIONS + 878 + 879 ;********** + 880 + 881 ;THIS TEST VERIFIES THAT TDN DOES NOT MODIFY THE AC BECAUSE + 882 ;TDN IS A NO-OP + 883 ;FIRST, THE AC IS PRELOADED WITH 0. THEN, + 884 ;TDN IS EXECUTED. THE AC IS THEN CHECKED FOR + 885 ;NO MODIFICATION. IF C(AC) IS UNALTERED, THE TEST PASSES + 886 030742 400 00 0 00 000000 B12600: SETZ ;PRELOAD AC WITH 0 + 887 030743 610 00 0 00 034012 TDN [-1] ;*TDN IS A NO-OP + 888 030744 310 00 0 00 000000 CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TDN SKIPS + 889 030745 302 00 0 00 000000 CAIE ;PASS TEST IF C(AC) IS UNMODIFIED BY TDN + 890 STOP^ + 891 030746 254 04 0 00 030747 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 892 030747 324 00 0 00 030750 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 893 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 894 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 895 + 896 ;***** FAILURE ANALYSIS ***** + 897 ;C(AC0) C(AC1) FAILING SIGNAL + 898 + 899 ;-1,,-1 FC: AD FM + EN + 900 + 901 ;********** + 902 + 903 ;THIS TEST VERIFIES THAT TSN DOES NOT MODIFY THE AC BECAUSE + 904 ;TSN IS A NO-OP + 905 ;FIRST, THE AC IS PRELOADED WITH -1. THEN, + 906 ;TSN IS EXECUTED. THE AC IS THEN CHECKED FOR + 907 ;NO MODIFICATION. IF C(AC) IS UNALTERED, THIS TEST PASSES + 908 + 909 030750 474 00 0 00 000000 B12700: SETO ;PRELOAD AC WITH -1,,-1 + 910 030751 611 00 0 00 034013 TSN [XWD -1,0] ;*TSN IS A NO-OP + 911 030752 310 00 0 00 000000 CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TSN SKIPS + 912 030753 312 00 0 00 034012 CAME [-1] ;PASS TEST IF C(AC) IS UNMODIFIED BY TSN + 913 STOP^ + 914 030754 254 04 0 00 030755 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 915 030755 324 00 0 00 030756 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 916 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 917 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 918 + 919 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 3 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0029 + + 920 ;THIS TEST VERIFIES THAT TRN DOE NOT MODIFY THE AC BECAUSE + 921 ;TRN IS A NO-OP. + 922 ;FIRST, THE AC IS PRELOADED WITH 0. THEN, + 923 ;TRN IS EXECUTED. THE AC IS THEN CHECKED FOR + 924 ;NO MODIFICATION. IF C(AC) IS UNALTERED, THIS TEST PASSES + 925 + 926 030756 400 00 0 00 000000 B13000: SETZ ;PRELOAD AC WITH 0 + 927 030757 600 00 0 00 123456 TRN 123456 ;*TRN IS A NO-OP + 928 030760 310 00 0 00 000000 CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TRN SKIPS + 929 030761 302 00 0 00 000000 CAIE ;PASS TEST IF C(AC) IS UNMODIFIED BY TRN + 930 STOP^ + 931 030762 254 04 0 00 030763 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 932 030763 324 00 0 00 030764 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 933 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 934 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 935 + 936 ;********** + 937 + 938 ;THIS TEST VERIFIES THAT TLN DOES NOT MODIFY THE AC BECAUSE + 939 ;TLN IS A NO-OP. + 940 ;FIRST,THE AC IS PRELOADED WITH -1,,-1. THEN, + 941 ;TRN IS EXECUTED. THE AC IS THEN CHECKED FOR + 942 ;NO MODIFICATION. IF C(AC) IS UNALTERED, THIS TEST PASSES + 943 + 944 030764 474 00 0 00 000000 B13100: SETO ;PRELOAD AC WITH -1,,-1 + 945 030765 601 00 0 00 123456 TLN 123456 ;*TRN IS A NO-OP + 946 030766 310 00 0 00 000000 CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TRN SKIPS + 947 030767 312 00 0 00 000000 CAME ;PASS TEST IF C(AC) IS UNMODIFIED BY TRN + 948 STOP^ + 949 030770 254 04 0 00 030771 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 950 030771 324 00 0 00 030772 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 951 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 952 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 953 + 954 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 4 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0030 + + 955 ;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC + 956 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 957 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. + 958 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC) -1,,-1, THE TEST PASSES. + 959 + 960 030772 400 00 0 00 000000 B13200: SETZ ;PRELOAD AC WITH 0 + 961 030773 670 00 0 00 034012 TDO [-1] ;*TDO SHOULD PLACE ALL ONES IN THE AC + 962 030774 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + 963 030775 312 00 0 00 034012 CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + 964 STOP^ + 965 030776 254 04 0 00 030777 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 966 030777 324 00 0 00 031000 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 967 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 968 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 969 + 970 ;***** FAILURE ANALYSIS ***** + 971 ;C(AC0) C(AC1) FAILING SIGNAL + 972 + 973 ;E SW: FCE + 974 ;0 SW: ET1 + 975 ;0 ET1: BR AR EN + 976 ;0 ET1: AD BR - EN + 977 ;0 ET1: AD EQV + 978 + 979 ;********** + 980 + 981 ;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC + 982 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 983 ;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 984 ;THIS AC IS CHECKED FOR ZERO. IF C(AC) IS ZERO, THE TEST PASSES. + 985 + 986 031000 400 00 0 00 000000 B13300: SETZ ;PRELOAD AC WITH 0 + 987 031001 670 00 0 00 000000 TDO ;*TDO SHOULD PLACE ALL ZERO IN THE AC + 988 031002 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + 989 031003 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC) ZERO + 990 STOP^ + 991 031004 254 04 0 00 031005 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 992 031005 324 00 0 00 031006 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^ + 995 + 996 ;***** FAILURE ANALYSIS ***** + 997 ;C(AC0) C(AC1) FAILING SIGNAL + 998 + 999 ;-1,,-1 ET1: AD AR + EN + 1000 + 1001 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 5 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0031 + + 1002 ;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC, + 1003 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1004 ;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 1005 ;THE AC IS CHECKED FOR ITS CONTENTS ZERO. IF C(AC) IS ZERO, THE TEST PASSES. + 1006 + 1007 031006 400 00 0 00 000000 B13400: SETZ ;PRELOAD AC WITH 0 + 1008 031007 670 00 0 00 034014 TDO [0] ;*TDO SHOULD PLACE ALL ZERO IN THE AC + 1009 031010 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + 1010 031011 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC) IS ZERO + 1011 STOP^ + 1012 031012 254 04 0 00 031013 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1013 031013 324 00 0 00 031014 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1014 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1015 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1016 + 1017 ;********** + 1018 + 1019 ;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC + 1020 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1021 ;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. + 1022 ;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. + 1023 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + 1024 + 1025 031014 474 00 0 00 000000 B13600: SETO ;PRELOAD AC WITH -1,,-1 + 1026 031015 670 00 0 00 000000 TDO ;*TDO SHOULD PLACE ALL ONES IN THE AC + 1027 031016 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + 1028 031017 312 00 0 00 034012 CAME [-1] ;PASS TEST IF C(AC) -1,,-1 + 1029 STOP^ + 1030 031020 254 04 0 00 031021 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1031 031021 324 00 0 00 031022 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1032 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1033 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1034 + 1035 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 6 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0032 + + 1036 ;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC + 1037 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1038 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. + 1039 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + 1040 + 1041 031022 474 00 0 00 000000 B14000: SETO ;PRELOAD AC WITH -1,,-1 + 1042 031023 670 00 0 00 034014 TDO [0] ;*TDO SHOULD PLACE ALL ONES IN THE AC + 1043 031024 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + 1044 031025 312 00 0 00 034012 CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + 1045 STOP^ + 1046 031026 254 04 0 00 031027 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1047 031027 324 00 0 00 031030 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1048 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1049 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1050 + 1051 ;***** FAILURE ANALYSIS ***** + 1052 ;C(AC0) C(AC1) FAILING SIGNAL + 1053 + 1054 ;0 ET1: AD FM - EN + 1055 ;0 ET2: AR AD EN + 1056 + 1057 ;********** + 1058 + 1059 ;THIS TEST VERIFIES THAT TDZ PLACES ZERO IN THE BITS OF THE AC + 1060 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1061 ;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 1062 ;THE AC IS CHECKED FOR 0. IF C(AC) 0, THE TEST PASSES. + 1063 + 1064 031030 400 00 0 00 000000 B14100: SETZ ;PRELOAD AC WITH 0 + 1065 031031 630 00 0 00 000000 TDZ ;*TDZ SHOULD PLACE ALL ZERO IN THE AC + 1066 031032 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + 1067 031033 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1068 STOP^ + 1069 031034 254 04 0 00 031035 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1070 031035 324 00 0 00 031036 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1071 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1072 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1073 + 1074 ;***** FAILURE ANALYSIS ***** + 1075 ;C(AC0) C(AC1) FAILING SIGNAL + 1076 + 1077 ;-1,,-1 FC: AD FM + EN + 1078 + 1079 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 7 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0033 + + 1080 ;THIS TEST VERIFIES THAT TDZ PLACES ZERO IN THE BITS OF THE AC + 1081 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1082 ;IN THIS CASE, C(AC)=-1,,-1,,-1 AND C(E)=-1,,0. + 1083 ;HENCE, THE RESULT IN THE AC SHOULD BE 0,,-1. + 1084 ;THE AC IS CHECKED FOR 0,,-1. IF C(AC)= 0,,-1, THE TEST PASSES. + 1085 + 1086 031036 474 00 0 00 000000 B14200: SETO ;PRELOAD AC WITH -1,,-1 + 1087 031037 630 00 0 00 034013 TDZ [XWD -1,0] ;*TDZ SHOULD PLACE 0,,-1 IN THE AC + 1088 031040 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + 1089 031041 312 00 0 00 034015 CAME [0,-1] ;PASS TEST IF C(AC)=0,,-1 + 1090 STOP^ + 1091 031042 254 04 0 00 031043 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1092 031043 324 00 0 00 031044 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1093 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1094 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1095 + 1096 ;***** FAILURE ANALYSIS ***** + 1097 ;C(AC0) C(AC1) FAILING SIGNAL + 1098 + 1099 ;-E SW: FCE + 1100 ;-1,,-1 FC: AD AR -EN + 1101 ;-1,,0 ET2: AR AD EN + 1102 + 1103 ;********** + 1104 + 1105 ;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC + 1106 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1107 ;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 1108 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + 1109 + 1110 031044 474 00 0 00 000000 B14400: SETO ;PRELOAD AC WITH -1,,-1 + 1111 031045 630 00 0 00 000000 TDZ ;*TDZ SHOULD PLACE ALL ZERO IN THE AC + 1112 031046 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + 1113 031047 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1114 STOP^ + 1115 031050 254 04 0 00 031051 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1116 031051 324 00 0 00 031052 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1117 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1118 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1119 + 1120 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 8 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0034 + + 1121 ;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC + 1122 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1123 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 1124 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + 1125 + 1126 031052 400 00 0 00 000000 B14500: SETZ ;PRELOAD AC WITH 0 + 1127 031053 630 00 0 00 034012 TDZ [-1] ;*TDZ SHOULD PLACE ALL ZEROS IN THE AC + 1128 031054 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + 1129 031055 332 00 0 00 000000 SKIPE ;PASS TEST IS C(AC)=0 + 1130 STOP^ + 1131 031056 254 04 0 00 031057 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1132 031057 324 00 0 00 031060 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1133 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1134 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1135 + 1136 ;********** + 1137 + 1138 ;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC + 1139 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1140 ;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. + 1141 ;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. + 1142 ;THE AC IS CHECKED -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + 1143 + 1144 031060 474 00 0 00 000000 B14600: SETO ;PRELOAD AC WITH -1,,-1 + 1145 031061 630 00 0 00 034014 TDZ [0] ;*TDZ SHOULD PLACE ALL ONES IN THE AC + 1146 031062 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + 1147 031063 312 00 0 00 034012 CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + 1148 STOP^ + 1149 031064 254 04 0 00 031065 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1150 031065 324 00 0 00 031066 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1151 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1152 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1153 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 9 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0035 + + 1154 ;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC + 1155 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1156 ;IN THIS CASE, C(AC)=-1 AND C(E)=0,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,0. + 1157 ;THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + 1158 + 1159 031066 474 00 0 00 000000 B14700: SETO ;PRELOAD AC WITH -1,,-1 + 1160 031067 650 00 0 00 034015 TDC [XWD 0,-1] ;*TDC SHOULD PLACE -1,,0 INTO THE AC + 1161 031070 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + 1162 031071 312 00 0 00 034013 CAME [-1,,0] ;PASS TEST IF C(AC)=-1,,0 + 1163 STOP^ + 1164 031072 254 04 0 00 031073 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1165 031073 324 00 0 00 031074 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 ;***** FAILURE ANALYSIS ***** + 1170 ;C(AC0) C(AC1) FAILING SIGNAL + 1171 + 1172 ;-E SW: FCE + 1173 ;0 FC: AD AR - EN + 1174 ;0,,-1 ET2: AR AD EN + 1175 + 1176 ;********** + 1177 + 1178 ;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC + 1179 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1180 ;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 1181 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 1182 + 1183 031074 400 00 0 00 000000 B15000: SETZ ;PRELOAD AC, E WITH 0 + 1184 031075 650 00 0 00 000000 TDC ;*TDC SHOULD PLACE 0 INTO THE AC + 1185 031076 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + 1186 031077 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1187 STOP^ + 1188 031100 254 04 0 00 031101 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1189 031101 324 00 0 00 031102 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1190 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1191 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1192 + 1193 ;***** FAILURE ANALYSIS ***** + 1194 ;C(AC0) C(AC1) FAILING SIGNAL + 1195 + 1196 ;-1,,-1 FC:AD FM + EN + 1197 + 1198 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 10 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0036 + + 1199 ;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC + 1200 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1201 ;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 1202 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST FAILS + 1203 + 1204 031102 474 00 0 00 000000 B15400: SETO ;PRELOAD AC WITH -1,,-1 + 1205 031103 650 00 0 00 000000 TDC ;*TDC SHOULD PLACE 0 INTO THE AC + 1206 031104 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + 1207 031105 332 00 0 00 000000 SKIPE ;PASS TEST IF C(AC)=0 + 1208 STOP^ + 1209 031106 254 04 0 00 031107 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1210 031107 324 00 0 00 031110 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1211 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1212 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1213 + 1214 ;********** + 1215 + 1216 ;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC + 1217 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1218 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. + 1219 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + 1220 + 1221 031110 400 00 0 00 000000 B15500: SETZ ;PRELOAD AC WITH 0 + 1222 031111 650 00 0 00 034012 TDC [-1] ;*TDC SHOULD PLACE -1,,-1 INTO THE AC + 1223 031112 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + 1224 031113 312 00 0 00 034012 CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + 1225 STOP^ + 1226 031114 254 04 0 00 031115 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1227 031115 324 00 0 00 031116 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1228 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1229 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1230 + 1231 ;***** FAILURE ANALYSIS ***** + 1232 ;C(AC0) C(AC1) FAILING SIGNAL + 1233 + 1234 ;0 FC: AD EQV + 1235 + 1236 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 11 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0037 + + 1237 ;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC + 1238 ;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. + 1239 ;IN THIS CASE, C(AC)=-1 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. + 1240 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + 1241 + 1242 031116 474 00 0 00 000000 B15600: SETO ;PRELOAD AC WITH -1,,-1 + 1243 031117 650 00 0 00 034014 TDC [0] ;*TDC SHOULD PLACE -1,,-1 INTO THE AC + 1244 031120 300 00 0 00 000000 CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + 1245 031121 312 00 0 00 034012 CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + 1246 STOP^ + 1247 031122 254 04 0 00 031123 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1248 031123 324 00 0 00 031124 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1249 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1250 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1251 + 1252 ;********** + 1253 + 1254 ;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT + 1255 ;SEQUENTIAL INSTRUCTION. IF TDNA DOES NOT + 1256 ;SKIP, THIS TEST FAILS. + 1257 + 1258 031124 400 00 0 00 000000 B15700: SETZ ;PRESET AC, E TO 0 + 1259 031125 614 00 0 00 000000 TDNA ;*TDNA SHOULD SKIP THE NEXT INSTRUCTION + 1260 STOP^ + 1261 031126 254 04 0 00 031127 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1262 031127 324 00 0 00 031130 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1263 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1264 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1265 + 1266 ;***** FAILURE ANALYSIS ***** + 1267 ;C(AC0) C(AC1) FAILING SIGNAL + 1268 + 1269 ;0 SW: ET1 + 1270 ;0 FC: AB PC EN + 1271 ;0 ET1: BR AR EN + 1272 ;0 ET1: PC CLOCK + 1273 ;0 ET2: MC INST FETCH EN + 1274 + 1275 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 12 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0038 + + 1276 ;THIS TEST VERIFIES THAT TDN NEVER SKIPS + 1277 ;NEXT SEQUENTIAL INSTRUCTION. + 1278 ;THIS TEST FAILS IF TDN SKIPS. + 1279 + 1280 031130 474 00 0 00 000000 B16000: SETO ;PRESET AC, E TO -1,,-1 + 1281 031131 610 00 0 00 000000 TDN ;*TDN SHOULD NOT SKIP + 1282 031132 334 00 0 00 000000 SKIPA ;SKIP HALT IF TDN PASSES + 1283 STOP^ + 1284 031133 254 04 0 00 031134 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1285 031134 324 00 0 00 031135 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1286 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1287 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1288 + 1289 ;********** + 1290 + 1291 ;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE + 1292 ;NEXT SEQUENTIAL INSTRUCTION. + 1293 ;THIS TEST FAILS IF TDN SKIPS. + 1294 + 1295 031135 400 00 0 00 000000 B16100: SETZ ;PRESET AC, E TO 0 + 1296 031136 610 00 0 00 000000 TDN ;*TDN SHOULD NOT SKIP + 1297 031137 334 00 0 00 000000 SKIPA ;SKIP HALT IF TDN PASSES + 1298 STOP^ + 1299 031140 254 04 0 00 031141 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1300 031141 324 00 0 00 031142 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1301 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1302 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1303 + 1304 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 13 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0039 + + 1305 ;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 1306 ;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED + 1307 ;BY C(E), ARE ZERO. + 1308 ;IN THIS TEST C(AC) = -1..0 AND C(E) = 707070..707070. + 1309 ;HENCE, TDNE SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION. + 1310 ;IF TDNE SKIPS, THIS TEST FAILS + 1311 + 1312 031142 200 00 0 00 034013 B16200: MOVE [XWD -1,0] ;PRELOAD AC WITH -1..0 + 1313 031143 612 00 0 00 034016 TDNE [707070707070] ;*TDNE SHOULD NOT SKIP + 1314 031144 334 00 0 00 000000 SKIPA ;SKIP HALT IF TDNE PASSES + 1315 STOP^ + 1316 031145 254 04 0 00 031146 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1317 031146 324 00 0 00 031147 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1318 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1319 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1320 + 1321 ;***** FAILURE ANALYSIS ***** + 1322 ;C(AC0) C(AC1) FAILING SIGNAL + 1323 + 1324 ;-1,,0 SW:FCE + 1325 ;-1,,0 SW: PC CHANGE + 1326 ;-1,,-1 FC: AD AR + EN + 1327 ;E ET2: MC INST FETCH EN + 1328 + 1329 ;********** + 1330 + 1331 ;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 1332 ;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED + 1333 ;BY C(E), ARE ZERO. + 1334 ;IN THIS CASE, AC=E AND C(AC)=0. + 1335 ;HENCE, TDNE SHOULD SKIP THE NEXT SEQUENTIAL INSTRUCTION + 1336 ;IF TDNE DOES NOT SKIP, THIS TEST FAILS. + 1337 + 1338 031147 400 00 0 00 000000 B16300: SETZ ;PRELOAD AC, E WITH 0 + 1339 031150 612 00 0 00 000000 TDNE ;*TDNE SHOULD SKIP THE NEXT INSTRUCTION + 1340 STOP^ + 1341 031151 254 04 0 00 031152 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1342 031152 324 00 0 00 031153 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1343 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1344 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1345 + 1346 ;***** FAILURE ANALYSIS ***** + 1347 ;C(AC0) C(AC1) FAILING SIGNAL + 1348 + 1349 ;0 SW: ET1 + 1350 ;0 ET1: PC CLOCK + 1351 + 1352 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 14 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0040 + + 1353 ;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 1354 ;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED + 1355 ;BY C(E) ARE ZERO. + 1356 ;IN THIS TEST AC=E AND C(AC)=C(E)=0. HENCE TDNN + 1357 ;SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION + 1358 ;IF TDNN SKIPS, THE TEST FAILS. + 1359 + 1360 031153 400 00 0 00 000000 B16400: SETZ ;PRELOAD AC,E WITH 0 + 1361 031154 616 00 0 00 000000 TDNN ;*TDNN SHOULD NOT SKIP THE NEXT INSTRUCTION + 1362 031155 334 00 0 00 000000 SKIPA ;SKIP HALT IF TDNE PASSES + 1363 STOP^ + 1364 031156 254 04 0 00 031157 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1365 031157 324 00 0 00 031160 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1366 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1367 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1368 + 1369 ;***** FAILURE ANALYSIS ***** + 1370 ;C(AC0) C(AC1) FAILING SIGNAL + 1371 + 1372 ;0 SW: PC CHANGE + 1373 ;0 FC: AB PC EN + 1374 ;0 ET2: MC INST FETCH EN + 1375 + 1376 ;********** + 1377 + 1378 ;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT + 1379 ;SEQUENTIAL INSTRUCTION. IF TDNA DOES NOT + 1380 ;SKIP, THIS TEST FAILS. + 1381 + 1382 031160 474 00 0 00 000000 B16500: SETO ;PRESET AC, E TO 0 + 1383 031161 614 00 0 00 000000 TDNA ;*TDNA SHOULD SKIP THE NEXT INSTRUCTION + 1384 STOP^ + 1385 031162 254 04 0 00 031163 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1386 031163 324 00 0 00 031164 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1387 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1388 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1389 + 1390 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 15 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0041 + + 1391 ;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 1392 ;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), + 1393 ;ARE ZERO + 1394 ;IN THIS TEST C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE, TDNN + 1395 ;SHOULD SKIP THE NEXT INSTRUCTION. IF IT DOES NOT SKIP, THIS TEST FAILS. + 1396 + 1397 031164 200 00 0 00 034013 B16600: MOVE [XWD -1,0] ;PRESET AC TO -1,,0 + 1398 031165 616 00 0 00 034016 TDNN [707070707070] ;*TDNN SHOULD SKIP THE NEXT INSTRUCTION + 1399 STOP^ + 1400 031166 254 04 0 00 031167 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1401 031167 324 00 0 00 031170 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1402 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1403 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1404 + 1405 ;***** FAILURE ANALYSIS ***** + 1406 ;C(AC0) C(AC1) FAILING SIGNAL + 1407 + 1408 ;-1,,0 SW: FCE + 1409 ;-1,,0 SW: ET1 + 1410 ;-1,,0 ET1: PC CLOCK + 1411 + 1412 ;********** + 1413 + 1414 ;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 1415 ;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED + 1416 ;BY C(E), ARE ZERO. + 1417 ;IN THIS TEST, C(AC)=-1,,-1 AND C(E)=0. HENCE, TDNE SHOULD SKIP + 1418 ;THE NEXT SEQUENTIAL INSTRUCTION. + 1419 ;IF TDNE DOES NOT SKIP, THIS TEST FAILS + 1420 + 1421 031170 474 00 0 00 000000 B16700: SETO ;PRESET AC TO ALL ONES + 1422 031171 612 00 0 00 034014 TDNE [0] ;*TDNE SHOULD SKIP THE NEXT INSTRUCTION + 1423 STOP^ + 1424 031172 254 04 0 00 031173 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1425 031173 324 00 0 00 031174 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1426 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1427 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1428 + 1429 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 16 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0042 + + 1430 ;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 1431 ;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED + 1432 ;BY C(E), ARE ZERO. + 1433 ;IN THIS TEST C(AC)=0 AND C(E)=-1,,-1, HENCE, TDNE SHOULD SKIP + 1434 ;THE NEXT SEQUENTIAL INSTRUCTION. + 1435 ;IF TDNE DOES NOT SKIP, THIS TEST FAILS + 1436 + 1437 031174 400 00 0 00 000000 B17000: SETZ ;PRESET AC TO 0 + 1438 031175 612 00 0 00 034012 TDNE [-1] ;*TDNE SHOULD SKIP THE NEXT INSTRUCTION + 1439 STOP^ + 1440 031176 254 04 0 00 031177 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1441 031177 324 00 0 00 031200 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1442 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1443 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1444 + 1445 ;***** FAILURE ANALYSIS ***** + 1446 ;C(AC0) C(AC1) FAILING SIGNAL + 1447 + 1448 ;0 FC: AD FM + EN + 1449 + 1450 ;********** + 1451 + 1452 ;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE NEXT SEQUENTIAL INSTRUCTION. + 1453 ;THIS TEST FAILS IF TDN SKIPS + 1454 + 1455 031200 474 00 0 00 000000 B17300: SETO ;PRESET AC TO -1,,-1 + 1456 031201 610 00 0 00 034014 TDN [0] ;*TDN SHOULD NOT SKIP + 1457 031202 334 00 0 00 000000 SKIPA ;SKIP HALT IF TDN PASSES + 1458 STOP^ + 1459 031203 254 04 0 00 031204 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1460 031204 324 00 0 00 031205 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1461 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1462 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1463 + 1464 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 17 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0043 + + 1465 ;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE NEXT SEQUENTIAL INSTRUCTION. + 1466 ;THIS TEST FAILS IF TDN SKIPS + 1467 + 1468 031205 400 00 0 00 000000 B17400: SETZ ;PRESET AC TO 0 + 1469 031206 610 00 0 00 034012 TDN [-1] ;*TDN SHOULD NOT SKIP + 1470 031207 334 00 0 00 000000 SKIPA ;SKIP HALT IF TDN PASSES + 1471 STOP^ + 1472 031210 254 04 0 00 031211 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1473 031211 324 00 0 00 031212 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1474 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1475 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1476 + 1477 ;********** + 1478 + 1479 ;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT SEQUENTIAL INSTRUCTION + 1480 ;THIS TEST FAILS IF TDNA DOES NOT SKIP + 1481 + 1482 031212 474 00 0 00 000000 B17700: SETO ;PRESET AC TO -1,,-1 + 1483 031213 614 00 0 00 034014 TDNA [0] ;*TDNA SHOULD SKIP + 1484 STOP^ + 1485 031214 254 04 0 00 031215 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1486 031215 324 00 0 00 031216 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1487 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1488 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1489 + 1490 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 18 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0044 + + 1491 ;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT SEQUENTIAL INSTRUCTION + 1492 ;THIS TEST FAILS IF TDNA DOES NOT SKIP + 1493 + 1494 031216 400 00 0 00 000000 B20000: SETZ ;PRESET AC TO 0 + 1495 031217 614 00 0 00 034012 TDNA [-1] ;*TDNA SHOULD SKIP + 1496 STOP^ + 1497 031220 254 04 0 00 031221 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1498 031221 324 00 0 00 031222 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1499 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1500 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1501 + 1502 ;********** + 1503 + 1504 ;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 1505 ;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. + 1506 ;IN THIS TEST AC=E AND C(AC)=C(E)=-1,,-1. HENCE TDNE SHOULD NOT SKIP. + 1507 ;IF TDNE SKIPS, THIS TEST FAILS. + 1508 + 1509 031222 474 00 0 00 000000 B20400: SETO ;PRESET AC,E TO -1,,-1 + 1510 031223 612 00 0 00 000000 TDNE ;*TDNE SHOULD NOT SKIP + 1511 031224 334 00 0 00 000000 SKIPA ;SKIP HALT IF TDNE PASSES + 1512 STOP^ + 1513 031225 254 04 0 00 031226 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1514 031226 324 00 0 00 031227 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1515 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1516 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1517 + 1518 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 19 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0045 + + 1519 ;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 1520 ;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. + 1521 ;IN THIS TEST, AC=E AND C(AC)=C(E)=-1,,-1. HENCE TDNN SHOULD SKIP + 1522 ;IF TDNN DOES NOT SKIP, THIS TEST FAILS + 1523 + 1524 031227 474 00 0 00 000000 B20600: SETO ;PRESET AC,E TO -1,,-1 + 1525 031230 616 00 0 00 000000 TDNN ;*TDNN SHOULD SKIP THE NEXT SEQUENTIAL INSTRUCTION + 1526 STOP^ + 1527 031231 254 04 0 00 031232 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1528 031232 324 00 0 00 031233 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1529 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1530 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1531 + 1532 ;********** + 1533 + 1534 ;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 1535 ;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. + 1536 ;IN THIS TEST, C(AC)=0 AND C(E)=-1,,-1. HENCE TDNN SHOULD NOT SKIP + 1537 ;IF TDNN SKIPS, THIS TEST FAILS + 1538 + 1539 031233 400 00 0 00 000000 B20700: SETZ ;PRESET AC TO 0 + 1540 031234 616 00 0 00 034012 TDNN [-1] ;*TDNN SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION + 1541 031235 334 00 0 00 000000 SKIPA ;SKIP HALT IF TDNN PASSES + 1542 STOP^ + 1543 031236 254 04 0 00 031237 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1544 031237 324 00 0 00 031240 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1545 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1546 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1547 + 1548 ;***** FAILURE ANALYSIS ***** + 1549 ;C(AC0) C(AC1) FAILING SIGNAL + 1550 + 1551 ;0 FC: AD FM + EN + 1552 + 1553 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 20 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0046 + + 1554 ;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN + 1555 ;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. + 1556 ;IN THIS TEST, C(AC)=-1,,-1 AND C(E)=0. HENCE TDNN SHOULD NOT SKIP + 1557 ;IF TDNN SKIPS, THIS TEST FAILS + 1558 + 1559 031240 474 00 0 00 000000 B21000: SETO ;PRESET AC TO -1,,-1 + 1560 031241 616 00 0 00 034014 TDNN [0] ;*TDNN SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION + 1561 031242 334 00 0 00 000000 SKIPA ;SKIP HALT IF TDNN PASSES + 1562 STOP^ + 1563 031243 254 04 0 00 031244 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1564 031244 324 00 0 00 031245 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1565 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1566 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1567 + 1568 ;***** FAILURE ANALYSIS ***** + 1569 ;C(AC0) C(AC1) FAILING SIGNAL + 1570 + 1571 ;-1,,-1 FC: AD AR + EN + 1572 + 1573 ;********** + 1574 + 1575 ;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC + 1576 ;WHICH ARE MASKED BY C(E) AND DOES NOT EFFECT THE UNMASKED BITS OF THE AC. + 1577 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 + 1578 ;THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + 1579 + 1580 031245 400 00 0 00 000000 B21100: SETZ ;PRELOAD AC WITH 0 + 1581 031246 670 00 0 00 034013 TDO [XWD -1,0] ;*TDO SHOULD PLACE -1,,0 INTO THE AC + 1582 031247 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 1583 STOP^ + 1584 031250 254 04 0 00 031251 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1585 031251 324 00 0 00 031252 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1586 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1587 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1588 + 1589 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 21 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0047 + + 1590 ;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC + 1591 ;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. + 1592 ;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED + 1593 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, + 1594 ;THE RESULT IN THE AC SHOULD BE 0,,-1. THE AC IS + 1595 ;CHECKED FOR 0,,-1. THIS TEST PASSES IF C(AC)=0,,-1 + 1596 + 1597 031252 400 00 0 00 000000 B21400: SETZ ;PRESET AC WITH 0 + 1598 031253 671 00 0 00 034013 TSO [XWD -1,0] ;*TSO SHOULD PLACE 0,,-1 INTO THE AC + 1599 031254 312 00 0 00 034015 CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + 1600 STOP^ + 1601 031255 254 04 0 00 031256 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1602 031256 324 00 0 00 031257 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1603 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1604 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1605 + 1606 ;***** FAILURE ANALYSIS ***** + 1607 ;C(AC0) C(AC1) FAILING SIGNAL + 1608 + 1609 ;0 SW: FCE + 1610 ;0 SW: ET0 + 1611 ;0 SW: ET1 + 1612 ;0 FC: AD FM + EN + 1613 ;0 FC: AD AR + EN + 1614 ;0 ET0: AR SWAP + 1615 ;0 ET0: AD FM + EN + 1616 ;0 ET0: AD AR + EN + 1617 ;0 ET1: BR AR EN + 1618 ;0 ET1: AD BR - EN + 1619 ;-1,,-1 ET1: AD AR + EN + 1620 ;0 ET1: AD EQV + 1621 + 1622 ;********** + 1623 + 1624 ;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC + 1625 ;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. + 1626 ;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED + 1627 ;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1. HENCE, + 1628 ;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS + 1629 ;CHECKED FOR -1,,0. THIS TEST PASSES IF C(AC)=-1,,0 + 1630 + 1631 031257 400 00 0 00 000000 B21500: SETZ ;PRESET AC WITH 0 + 1632 031260 671 00 0 00 034015 TSO [XWD 0,-1] ;*TSO SHOULD PLACE -1,,0 INTO THE AC + 1633 031261 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 1634 STOP^ + 1635 031262 254 04 0 00 031263 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1636 031263 324 00 0 00 031264 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1637 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1638 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1639 + 1640 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 22 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0048 + + 1641 ;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC + 1642 ;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. + 1643 ;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED + 1644 ;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1. HENCE, + 1645 ;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS + 1646 ;CHECKED FOR ITS CONTENTS NON-ZERO. THIS TEST PASSES IF C(AC) IS NON-ZERO + 1647 + 1648 031264 400 00 0 00 000000 B21600: SETZ ;PRELOAD AC,E WITH 0 + 1649 031265 671 00 0 00 000000 TSO ;*TSO SHOULD PLACE 0 INTO THE AC + 1650 031266 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 1651 STOP^ + 1652 031267 254 04 0 00 031270 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1653 031270 324 00 0 00 031271 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1654 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1655 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1656 + 1657 ;********** + 1658 + 1659 ;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC + 1660 ;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. + 1661 ;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED + 1662 ;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE, + 1663 ;THE RESULT IN THE AC SHOULD BE -1,,-1. THE AC IS + 1664 ;CHECKED FOR -1,,-1. THIS TEST PASSES IF C(AC) -1,,-1 + 1665 + 1666 031271 474 00 0 00 000000 B21700: SETO ;PRELOAD AC,E WITH -1,,-1 + 1667 031272 671 00 0 00 000000 TSO ;*TSO SHOULD PLACE -1,,-1 INTO THE AC + 1668 031273 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 1669 STOP^ + 1670 031274 254 04 0 00 031275 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1671 031275 324 00 0 00 031276 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1672 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1673 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1674 + 1675 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 23 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0049 + + 1676 ;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC + 1677 ;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. + 1678 ;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED + 1679 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0,,-1. HENCE, + 1680 ;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS + 1681 ;CHECKED FOR -1,,0. THIS TEST PASSES IF C(AC)=-1,,0 + 1682 + 1683 031276 200 00 0 00 034013 B22200: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + 1684 031277 671 00 0 00 034015 TSO [XWD 0,-1] ;*TSO SHOULD PLACE -1,,0 INTO THE AC + 1685 031300 312 00 0 00 034013 CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + 1686 STOP^ + 1687 031301 254 04 0 00 031302 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1688 031302 324 00 0 00 031303 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1689 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1690 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1691 + 1692 ;********** + 1693 + 1694 ;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC + 1695 ;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. + 1696 ;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED + 1697 ;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, + 1698 ;THE RESULT IN THE AC SHOULD BE 0,,-1. THE AC IS + 1699 ;CHECKED FOR 0,,-1. THIS TEST PASSES IF C(AC)=0,,-1 + 1700 + 1701 031303 201 00 0 00 777777 B22300: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 1702 031304 671 00 0 00 034014 TSO [0] ;*TSO SHOULD PLACE 0,,-1 INTO THE AC + 1703 031305 312 00 0 00 034015 CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + 1704 STOP^ + 1705 031306 254 04 0 00 031307 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1706 031307 324 00 0 00 031310 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1707 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1708 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1709 + 1710 ;***** FAILURE ANALYSIS ***** + 1711 ;C(AC0) C(AC1) FAILING SIGNAL + 1712 + 1713 ;0 ET1: AD FM - EN + 1714 ;0 ET2: AR AD EN + 1715 + 1716 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 24 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0050 + + 1717 ;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC + 1718 ;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. + 1719 ;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED + 1720 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, + 1721 ;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS + 1722 ;CHECKED FOR -1,,0. THIS TEST PASSES IF C(AC)=-1,,0 + 1723 + 1724 031310 200 00 0 00 034013 B22400: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + 1725 031311 671 00 0 00 034014 TSO [0] ;*TSO SHOULD PLACE -1,,0 INTO THE AC + 1726 031312 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 1727 STOP^ + 1728 031313 254 04 0 00 031314 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1729 031314 324 00 0 00 031315 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1730 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1731 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1732 + 1733 ;********** + 1734 + 1735 ;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC + 1736 ;WHICH ARE MARKED BY BOTH HALVES OF C(E) SWAPPED. + 1737 ;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED + 1738 ;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, + 1739 ;THE RESULT IN THE AC SHOULD BE -1,,-1. THE AC IS + 1740 ;CHECKED FOR -1,,-1. THIS TEST PASSES IF C(AC)=-1,,-1 + 1741 + 1742 031315 201 00 0 00 777777 B22500: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 1743 031316 671 00 0 00 034012 TSO [-1] ;*TSO SHOULD PLACE -1,,-1 INTO THE AC + 1744 031317 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 1745 STOP^ + 1746 031320 254 04 0 00 031321 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1747 031321 324 00 0 00 031322 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1748 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1749 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1750 + 1751 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 25 +DAKACM MAC 19-JAN-77 13:40 TEST OF LOGICAL TEST INSTRUCTIONS SEQ 0051 + + 1752 ;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC + 1753 ;WHICH ARE MARKED BY BOTH HALVES OF C(E) SWAPPED. + 1754 ;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED + 1755 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, + 1756 ;THE RESULT IN THE AC SHOULD BE -1,,-1. THE AC IS + 1757 ;CHECKED FOR -1,,-1. THIS TEST PASSES IF C(AC)=-1,,-1 + 1758 + 1759 031322 200 00 0 00 034013 B22600: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + 1760 031323 671 00 0 00 034012 TSO [-1] ;*TSO SHOULD PLACE -1,,-1 INTO THE AC + 1761 031324 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 1762 STOP^ + 1763 031325 254 04 0 00 031326 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1764 031326 324 00 0 00 031327 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1765 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1766 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1767 + 1768 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 26 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0052 + + 1769 SUBTTL TEST OF HWT INSTRUCTIONS + 1770 + 1771 ;********** + 1772 + 1773 ;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO + 1774 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. + 1775 ;IN THIS CASE AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC + 1776 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 1777 + 1778 031327 400 00 0 00 000000 B22700: SETZ ;PRELOAD AC,E WITH 0 + 1779 031330 500 00 0 00 000000 HLL ;*HLL SHOULD PLACE 0 INTO THE AC + 1780 031331 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 1781 STOP^ + 1782 031332 254 04 0 00 031333 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1783 031333 324 00 0 00 031334 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1784 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1785 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1786 + 1787 ;***** FAILURE ANALYSIS ***** + 1788 ;C(AC0) C(AC1) FAILING SIGNAL + 1789 + 1790 ;-1,,0 FC: AD AR + EN + 1791 ;0,,-1 FC: AD RT FM + EN + 1792 + 1793 ;********** + 1794 + 1795 ;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO + 1796 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. + 1797 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 1798 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, + 1799 ;THIS TEST PASSES. + 1800 + 1801 031334 474 00 0 00 000000 B23000: SETO ;PRELOAD AC WITH -1,,-1 + 1802 031335 500 00 0 00 034014 HLL [0] ;*HLL SHOULD PLACE 0,,-1 INTO THE AC + 1803 031336 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 1804 STOP^ + 1805 031337 254 04 0 00 031340 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1806 031340 324 00 0 00 031341 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 ;***** FAILURE ANALYSIS ***** + 1811 ;C(AC0) C(AC1) FAILING SIGNAL + 1812 + 1813 ;0,,-1 SW: FCE + 1814 ;0 ET2: AR AD EN + 1815 + 1816 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 27 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0053 + + 1817 ;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO + 1818 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. + 1819 ;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 1820 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 1821 + 1822 031341 474 00 0 00 000000 B23200: SETO ;PRELOAD AC,E WITH -1,,-1 + 1823 031342 500 00 0 00 000000 HLL ;*HLL SHOULD PLACE -1,,-1 INTO THE AC + 1824 031343 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 1825 STOP^ + 1826 031344 254 04 0 00 031345 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1827 031345 324 00 0 00 031346 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1828 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1829 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1830 + 1831 ;********** + 1832 + 1833 ;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO + 1834 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. + 1835 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 1836 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, + 1837 ;THIS TEST PASSES + 1838 + 1839 031346 400 00 0 00 000000 B23400: SETZ ;PRELOAD AC WITH 0 + 1840 031347 500 00 0 00 034012 HLL [-1] ;*HLL SHOULD PLACE -1,,0 INTO THE AC + 1841 031350 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 1842 STOP^ + 1843 031351 254 04 0 00 031352 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1844 031352 324 00 0 00 031353 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 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 28 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0054 + + 1849 ;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO + 1850 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. + 1851 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 1852 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, + 1853 ;THIS TEST PASSES. + 1854 + 1855 031353 400 00 0 00 000000 B23600: SETZ ;PRELOAD AC WITH 0 + 1856 031354 500 00 0 00 034013 HLL [XWD -1,0] ;*HLL SHOULD PLACE -1,,0 INTO THE AC + 1857 031355 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 1858 STOP^ + 1859 031356 254 04 0 00 031357 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1860 031357 324 00 0 00 031360 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1861 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1862 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1863 + 1864 ;********** + 1865 + 1866 ;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO + 1867 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. + 1868 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0,,-1. HENCE, THE RESULT IN THE AC + 1869 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, + 1870 ;THIS TEST PASSES. + 1871 + 1872 031360 474 00 0 00 000000 B23700: SETO ;PRELOAD AC WITH -1,,-1 + 1873 031361 500 00 0 00 034015 HLL [XWD 0,-1] ;*HLL SHOULD PLACE 0,,-1 INTO THE AC + 1874 031362 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 1875 STOP^ + 1876 031363 254 04 0 00 031364 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1877 031364 324 00 0 00 031365 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1878 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1879 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1880 + 1881 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 29 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0055 + + 1882 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 1883 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 1884 ;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC + 1885 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 1886 + 1887 031365 400 00 0 00 000000 B24000: SETZ ;PRELOAD AC,E WITH 0 + 1888 031366 510 00 0 00 000000 HLLZ ;*HLLZ SHOULD PLACE 0 INTO THE AC + 1889 031367 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 1890 STOP^ + 1891 031370 254 04 0 00 031371 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1892 031371 324 00 0 00 031372 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1893 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1894 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1895 + 1896 ;***** FAILURE ANALYSIS ***** + 1897 ;C(AC0) C(AC1) FAILING SIGNAL + 1898 + 1899 ;-1,,0 FC: AD LT AR + EN + 1900 + 1901 ;********** + 1902 + 1903 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 1904 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 1905 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 1906 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. + 1907 ;IF C(AC)=-1,,0, THIS TEST PASSES. + 1908 + 1909 031372 474 00 0 00 000000 B24300: SETO ;PRELOAD AC WITH -1,,-1 + 1910 031373 510 00 0 00 034012 HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + 1911 031374 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 1912 STOP^ + 1913 031375 254 04 0 00 031376 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1914 031376 324 00 0 00 031377 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1915 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1916 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1917 + 1918 ;***** FAILURE ANALYSIS ***** + 1919 ;C(AC0) C(AC1) FAILING SIGNAL + 1920 + 1921 ;0 SW: FCE + 1922 ;-1,,-1 ET2: AR LT AD EN + 1923 + 1924 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 30 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0056 + + 1925 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 1926 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 1927 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 1928 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO + 1929 ;IF C(AC) IS NON-ZERO, THIS TEST PASSES. + 1930 + 1931 031377 400 00 0 00 000000 B24400: SETZ ;PRELOAD AC WITH -1,,-1 + 1932 031400 510 00 0 00 034012 HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + 1933 031401 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 1934 STOP^ + 1935 031402 254 04 0 00 031403 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1936 031403 324 00 0 00 031404 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1937 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1938 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1939 + 1940 ;********** + 1941 + 1942 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 1943 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 1944 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 1945 ;SHOULD BE 0. THE AC IS CHECKED FOR ZERO + 1946 ;IF C(AC) IS ZERO, THIS TEST PASSES. + 1947 + 1948 031404 474 00 0 00 000000 B24500: SETO ;PRELOAD AC WITH -1,,-1 + 1949 031405 510 00 0 00 034014 HLLZ [0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + 1950 031406 332 00 0 00 000000 SKIPE ;PASS IF C(AC) IS ZERO. + 1951 STOP^ + 1952 031407 254 04 0 00 031410 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1953 031410 324 00 0 00 031411 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1954 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1955 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1956 + 1957 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 31 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0057 + + 1958 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 1959 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 1960 ;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC + 1961 ;SHOULD BE 0. THE AC IS CHECKED FOR ZERO + 1962 ;IF C(AC) IS ZERO, THIS TEST PASSES. + 1963 + 1964 031411 400 00 0 00 000000 B24600: SETZ ;PRELOAD AC WITH 0 + 1965 031412 510 00 0 00 034014 HLLZ [0] ;*HLLZ SHOULD PLACE 0 INTO THE AC + 1966 031413 332 00 0 00 000000 SKIPE ;PASS IF C(AC) IS ZERO. + 1967 STOP^ + 1968 031414 254 04 0 00 031415 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1969 031415 324 00 0 00 031416 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1970 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1971 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1972 + 1973 ;********** + 1974 + 1975 ;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. + 1976 ;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1. + 1977 ;THE RESULT IN THE AC SHOULD BE 0 + 1978 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 1979 + 1980 031416 474 00 0 00 000000 B24700: SETO ;PRELOAD AC WITH -1,,-1 + 1981 031417 511 00 0 00 777777 HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + 1982 031420 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 1983 STOP^ + 1984 031421 254 04 0 00 031422 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1985 031422 324 00 0 00 031423 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 1986 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 1987 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 1988 + 1989 ;***** FAILURE ANALYSIS ***** + 1990 ;C(AC0) C(AC1) FAILING SIGNAL + 1991 + 1992 ;-1,,0 FC: AD LT AR + EN + 1993 ;0,,-1 ET2: AR LT AD EN + 1994 + 1995 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 32 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0058 + + 1996 ;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. + 1997 ;IN THIS CASE C(AC)=0 AND E=0,,-1. + 1998 ;THE RESULT IN THE AC SHOULD BE 0 + 1999 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 2000 + 2001 031423 400 00 0 00 000000 B25000: SETZ ;PRELOAD AC WITH 0 + 2002 031424 511 00 0 00 777777 HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + 2003 031425 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2004 STOP^ + 2005 031426 254 04 0 00 031427 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2006 031427 324 00 0 00 031430 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2007 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2008 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2009 + 2010 ;********** + 2011 + 2012 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 2013 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 2014 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2015 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. + 2016 ;IF C(AC)=-1,,0, THIS TEST PASSES. + 2017 + 2018 031430 474 00 0 00 000000 B25100: SETO ;PRELOAD AC WITH -1,,-1 + 2019 031431 510 00 0 00 034013 HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + 2020 031432 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + 2021 STOP^ + 2022 031433 254 04 0 00 031434 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2023 031434 324 00 0 00 031435 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2024 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2025 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2026 + 2027 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 33 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0059 + + 2028 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 2029 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 2030 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2031 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. + 2032 ;IF C(AC)=-1,,0 THIS TEST PASSES. + 2033 + 2034 031435 400 00 0 00 000000 B25200: SETZ ;PRELOAD AC WITH 0 + 2035 031436 510 00 0 00 034013 HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + 2036 031437 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 2037 STOP^ + 2038 031440 254 04 0 00 031441 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2039 031441 324 00 0 00 031442 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2040 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2041 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2042 + 2043 ;********** + 2044 + 2045 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 2046 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 2047 ;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2048 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. + 2049 ;IF C(AC)=-1,,0, THIS TEST PASSES. + 2050 + 2051 031442 201 00 0 00 777777 B25300: MOVEI -1 ;PRELOAD AC WITH -1,,-1 + 2052 031443 510 00 0 00 034012 HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + 2053 031444 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 2054 STOP^ + 2055 031445 254 04 0 00 031446 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2056 031446 324 00 0 00 031447 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2057 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2058 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2059 + 2060 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 34 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0060 + + 2061 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 2062 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 2063 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2064 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. + 2065 ;IF C(AC)=-1,,0 THIS TEST PASSES. + 2066 + 2067 031447 205 00 0 00 777777 B25400: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2068 031450 510 00 0 00 034012 HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + 2069 031451 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + 2070 STOP^ + 2071 031452 254 04 0 00 031453 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2072 031453 324 00 0 00 031454 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2073 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2074 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2075 + 2076 ;********** + 2077 + 2078 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 2079 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 2080 ;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2081 ;SHOULD BE 0. THE AC IS CHECKED FOR ZERO. + 2082 ;IF C(AC) IS ZERO, THIS TEST PASSES. + 2083 + 2084 031454 201 00 0 00 777777 B25500: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2085 031455 510 00 0 00 034014 HLLZ [0] ;*HLLZ SHOULD PLACE 0 INTO THE AC + 2086 031456 332 00 0 00 000000 SKIPE ;PASS IF C(AC) IS ZERO. + 2087 STOP^ + 2088 031457 254 04 0 00 031460 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2089 031460 324 00 0 00 031461 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2090 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2091 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2092 + 2093 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 35 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0061 + + 2094 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 2095 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 2096 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2097 ;SHOULD BE 0. THE AC IS CHECKED FOR ZERO. + 2098 ;IF C(AC) IS ZERO, THIS TEST PASSES. + 2099 + 2100 031461 205 00 0 00 777777 B25600: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2101 031462 510 00 0 00 034014 HLLZ [0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + 2102 031463 332 00 0 00 000000 SKIPE ;PASS IF C(AC) IS ZERO. + 2103 STOP^ + 2104 031464 254 04 0 00 031465 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2105 031465 324 00 0 00 031466 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2106 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2107 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2108 + 2109 ;********** + 2110 + 2111 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 2112 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 2113 ;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2114 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. + 2115 ;IF C(AC)=-1,,0, THIS TEST PASSES. + 2116 + 2117 031466 201 00 0 00 777777 B25700: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2118 031467 510 00 0 00 034013 HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + 2119 031470 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 2120 STOP^ + 2121 031471 254 04 0 00 031472 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2122 031472 324 00 0 00 031473 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2123 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2124 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2125 + 2126 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 36 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0062 + + 2127 ;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. + 2128 ;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1. + 2129 ;THE RESULT IN THE AC SHOULD BE 0 + 2130 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 2131 + 2132 031473 201 00 0 00 777777 B26000: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2133 031474 511 00 0 00 777777 HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + 2134 031475 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2135 STOP^ + 2136 031476 254 04 0 00 031477 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2137 031477 324 00 0 00 031500 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2138 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2139 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2140 + 2141 ;********** + 2142 + 2143 ;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO + 2144 ;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 2145 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2146 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. + 2147 ;IF C(AC)=-1,,0, THIS TEST PASSES. + 2148 + 2149 031500 205 00 0 00 777777 B26100: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2150 031501 510 00 0 00 034013 HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + 2151 031502 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 2152 STOP^ + 2153 031503 254 04 0 00 031504 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2154 031504 324 00 0 00 031505 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 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 37 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0063 + + 2159 ;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. + 2160 ;IN THIS CASE C(AC)=-1,,0 AND E=0,,-1. + 2161 ;THE RESULT IN THE AC SHOULD BE 0 + 2162 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 2163 + 2164 031505 205 00 0 00 777777 B26200: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2165 031506 511 00 0 00 777777 HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + 2166 031507 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2167 STOP^ + 2168 031510 254 04 0 00 031511 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2169 031511 324 00 0 00 031512 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2170 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2171 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2172 + 2173 ;********** + 2174 + 2175 ;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO + 2176 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2177 ;IN THIS CASE AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC + 2178 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2179 + 2180 031512 400 00 0 00 000000 B26300: SETZ ;PRELOAD AC WITH 0 + 2181 031513 540 00 0 00 000000 HRR ;*HRR SHOULD PLACE 0 INTO THE AC + 2182 031514 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2183 STOP^ + 2184 031515 254 04 0 00 031516 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2185 031516 324 00 0 00 031517 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2186 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2187 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2188 + 2189 ;***** FAILURE ANALYSIS ***** + 2190 ;C(AC0) C(AC1) FAILING SIGNAL + 2191 + 2192 ;0,,-1 FC: AD RT AR + EN + 2193 ;-1,,0 FC: AD LT FM + EN + 2194 + 2195 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 38 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0064 + + 2196 ;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO + 2197 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2198 ;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2199 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 2200 + 2201 031517 474 00 0 00 000000 B26500: SETO ;PRELOAD AC WITH -1,,-1 + 2202 031520 540 00 0 00 000000 HRR ;*HRR SHOULD PLACE -1,,-1 INTO THE AC + 2203 031521 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 2204 STOP^ + 2205 031522 254 04 0 00 031523 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2206 031523 324 00 0 00 031524 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2207 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2208 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2209 + 2210 ;***** FAILURE ANALYSIS ***** + 2211 ;C(AC0) C(AC1) FAILING SIGNAL + 2212 + 2213 ;-1,,0 SW: FCE + 2214 + 2215 ;********** + 2216 + 2217 ;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO + 2218 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2219 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2220 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + 2221 + 2222 031524 474 00 0 00 000000 B26600: SETO ;PRELOAD AC WITH -1,,-1 + 2223 031525 540 00 0 00 034013 HRR [XWD -1,0] ;*HRR SHOULD PLACE -1,,0 INTO THE AC + 2224 031526 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 2225 STOP^ + 2226 031527 254 04 0 00 031530 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2227 031530 324 00 0 00 031531 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2228 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2229 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2230 + 2231 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 39 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0065 + + 2232 ;THIS TEST VERIFIES THAT HRRI PLACES E INTO + 2233 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED + 2234 ;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC + 2235 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 2236 + 2237 031531 474 00 0 00 000000 B26700: SETO ;PRELOAD AC WITH -1,,-1 + 2238 031532 541 00 0 00 777777 HRRI -1 ;*HRRI SHOULD PLACE -1,,-1 INTO THE AC + 2239 031533 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 2240 STOP^ + 2241 031534 254 04 0 00 031535 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2242 031535 324 00 0 00 031536 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2243 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2244 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2245 + 2246 ;***** FAILURE ANALYSIS ***** + 2247 ;C(AC0) C(AC1) FAILING SIGNAL + 2248 + 2249 ;0,,-1 ET2: AR AD EN + 2250 + 2251 ;********** + 2252 + 2253 ;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO + 2254 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2255 ;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2256 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + 2257 + 2258 031536 474 00 0 00 000000 B27000: SETO ;PRELOAD AC WITH -1,,-1 + 2259 031537 540 00 0 00 034014 HRR [0] ;*HRR SHOULD PLACE -1,,0 INTO THE AC + 2260 031540 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=0 + 2261 STOP^ + 2262 031541 254 04 0 00 031542 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2263 031542 324 00 0 00 031543 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2264 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2265 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2266 + 2267 ;***** FAILURE ANALYSIS ***** + 2268 ;C(AC0) C(AC1) FAILING SIGNAL + 2269 + 2270 ;0 ET2: AR AD EN + 2271 + 2272 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 40 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0066 + + 2273 ;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO + 2274 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2275 ;IN THIS CASE C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2276 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2277 + 2278 031543 400 00 0 00 000000 B27100: SETZ ;PRELOAD AC WITH 0 + 2279 031544 540 00 0 00 034014 HRR [0] ;*HRR SHOULD PLACE 0 INTO THE AC + 2280 031545 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2281 STOP^ + 2282 031546 254 04 0 00 031547 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2283 031547 324 00 0 00 031550 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2284 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2285 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2286 + 2287 ;********** + 2288 + 2289 ;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO + 2290 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2291 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2292 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2293 + 2294 031550 400 00 0 00 000000 B27200: SETZ ;PRELOAD AC WITH 0 + 2295 031551 540 00 0 00 034012 HRR [-1] ;*HRR SHOULD PLACE 0,,-1 INTO THE AC + 2296 031552 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2297 STOP^ + 2298 031553 254 04 0 00 031554 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2299 031554 324 00 0 00 031555 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2300 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2301 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2302 + 2303 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 41 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0067 + + 2304 ;THIS TEST VERIFIES THAT HRRI PLACES E INTO + 2305 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED + 2306 ;IN THIS CASE C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC + 2307 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2308 + 2309 031555 400 00 0 00 000000 B27300: SETZ ;PRELOAD AC WITH 0 + 2310 031556 541 00 0 00 777777 HRRI -1 ;*HRRI SHOULD PLACE 0,,-1 INTO THE AC + 2311 031557 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2312 STOP^ + 2313 031560 254 04 0 00 031561 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2314 031561 324 00 0 00 031562 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2315 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2316 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2317 + 2318 ;***** FAILURE ANALYSIS ***** + 2319 ;C(AC0) C(AC1) FAILING SIGNAL + 2320 + 2321 ;-1,,-1 FC: AD LT FM + EN + 2322 + 2323 ;********** + 2324 + 2325 ;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO + 2326 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2327 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2328 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2329 + 2330 031562 400 00 0 00 000000 B27400: SETZ ;PRELOAD AC WITH 0 + 2331 031563 540 00 0 00 034013 HRR [XWD -1,0] ;*HRR SHOULD PLACE 0 INTO THE AC + 2332 031564 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2333 STOP^ + 2334 031565 254 04 0 00 031566 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2335 031566 324 00 0 00 031567 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2336 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2337 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2338 + 2339 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 42 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0068 + + 2340 ;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO + 2341 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2342 ;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2343 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2344 + 2345 031567 201 00 0 00 777777 B27500: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2346 031570 540 00 0 00 034013 HRR [XWD -1,0] ;*HRR SHOULD PLACE 0 INTO THE AC + 2347 031571 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2348 STOP^ + 2349 031572 254 04 0 00 031573 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2350 031573 324 00 0 00 031574 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2351 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2352 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2353 + 2354 ;********** + 2355 + 2356 ;THIS TEST VERIFIES THAT HRRI PLACES E INTO + 2357 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED + 2358 ;IN THIS CASE C(AC)=-1,,0 AND E=0,,-1. HENCE, THE RESULT IN THE AC + 2359 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 2360 + 2361 031574 205 00 0 00 777777 B27600: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2362 031575 541 00 0 00 777777 HRRI -1 ;*HRRI SHOULD PLACE -1,,-1 INTO THE AC + 2363 031576 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 2364 STOP^ + 2365 031577 254 04 0 00 031600 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2366 031600 324 00 0 00 031601 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2367 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2368 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2369 + 2370 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 43 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0069 + + 2371 ;THIS TEST VERIFIES THAT HRRI PLACES E INTO + 2372 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED + 2373 ;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC + 2374 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2375 + 2376 031601 201 00 0 00 777777 B27700: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2377 031602 541 00 0 00 777777 HRRI -1 ;*HRRI SHOULD PLACE 0,,-1 INTO THE AC + 2378 031603 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2379 STOP^ + 2380 031604 254 04 0 00 031605 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2381 031605 324 00 0 00 031606 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2382 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2383 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2384 + 2385 ;********** + 2386 + 2387 ;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO + 2388 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2389 ;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2390 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + 2391 + 2392 031606 205 00 0 00 777777 B30000: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2393 031607 540 00 0 00 034013 HRR [XWD -1,0] ;*HRR SHOULD PLACE -1,,0 INTO THE AC + 2394 031610 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 2395 STOP^ + 2396 031611 254 04 0 00 031612 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2397 031612 324 00 0 00 031613 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2398 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2399 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2400 + 2401 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 44 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0070 + + 2402 ;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO + 2403 ;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC + 2404 ;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC + 2405 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2406 + 2407 031613 400 00 0 00 000000 B30100: SETZ ;PRELOAD AC,E WITH 0 + 2408 031614 550 00 0 00 000000 HRRZ ;*HRRZ SHOULD PLACE 0 INTO THE AC + 2409 031615 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2410 STOP^ + 2411 031616 254 04 0 00 031617 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2412 031617 324 00 0 00 031620 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2413 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2414 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2415 + 2416 ;***** FAILURE ANALYSIS ***** + 2417 ;C(AC0) C(AC1) FAILING SIGNAL + 2418 + 2419 ;0,,-1 FC: AD RT AR + EN + 2420 + 2421 ;********** + 2422 + 2423 ;THIS TEST VERIFIES THAT HRRZI PLACES E INTO + 2424 ;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC + 2425 ;IN THIS CASE C(AC)=-1,,-1. HENCE, THE RESULT IN THE AC + 2426 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + 2427 + 2428 031620 474 00 0 00 000000 B30400: SETO ;PRELOAD AC WITH -1,,-1 + 2429 031621 551 00 0 00 777777 HRRZI -1 ;*HRRZI SHOULD PLACE 0,,-1 INTO THE AC + 2430 031622 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2431 STOP^ + 2432 031623 254 04 0 00 031624 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2433 031624 324 00 0 00 031625 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2434 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2435 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2436 + 2437 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 45 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0071 + + 2438 ;THIS TEST VERIFIES THAT HRRZI PLACES E INTO + 2439 ;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC + 2440 ;IN THIS CASE C(AC)=-1,,-1. HENCE, THE RESULT IN THE AC + 2441 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 2442 + 2443 031625 474 00 0 00 000000 B30500: SETO ;PRELOAD AC WITH -1,,-1 + 2444 031626 551 00 0 00 000000 HRRZI 0 ;*HRRZI SHOULD PLACE 0 INTO THE AC + 2445 031627 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2446 STOP^ + 2447 031630 254 04 0 00 031631 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2448 031631 324 00 0 00 031632 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2449 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2450 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2451 + 2452 ;***** FAILURE ANALYSIS ***** + 2453 ;C(AC0) C(AC1) FAILING SIGNAL + 2454 + 2455 ;0,,-1 FC: AD RT AR + EN + 2456 + 2457 ;********** + 2458 + 2459 ;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO + 2460 ;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC + 2461 ;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2462 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2463 + 2464 031632 474 00 0 00 000000 B30600: SETO ;PRELOAD AC WITH -1,,-1 + 2465 031633 550 00 0 00 034013 HRRZ [XWD -1,0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + 2466 031634 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2467 STOP^ + 2468 031635 254 04 0 00 031636 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2469 031636 324 00 0 00 031637 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2470 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2471 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2472 + 2473 ;***** FAILURE ANALYSIS ***** + 2474 ;C(AC0) C(AC1) FAILING SIGNAL + 2475 + 2476 ;E SW: FCE + 2477 ;-1,,0 ET2: AR RT AD EN + 2478 + 2479 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 46 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0072 + + 2480 ;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO + 2481 ;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC + 2482 ;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2483 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2484 + 2485 031637 474 00 0 00 000000 B30700: SETO ;PRELOAD AC WITH -1,,-1 + 2486 031640 550 00 0 00 034012 HRRZ [-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + 2487 031641 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2488 STOP^ + 2489 031642 254 04 0 00 031643 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2490 031643 324 00 0 00 031644 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2491 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2492 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2493 + 2494 ;********** + 2495 + 2496 ;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO + 2497 ;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC + 2498 ;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2499 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2500 + 2501 031644 201 00 0 00 777777 B31000: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2502 031645 550 00 0 00 034012 HRRZ [-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + 2503 031646 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2504 STOP^ + 2505 031647 254 04 0 00 031650 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2506 031650 324 00 0 00 031651 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2507 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2508 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2509 + 2510 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 47 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0073 + + 2511 ;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO + 2512 ;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC + 2513 ;IN THIS CASE C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2514 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2515 + 2516 031651 201 00 0 00 777777 B31100: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2517 031652 550 00 0 00 034014 HRRZ [0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + 2518 031653 302 00 0 00 000000 CAIE 0 ;PASS IF C(AC)=0 + 2519 STOP^ + 2520 031654 254 04 0 00 031655 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2521 031655 324 00 0 00 031656 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2522 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2523 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2524 + 2525 ;********** + 2526 + 2527 ;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO + 2528 ;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC + 2529 ;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2530 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2531 + 2532 031656 205 00 0 00 777777 B31200: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2533 031657 550 00 0 00 034012 HRRZ [-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + 2534 031660 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2535 STOP^ + 2536 031661 254 04 0 00 031662 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2537 031662 324 00 0 00 031663 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2538 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2539 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2540 + 2541 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 48 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0074 + + 2542 ;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO + 2543 ;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC + 2544 ;IN THIS CASE C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2545 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2546 + 2547 031663 205 00 0 00 777777 B31300: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2548 031664 550 00 0 00 034014 HRRZ [0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + 2549 031665 302 00 0 00 000000 CAIE 0 ;PASS IF C(AC)=0 + 2550 STOP^ + 2551 031666 254 04 0 00 031667 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2552 031667 324 00 0 00 031670 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2553 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2554 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2555 + 2556 ;********** + 2557 + 2558 ;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO + 2559 ;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC + 2560 ;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2561 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2562 + 2563 031670 201 00 0 00 777777 B31400: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2564 031671 550 00 0 00 034013 HRRZ [XWD -1,0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + 2565 031672 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2566 STOP^ + 2567 031673 254 04 0 00 031674 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2568 031674 324 00 0 00 031675 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2569 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2570 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2571 + 2572 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 49 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0075 + + 2573 ;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO + 2574 ;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC + 2575 ;IN THIS CASE C(AC)=-1,,0 AND C(E)=0,,-1. HENCE, THE RESULT IN THE AC + 2576 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2577 + 2578 031675 205 00 0 00 777777 B31500: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2579 031676 550 00 0 00 034015 HRRZ [XWD 0,-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + 2580 031677 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2581 STOP^ + 2582 031700 254 04 0 00 031701 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2583 031701 324 00 0 00 031702 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 HRRZI PLACES E INTO + 2590 ;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC + 2591 ;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC + 2592 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + 2593 + 2594 031702 201 00 0 00 777777 B31600: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2595 031703 551 00 0 00 777777 HRRZI -1 ;*HRRZI SHOULD PLACE 0,,-1 INTO THE AC + 2596 031704 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,1 + 2597 STOP^ + 2598 031705 254 04 0 00 031706 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2599 031706 324 00 0 00 031707 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2600 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2601 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2602 + 2603 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 50 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0076 + + 2604 ;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO + 2605 ;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC + 2606 ;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2607 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2608 + 2609 031707 205 00 0 00 777777 B31700: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2610 031710 550 00 0 00 034013 HRRZ [XWD -1,0] ;*HRRZ SHOULD PLACE 0 INTO THE AC,0] + 2611 031711 302 00 0 00 000000 CAIE 0 ;PASS IF C(AC)=0 + 2612 STOP^ + 2613 031712 254 04 0 00 031713 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2614 031713 324 00 0 00 031714 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2615 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2616 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2617 + 2618 ;********** + 2619 + 2620 ;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO + 2621 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED + 2622 ;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC + 2623 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2624 + 2625 031714 400 00 0 00 000000 B32000: SETZ ;PRELOAD AC WITH 0 + 2626 031715 504 00 0 00 000000 HRL ;*HRL SHOULD PLACE 0 INTO THE AC + 2627 031716 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2628 STOP^ + 2629 031717 254 04 0 00 031720 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2630 031720 324 00 0 00 031721 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2631 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2632 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2633 + 2634 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 51 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0077 + + 2635 ;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO + 2636 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED + 2637 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2638 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 2639 + 2640 031721 474 00 0 00 000000 B32100: SETO ;PRELOAD AC WITH -1,,-1 + 2641 031722 504 00 0 00 034012 HRL [-1] ;*HRL SHOULD PLACE -1,,-1 INTO THE AC + 2642 031723 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 2643 STOP^ + 2644 031724 254 04 0 00 031725 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2645 031725 324 00 0 00 031726 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2646 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2647 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2648 + 2649 ;***** FAILURE ANALYSIS ***** + 2650 ;C(AC0) C(AC1) FAILING SIGNAL + 2651 + 2652 ;E,,-1 SW: FCE + 2653 ;0,,-1 FC: AD RT FM + EN + 2654 ;0,,-1 ET2: AR LT AR RT EN + 2655 ;-1,,0 ET2: AR RT AD EN + 2656 + 2657 ;********** + 2658 + 2659 ;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO + 2660 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED + 2661 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2662 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2663 + 2664 031726 474 00 0 00 000000 B32200: SETO ;PRELOAD AC WITH -1,,-1 + 2665 031727 504 00 0 00 034014 HRL [0] ;*HRL SHOULD PLACE 0,,-1 INTO THE AC + 2666 031730 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2667 STOP^ + 2668 031731 254 04 0 00 031732 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2669 031732 324 00 0 00 031733 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2670 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2671 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2672 + 2673 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 52 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0078 + + 2674 ;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO + 2675 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2676 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2677 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + 2678 + 2679 031733 474 00 0 00 000000 B32300: SETO ;PRELOAD AC WITH -1,,-1 + 2680 031734 544 00 0 00 034014 HLR [0] ;*HLR SHOULD PLACE -1,,0 INTO THE AC + 2681 031735 312 00 0 00 034013 CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + 2682 STOP^ + 2683 031736 254 04 0 00 031737 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2684 031737 324 00 0 00 031740 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2685 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2686 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2687 + 2688 ;***** FAILURE ANALYSIS ***** + 2689 ;C(AC0) C(AC1) FAILING SIGNAL + 2690 + 2691 ;0 ET2: AR LT AD EN + 2692 + 2693 ;********** + 2694 + 2695 ;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO + 2696 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED + 2697 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2698 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + 2699 + 2700 031740 400 00 0 00 000000 B32600: SETZ ;PRELOAD AC WITH 0 + 2701 031741 504 00 0 00 034012 HRL [-1] ;*HRL SHOULD PLACE -1,,0 INTO THE AC + 2702 031742 312 00 0 00 034013 CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + 2703 STOP^ + 2704 031743 254 04 0 00 031744 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2705 031744 324 00 0 00 031745 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2706 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2707 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2708 + 2709 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 53 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0079 + + 2710 ;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO + 2711 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2712 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2713 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2714 + 2715 031745 400 00 0 00 000000 B32700: SETZ ;PRELOAD AC WITH 0 + 2716 031746 544 00 0 00 034012 HLR [-1] ;*HLR SHOULD PLACE 0,,-1 INTO THE AC + 2717 031747 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2718 STOP^ + 2719 031750 254 04 0 00 031751 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2720 031751 324 00 0 00 031752 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2721 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2722 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2723 + 2724 ;***** FAILURE ANALYSIS ***** + 2725 ;C(AC0) C(AC1) FAILING SIGNAL + 2726 + 2727 ;0 SW: FCE + 2728 ;-1,,-1 FC: AD LT FM + EN + 2729 ;0 ET2: AR RT AR LT EN + 2730 + 2731 ;********** + 2732 + 2733 ;THIS TEST VERIFIES THAT HRLI PLACES E INTO + 2734 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. + 2735 ;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC + 2736 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + 2737 + 2738 031752 400 00 0 00 000000 B33000: SETZ ;PRELOAD AC WITH -1,,-1 + 2739 031753 505 00 0 00 777777 HRLI -1 ;*HRLI SHOULD PLACE -1,,-1 INTO THE AC + 2740 031754 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,-1 + 2741 STOP^ + 2742 031755 254 04 0 00 031756 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2743 031756 324 00 0 00 031757 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2744 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2745 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2746 + 2747 ;***** FAILURE ANALYSIS ***** + 2748 ;C(AC0) C(AC1) FAILING SIGNAL + 2749 + 2750 ;-1,,-1 FC: AD RT FM + EN + 2751 ;0 ET2: AR LT AR RT EN + 2752 + 2753 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 54 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0080 + + 2754 ;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO + 2755 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2756 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2757 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2758 + 2759 031757 400 00 0 00 000000 B33100: SETZ ;PRELOAD AC WITH -1,,-1 + 2760 031760 544 00 0 00 034013 HLR [XWD -1,0] ;*HLR SHOULD PLACE -1,,-1 INTO THE AC + 2761 031761 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2762 STOP^ + 2763 031762 254 04 0 00 031763 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2764 031763 324 00 0 00 031764 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2765 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2766 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2767 + 2768 ;********** + 2769 + 2770 ;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO + 2771 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED + 2772 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2773 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2774 + 2775 031764 400 00 0 00 000000 B33200: SETZ ;PRELOAD AC WITH 0 + 2776 031765 504 00 0 00 034013 HRL [XWD -1,0] ;*HRL SHOULD PLACE 0 INTO THE AC + 2777 031766 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2778 STOP^ + 2779 031767 254 04 0 00 031770 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2780 031770 324 00 0 00 031771 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2781 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2782 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2783 + 2784 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 55 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0081 + + 2785 ;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF + 2786 ;OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2787 ;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC + 2788 ;SHOULD BE 0. THE AC IS CHECKED FOR 0 + 2789 ;IF C(AC)=0, THIS TEST PASSES. + 2790 + 2791 031771 400 00 0 00 000000 B33300: SETZ ;PRELOAD AC WITH 0 + 2792 031772 545 00 0 00 777777 HLRI -1 ;*HLRI SHOULD PLACE 0 INTO THE AC + 2793 031773 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2794 STOP^ + 2795 031774 254 04 0 00 031775 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2796 031775 324 00 0 00 031776 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2797 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2798 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2799 + 2800 ;***** FAILURE ANALYSIS ***** + 2801 ;C(AC0) C(AC1) FAILING SIGNAL + 2802 + 2803 ;-1,,0 FC:AD LT FM + EN + 2804 + 2805 ;********** + 2806 + 2807 ;THIS TEST VERIFIES THAT HRLI PLACES E INTO + 2808 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. + 2809 ;IN THIS CASE C(AC)=-1,,-1 AND E=-1,,-1. HENCE, THE RESULT IN THE AC + 2810 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + 2811 + 2812 031776 474 00 0 00 000000 B33400: SETO ;PRELOAD AC WITH -1,,-1 + 2813 031777 505 00 0 00 777777 HRLI -1 ;*HRLI SHOULD PLACE -1,,-1 INTO THE AC + 2814 032000 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 2815 STOP^ + 2816 032001 254 04 0 00 032002 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2817 032002 324 00 0 00 032003 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2818 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2819 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2820 + 2821 ;***** FAILURE ANALYSIS ***** + 2822 ;C(AC0) C(AC1) FAILING SIGNAL + 2823 + 2824 ;-1,,0 ET2: AR RT AD EN + 2825 + 2826 + 2827 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 56 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0082 + + 2828 ;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO + 2829 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2830 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2831 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 2832 + 2833 032003 474 00 0 00 000000 B33500: SETO ;PRELOAD AC WITH -1,,-1 + 2834 032004 544 00 0 00 034013 HLR [XWD -1,0] ;*HLR SHOULD PLACE -1,,-1 INTO THE AC + 2835 032005 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 2836 STOP^ + 2837 032006 254 04 0 00 032007 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2838 032007 324 00 0 00 032010 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2839 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2840 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2841 + 2842 ;********** + 2843 + 2844 ;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO + 2845 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED + 2846 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 2847 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2848 + 2849 032010 474 00 0 00 000000 B33600: SETO ;PRELOAD AC WITH -1,,-1 + 2850 032011 504 00 0 00 034013 HRL [XWD -1,0] ;*HRL SHOULD PLACE 0,,-1 INTO THE AC + 2851 032012 312 00 0 00 034015 CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + 2852 STOP^ + 2853 032013 254 04 0 00 032014 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2854 032014 324 00 0 00 032015 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2855 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2856 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2857 + 2858 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 57 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0083 + + 2859 ;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF + 2860 ;OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2861 ;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC + 2862 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0 + 2863 ;IF C(AC)=-1,,0, THIS TEST PASSES. + 2864 + 2865 032015 474 00 0 00 000000 B33700: SETO ;PRELOAD AC WITH -1,,-1 + 2866 032016 545 00 0 00 777777 HLRI -1 ;*HLRI SHOULD PLACE -1,,0 INTO THE AC + 2867 032017 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 2868 STOP^ + 2869 032020 254 04 0 00 032021 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2870 032021 324 00 0 00 032022 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2871 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2872 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2873 + 2874 ;***** FAILURE ANALYSIS ***** + 2875 ;C(AC0) C(AC1) FAILING SIGNAL + 2876 + 2877 ;0 ET2: AR LT AD EN + 2878 + 2879 ;********** + 2880 + 2881 ;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO + 2882 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED + 2883 ;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2884 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2885 + 2886 032022 201 00 0 00 777777 B34000: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2887 032023 504 00 0 00 034014 HRL [0] ;*HRL SHOULD PLACE 0,,-1 INTO THE AC + 2888 032024 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2889 STOP^ + 2890 032025 254 04 0 00 032026 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2891 032026 324 00 0 00 032027 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2892 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2893 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2894 + 2895 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 58 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0084 + + 2896 ;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF + 2897 ;OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2898 ;IN THIS CASE, C(AC)=0,,-1 AND E=0. HENCE, THE RESULT IN THE AC + 2899 ;SHOULD BE 0. THE AC IS CHECKED FOR 0 + 2900 ;IF C(AC)=0, THIS TEST PASSES. + 2901 + 2902 032027 201 00 0 00 777777 B34100: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2903 032030 545 00 0 00 000000 HLRI ;*HLRI SHOULD PLACE 0 INTO THE AC + 2904 032031 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 2905 STOP^ + 2906 032032 254 04 0 00 032033 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2907 032033 324 00 0 00 032034 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2908 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2909 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2910 + 2911 ;********** + 2912 + 2913 ;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO + 2914 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED + 2915 ;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2916 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 2917 + 2918 032034 201 00 0 00 777777 B34200: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2919 032035 504 00 0 00 034012 HRL [-1] ;*HRL SHOULD PLACE -1,,-1 INTO THE AC + 2920 032036 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 2921 STOP^ + 2922 032037 254 04 0 00 032040 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2923 032040 324 00 0 00 032041 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2924 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2925 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2926 + 2927 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 59 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0085 + + 2928 ;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO + 2929 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2930 ;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2931 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 2932 + 2933 032041 201 00 0 00 777777 B34300: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 2934 032042 544 00 0 00 034012 HLR [-1] ;*HLR SHOULD PLACE 0,,-1 INTO THE AC + 2935 032043 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 2936 STOP^ + 2937 032044 254 04 0 00 032045 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2938 032045 324 00 0 00 032046 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2939 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2940 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2941 + 2942 ;********** + 2943 + 2944 ;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO + 2945 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED + 2946 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2947 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 2948 + 2949 032046 205 00 0 00 777777 B34400: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2950 032047 504 00 0 00 034014 HRL [0] ;*HRL SHOULD PLACE 0 INTO THE AC + 2951 032050 302 00 0 00 000000 CAIE 0 ;PASS IF C(AC)=0 + 2952 STOP^ + 2953 032051 254 04 0 00 032052 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2954 032052 324 00 0 00 032053 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2955 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2956 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2957 + 2958 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 60 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0086 + + 2959 ;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO + 2960 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2961 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC + 2962 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + 2963 + 2964 032053 205 00 0 00 777777 B34500: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2965 032054 544 00 0 00 034014 HLR [0] ;*HLR SHOULD PLACE -1,,0 INTO THE AC + 2966 032055 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 2967 STOP^ + 2968 032056 254 04 0 00 032057 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2969 032057 324 00 0 00 032060 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2970 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2971 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2972 + 2973 ;********** + 2974 + 2975 ;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO + 2976 ;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED + 2977 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 2978 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + 2979 + 2980 032060 205 00 0 00 777777 B34600: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2981 032061 504 00 0 00 034012 HRL [-1] ;*HRL SHOULD PLACE -1,,0 INTO THE AC + 2982 032062 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 2983 STOP^ + 2984 032063 254 04 0 00 032064 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2985 032064 324 00 0 00 032065 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 2986 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 2987 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 2988 + 2989 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 61 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0087 + + 2990 ;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO + 2991 ;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. + 2992 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1 HENCE, THE RESULT IN THE AC + 2993 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 2994 + 2995 032065 205 00 0 00 777777 B34700: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 2996 032066 544 00 0 00 034012 HLR [-1] ;*HLR SHOULD PLACE -1,,-1 INTO THE AC + 2997 032067 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 2998 STOP^ + 2999 032070 254 04 0 00 032071 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3000 032071 324 00 0 00 032072 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 + 3006 ;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO + 3007 ;THE LEFT HALF OF E. THE RIGHT HALF OF E IS UNAFFECTED. + 3008 ;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN E + 3009 ;SHOULD BE 0. E IS CHECKED FOR 0. IF C(E)=0, THIS TEXT PASSES. + 3010 + 3011 032072 400 00 0 00 000000 B35000: SETZ ;PRELOAD AC,E WITH 0 + 3012 032073 502 00 0 00 000000 HLLM ;*HLLM SHOULD PLACE 0 INTO E + 3013 032074 332 00 0 00 000000 SKIPE ;PASS IF C(E)=0 + 3014 STOP^ + 3015 032075 254 04 0 00 032076 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3016 032076 324 00 0 00 032077 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3017 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3018 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3019 + 3020 ;***** FAILURE ANALYSIS ***** + 3021 ;C(AC0) C(AC1) FAILING SIGNAL + 3022 + 3023 ;-1,,0 0 FC: AD FM + EN + 3024 ;0,,-1 0,,-1 ET0: AD RT BR + EN + 3025 ;B35000 0,,-1 ET0: BR AR EN + 3026 ;-1,,0 0,,-1 ET0: AD LT AR + EN + 3027 + 3028 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 62 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0088 + + 3029 ;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO + 3030 ;THE LEFT HALF OF E. THE RIGHT HALF OF E IS UNAFFECTED. + 3031 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN E + 3032 ;SHOULD BE 0,,-1. E IS CHECKED FOR 0,,-1. IF C(E)=0,,-1, THIS TEST PASSES. + 3033 + 3034 032077 400 00 0 00 000000 B35500: SETZ ;PRELOAD AC WITH 0 + 3035 032100 474 01 0 00 000000 SETO 1, ;PRELOAD E WITH -1,,-1 + 3036 032101 502 00 0 00 000001 HLLM 1 ;*HLLM SHOULD PLACE 0,,-1 INTO E + 3037 032102 302 01 0 00 777777 CAIE 1,- 1 ;PASS IF C(E) =0,,-1 + 3038 STOP^ + 3039 032103 254 04 0 00 032104 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3040 032104 324 00 0 00 032105 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3041 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3042 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3043 + 3044 ;***** FAILURE ANALYSIS ***** + 3045 ;C(AC0) C(AC1) FAILING SIGNAL + 3046 + 3047 ;0 -1,,-1 SW: FCE PSE + 3048 ;0 0 SW: ET0 + 3049 ;0 -1,,-1 ET0: AR AD EN + 3050 ;0 0 ET2: AR LT AD EN + 3051 + 3052 ;********** + 3053 + 3054 ;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO + 3055 ;THE LEFT HALF OF E. THE RIGHT HALF OF E IS UNAFFECTED. + 3056 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN E + 3057 ;SHOULD BE -1,,0. E IS CHECKED FOR -1,,0. IF C(E)=-1,,0, THIS TEST PASSES + 3058 + 3059 032105 474 00 0 00 000000 B35600: SETO ;PRELOAD AC WITH -1,,-1 + 3060 032106 400 01 0 00 000000 SETZ 1, ;PRELOAD E WITH 0 + 3061 032107 502 00 0 00 000001 HLLM 1 ;*HLLM SHOULD PLACE -1,,0 INTO E + 3062 032110 312 01 0 00 034013 CAME 1,[XWD -1,0] ;PASS IF C(E) = -1,,0 + 3063 STOP^ + 3064 032111 254 04 0 00 032112 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3065 032112 324 00 0 00 032113 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3066 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3067 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3068 + 3069 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 63 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0089 + + 3070 ;THIS TEST VERIFIES THAT HRRM PLACES THE RIGHT HALF OF C(AC) INTO + 3071 ;THE RIGHT HALF OF E. THE LEFT HALF OF E IS UNAFFECTED. + 3072 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN E + 3073 ;SHOULD BE -1,,0. E IS CHECKED FOR -1,,0 + 3074 ;IF C(E) = -1,,0, THIS TEST PASSES. + 3075 + 3076 032113 400 00 0 00 000000 B35700: SETZ ;PRELOAD AC WITH 0 + 3077 032114 474 01 0 00 000000 SETO 1, ;PRELOAD E WITH -1,,-1 + 3078 032115 542 00 0 00 000001 HRRM 1 ;*HRRM SHOULD PLACE -1,,0 INTO E + 3079 032116 312 01 0 00 034013 CAME 1,[XWD -1,0] ;PASS IF C(E) = -1,,0 + 3080 STOP^ + 3081 032117 254 04 0 00 032120 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3082 032120 324 00 0 00 032121 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3083 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3084 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3085 + 3086 ;***** FAILURE ANALYSIS ***** + 3087 ;C(AC0) C(AC1) FAILING SIGNAL + 3088 + 3089 ;0 -1,,-1 SW: FCE PSE + 3090 ;0 0 SW: ET0 + 3091 ;0 -1,,-1 FC: AD FM + EN + 3092 ;-1,,-1 -1,,-1 ET0: AD LT BR + EN + 3093 ;0 -1,,-1 ET0: AD RT AR + EN + 3094 ;0 0 ET0: BR AR EN + 3095 ;0 -1,,-1 ET0: AR AD EN + 3096 ;0 0 ET2: AR AD EN + 3097 + 3098 ;********** + 3099 + 3100 ;THIS TEST VERIFIES THAT HRRM PLACES THE RIGHT HALF OF C(AC) INTO + 3101 ;THE RIGHT HALF OF E. THE LEFT HALF OF E IS UNAFFECTED. + 3102 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN E + 3103 ;SHOULD BE 0,,-1. E IS CHECKED FOR = 0,,-1 + 3104 ;IF C(E) = 0,,-1, THIS TEST PASSES. + 3105 + 3106 032121 474 00 0 00 000000 B36000: SETO ;PRELOAD AC WITH -1,,-1 + 3107 032122 400 01 0 00 000000 SETZ 1, ;PRELOAD E WITH 0 + 3108 032123 542 00 0 00 000001 HRRM 1 ;*HRRM SHOULD PLACE 0,,-1 INTO E + 3109 032124 302 01 0 00 777777 CAIE 1,-1 ;PASS IF C(E) = 0,,-1 + 3110 STOP^ + 3111 032125 254 04 0 00 032126 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3112 032126 324 00 0 00 032127 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3113 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3114 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3115 + 3116 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 64 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0090 + + 3117 ;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO + 3118 ;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. + 3119 ;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE THE RESULT IN THE AC + 3120 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 3121 + 3122 032127 474 00 0 00 000000 B36100: SETO ;PRELOAD AC WITH -1,,-1 + 3123 032130 520 00 0 00 000000 HLLO ;*HLLO SHOULD PLACE -1,,-1 INTO THE AC + 3124 032131 312 00 0 00 034012 CAME [-1] ;PASS OF C(AC)=-1,,-1 + 3125 STOP^ + 3126 032132 254 04 0 00 032133 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3127 032133 324 00 0 00 032134 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3128 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3129 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3130 + 3131 ;***** FAILURE ANALYSIS ***** + 3132 ;C(AC0) C(AC1) FAILING SIGNAL + 3133 + 3134 ;0,,-1 SW: FCE + 3135 + 3136 ;********** + 3137 + 3138 ;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO + 3139 ;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. + 3140 ;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1. HENCE THE RESULT IN THE AC + 3141 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 3142 + 3143 032134 400 00 0 00 000000 B36200: SETZ ;PRELOAD AC WITH 0 + 3144 032135 520 00 0 00 034015 HLLO [XWD 0,-1] ;*HLLO SHOULD PLACE 0,,-1 INTO THE AC + 3145 032136 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 3146 STOP^ + 3147 032137 254 04 0 00 032140 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3148 032140 324 00 0 00 032141 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3149 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3150 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3151 + 3152 ;***** FAILURE ANALYSIS ***** + 3153 ;C(AC0) C(AC1) FAILING SIGNAL + 3154 + 3155 ;-1,,-1 FC: AD LT AR + EN + 3156 + 3157 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 65 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0091 + + 3158 ;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO + 3159 ;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC. + 3160 ;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC + 3161 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 3162 + 3163 032141 474 00 0 00 000000 B36300: SETO ;PRELOAD AC,E WITH -1,,-1 + 3164 032142 560 00 0 00 000000 HRRO ;*HRRO SHOULD PLACE -1,,-1 INTO THE AC + 3165 032143 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 3166 STOP^ + 3167 032144 254 04 0 00 032145 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3168 032145 324 00 0 00 032146 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3169 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3170 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3171 + 3172 ;***** FAILURE ANALYSIS ***** + 3173 ;C(AC0) C(AC1) FAILING SIGNAL + 3174 + 3175 ;-1,,0 SW: FCE + 3176 + 3177 ;********** + 3178 + 3179 ;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO + 3180 ;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC. + 3181 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 3182 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + 3183 + 3184 032146 400 00 0 00 000000 B36400: SETZ ;PRELOAD AC WITH 0 + 3185 032147 560 00 0 00 034013 HRRO [XWD -1,0] ;*HRRO SHOULD PLACE -1,,0 INTO THE AC + 3186 032150 312 00 0 00 034013 CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + 3187 STOP^ + 3188 032151 254 04 0 00 032152 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3189 032152 324 00 0 00 032153 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3190 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3191 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3192 + 3193 ;***** FAILURE ANALYSIS ***** + 3194 ;C(AC0) C(AC1) FAILING SIGNAL + 3195 + 3196 ;-1,,-1 FC: AD RT AR + EN + 3197 + 3198 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 66 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0092 + + 3199 ;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO + 3200 ;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. + 3201 ;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE THE RESULT IN THE AC + 3202 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 3203 + 3204 032153 400 00 0 00 000000 B36500: SETZ ;PRELOAD AC WITH 0 + 3205 032154 520 00 0 00 034014 HLLO [0] ;*HLLO SHOULD PLACE 0,,-1 INTO THE AC + 3206 032155 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 3207 STOP^ + 3208 032156 254 04 0 00 032157 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3209 032157 324 00 0 00 032160 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3210 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3211 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3212 + 3213 ;***** FAILURE ANALYSIS ***** + 3214 ;C(AC0) C(AC1) FAILING SIGNAL + 3215 + 3216 ;0 ET2: AR LT AD EN + 3217 + 3218 ;********** + 3219 + 3220 ;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO + 3221 ;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC. + 3222 ;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC + 3223 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + 3224 + 3225 032160 400 00 0 00 000000 B36600: SETZ ;PRELOAD AC WITH 0 + 3226 032161 560 00 0 00 034014 HRRO [0] ;*HRRO SHOULD PLACE -1,,0 INTO THE AC + 3227 032162 312 00 0 00 034013 CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + 3228 STOP^ + 3229 032163 254 04 0 00 032164 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3230 032164 324 00 0 00 032165 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3231 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3232 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3233 + 3234 ;***** FAILURE ANALYSIS ***** + 3235 ;C(AC0) C(AC1) FAILING SIGNAL + 3236 + 3237 ;0 ET2: AR AD EN + 3238 + 3239 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 67 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0093 + + 3240 ;THIS TEST VERIFIES THAT HLLOI ALWAYS PLACES 0,,-1 INTO THE AC. + 3241 ;IN THIS CASE, C(AC)=0 AND E=0. + 3242 ;THE RESULT IN THE AC SHOULD BE 0,,-1. + 3243 ;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + 3244 + 3245 032165 400 00 0 00 000000 B37100: SETZ ;PRELOAD AC WITH 0 + 3246 032166 521 00 0 00 000000 HLLOI ;*HLLOI SHOULD PLACE 0,,-1 INTO THE AC + 3247 032167 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 3248 STOP^ + 3249 032170 254 04 0 00 032171 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3250 032171 324 00 0 00 032172 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3251 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3252 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3253 + 3254 ;***** FAILURE ANALYSIS ***** + 3255 ;C(AC0) C(AC1) FAILING SIGNAL + 3256 + 3257 ;-1,,-1 FC: AD LT AR + EN + 3258 ;0 ET2: AR AD EN + 3259 + 3260 ;********** + 3261 + 3262 ;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC + 3263 ;AND PLACES ONES INTO THE LEFT HALF OF THE AC. + 3264 ;IN THIS CASE, C(AC)=0 AND E=0. HENCE, THE RESULT IN THE AC + 3265 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1, THIS TEST PASSES + 3266 + 3267 032172 400 00 0 00 000000 B37200: SETZ ;PRELOAD AC WITH 0 + 3268 032173 561 00 0 00 000000 HRROI ;*HRROI SHOULD PLACE -1,,0 INTO THE AC + 3269 032174 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 3270 STOP^ + 3271 032175 254 04 0 00 032176 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3272 032176 324 00 0 00 032177 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3273 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3274 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3275 + 3276 ;***** FAILURE ANALYSIS ***** + 3277 ;C(AC0) C(AC1) FAILING SIGNAL + 3278 + 3279 ;-1,,-1 FC: AD RT AR + EN + 3280 ;0 ET2: AR AD EN + 3281 + 3282 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 68 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0094 + + 3283 ;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO + 3284 ;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. + 3285 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE THE RESULT IN THE AC + 3286 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 3287 + 3288 032177 400 00 0 00 000000 B37300: SETZ ;PRELOAD AC WITH 0 + 3289 032200 520 00 0 00 034013 HLLO [XWD -1,0] ;*HLLO SHOULD PLACE -1,,-1 INTO THE AC + 3290 032201 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 3291 STOP^ + 3292 032202 254 04 0 00 032203 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3293 032203 324 00 0 00 032204 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3294 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3295 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3296 + 3297 ;********** + 3298 + 3299 ;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC + 3300 ;AND PLACES ONES INTO THE LEFT HALF OF THE AC. + 3301 ;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC + 3302 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + 3303 + 3304 032204 400 00 0 00 000000 B37400: SETZ ;PRELOAD AC WITH 0 + 3305 032205 561 00 0 00 777777 HRROI -1 ;*HRRIO SHOULD PLACE -1,,-1 INTO THE AC + 3306 032206 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 3307 STOP^ + 3308 032207 254 04 0 00 032210 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3309 032210 324 00 0 00 032211 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3310 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3311 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3312 + 3313 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 69 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0095 + + 3314 ;THIS TEST VERIFIES THAT HLLOI ALWAYS PLACES 0,,-1 INTO THE AC. + 3315 ;IN THIS CASE, C(AC)=0 AND E=0. + 3316 ;THE RESULT IN THE AC SHOULD BE 0,,-1. + 3317 ;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + 3318 + 3319 032211 474 00 0 00 000000 B37500: SETO ;PRELOAD AC WITH -1,,-1 + 3320 032212 521 00 0 00 000000 HLLOI ;*HLLOI SHOULD PLACE 0,,-1 INTO THE AC + 3321 032213 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 3322 STOP^ + 3323 032214 254 04 0 00 032215 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3324 032215 324 00 0 00 032216 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3325 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3326 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3327 + 3328 ;********** + 3329 + 3330 ;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC + 3331 ;AND PLACES ONES INTO THE LEFT HALF OF THE AC. + 3332 ;IN THIS CASE, C(AC)=0 AND E=0. HENCE, THE RESULT IN THE AC + 3333 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + 3334 + 3335 032216 474 00 0 00 000000 B37600: SETO ;PRELOAD AC WITH -1,,-1 + 3336 032217 561 00 0 00 000000 HRROI ;*HRRIO SHOULD PLACE -1,,0 INTO THE AC + 3337 032220 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 3338 STOP^ + 3339 032221 254 04 0 00 032222 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3340 032222 324 00 0 00 032223 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^ + 3343 + 3344 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 70 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0096 + + 3345 ;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO + 3346 ;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. + 3347 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE THE RESULT IN THE AC + 3348 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 3349 + 3350 032223 474 00 0 00 000000 B37700: SETO ;PRELOAD AC WITH -1,,-1 + 3351 032224 520 00 0 00 034013 HLLO [XWD -1,0] ;*HLLO SHOULD PLACE -1,,-1 INTO THE AC + 3352 032225 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 3353 STOP^ + 3354 032226 254 04 0 00 032227 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3355 032227 324 00 0 00 032230 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3356 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3357 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3358 + 3359 ;********** + 3360 + 3361 ;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC + 3362 ;AND PLACES ONES INTO THE LEFT HALF OF THE AC. + 3363 ;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC + 3364 ;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + 3365 + 3366 032230 474 00 0 00 000000 B40000: SETO ;PRELOAD AC WITH -1,,-1 + 3367 032231 561 00 0 00 777777 HRROI -1 ;*HRRIO SHOULD PLACE -1,,-1 INTO THE AC + 3368 032232 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 3369 STOP^ + 3370 032233 254 04 0 00 032234 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3371 032234 324 00 0 00 032235 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3372 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3373 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3374 + 3375 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 71 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0097 + + 3376 ;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC + 3377 ;AND PLACES ONES INTO THE LEFT HALF OF THE AC. + 3378 ;IN THIS CASE, C(AC)=0,,-1 AND E=0. HENCE, THE RESULT IN THE AC + 3379 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + 3380 + 3381 032235 201 00 0 00 777777 B40100: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 3382 032236 561 00 0 00 000000 HRROI ;*HRRIO SHOULD PLACE -1,,0 INTO THE AC + 3383 032237 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + 3384 STOP^ + 3385 032240 254 04 0 00 032241 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3386 032241 324 00 0 00 032242 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3387 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3388 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3389 + 3390 ;********** + 3391 + 3392 ;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO + 3393 ;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. + 3394 ;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0,,-1. HENCE THE RESULT IN THE AC + 3395 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 3396 + 3397 032242 205 00 0 00 777777 B40200: MOVSI -1 ;PRELOAD AC WITH -1,,0 + 3398 032243 520 00 0 00 034015 HLLO [XWD 0,-1] ;*HLLO SHOULD PLACE 0,,-1 INTO THE AC + 3399 032244 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 3400 STOP^ + 3401 032245 254 04 0 00 032246 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3402 032246 324 00 0 00 032247 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3403 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3404 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3405 + 3406 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 72 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0098 + + 3407 ;THIS TEST VERIFIES THAT HRLZ PLACES THE RIGHT HALF OF C(E) + 3408 ;INTO THE LEFT HALF OF THE AC. + 3409 ;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 3410 ;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE FINAL RESULT IN THE AC + 3411 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 3412 + 3413 032247 400 00 0 00 000000 B40300: SETZ ;PRELOAD AC WITH 0 + 3414 032250 514 00 0 00 000000 HRLZ ;*HRLZ SHOULD PLACE 0 INTO THE AC + 3415 032251 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 3416 STOP^ + 3417 032252 254 04 0 00 032253 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3418 032253 324 00 0 00 032254 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3419 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3420 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3421 + 3422 ;********** + 3423 + 3424 ;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E) + 3425 ;INTO THE RIGHT HALF OF THE AC + 3426 ;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC. + 3427 ;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC + 3428 ;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 3429 + 3430 032254 400 00 0 00 000000 B40400: SETZ ;PRELOAD AC WITH 0 + 3431 032255 554 00 0 00 000000 HLRZ ;*HLRZ SHOULD PLACE 0 INTO THE AC + 3432 032256 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 3433 STOP^ + 3434 032257 254 04 0 00 032260 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3435 032260 324 00 0 00 032261 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3436 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3437 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3438 + 3439 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 73 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0099 + + 3440 ;THIS TEST VERIFIES THAT HRLZI PLACES E INTO THE LEFT HALF OF THE AC + 3441 ;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 3442 ;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE THE RESULT IN THE AC + 3443 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0 + 3444 ;IF C(AC)=-1,,0, THIS TEST PASSES. + 3445 + 3446 032261 400 00 0 00 000000 B40700: SETZ ;PRELOAD AC WITH 0 + 3447 032262 515 00 0 00 777777 HRLZI -1 ;*HRLZI SHOULD PLACE -1,,0 INTO THE AC + 3448 032263 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + 3449 STOP^ + 3450 032264 254 04 0 00 032265 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3451 032265 324 00 0 00 032266 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3452 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3453 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3454 + 3455 ;***** FAILURE ANALYSIS ***** + 3456 ;C(AC0) C(AC1) FAILING SIGNAL + 3457 + 3458 ;0 ET2: AR LT AR RT EN + 3459 + 3460 ;********** + 3461 + 3462 ;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E) + 3463 ;INTO THE RIGHT HALF OF THE AC + 3464 ;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC. + 3465 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 3466 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 3467 + 3468 032266 400 00 0 00 000000 B41000: SETZ ;PRELOAD AC WITH 0 + 3469 032267 554 00 0 00 034013 HLRZ [XWD -1,0] ;*HLRZ SHOULD PLACE 0,,-1 INTO THE AC + 3470 032270 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 3471 STOP^ + 3472 032271 254 04 0 00 032272 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3473 032272 324 00 0 00 032273 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3474 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3475 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3476 + 3477 ;***** FAILURE ANALYSIS ***** + 3478 ;C(AC0) C(AC1) FAILING SIGNAL + 3479 + 3480 ;0 SW: FCE + 3481 ;-1,,0 ET2: AR RT AR LT EN + 3482 + 3483 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 74 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0100 + + 3484 ;THIS TEST VERIFIES THAT HRLZI PLACES E INTO THE LEFT HALF OF THE AC + 3485 ;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. + 3486 ;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. HENCE THE RESULT IN THE AC + 3487 ;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. + 3488 ;IF C(AC)=-1,,0, THIS TEST PASSES. + 3489 + 3490 032273 474 00 0 00 000000 B41100: SETO ;PRELOAD AC WITH -1,,-1 + 3491 032274 515 00 0 00 777777 HRLZI -1 ;*HRLZI SHOULD PLACE -1,,0 INTO THE AC + 3492 032275 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + 3493 STOP^ + 3494 032276 254 04 0 00 032277 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3495 032277 324 00 0 00 032300 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3496 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3497 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3498 + 3499 ;********** + 3500 + 3501 ;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E) + 3502 ;INTO THE RIGHT HALF OF THE AC + 3503 ;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC. + 3504 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC + 3505 ;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + 3506 + 3507 032300 474 00 0 00 000000 B41200: SETO ;PRELOAD AC WITH -1,,-1 + 3508 032301 554 00 0 00 034013 HLRZ [XWD -1,0] ;*HLRZ SHOULD PLACE 0,,-1 INTO THE AC + 3509 032302 302 00 0 00 777777 CAIE -1 ;PASS IF C(AC)=0,,-1 + 3510 STOP^ + 3511 032303 254 04 0 00 032304 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3512 032304 324 00 0 00 032305 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3513 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3514 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3515 + 3516 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 75 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0101 + + 3517 ;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E) + 3518 ;INTO THE LEFT HALF OF THE AC + 3519 ;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. + 3520 ;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0 + 3521 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 3522 + 3523 032305 400 00 0 00 000000 B41500: SETZ ;PRELOAD AC WITH 0 + 3524 032306 530 00 0 00 000000 HLLE ;*HLLE SHOULD PLACE 0 INTO THE AC + 3525 032307 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 3526 STOP^ + 3527 032310 254 04 0 00 032311 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3528 032311 324 00 0 00 032312 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3529 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3530 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3531 + 3532 ;***** FAILURE ANALYSIS ***** + 3533 ;C(AC0) C(AC1) FAILING SIGNAL + 3534 + 3535 ;-1,,0 FC: AD LT AR + EN + 3536 + 3537 ;********** + 3538 + 3539 ;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E) + 3540 ;INTO THE LEFT HALF OF THE AC + 3541 ;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. + 3542 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 + 3543 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + 3544 + 3545 032312 400 00 0 00 000000 B41600: SETZ ;PRELOAD AC WITH 0 + 3546 032313 530 00 0 00 034012 HLLE [-1] ;*HLLE SHOULD PLACE -1,,-1 INTO THE AC + 3547 032314 312 00 0 00 034012 CAME [XWD -1,-1] ;PASS IF C(AC)=-1,,-1 + 3548 STOP^ + 3549 032315 254 04 0 00 032316 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3550 032316 324 00 0 00 032317 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3551 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3552 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3553 + 3554 ;***** FAILURE ANALYSIS ***** + 3555 ;C(AC0) C(AC1) FAILING SIGNAL + 3556 + 3557 ;0 SW: FCE + 3558 ;-1,,-1 ET2: AR LT AD EN + 3559 ;-1,,0 ET2: AR0(1): AR RT AD EN + 3560 + 3561 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 76 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0102 + + 3562 ;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E) + 3563 ;INTO THE RIGHT HALF OF THE AC. + 3564 ;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC. + 3565 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. + 3566 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 3567 + 3568 032317 400 00 0 00 000000 B42000: SETZ ;PRELOAD AC WITH 0 + 3569 032320 570 00 0 00 034012 HRRE [-1] ;*HRRE SHOULD PLACE -1,,-1 INTO THE AC + 3570 032321 312 00 0 00 034012 CAME [-1,,-1] ;PASS IF C(AC)=-1,,-1 + 3571 STOP^ + 3572 032322 254 04 0 00 032323 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3573 032323 324 00 0 00 032324 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3574 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3575 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3576 + 3577 ;********** + 3578 + 3579 ;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E) + 3580 ;INTO THE LEFT HALF OF THE AC + 3581 ;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. + 3582 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 + 3583 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + 3584 + 3585 032324 400 00 0 00 000000 B42200: SETZ ;PRELOAD AC WITH 0 + 3586 032325 530 00 0 00 034013 HLLE [XWD -1,0] ;*HLLE SHOULD PLACE -1,,-1 INTO THE AC + 3587 032326 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 3588 STOP^ + 3589 032327 254 04 0 00 032330 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3590 032330 324 00 0 00 032331 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3591 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3592 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3593 + 3594 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 77 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0103 + + 3595 ;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E) + 3596 ;INTO THE RIGHT HALF OF THE AC. + 3597 ;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC. + 3598 ;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 3599 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 3600 + 3601 032331 400 00 0 00 000000 B42300: SETZ ;PRELOAD AC,E WITH 0 + 3602 032332 570 00 0 00 000000 HRRE ;*HRRE SHOULD PLACE 0 INTO THE AC + 3603 032333 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 3604 STOP^ + 3605 032334 254 04 0 00 032335 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3606 032335 324 00 0 00 032336 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3607 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3608 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3609 + 3610 ;***** FAILURE ANALYSIS ***** + 3611 ;C(AC0) C(AC1) FAILING SIGNAL + 3612 + 3613 ;E SW: FCE + 3614 ;-1,,0 ET2: AR RT AD EN + 3615 ;0,,-1 ET2: AR18(1): AR LT AD EN + 3616 ;0,,-1 FC: AR RT AR + EN + 3617 + 3618 ;********** + 3619 + 3620 ;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E) + 3621 ;INTO THE RIGHT HALF OF THE AC. + 3622 ;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC. + 3623 ;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 3624 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + 3625 + 3626 032336 400 00 0 00 000000 B42500: SETZ ;PRELOAD AC WITH 0 + 3627 032337 570 00 0 00 034013 HRRE [XWD -1,0] ;*HRRE SHOULD PLACE 0 INTO THE AC + 3628 032340 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 3629 STOP^ + 3630 032341 254 04 0 00 032342 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3631 032342 324 00 0 00 032343 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3632 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3633 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3634 + 3635 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 78 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0104 + + 3636 ;THIS TEST VERIFIES THAT HRREI PLACES E INTO THE RIGHT HALF OF THE AC + 3637 ;AND PLACES THE LEFTMOST BIT OF E INTO ALL BITS OF THE LEFT HALF OF THE AC + 3638 ;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. + 3639 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + 3640 + 3641 032343 400 00 0 00 000000 B42700: SETZ ;PRELOAD AC WITH 0 + 3642 032344 571 00 0 00 777777 HRREI -1 ;*HRREI SHOULD PLACE -1,,-1 INTO THE AC + 3643 032345 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 3644 STOP^ + 3645 032346 254 04 0 00 032347 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3646 032347 324 00 0 00 032350 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3647 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3648 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3649 + 3650 ;***** FAILURE ANALYSIS ***** + 3651 ;C(AC0) C(AC1) FAILING SIGNAL + 3652 + 3653 ;-1,,0 ET2: AR RT AD EN + 3654 ;0,,-1 ET2: AR18(1): AR LT AD EN + 3655 + 3656 ;********** + 3657 + 3658 ;THIS TEST VERIFIES THAT HLLEI ALWAYS CLEARS THE AC. + 3659 ;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. + 3660 ;THE RESULT IN THE AC SHOULD BE 0 + 3661 ;THE AC IS CHECKED FOR 0. + 3662 ;IF C(AC)=0, THIS TEST PASSES. + 3663 + 3664 032350 474 00 0 00 000000 B43000: SETO ;PRELOAD AC WITH -1,,-1 + 3665 032351 531 00 0 00 777777 HLLEI -1 ;*HLLEI SHOULD CLEAR THE AC + 3666 032352 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 3667 STOP^ + 3668 032353 254 04 0 00 032354 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3669 032354 324 00 0 00 032355 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3670 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3671 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3672 + 3673 ;***** FAILURE ANALYSIS ***** + 3674 ;C(AC0) C(AC1) FAILING SIGNAL + 3675 + 3676 ;-1,,0 FC: AD LT AR + EN + 3677 ;0,,-1 ET2: AR LT AD EN + 3678 + 3679 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 79 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0105 + + 3680 ;THIS TEST VERIFIES THAT HLLEI ALWAYS CLEARS THE AC. + 3681 ;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,400000. + 3682 ;THE RESULT IN THE AC SHOULD BE 0 + 3683 ;THE AC IS CHECKED FOR 0. + 3684 ;IF C(AC) = ZERO, THIS TEST PASSES. + 3685 + 3686 032355 474 00 0 00 000000 B43100: SETO ;PRELOAD AC WITH -1,,-1 + 3687 032356 531 00 0 00 400000 HLLEI 400000 ;*HLLEI SHOULD CLEAR THE AC + 3688 032357 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0. + 3689 STOP^ + 3690 032360 254 04 0 00 032361 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3691 032361 324 00 0 00 032362 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3692 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3693 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3694 + 3695 ;********** + 3696 + 3697 ;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) + 3698 ;INTO THE LEFT HALF OF THE AC + 3699 ;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. + 3700 ;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 3701 ;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + 3702 + 3703 032362 400 00 0 00 000000 B43400: SETZ ;PRELOAD AC WITH 0 + 3704 032363 534 00 0 00 000000 HRLE ;*HRLE SHOULD PLACE 0 INTO THE AC + 3705 032364 332 00 0 00 000000 SKIPE ;FAIL IF C(AC)=0,,-1 + 3706 STOP^ + 3707 032365 254 04 0 00 032366 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3708 032366 324 00 0 00 032367 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3709 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3710 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3711 + 3712 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 80 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0106 + + 3713 ;THIS TEST VERIFIES THAT HRLEI PLACES E INTO THE LEFT HALF OF THE AC + 3714 ;AND PLACES THE LEFTMOST BIT OF E INTO ALL BITS OF THE RIGHT HALF OF THE AC + 3715 ;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC SHOULD -1,,-1 + 3716 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=1,,-1, THIS TEST PASSES. + 3717 + 3718 032367 400 00 0 00 000000 B43500: SETZ ;PRELOAD AC WITH 0 + 3719 032370 535 00 0 00 777777 HRLEI -1 ;*HRLEI SHOULD PLACE -1,,-1 INTO THE AC + 3720 032371 312 00 0 00 034012 CAME [XWD -1,-1] ;PASS IF C(AC)=-1,,-1 + 3721 STOP^ + 3722 032372 254 04 0 00 032373 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3723 032373 324 00 0 00 032374 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 ;***** FAILURE ANALYSIS ***** + 3728 ;C(AC0) C(AC1) FAILING SIGNAL + 3729 + 3730 ;-1,,0 ET2: AR LT AR RT EN + 3731 ;-1,,0 ET2: AR 18(1): AR RT AD EN + 3732 + 3733 ;********** + 3734 + 3735 ;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) + 3736 ;INTO THE LEFT HALF OF THE AC + 3737 ;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. + 3738 ;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 3739 ;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + 3740 + 3741 032374 534 00 0 00 034014 B43600: HRLE [0] ;*HRLE SHOULD PLACE 0 INTO THE AC + 3742 032375 332 00 0 00 000000 SKIPE ;FAIL IF C(AC)=0,,-1 + 3743 STOP^ + 3744 032376 254 04 0 00 032377 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3745 032377 324 00 0 00 032400 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3746 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3747 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3748 + 3749 ;***** FAILURE ANALYSIS ***** + 3750 ;C(AC0) C(AC1) FAILING SIGNAL + 3751 + 3752 ;E,,0 SW: FCE + 3753 + 3754 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 81 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0107 + + 3755 ;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) + 3756 ;INTO THE LEFT HALF OF THE AC + 3757 ;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. + 3758 ;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 3759 ;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + 3760 + 3761 032400 534 00 0 00 034012 B43700: HRLE [-1] ;PRELOAD AC WITH 0 + 3762 032401 312 00 0 00 034012 CAME [-1] ;*HRLE SHOULD PLACE 0 INTO THE AC + 3763 STOP ^;FAIL IF C(AC)=0,,-1 + 3764 + 3765 032402 254 04 0 00 032403 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3766 032403 324 00 0 00 032404 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3767 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3768 ;IN THE SUBTEST) TO LOOP ON ERROR + 3769 + 3770 ;***** FAILURE ANALYSIS ***** + 3771 ;C(AC0) C(AC1) FAILING SIGNAL + 3772 + 3773 ;-1,,0 ET2: AR LT AR RT EN + 3774 ;-1,,0 ET2: AR18(1): AR RT AD EN + 3775 + 3776 ;********** + 3777 + 3778 ;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) + 3779 ;INTO THE LEFT HALF OF THE AC + 3780 ;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. + 3781 ;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 3782 ;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + 3783 + 3784 032404 534 00 0 00 034013 B44000: HRLE [XWD -1,0] ;PRELOAD AC WITH 0 + 3785 032405 332 00 0 00 000000 SKIPE ;*HRLE SHOULD PLACE 0 INTO THE AC + 3786 STOP ^;FAIL IF C(AC)=0,,-1 + 3787 + 3788 032406 254 04 0 00 032407 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3789 032407 324 00 0 00 032410 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3790 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3791 ;IN THE SUBTEST) TO LOOP ON ERROR + 3792 + 3793 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 82 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0108 + + 3794 ;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) + 3795 ;INTO THE LEFT HALF OF THE AC + 3796 ;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. + 3797 ;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 3798 ;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + 3799 + 3800 032410 534 00 0 00 034015 B44100: HRLE [XWD 0,-1] ;PRELOAD AC WITH 0 + 3801 032411 312 00 0 00 034012 CAME [-1] ;*HRLE SHOULD PLACE 0 INTO THE AC + 3802 STOP ^;FAIL IF C(AC)=0,,-1 + 3803 + 3804 032412 254 04 0 00 032413 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3805 032413 324 00 0 00 032414 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3806 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3807 ;IN THE SUBTEST) TO LOOP ON ERROR + 3808 + 3809 ;********** + 3810 + 3811 ;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) + 3812 ;INTO THE RIGHT HALF OF THE AC + 3813 ;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC + 3814 ;IN THIS CASE, C(AC=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 3815 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 3816 + 3817 + 3818 032414 400 00 0 00 000000 B44200: SETZ ;PRELOAD AC WITH 0 + 3819 032415 574 00 0 00 000000 HLRE ;*HLRE SHOULD PLACE 0 INTO THE AC + 3820 032416 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 3821 STOP^ + 3822 032417 254 04 0 00 032420 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3823 032420 324 00 0 00 032421 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3824 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3825 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3826 + 3827 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 83 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0109 + + 3828 ;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) + 3829 ;INTO THE RIGHT HALF OF THE AC + 3830 ;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC + 3831 ;IN THIS CASE, C(AC=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 3832 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 3833 + 3834 + 3835 032421 400 00 0 00 000000 B44300: SETZ ;PRELOAD AC WITH 0 + 3836 032422 574 00 0 00 034012 HLRE [-1] ;*HLRE SHOULD PLACE -1,,-1 INTO THE AC + 3837 032423 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 3838 STOP^ + 3839 032424 254 04 0 00 032425 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3840 032425 324 00 0 00 032426 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3841 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3842 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3843 + 3844 ;***** FAILURE ANALYSIS ***** + 3845 ;C(AC0) C(AC1) FAILING SIGNAL + 3846 + 3847 ;0 SW: FCE + 3848 ;-1,,0 ET2: AR RT AR LT EN + 3849 ;0,,-1 ET2: AR0(1): AR LT AD EN + 3850 + 3851 ;********** + 3852 + 3853 ;THIS TEST VERIFIES THAT HLREI CLEARS THE AC + 3854 ;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1 + 3855 ;THE RESULT IN THE AC SHOULD BE 0 + 3856 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THEN TEST PASSES + 3857 + 3858 032426 474 00 0 00 000000 B44500: SETO ;PRELOAD AC WITH -1,,-1 + 3859 032427 575 00 0 00 777777 HLREI -1 ;*HLREI SHOULD CLEAR THE AC + 3860 032430 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 3861 STOP^ + 3862 032431 254 04 0 00 032432 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3863 032432 324 00 0 00 032433 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3864 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3865 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3866 + 3867 ;***** FAILURE ANALYSIS ***** + 3868 ;C(AC0) C(AC1) FAILING SIGNAL + 3869 + 3870 ;0,,1 ET2: AR RT AR LT EN + 3871 + 3872 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 84 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0110 + + 3873 ;THIS TEST VERIFIES THAT HLREI CLEARS THE AC + 3874 ;IN THIS CASE C(AC)=0 AND E=0 + 3875 ;THE RESULT IN THE AC SHOULD BE 0 + 3876 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES + 3877 + 3878 032433 575 00 0 00 000000 B44600: HLREI ;*HLREI SHOULD CLEAR THE AC + 3879 032434 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 3880 STOP^ + 3881 032435 254 04 0 00 032436 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3882 032436 324 00 0 00 032437 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3883 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3884 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3885 + 3886 ;********** + 3887 + 3888 ;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) + 3889 ;INTO THE RIGHT HALF OF THE AC + 3890 ;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC + 3891 ;IN THIS CASE, C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. + 3892 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + 3893 + 3894 + 3895 032437 574 00 0 00 034013 B44700: HLRE [XWD -1,0] ;*HLRE SHOULD PLACE -1,,0 INTO THE AC + 3896 032440 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 3897 STOP^ + 3898 032441 254 04 0 00 032442 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3899 032442 324 00 0 00 032443 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3900 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3901 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3902 + 3903 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 85 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0111 + + 3904 ;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) + 3905 ;INTO THE RIGHT HALF OF THE AC + 3906 ;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC + 3907 ;IN THIS CASE, C(E)=0,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. + 3908 ;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + 3909 + 3910 032443 574 00 0 00 034015 B45000: HLRE [XWD 0,-1] ;*HLRE SHOULD PLACE 0,,-1 INTO THE AC + 3911 032444 332 00 0 00 000000 SKIPE ;PASS IF C(AC)=0 + 3912 STOP^ + 3913 032445 254 04 0 00 032446 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3914 032446 324 00 0 00 032447 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3915 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3916 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3917 + 3918 ;********** + 3919 + 3920 ;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) + 3921 ;INTO THE RIGHT HALF OF THE AC + 3922 ;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC + 3923 ;IN THIS CASE, C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. + 3924 ;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + 3925 + 3926 032447 574 00 0 00 034012 B45100: HLRE [-1] ;*HLRE SHOULD PLACE -1,,-1 INTO THE AC + 3927 032450 312 00 0 00 034012 CAME [-1] ;PASS IF C(AC)=-1,,-1 + 3928 STOP^ + 3929 032451 254 04 0 00 032452 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3930 032452 324 00 0 00 032453 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3931 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3932 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3933 + 3934 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 86 +DAKACM MAC 19-JAN-77 13:40 TEST OF HWT INSTRUCTIONS SEQ 0112 + + 3935 ;THIS TEST VERIFIES THAT HLREM PLACES THE LEFT HALF OF C(AC) + 3936 ;INTO THE RIGHT HALF OF E + 3937 ;AND PLACES BIT 0 OF C(AC) INTO ALL BITS OF THE LEFT HALF OF E. + 3938 ;IN THIS CASE, C(AC)=1,,0 AND C(E)=0. HENCE, THE RESULT IN E SHOULD BE -1,,-1. + 3939 ;E IS CHECKED FOR -1,,-1. IF C(E)=-1,,-1, THIS TEST PASSES + 3940 + 3941 032453 400 00 0 00 000000 B45200: SETZ ;PRELOAD E WITH 0 + 3942 032454 200 01 0 00 034013 MOVE 1,[XWD -1,0] ;PRELOAD AC WITH -1,,0 + 3943 032455 576 01 0 00 000000 HLREM 1, ;*HLREM SHOULD PLACE -1,,-1 INTO E + 3944 032456 312 00 0 00 034012 CAME [-1] ;PASS IF C(E)=-1,,-1 + 3945 STOP^ + 3946 032457 254 04 0 00 032460 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3947 032460 324 00 0 00 032461 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3948 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3949 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3950 + 3951 ;***** FAILURE ANALYSIS ***** + 3952 ;C(AC0) C(AC1) FAILING SIGNAL + 3953 + 3954 ;0 -1,,0 SW: SCE + 3955 ;0 -1,,0 SW: ET0 + 3956 ;0 -1,,0 ET0: AR AD EN + 3957 ;-1,,0 -1,,0 ET2: AR RT AR + EN + 3958 ;0,,-1 -1,,0 ET2: AR0(1): AR LT AD EN + 3959 + 3960 ;********** + 3961 + 3962 ;THIS TEST VERIFIES THAT HRLM PLACES THE RIGHT HALF OF C(AC) INTO THE LEFT HALF OF E. + 3963 ;THE RIGHT HALF OF E IS UNAFFECTED + 3964 ;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN E SHOULD BE -1,,0. + 3965 ;E IS CHECKED FOR -1,,0. IF C(E)=-1,,0, THIS TEST PASSES. + 3966 + 3967 032461 400 00 0 00 000000 B45400: SETZ ;PRELOAD E WITH 0 + 3968 032462 201 01 0 00 777777 MOVEI 1,-1 ;PRELOAD AC WITH 0,,-1 + 3969 032463 506 01 0 00 000000 HRLM 1, ;*HRLM SHOULD PLACE -1,,0 INTO E + 3970 032464 312 00 0 00 034013 CAME [XWD -1,0] ;PASS IF C(E)=-1,,0 + 3971 STOP^ + 3972 032465 254 04 0 00 032466 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3973 032466 324 00 0 00 032467 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 3974 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 3975 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 3976 + 3977 ;***** FAILURE ANALYSIS ***** + 3978 ;C(AC0) C(AC1) FAILING SIGNAL + 3979 + 3980 ;0 0,,-1 SW: FCE PSE + 3981 ;0,,-1 0,,-1 SW: ET0 + 3982 ;-1,,-1 0,,-1 ET0: AD RT BR + EN + 3983 ;-1,,B45400 0,,-1 ET0: BR AR EN + 3984 ;0 0,,-1 ET0: AR AD EN + 3985 ;0 0,,-1 ET2: AR LT AR RT EN + 3986 + 3987 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0113 + + 3988 SUBTTL SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 + 3989 + 3990 ;********** + 3991 + 3992 045500 SN=45500 + 3993 000000 XX=0 + 3994 + 3995 B45500: REPEAT ^D18,< + 3996 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 3997 ;IS THE FLOATING ONE. + 3998 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 3999 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4000 + 4001 SN=SN+1 + 4002 XX=XX+XX + 4003 IFE XX, + 4004 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4005 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4006 CAME [XX] ;CHECK ADDER UPON FAILURE + 4007 STOP + 4008 + 4009 ;********** + 4010 > + 4011 + 4012 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4013 ;IS THE FLOATING ONE. + 4014 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4015 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4016 + 4017 045501 SN=SN+1 + 4018 000000 XX=XX+XX + 4019 000001 IFE XX, + 4020 032467 551 00 0 00 000001 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4021 032470 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4022 032471 312 00 0 00 034017 CAME [XX] ;CHECK ADDER UPON FAILURE + 4023 STOP^ + 4024 032472 254 04 0 00 032473 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4025 032473 324 00 0 00 032474 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4026 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4027 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4028 + 4029 ;********** + 4030 + 4031 + 4032 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4033 ;IS THE FLOATING ONE. + 4034 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4035 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4036 + 4037 045502 SN=SN+1 + 4038 000002 XX=XX+XX + 4039 IFE XX, + 4040 032474 551 00 0 00 000002 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4041 032475 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4042 032476 312 00 0 00 034020 CAME [XX] ;CHECK ADDER UPON FAILURE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-1 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0114 + + 4043 STOP^ + 4044 032477 254 04 0 00 032500 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4045 032500 324 00 0 00 032501 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4046 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4047 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4048 + 4049 ;********** + 4050 + 4051 + 4052 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4053 ;IS THE FLOATING ONE. + 4054 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4055 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4056 + 4057 045503 SN=SN+1 + 4058 000004 XX=XX+XX + 4059 IFE XX, + 4060 032501 551 00 0 00 000004 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4061 032502 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4062 032503 312 00 0 00 034021 CAME [XX] ;CHECK ADDER UPON FAILURE + 4063 STOP^ + 4064 032504 254 04 0 00 032505 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4065 032505 324 00 0 00 032506 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 + 4069 ;********** + 4070 + 4071 + 4072 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4073 ;IS THE FLOATING ONE. + 4074 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4075 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4076 + 4077 045504 SN=SN+1 + 4078 000010 XX=XX+XX + 4079 IFE XX, + 4080 032506 551 00 0 00 000010 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4081 032507 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4082 032510 312 00 0 00 034022 CAME [XX] ;CHECK ADDER UPON FAILURE + 4083 STOP^ + 4084 032511 254 04 0 00 032512 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4085 032512 324 00 0 00 032513 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4086 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4087 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4088 + 4089 ;********** + 4090 + 4091 + 4092 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4093 ;IS THE FLOATING ONE. + 4094 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4095 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4096 + 4097 045505 SN=SN+1 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-2 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0115 + + 4098 000020 XX=XX+XX + 4099 IFE XX, + 4100 032513 551 00 0 00 000020 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4101 032514 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4102 032515 312 00 0 00 034023 CAME [XX] ;CHECK ADDER UPON FAILURE + 4103 STOP^ + 4104 032516 254 04 0 00 032517 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4105 032517 324 00 0 00 032520 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4106 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4107 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4108 + 4109 ;********** + 4110 + 4111 + 4112 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4113 ;IS THE FLOATING ONE. + 4114 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4115 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4116 + 4117 045506 SN=SN+1 + 4118 000040 XX=XX+XX + 4119 IFE XX, + 4120 032520 551 00 0 00 000040 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4121 032521 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4122 032522 312 00 0 00 034024 CAME [XX] ;CHECK ADDER UPON FAILURE + 4123 STOP^ + 4124 032523 254 04 0 00 032524 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4125 032524 324 00 0 00 032525 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4126 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4127 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4128 + 4129 ;********** + 4130 + 4131 + 4132 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4133 ;IS THE FLOATING ONE. + 4134 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4135 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4136 + 4137 045507 SN=SN+1 + 4138 000100 XX=XX+XX + 4139 IFE XX, + 4140 032525 551 00 0 00 000100 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4141 032526 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4142 032527 312 00 0 00 034025 CAME [XX] ;CHECK ADDER UPON FAILURE + 4143 STOP^ + 4144 032530 254 04 0 00 032531 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4145 032531 324 00 0 00 032532 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4146 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4147 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4148 + 4149 ;********** + 4150 + 4151 + 4152 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-3 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0116 + + 4153 ;IS THE FLOATING ONE. + 4154 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4155 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4156 + 4157 045510 SN=SN+1 + 4158 000200 XX=XX+XX + 4159 IFE XX, + 4160 032532 551 00 0 00 000200 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4161 032533 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4162 032534 312 00 0 00 034026 CAME [XX] ;CHECK ADDER UPON FAILURE + 4163 STOP^ + 4164 032535 254 04 0 00 032536 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4165 032536 324 00 0 00 032537 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4166 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4167 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4168 + 4169 ;********** + 4170 + 4171 + 4172 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4173 ;IS THE FLOATING ONE. + 4174 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4175 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4176 + 4177 045511 SN=SN+1 + 4178 000400 XX=XX+XX + 4179 IFE XX, + 4180 032537 551 00 0 00 000400 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4181 032540 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4182 032541 312 00 0 00 034027 CAME [XX] ;CHECK ADDER UPON FAILURE + 4183 STOP^ + 4184 032542 254 04 0 00 032543 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4185 032543 324 00 0 00 032544 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4186 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4187 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4188 + 4189 ;********** + 4190 + 4191 + 4192 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4193 ;IS THE FLOATING ONE. + 4194 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4195 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4196 + 4197 045512 SN=SN+1 + 4198 001000 XX=XX+XX + 4199 IFE XX, + 4200 032544 551 00 0 00 001000 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4201 032545 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4202 032546 312 00 0 00 034030 CAME [XX] ;CHECK ADDER UPON FAILURE + 4203 STOP^ + 4204 032547 254 04 0 00 032550 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4205 032550 324 00 0 00 032551 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4206 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4207 ;IN THE SUBTEST) TO LOOP ON ERROR^ +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-4 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0117 + + 4208 + 4209 ;********** + 4210 + 4211 + 4212 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4213 ;IS THE FLOATING ONE. + 4214 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4215 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4216 + 4217 045513 SN=SN+1 + 4218 002000 XX=XX+XX + 4219 IFE XX, + 4220 032551 551 00 0 00 002000 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4221 032552 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4222 032553 312 00 0 00 034031 CAME [XX] ;CHECK ADDER UPON FAILURE + 4223 STOP^ + 4224 032554 254 04 0 00 032555 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4225 032555 324 00 0 00 032556 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4226 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4227 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4228 + 4229 ;********** + 4230 + 4231 + 4232 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4233 ;IS THE FLOATING ONE. + 4234 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4235 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4236 + 4237 045514 SN=SN+1 + 4238 004000 XX=XX+XX + 4239 IFE XX, + 4240 032556 551 00 0 00 004000 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4241 032557 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4242 032560 312 00 0 00 034032 CAME [XX] ;CHECK ADDER UPON FAILURE + 4243 STOP^ + 4244 032561 254 04 0 00 032562 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4245 032562 324 00 0 00 032563 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 + 4251 + 4252 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4253 ;IS THE FLOATING ONE. + 4254 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4255 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4256 + 4257 045515 SN=SN+1 + 4258 010000 XX=XX+XX + 4259 IFE XX, + 4260 032563 551 00 0 00 010000 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4261 032564 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4262 032565 312 00 0 00 034033 CAME [XX] ;CHECK ADDER UPON FAILURE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-5 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0118 + + 4263 STOP^ + 4264 032566 254 04 0 00 032567 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4265 032567 324 00 0 00 032570 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4266 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4267 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4268 + 4269 ;********** + 4270 + 4271 + 4272 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4273 ;IS THE FLOATING ONE. + 4274 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4275 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4276 + 4277 045516 SN=SN+1 + 4278 020000 XX=XX+XX + 4279 IFE XX, + 4280 032570 551 00 0 00 020000 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4281 032571 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4282 032572 312 00 0 00 034034 CAME [XX] ;CHECK ADDER UPON FAILURE + 4283 STOP^ + 4284 032573 254 04 0 00 032574 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4285 032574 324 00 0 00 032575 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4286 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4287 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4288 + 4289 ;********** + 4290 + 4291 + 4292 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4293 ;IS THE FLOATING ONE. + 4294 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4295 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4296 + 4297 045517 SN=SN+1 + 4298 040000 XX=XX+XX + 4299 IFE XX, + 4300 032575 551 00 0 00 040000 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4301 032576 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4302 032577 312 00 0 00 034035 CAME [XX] ;CHECK ADDER UPON FAILURE + 4303 STOP^ + 4304 032600 254 04 0 00 032601 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4305 032601 324 00 0 00 032602 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4306 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4307 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4308 + 4309 ;********** + 4310 + 4311 + 4312 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4313 ;IS THE FLOATING ONE. + 4314 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4315 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4316 + 4317 045520 SN=SN+1 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-6 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0119 + + 4318 100000 XX=XX+XX + 4319 IFE XX, + 4320 032602 551 00 0 00 100000 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4321 032603 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4322 032604 312 00 0 00 034036 CAME [XX] ;CHECK ADDER UPON FAILURE + 4323 STOP^ + 4324 032605 254 04 0 00 032606 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4325 032606 324 00 0 00 032607 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4326 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4327 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4328 + 4329 ;********** + 4330 + 4331 + 4332 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4333 ;IS THE FLOATING ONE. + 4334 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4335 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4336 + 4337 045521 SN=SN+1 + 4338 200000 XX=XX+XX + 4339 IFE XX, + 4340 032607 551 00 0 00 200000 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4341 032610 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4342 032611 312 00 0 00 034037 CAME [XX] ;CHECK ADDER UPON FAILURE + 4343 STOP^ + 4344 032612 254 04 0 00 032613 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4345 032613 324 00 0 00 032614 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4346 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4347 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4348 + 4349 ;********** + 4350 + 4351 + 4352 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4353 ;IS THE FLOATING ONE. + 4354 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4355 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4356 + 4357 045522 SN=SN+1 + 4358 400000 XX=XX+XX + 4359 IFE XX, + 4360 032614 551 00 0 00 400000 HRRZI XX ;PRELOAD AC WITH FLOATING ONE + 4361 032615 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4362 032616 312 00 0 00 034040 CAME [XX] ;CHECK ADDER UPON FAILURE + 4363 STOP^ + 4364 032617 254 04 0 00 032620 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4365 032620 324 00 0 00 032621 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4366 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4367 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4368 + 4369 ;********** + 4370 + 4371 PAGE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-7 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0120 + + 4372 000000 XX=0 + 4373 + 4374 REPEAT ^D18,< + 4375 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4376 ;IS THE FLOATING ONE. + 4377 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4378 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4379 + 4380 SN=SN+1 + 4381 XX=XX+XX + 4382 IFE XX, + 4383 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4384 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4385 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4386 STOP + 4387 + 4388 ;********** + 4389 > + 4390 + 4391 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4392 ;IS THE FLOATING ONE. + 4393 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4394 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4395 + 4396 045523 SN=SN+1 + 4397 000000 XX=XX+XX + 4398 000001 IFE XX, + 4399 032621 515 00 0 00 000001 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4400 032622 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4401 032623 312 00 0 00 034041 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4402 STOP ^ + 4403 032624 254 04 0 00 032625 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4404 032625 324 00 0 00 032626 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4405 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4406 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4407 + 4408 ;********** + 4409 + 4410 + 4411 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4412 ;IS THE FLOATING ONE. + 4413 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4414 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4415 + 4416 045524 SN=SN+1 + 4417 000002 XX=XX+XX + 4418 IFE XX, + 4419 032626 515 00 0 00 000002 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4420 032627 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4421 032630 312 00 0 00 034042 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4422 STOP ^ + 4423 032631 254 04 0 00 032632 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4424 032632 324 00 0 00 032633 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4425 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4426 ;IN THE SUBTEST) TO LOOP ON ERROR^ +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-8 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0121 + + 4427 + 4428 ;********** + 4429 + 4430 + 4431 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4432 ;IS THE FLOATING ONE. + 4433 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4434 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4435 + 4436 045525 SN=SN+1 + 4437 000004 XX=XX+XX + 4438 IFE XX, + 4439 032633 515 00 0 00 000004 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4440 032634 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4441 032635 312 00 0 00 034043 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4442 STOP ^ + 4443 032636 254 04 0 00 032637 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4444 032637 324 00 0 00 032640 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4445 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4446 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4447 + 4448 ;********** + 4449 + 4450 + 4451 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4452 ;IS THE FLOATING ONE. + 4453 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4454 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4455 + 4456 045526 SN=SN+1 + 4457 000010 XX=XX+XX + 4458 IFE XX, + 4459 032640 515 00 0 00 000010 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4460 032641 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4461 032642 312 00 0 00 034044 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4462 STOP ^ + 4463 032643 254 04 0 00 032644 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4464 032644 324 00 0 00 032645 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4465 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4466 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4467 + 4468 ;********** + 4469 + 4470 + 4471 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4472 ;IS THE FLOATING ONE. + 4473 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4474 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4475 + 4476 045527 SN=SN+1 + 4477 000020 XX=XX+XX + 4478 IFE XX, + 4479 032645 515 00 0 00 000020 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4480 032646 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4481 032647 312 00 0 00 034045 CAME [XX,,0] ;CHECK ADDER UPON FALIRE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-9 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0122 + + 4482 STOP ^ + 4483 032650 254 04 0 00 032651 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4484 032651 324 00 0 00 032652 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4485 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4486 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4487 + 4488 ;********** + 4489 + 4490 + 4491 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4492 ;IS THE FLOATING ONE. + 4493 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4494 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4495 + 4496 045530 SN=SN+1 + 4497 000040 XX=XX+XX + 4498 IFE XX, + 4499 032652 515 00 0 00 000040 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4500 032653 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4501 032654 312 00 0 00 034046 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4502 STOP ^ + 4503 032655 254 04 0 00 032656 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4504 032656 324 00 0 00 032657 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4505 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4506 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4507 + 4508 ;********** + 4509 + 4510 + 4511 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4512 ;IS THE FLOATING ONE. + 4513 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4514 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4515 + 4516 045531 SN=SN+1 + 4517 000100 XX=XX+XX + 4518 IFE XX, + 4519 032657 515 00 0 00 000100 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4520 032660 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4521 032661 312 00 0 00 034047 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4522 STOP ^ + 4523 032662 254 04 0 00 032663 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4524 032663 324 00 0 00 032664 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4525 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4526 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4527 + 4528 ;********** + 4529 + 4530 + 4531 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4532 ;IS THE FLOATING ONE. + 4533 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4534 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4535 + 4536 045532 SN=SN+1 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-10 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0123 + + 4537 000200 XX=XX+XX + 4538 IFE XX, + 4539 032664 515 00 0 00 000200 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4540 032665 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4541 032666 312 00 0 00 034050 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4542 STOP ^ + 4543 032667 254 04 0 00 032670 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4544 032670 324 00 0 00 032671 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4545 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4546 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4547 + 4548 ;********** + 4549 + 4550 + 4551 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4552 ;IS THE FLOATING ONE. + 4553 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4554 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4555 + 4556 045533 SN=SN+1 + 4557 000400 XX=XX+XX + 4558 IFE XX, + 4559 032671 515 00 0 00 000400 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4560 032672 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4561 032673 312 00 0 00 034051 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4562 STOP ^ + 4563 032674 254 04 0 00 032675 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4564 032675 324 00 0 00 032676 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4565 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4566 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4567 + 4568 ;********** + 4569 + 4570 + 4571 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4572 ;IS THE FLOATING ONE. + 4573 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4574 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4575 + 4576 045534 SN=SN+1 + 4577 001000 XX=XX+XX + 4578 IFE XX, + 4579 032676 515 00 0 00 001000 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4580 032677 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4581 032700 312 00 0 00 034052 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4582 STOP ^ + 4583 032701 254 04 0 00 032702 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4584 032702 324 00 0 00 032703 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4585 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4586 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4587 + 4588 ;********** + 4589 + 4590 + 4591 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-11 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0124 + + 4592 ;IS THE FLOATING ONE. + 4593 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4594 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4595 + 4596 045535 SN=SN+1 + 4597 002000 XX=XX+XX + 4598 IFE XX, + 4599 032703 515 00 0 00 002000 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4600 032704 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4601 032705 312 00 0 00 034053 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4602 STOP ^ + 4603 032706 254 04 0 00 032707 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4604 032707 324 00 0 00 032710 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 + 4611 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4612 ;IS THE FLOATING ONE. + 4613 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4614 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4615 + 4616 045536 SN=SN+1 + 4617 004000 XX=XX+XX + 4618 IFE XX, + 4619 032710 515 00 0 00 004000 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4620 032711 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4621 032712 312 00 0 00 034054 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4622 STOP ^ + 4623 032713 254 04 0 00 032714 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4624 032714 324 00 0 00 032715 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4625 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4626 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4627 + 4628 ;********** + 4629 + 4630 + 4631 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4632 ;IS THE FLOATING ONE. + 4633 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4634 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4635 + 4636 045537 SN=SN+1 + 4637 010000 XX=XX+XX + 4638 IFE XX, + 4639 032715 515 00 0 00 010000 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4640 032716 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4641 032717 312 00 0 00 034055 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4642 STOP ^ + 4643 032720 254 04 0 00 032721 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4644 032721 324 00 0 00 032722 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4645 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4646 ;IN THE SUBTEST) TO LOOP ON ERROR^ +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-12 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0125 + + 4647 + 4648 ;********** + 4649 + 4650 + 4651 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4652 ;IS THE FLOATING ONE. + 4653 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4654 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4655 + 4656 045540 SN=SN+1 + 4657 020000 XX=XX+XX + 4658 IFE XX, + 4659 032722 515 00 0 00 020000 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4660 032723 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4661 032724 312 00 0 00 034056 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4662 STOP ^ + 4663 032725 254 04 0 00 032726 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4664 032726 324 00 0 00 032727 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4665 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4666 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4667 + 4668 ;********** + 4669 + 4670 + 4671 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4672 ;IS THE FLOATING ONE. + 4673 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4674 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4675 + 4676 045541 SN=SN+1 + 4677 040000 XX=XX+XX + 4678 IFE XX, + 4679 032727 515 00 0 00 040000 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4680 032730 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4681 032731 312 00 0 00 034057 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4682 STOP ^ + 4683 032732 254 04 0 00 032733 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4684 032733 324 00 0 00 032734 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4685 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4686 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4687 + 4688 ;********** + 4689 + 4690 + 4691 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4692 ;IS THE FLOATING ONE. + 4693 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4694 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4695 + 4696 045542 SN=SN+1 + 4697 100000 XX=XX+XX + 4698 IFE XX, + 4699 032734 515 00 0 00 100000 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4700 032735 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4701 032736 312 00 0 00 034060 CAME [XX,,0] ;CHECK ADDER UPON FALIRE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 87-13 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 SEQ 0126 + + 4702 STOP ^ + 4703 032737 254 04 0 00 032740 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4704 032740 324 00 0 00 032741 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4705 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4706 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4707 + 4708 ;********** + 4709 + 4710 + 4711 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4712 ;IS THE FLOATING ONE. + 4713 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4714 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4715 + 4716 045543 SN=SN+1 + 4717 200000 XX=XX+XX + 4718 IFE XX, + 4719 032741 515 00 0 00 200000 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4720 032742 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4721 032743 312 00 0 00 034061 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4722 STOP ^ + 4723 032744 254 04 0 00 032745 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4724 032745 324 00 0 00 032746 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4725 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4726 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4727 + 4728 ;********** + 4729 + 4730 + 4731 ;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE + 4732 ;IS THE FLOATING ONE. + 4733 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 4734 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4735 + 4736 045544 SN=SN+1 + 4737 400000 XX=XX+XX + 4738 IFE XX, + 4739 032746 515 00 0 00 400000 HRLZI XX ;PRELOAD AC WITH FLOATING ONE + 4740 032747 270 00 0 00 034014 ADD [0] ;ADD ZERO TO A FLOATING ONE + 4741 032750 312 00 0 00 034062 CAME [XX,,0] ;CHECK ADDER UPON FALIRE + 4742 STOP ^ + 4743 032751 254 04 0 00 032752 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4744 032752 324 00 0 00 032753 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4745 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4746 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4747 + 4748 ;********** + 4749 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0127 + + 4750 SUBTTL SUPPLEMENTARY ADDER TESTS - O + FLT 0 + 4751 + 4752 ;********** + 4753 + 4754 045600 SN=45600 + 4755 B45600: REPEAT ^D18,< + 4756 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4757 ;IS THE FLOATING ZERO. + 4758 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4759 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4760 + 4761 SN=SN+1 + 4762 XX=&777777 + 4763 IFE , + 4764 SETZ ;PRELOAD AC WITH 0 + 4765 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4766 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4767 STOP + 4768 + 4769 ;********** + 4770 > + 4771 + 4772 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4773 ;IS THE FLOATING ZERO. + 4774 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4775 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4776 + 4777 045601 SN=SN+1 + 4778 000001 XX=&777777 + 4779 777776 IFE , + 4780 032753 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 4781 032754 270 00 0 00 034063 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4782 032755 312 00 0 00 034063 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4783 STOP ^ + 4784 032756 254 04 0 00 032757 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4785 032757 324 00 0 00 032760 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4786 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4787 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4788 + 4789 ;********** + 4790 + 4791 + 4792 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4793 ;IS THE FLOATING ZERO. + 4794 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4795 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4796 + 4797 045602 SN=SN+1 + 4798 777775 XX=&777777 + 4799 IFE , + 4800 032760 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 4801 032761 270 00 0 00 034064 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4802 032762 312 00 0 00 034064 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4803 STOP ^ + 4804 032763 254 04 0 00 032764 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-1 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0128 + + 4805 032764 324 00 0 00 032765 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4806 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4807 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4808 + 4809 ;********** + 4810 + 4811 + 4812 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4813 ;IS THE FLOATING ZERO. + 4814 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4815 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4816 + 4817 045603 SN=SN+1 + 4818 777773 XX=&777777 + 4819 IFE , + 4820 032765 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 4821 032766 270 00 0 00 034065 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4822 032767 312 00 0 00 034065 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4823 STOP ^ + 4824 032770 254 04 0 00 032771 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4825 032771 324 00 0 00 032772 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4826 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4827 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4828 + 4829 ;********** + 4830 + 4831 + 4832 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4833 ;IS THE FLOATING ZERO. + 4834 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4835 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4836 + 4837 045604 SN=SN+1 + 4838 777767 XX=&777777 + 4839 IFE , + 4840 032772 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 4841 032773 270 00 0 00 034066 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4842 032774 312 00 0 00 034066 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4843 STOP ^ + 4844 032775 254 04 0 00 032776 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4845 032776 324 00 0 00 032777 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4846 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4847 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4848 + 4849 ;********** + 4850 + 4851 + 4852 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4853 ;IS THE FLOATING ZERO. + 4854 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4855 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4856 + 4857 045605 SN=SN+1 + 4858 777757 XX=&777777 + 4859 IFE , +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-2 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0129 + + 4860 032777 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 4861 033000 270 00 0 00 034067 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4862 033001 312 00 0 00 034067 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4863 STOP ^ + 4864 033002 254 04 0 00 033003 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4865 033003 324 00 0 00 033004 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4866 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4867 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4868 + 4869 ;********** + 4870 + 4871 + 4872 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4873 ;IS THE FLOATING ZERO. + 4874 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4875 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4876 + 4877 045606 SN=SN+1 + 4878 777737 XX=&777777 + 4879 IFE , + 4880 033004 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 4881 033005 270 00 0 00 034070 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4882 033006 312 00 0 00 034070 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4883 STOP ^ + 4884 033007 254 04 0 00 033010 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4885 033010 324 00 0 00 033011 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4886 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4887 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4888 + 4889 ;********** + 4890 + 4891 + 4892 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4893 ;IS THE FLOATING ZERO. + 4894 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4895 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4896 + 4897 045607 SN=SN+1 + 4898 777677 XX=&777777 + 4899 IFE , + 4900 033011 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 4901 033012 270 00 0 00 034071 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4902 033013 312 00 0 00 034071 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4903 STOP ^ + 4904 033014 254 04 0 00 033015 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4905 033015 324 00 0 00 033016 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4906 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4907 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4908 + 4909 ;********** + 4910 + 4911 + 4912 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4913 ;IS THE FLOATING ZERO. + 4914 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-3 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0130 + + 4915 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4916 + 4917 045610 SN=SN+1 + 4918 777577 XX=&777777 + 4919 IFE , + 4920 033016 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 4921 033017 270 00 0 00 034072 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4922 033020 312 00 0 00 034072 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4923 STOP ^ + 4924 033021 254 04 0 00 033022 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4925 033022 324 00 0 00 033023 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4926 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4927 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4928 + 4929 ;********** + 4930 + 4931 + 4932 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4933 ;IS THE FLOATING ZERO. + 4934 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4935 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4936 + 4937 045611 SN=SN+1 + 4938 777377 XX=&777777 + 4939 IFE , + 4940 033023 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 4941 033024 270 00 0 00 034073 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4942 033025 312 00 0 00 034073 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4943 STOP ^ + 4944 033026 254 04 0 00 033027 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4945 033027 324 00 0 00 033030 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4946 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4947 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4948 + 4949 ;********** + 4950 + 4951 + 4952 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4953 ;IS THE FLOATING ZERO. + 4954 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4955 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4956 + 4957 045612 SN=SN+1 + 4958 776777 XX=&777777 + 4959 IFE , + 4960 033030 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 4961 033031 270 00 0 00 034074 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4962 033032 312 00 0 00 034074 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4963 STOP ^ + 4964 033033 254 04 0 00 033034 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4965 033034 324 00 0 00 033035 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4966 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4967 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4968 + 4969 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-4 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0131 + + 4970 + 4971 + 4972 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4973 ;IS THE FLOATING ZERO. + 4974 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4975 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4976 + 4977 045613 SN=SN+1 + 4978 775777 XX=&777777 + 4979 IFE , + 4980 033035 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 4981 033036 270 00 0 00 034075 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 4982 033037 312 00 0 00 034075 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 4983 STOP ^ + 4984 033040 254 04 0 00 033041 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4985 033041 324 00 0 00 033042 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 4986 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 4987 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 4988 + 4989 ;********** + 4990 + 4991 + 4992 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 4993 ;IS THE FLOATING ZERO. + 4994 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 4995 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 4996 + 4997 045614 SN=SN+1 + 4998 773777 XX=&777777 + 4999 IFE , + 5000 033042 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5001 033043 270 00 0 00 034076 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 5002 033044 312 00 0 00 034076 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 5003 STOP ^ + 5004 033045 254 04 0 00 033046 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5005 033046 324 00 0 00 033047 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5006 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5007 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5008 + 5009 ;********** + 5010 + 5011 + 5012 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5013 ;IS THE FLOATING ZERO. + 5014 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 5015 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5016 + 5017 045615 SN=SN+1 + 5018 767777 XX=&777777 + 5019 IFE , + 5020 033047 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5021 033050 270 00 0 00 034077 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 5022 033051 312 00 0 00 034077 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 5023 STOP ^ + 5024 033052 254 04 0 00 033053 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-5 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0132 + + 5025 033053 324 00 0 00 033054 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5026 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5027 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5028 + 5029 ;********** + 5030 + 5031 + 5032 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5033 ;IS THE FLOATING ZERO. + 5034 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 5035 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5036 + 5037 045616 SN=SN+1 + 5038 757777 XX=&777777 + 5039 IFE , + 5040 033054 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5041 033055 270 00 0 00 034100 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 5042 033056 312 00 0 00 034100 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 5043 STOP ^ + 5044 033057 254 04 0 00 033060 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5045 033060 324 00 0 00 033061 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 + 5052 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5053 ;IS THE FLOATING ZERO. + 5054 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 5055 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5056 + 5057 045617 SN=SN+1 + 5058 737777 XX=&777777 + 5059 IFE , + 5060 033061 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5061 033062 270 00 0 00 034101 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 5062 033063 312 00 0 00 034101 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 5063 STOP ^ + 5064 033064 254 04 0 00 033065 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5065 033065 324 00 0 00 033066 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5066 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5067 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5068 + 5069 ;********** + 5070 + 5071 + 5072 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5073 ;IS THE FLOATING ZERO. + 5074 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 5075 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5076 + 5077 045620 SN=SN+1 + 5078 677777 XX=&777777 + 5079 IFE , +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-6 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0133 + + 5080 033066 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5081 033067 270 00 0 00 034102 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 5082 033070 312 00 0 00 034102 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 5083 STOP ^ + 5084 033071 254 04 0 00 033072 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5085 033072 324 00 0 00 033073 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5086 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5087 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5088 + 5089 ;********** + 5090 + 5091 + 5092 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5093 ;IS THE FLOATING ZERO. + 5094 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 5095 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5096 + 5097 045621 SN=SN+1 + 5098 577777 XX=&777777 + 5099 IFE , + 5100 033073 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5101 033074 270 00 0 00 034103 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 5102 033075 312 00 0 00 034103 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 5103 STOP ^ + 5104 033076 254 04 0 00 033077 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5105 033077 324 00 0 00 033100 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5106 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5107 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5108 + 5109 ;********** + 5110 + 5111 + 5112 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5113 ;IS THE FLOATING ZERO. + 5114 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 5115 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5116 + 5117 045622 SN=SN+1 + 5118 377777 XX=&777777 + 5119 IFE , + 5120 033100 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5121 033101 270 00 0 00 034104 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + 5122 033102 312 00 0 00 034104 CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + 5123 STOP ^ + 5124 033103 254 04 0 00 033104 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5125 033104 324 00 0 00 033105 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5126 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5127 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5128 + 5129 ;********** + 5130 + 5131 PAGE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-7 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0134 + + 5132 000000 XX=0 + 5133 + 5134 REPEAT ^D18,< + 5135 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5136 ;IS THE FLOATING ZERO. + 5137 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5138 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5139 + 5140 SN=SN+1 + 5141 XX=&777777 + 5142 IFE , + 5143 SETZ ;PRELOAD AC WITH 0 + 5144 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5145 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5146 STOP + 5147 + 5148 ;********** + 5149 > + 5150 + 5151 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5152 ;IS THE FLOATING ZERO. + 5153 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5154 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5155 + 5156 045623 SN=SN+1 + 5157 000001 XX=&777777 + 5158 777776 IFE , + 5159 033105 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5160 033106 270 00 0 00 034105 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5161 033107 312 00 0 00 034105 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5162 STOP ^ + 5163 033110 254 04 0 00 033111 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5164 033111 324 00 0 00 033112 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5165 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5166 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5167 + 5168 ;********** + 5169 + 5170 + 5171 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5172 ;IS THE FLOATING ZERO. + 5173 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5174 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5175 + 5176 045624 SN=SN+1 + 5177 777775 XX=&777777 + 5178 IFE , + 5179 033112 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5180 033113 270 00 0 00 034106 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5181 033114 312 00 0 00 034106 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5182 STOP ^ + 5183 033115 254 04 0 00 033116 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5184 033116 324 00 0 00 033117 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5185 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5186 ;IN THE SUBTEST) TO LOOP ON ERROR^ +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-8 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0135 + + 5187 + 5188 ;********** + 5189 + 5190 + 5191 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5192 ;IS THE FLOATING ZERO. + 5193 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5194 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5195 + 5196 045625 SN=SN+1 + 5197 777773 XX=&777777 + 5198 IFE , + 5199 033117 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5200 033120 270 00 0 00 034107 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5201 033121 312 00 0 00 034107 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5202 STOP ^ + 5203 033122 254 04 0 00 033123 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5204 033123 324 00 0 00 033124 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5205 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5206 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5207 + 5208 ;********** + 5209 + 5210 + 5211 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5212 ;IS THE FLOATING ZERO. + 5213 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5214 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5215 + 5216 045626 SN=SN+1 + 5217 777767 XX=&777777 + 5218 IFE , + 5219 033124 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5220 033125 270 00 0 00 034110 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5221 033126 312 00 0 00 034110 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5222 STOP ^ + 5223 033127 254 04 0 00 033130 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5224 033130 324 00 0 00 033131 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5225 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5226 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5227 + 5228 ;********** + 5229 + 5230 + 5231 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5232 ;IS THE FLOATING ZERO. + 5233 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5234 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5235 + 5236 045627 SN=SN+1 + 5237 777757 XX=&777777 + 5238 IFE , + 5239 033131 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5240 033132 270 00 0 00 034111 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5241 033133 312 00 0 00 034111 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-9 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0136 + + 5242 STOP ^ + 5243 033134 254 04 0 00 033135 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5244 033135 324 00 0 00 033136 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5245 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5246 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5247 + 5248 ;********** + 5249 + 5250 + 5251 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5252 ;IS THE FLOATING ZERO. + 5253 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5254 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5255 + 5256 045630 SN=SN+1 + 5257 777737 XX=&777777 + 5258 IFE , + 5259 033136 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5260 033137 270 00 0 00 034112 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5261 033140 312 00 0 00 034112 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5262 STOP ^ + 5263 033141 254 04 0 00 033142 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5264 033142 324 00 0 00 033143 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5265 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5266 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5267 + 5268 ;********** + 5269 + 5270 + 5271 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5272 ;IS THE FLOATING ZERO. + 5273 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5274 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5275 + 5276 045631 SN=SN+1 + 5277 777677 XX=&777777 + 5278 IFE , + 5279 033143 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5280 033144 270 00 0 00 034113 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5281 033145 312 00 0 00 034113 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5282 STOP ^ + 5283 033146 254 04 0 00 033147 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5284 033147 324 00 0 00 033150 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5285 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5286 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5287 + 5288 ;********** + 5289 + 5290 + 5291 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5292 ;IS THE FLOATING ZERO. + 5293 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5294 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5295 + 5296 045632 SN=SN+1 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-10 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0137 + + 5297 777577 XX=&777777 + 5298 IFE , + 5299 033150 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5300 033151 270 00 0 00 034114 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5301 033152 312 00 0 00 034114 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5302 STOP ^ + 5303 033153 254 04 0 00 033154 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5304 033154 324 00 0 00 033155 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5305 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5306 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5307 + 5308 ;********** + 5309 + 5310 + 5311 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5312 ;IS THE FLOATING ZERO. + 5313 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5314 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5315 + 5316 045633 SN=SN+1 + 5317 777377 XX=&777777 + 5318 IFE , + 5319 033155 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5320 033156 270 00 0 00 034115 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5321 033157 312 00 0 00 034115 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5322 STOP ^ + 5323 033160 254 04 0 00 033161 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5324 033161 324 00 0 00 033162 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5325 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5326 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5327 + 5328 ;********** + 5329 + 5330 + 5331 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5332 ;IS THE FLOATING ZERO. + 5333 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5334 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5335 + 5336 045634 SN=SN+1 + 5337 776777 XX=&777777 + 5338 IFE , + 5339 033162 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5340 033163 270 00 0 00 034116 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5341 033164 312 00 0 00 034116 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5342 STOP ^ + 5343 033165 254 04 0 00 033166 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5344 033166 324 00 0 00 033167 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5345 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5346 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5347 + 5348 ;********** + 5349 + 5350 + 5351 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-11 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0138 + + 5352 ;IS THE FLOATING ZERO. + 5353 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5354 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5355 + 5356 045635 SN=SN+1 + 5357 775777 XX=&777777 + 5358 IFE , + 5359 033167 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5360 033170 270 00 0 00 034117 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5361 033171 312 00 0 00 034117 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5362 STOP ^ + 5363 033172 254 04 0 00 033173 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5364 033173 324 00 0 00 033174 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5365 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5366 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5367 + 5368 ;********** + 5369 + 5370 + 5371 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5372 ;IS THE FLOATING ZERO. + 5373 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5374 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5375 + 5376 045636 SN=SN+1 + 5377 773777 XX=&777777 + 5378 IFE , + 5379 033174 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5380 033175 270 00 0 00 034120 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5381 033176 312 00 0 00 034120 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5382 STOP ^ + 5383 033177 254 04 0 00 033200 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5384 033200 324 00 0 00 033201 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5385 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5386 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5387 + 5388 ;********** + 5389 + 5390 + 5391 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5392 ;IS THE FLOATING ZERO. + 5393 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5394 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5395 + 5396 045637 SN=SN+1 + 5397 767777 XX=&777777 + 5398 IFE , + 5399 033201 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5400 033202 270 00 0 00 034121 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5401 033203 312 00 0 00 034121 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5402 STOP ^ + 5403 033204 254 04 0 00 033205 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5404 033205 324 00 0 00 033206 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5405 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5406 ;IN THE SUBTEST) TO LOOP ON ERROR^ +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-12 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0139 + + 5407 + 5408 ;********** + 5409 + 5410 + 5411 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5412 ;IS THE FLOATING ZERO. + 5413 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5414 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5415 + 5416 045640 SN=SN+1 + 5417 757777 XX=&777777 + 5418 IFE , + 5419 033206 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5420 033207 270 00 0 00 034122 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5421 033210 312 00 0 00 034122 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5422 STOP ^ + 5423 033211 254 04 0 00 033212 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5424 033212 324 00 0 00 033213 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5425 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5426 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5427 + 5428 ;********** + 5429 + 5430 + 5431 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5432 ;IS THE FLOATING ZERO. + 5433 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5434 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5435 + 5436 045641 SN=SN+1 + 5437 737777 XX=&777777 + 5438 IFE , + 5439 033213 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5440 033214 270 00 0 00 034123 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5441 033215 312 00 0 00 034123 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5442 STOP ^ + 5443 033216 254 04 0 00 033217 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5444 033217 324 00 0 00 033220 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5445 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5446 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5447 + 5448 ;********** + 5449 + 5450 + 5451 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5452 ;IS THE FLOATING ZERO. + 5453 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5454 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5455 + 5456 045642 SN=SN+1 + 5457 677777 XX=&777777 + 5458 IFE , + 5459 033220 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5460 033221 270 00 0 00 034124 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5461 033222 312 00 0 00 034124 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 88-13 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - O + FLT 0 SEQ 0140 + + 5462 STOP ^ + 5463 033223 254 04 0 00 033224 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5464 033224 324 00 0 00 033225 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5465 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5466 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5467 + 5468 ;********** + 5469 + 5470 + 5471 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5472 ;IS THE FLOATING ZERO. + 5473 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5474 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5475 + 5476 045643 SN=SN+1 + 5477 577777 XX=&777777 + 5478 IFE , + 5479 033225 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5480 033226 270 00 0 00 034125 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5481 033227 312 00 0 00 034125 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5482 STOP ^ + 5483 033230 254 04 0 00 033231 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5484 033231 324 00 0 00 033232 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5485 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5486 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5487 + 5488 ;********** + 5489 + 5490 + 5491 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO + 5492 ;IS THE FLOATING ZERO. + 5493 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5494 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5495 + 5496 045644 SN=SN+1 + 5497 377777 XX=&777777 + 5498 IFE , + 5499 033232 400 00 0 00 000000 SETZ ;PRELOAD AC WITH 0 + 5500 033233 270 00 0 00 034126 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + 5501 033234 312 00 0 00 034126 CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + 5502 STOP ^ + 5503 033235 254 04 0 00 033236 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5504 033236 324 00 0 00 033237 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5505 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5506 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5507 + 5508 ;********** + 5509 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0141 + + 5510 SUBTTL SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 + 5511 + 5512 ;********** + 5513 + 5514 045700 SN=45700 + 5515 000000 XX=0 + 5516 + 5517 B45700: REPEAT ^D17,< + 5518 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5519 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5520 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5521 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5522 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5523 + 5524 SN=SN+1 + 5525 XX=XX+XX + 5526 IFE XX, + 5527 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5528 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5529 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5530 STOP + 5531 + 5532 ;********** + 5533 > + 5534 + 5535 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5536 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5537 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5538 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5539 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5540 + 5541 045701 SN=SN+1 + 5542 000000 XX=XX+XX + 5543 000001 IFE XX, + 5544 033237 551 00 0 00 000001 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5545 033240 270 00 0 00 034017 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5546 033241 312 00 0 00 034020 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5547 STOP ^ + 5548 033242 254 04 0 00 033243 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5549 033243 324 00 0 00 033244 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5550 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5551 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5552 + 5553 ;********** + 5554 + 5555 + 5556 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5557 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5558 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5559 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5560 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5561 + 5562 045702 SN=SN+1 + 5563 000002 XX=XX+XX + 5564 IFE XX, +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-1 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0142 + + 5565 033244 551 00 0 00 000002 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5566 033245 270 00 0 00 034020 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5567 033246 312 00 0 00 034021 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5568 STOP ^ + 5569 033247 254 04 0 00 033250 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5570 033250 324 00 0 00 033251 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5571 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5572 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5573 + 5574 ;********** + 5575 + 5576 + 5577 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5578 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5579 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5580 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5581 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5582 + 5583 045703 SN=SN+1 + 5584 000004 XX=XX+XX + 5585 IFE XX, + 5586 033251 551 00 0 00 000004 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5587 033252 270 00 0 00 034021 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5588 033253 312 00 0 00 034022 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5589 STOP ^ + 5590 033254 254 04 0 00 033255 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5591 033255 324 00 0 00 033256 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5592 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5593 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5594 + 5595 ;********** + 5596 + 5597 + 5598 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5599 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5600 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5601 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5602 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5603 + 5604 045704 SN=SN+1 + 5605 000010 XX=XX+XX + 5606 IFE XX, + 5607 033256 551 00 0 00 000010 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5608 033257 270 00 0 00 034022 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5609 033260 312 00 0 00 034023 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5610 STOP ^ + 5611 033261 254 04 0 00 033262 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5612 033262 324 00 0 00 033263 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5613 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5614 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5615 + 5616 ;********** + 5617 + 5618 + 5619 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-2 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0143 + + 5620 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5621 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5622 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5623 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5624 + 5625 045705 SN=SN+1 + 5626 000020 XX=XX+XX + 5627 IFE XX, + 5628 033263 551 00 0 00 000020 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5629 033264 270 00 0 00 034023 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5630 033265 312 00 0 00 034024 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5631 STOP ^ + 5632 033266 254 04 0 00 033267 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5633 033267 324 00 0 00 033270 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5634 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5635 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5636 + 5637 ;********** + 5638 + 5639 + 5640 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5641 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5642 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5643 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5644 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5645 + 5646 045706 SN=SN+1 + 5647 000040 XX=XX+XX + 5648 IFE XX, + 5649 033270 551 00 0 00 000040 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5650 033271 270 00 0 00 034024 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5651 033272 312 00 0 00 034025 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5652 STOP ^ + 5653 033273 254 04 0 00 033274 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5654 033274 324 00 0 00 033275 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5655 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5656 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5657 + 5658 ;********** + 5659 + 5660 + 5661 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5662 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5663 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5664 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5665 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5666 + 5667 045707 SN=SN+1 + 5668 000100 XX=XX+XX + 5669 IFE XX, + 5670 033275 551 00 0 00 000100 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5671 033276 270 00 0 00 034025 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5672 033277 312 00 0 00 034026 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5673 STOP ^ + 5674 033300 254 04 0 00 033301 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-3 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0144 + + 5675 033301 324 00 0 00 033302 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5676 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5677 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5678 + 5679 ;********** + 5680 + 5681 + 5682 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5683 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5684 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5685 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5686 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5687 + 5688 045710 SN=SN+1 + 5689 000200 XX=XX+XX + 5690 IFE XX, + 5691 033302 551 00 0 00 000200 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5692 033303 270 00 0 00 034026 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5693 033304 312 00 0 00 034027 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5694 STOP ^ + 5695 033305 254 04 0 00 033306 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5696 033306 324 00 0 00 033307 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5697 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5698 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5699 + 5700 ;********** + 5701 + 5702 + 5703 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5704 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5705 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5706 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5707 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5708 + 5709 045711 SN=SN+1 + 5710 000400 XX=XX+XX + 5711 IFE XX, + 5712 033307 551 00 0 00 000400 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5713 033310 270 00 0 00 034027 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5714 033311 312 00 0 00 034030 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5715 STOP ^ + 5716 033312 254 04 0 00 033313 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5717 033313 324 00 0 00 033314 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5718 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5719 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5720 + 5721 ;********** + 5722 + 5723 + 5724 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5725 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5726 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5727 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5728 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5729 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-4 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0145 + + 5730 045712 SN=SN+1 + 5731 001000 XX=XX+XX + 5732 IFE XX, + 5733 033314 551 00 0 00 001000 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5734 033315 270 00 0 00 034030 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5735 033316 312 00 0 00 034031 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5736 STOP ^ + 5737 033317 254 04 0 00 033320 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5738 033320 324 00 0 00 033321 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5739 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5740 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5741 + 5742 ;********** + 5743 + 5744 + 5745 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5746 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5747 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5748 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5749 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5750 + 5751 045713 SN=SN+1 + 5752 002000 XX=XX+XX + 5753 IFE XX, + 5754 033321 551 00 0 00 002000 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5755 033322 270 00 0 00 034031 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5756 033323 312 00 0 00 034032 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5757 STOP ^ + 5758 033324 254 04 0 00 033325 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5759 033325 324 00 0 00 033326 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5760 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5761 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5762 + 5763 ;********** + 5764 + 5765 + 5766 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5767 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5768 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5769 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5770 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5771 + 5772 045714 SN=SN+1 + 5773 004000 XX=XX+XX + 5774 IFE XX, + 5775 033326 551 00 0 00 004000 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5776 033327 270 00 0 00 034032 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5777 033330 312 00 0 00 034033 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5778 STOP ^ + 5779 033331 254 04 0 00 033332 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5780 033332 324 00 0 00 033333 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5781 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5782 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5783 + 5784 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-5 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0146 + + 5785 + 5786 + 5787 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5788 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5789 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5790 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5791 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5792 + 5793 045715 SN=SN+1 + 5794 010000 XX=XX+XX + 5795 IFE XX, + 5796 033333 551 00 0 00 010000 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5797 033334 270 00 0 00 034033 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5798 033335 312 00 0 00 034034 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5799 STOP ^ + 5800 033336 254 04 0 00 033337 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5801 033337 324 00 0 00 033340 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5802 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5803 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5804 + 5805 ;********** + 5806 + 5807 + 5808 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5809 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5810 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5811 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5812 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5813 + 5814 045716 SN=SN+1 + 5815 020000 XX=XX+XX + 5816 IFE XX, + 5817 033340 551 00 0 00 020000 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5818 033341 270 00 0 00 034034 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5819 033342 312 00 0 00 034035 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5820 STOP ^ + 5821 033343 254 04 0 00 033344 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5822 033344 324 00 0 00 033345 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5823 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5824 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5825 + 5826 ;********** + 5827 + 5828 + 5829 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5830 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5831 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5832 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5833 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5834 + 5835 045717 SN=SN+1 + 5836 040000 XX=XX+XX + 5837 IFE XX, + 5838 033345 551 00 0 00 040000 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5839 033346 270 00 0 00 034035 ADD [XX] ;ADD A FLOATING ONE TO ITSELF +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-6 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0147 + + 5840 033347 312 00 0 00 034036 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5841 STOP ^ + 5842 033350 254 04 0 00 033351 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5843 033351 324 00 0 00 033352 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5844 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5845 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5846 + 5847 ;********** + 5848 + 5849 + 5850 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5851 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5852 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5853 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5854 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5855 + 5856 045720 SN=SN+1 + 5857 100000 XX=XX+XX + 5858 IFE XX, + 5859 033352 551 00 0 00 100000 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5860 033353 270 00 0 00 034036 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5861 033354 312 00 0 00 034037 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5862 STOP ^ + 5863 033355 254 04 0 00 033356 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5864 033356 324 00 0 00 033357 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5865 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5866 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5867 + 5868 ;********** + 5869 + 5870 + 5871 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5872 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5873 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5874 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5875 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5876 + 5877 045721 SN=SN+1 + 5878 200000 XX=XX+XX + 5879 IFE XX, + 5880 033357 551 00 0 00 200000 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5881 033360 270 00 0 00 034037 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5882 033361 312 00 0 00 034040 CAME [XX+XX] ;CHECK ADDER UPON FAILURE + 5883 STOP ^ + 5884 033362 254 04 0 00 033363 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5885 033363 324 00 0 00 033364 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5886 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5887 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5888 + 5889 ;********** + 5890 + 5891 PAGE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-7 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0148 + + 5892 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5893 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5894 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5895 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5896 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5897 045722 SN=SN+1 + 5898 400000 XX=XX+XX + 5899 033364 551 00 0 00 400000 HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + 5900 033365 270 00 0 00 034040 ADD [XX] ;ADD A FLOATING ONE TO ITSELF + 5901 033366 312 00 0 00 034041 CAME [1,,0] ;CHECK ADDRESS UPON FAILURE + 5902 STOP ^ + 5903 033367 254 04 0 00 033370 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5904 033370 324 00 0 00 033371 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5905 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5906 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5907 + 5908 ;********** + 5909 + 5910 000000 XX=0 + 5911 + 5912 REPEAT ^D18,< + 5913 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5914 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5915 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5916 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5917 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5918 + 5919 SN=SN+1 + 5920 XX=XX+XX + 5921 IFE XX, + 5922 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 5923 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 5924 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 5925 STOP + 5926 + 5927 ;********** + 5928 > + 5929 + 5930 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5931 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5932 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5933 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5934 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5935 + 5936 045723 SN=SN+1 + 5937 000000 XX=XX+XX + 5938 000001 IFE XX, + 5939 033371 515 00 0 00 000001 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 5940 033372 270 00 0 00 034041 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 5941 033373 312 00 0 00 034042 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 5942 STOP ^ + 5943 033374 254 04 0 00 033375 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5944 033375 324 00 0 00 033376 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5945 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5946 ;IN THE SUBTEST) TO LOOP ON ERROR^ +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-8 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0149 + + 5947 + 5948 ;********** + 5949 + 5950 + 5951 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5952 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5953 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5954 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5955 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5956 + 5957 045724 SN=SN+1 + 5958 000002 XX=XX+XX + 5959 IFE XX, + 5960 033376 515 00 0 00 000002 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 5961 033377 270 00 0 00 034042 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 5962 033400 312 00 0 00 034043 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 5963 STOP ^ + 5964 033401 254 04 0 00 033402 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5965 033402 324 00 0 00 033403 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5966 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5967 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5968 + 5969 ;********** + 5970 + 5971 + 5972 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5973 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5974 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5975 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5976 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5977 + 5978 045725 SN=SN+1 + 5979 000004 XX=XX+XX + 5980 IFE XX, + 5981 033403 515 00 0 00 000004 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 5982 033404 270 00 0 00 034043 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 5983 033405 312 00 0 00 034044 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 5984 STOP ^ + 5985 033406 254 04 0 00 033407 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5986 033407 324 00 0 00 033410 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 5987 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 5988 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 5989 + 5990 ;********** + 5991 + 5992 + 5993 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 5994 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 5995 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 5996 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 5997 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 5998 + 5999 045726 SN=SN+1 + 6000 000010 XX=XX+XX + 6001 IFE XX, +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-9 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0150 + + 6002 033410 515 00 0 00 000010 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6003 033411 270 00 0 00 034044 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6004 033412 312 00 0 00 034045 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6005 STOP ^ + 6006 033413 254 04 0 00 033414 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6007 033414 324 00 0 00 033415 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6008 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6009 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6010 + 6011 ;********** + 6012 + 6013 + 6014 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6015 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6016 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6017 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6018 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6019 + 6020 045727 SN=SN+1 + 6021 000020 XX=XX+XX + 6022 IFE XX, + 6023 033415 515 00 0 00 000020 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6024 033416 270 00 0 00 034045 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6025 033417 312 00 0 00 034046 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6026 STOP ^ + 6027 033420 254 04 0 00 033421 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6028 033421 324 00 0 00 033422 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6029 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6030 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6031 + 6032 ;********** + 6033 + 6034 + 6035 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6036 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6037 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6038 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6039 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6040 + 6041 045730 SN=SN+1 + 6042 000040 XX=XX+XX + 6043 IFE XX, + 6044 033422 515 00 0 00 000040 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6045 033423 270 00 0 00 034046 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6046 033424 312 00 0 00 034047 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6047 STOP ^ + 6048 033425 254 04 0 00 033426 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6049 033426 324 00 0 00 033427 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6050 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6051 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6052 + 6053 ;********** + 6054 + 6055 + 6056 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-10 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0151 + + 6057 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6058 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6059 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6060 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6061 + 6062 045731 SN=SN+1 + 6063 000100 XX=XX+XX + 6064 IFE XX, + 6065 033427 515 00 0 00 000100 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6066 033430 270 00 0 00 034047 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6067 033431 312 00 0 00 034050 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6068 STOP ^ + 6069 033432 254 04 0 00 033433 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6070 033433 324 00 0 00 033434 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6071 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6072 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6073 + 6074 ;********** + 6075 + 6076 + 6077 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6078 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6079 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6080 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6081 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6082 + 6083 045732 SN=SN+1 + 6084 000200 XX=XX+XX + 6085 IFE XX, + 6086 033434 515 00 0 00 000200 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6087 033435 270 00 0 00 034050 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6088 033436 312 00 0 00 034051 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6089 STOP ^ + 6090 033437 254 04 0 00 033440 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6091 033440 324 00 0 00 033441 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6092 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6093 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6094 + 6095 ;********** + 6096 + 6097 + 6098 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6099 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6100 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6101 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6102 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6103 + 6104 045733 SN=SN+1 + 6105 000400 XX=XX+XX + 6106 IFE XX, + 6107 033441 515 00 0 00 000400 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6108 033442 270 00 0 00 034051 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6109 033443 312 00 0 00 034052 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6110 STOP ^ + 6111 033444 254 04 0 00 033445 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-11 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0152 + + 6112 033445 324 00 0 00 033446 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6113 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6114 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6115 + 6116 ;********** + 6117 + 6118 + 6119 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6120 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6121 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6122 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6123 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6124 + 6125 045734 SN=SN+1 + 6126 001000 XX=XX+XX + 6127 IFE XX, + 6128 033446 515 00 0 00 001000 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6129 033447 270 00 0 00 034052 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6130 033450 312 00 0 00 034053 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6131 STOP ^ + 6132 033451 254 04 0 00 033452 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6133 033452 324 00 0 00 033453 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6134 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6135 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6136 + 6137 ;********** + 6138 + 6139 + 6140 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6141 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6142 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6143 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6144 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6145 + 6146 045735 SN=SN+1 + 6147 002000 XX=XX+XX + 6148 IFE XX, + 6149 033453 515 00 0 00 002000 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6150 033454 270 00 0 00 034053 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6151 033455 312 00 0 00 034054 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6152 STOP ^ + 6153 033456 254 04 0 00 033457 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6154 033457 324 00 0 00 033460 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6155 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6156 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6157 + 6158 ;********** + 6159 + 6160 + 6161 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6162 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6163 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6164 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6165 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6166 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-12 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0153 + + 6167 045736 SN=SN+1 + 6168 004000 XX=XX+XX + 6169 IFE XX, + 6170 033460 515 00 0 00 004000 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6171 033461 270 00 0 00 034054 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6172 033462 312 00 0 00 034055 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6173 STOP ^ + 6174 033463 254 04 0 00 033464 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6175 033464 324 00 0 00 033465 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6176 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6177 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6178 + 6179 ;********** + 6180 + 6181 + 6182 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6183 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6184 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6185 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6186 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6187 + 6188 045737 SN=SN+1 + 6189 010000 XX=XX+XX + 6190 IFE XX, + 6191 033465 515 00 0 00 010000 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6192 033466 270 00 0 00 034055 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6193 033467 312 00 0 00 034056 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6194 STOP ^ + 6195 033470 254 04 0 00 033471 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6196 033471 324 00 0 00 033472 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6197 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6198 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6199 + 6200 ;********** + 6201 + 6202 + 6203 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6204 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6205 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6206 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6207 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6208 + 6209 045740 SN=SN+1 + 6210 020000 XX=XX+XX + 6211 IFE XX, + 6212 033472 515 00 0 00 020000 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6213 033473 270 00 0 00 034056 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6214 033474 312 00 0 00 034057 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6215 STOP ^ + 6216 033475 254 04 0 00 033476 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6217 033476 324 00 0 00 033477 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6218 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6219 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6220 + 6221 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-13 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0154 + + 6222 + 6223 + 6224 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6225 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6226 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6227 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6228 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6229 + 6230 045741 SN=SN+1 + 6231 040000 XX=XX+XX + 6232 IFE XX, + 6233 033477 515 00 0 00 040000 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6234 033500 270 00 0 00 034057 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6235 033501 312 00 0 00 034060 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6236 STOP ^ + 6237 033502 254 04 0 00 033503 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6238 033503 324 00 0 00 033504 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6239 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6240 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6241 + 6242 ;********** + 6243 + 6244 + 6245 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6246 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6247 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6248 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6249 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6250 + 6251 045742 SN=SN+1 + 6252 100000 XX=XX+XX + 6253 IFE XX, + 6254 033504 515 00 0 00 100000 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6255 033505 270 00 0 00 034060 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6256 033506 312 00 0 00 034061 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6257 STOP ^ + 6258 033507 254 04 0 00 033510 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6259 033510 324 00 0 00 033511 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6260 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6261 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6262 + 6263 ;********** + 6264 + 6265 + 6266 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6267 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6268 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6269 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6270 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6271 + 6272 045743 SN=SN+1 + 6273 200000 XX=XX+XX + 6274 IFE XX, + 6275 033511 515 00 0 00 200000 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6276 033512 270 00 0 00 034061 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 89-14 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 SEQ 0155 + + 6277 033513 312 00 0 00 034062 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6278 STOP ^ + 6279 033514 254 04 0 00 033515 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6280 033515 324 00 0 00 033516 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6281 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6282 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6283 + 6284 ;********** + 6285 + 6286 + 6287 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE + 6288 ;ADDED TO A FLOATING ONE IS A FLOATING ONE + 6289 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. + 6290 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. + 6291 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6292 + 6293 045744 SN=SN+1 + 6294 400000 XX=XX+XX + 6295 IFE XX, + 6296 033516 515 00 0 00 400000 HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + 6297 033517 270 00 0 00 034062 ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + 6298Q 033520 312 00 0 00 034127 CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + 6299 STOP ^ + 6300 033521 254 04 0 00 033522 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6301 033522 324 00 0 00 033523 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6302 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6303 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6304 + 6305 ;********** + 6306 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0156 + + 6307 SUBTTL SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT + 6308 + 6309 ;********** + 6310 + 6311 046000 SN=46000 + 6312 000000 XX=0 + 6313 + 6314 B46000: REPEAT ^D17,< + 6315 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6316 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6317 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6318 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6319 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6320 + 6321 SN=SN+1 + 6322 XX=&777777 + 6323 IFE , + 6324 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6325 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6326 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6327 STOP + 6328 + 6329 ;********** + 6330 > + 6331 + 6332 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6333 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6334 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6335 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6336 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6337 + 6338 046001 SN=SN+1 + 6339 000001 XX=&777777 + 6340 777776 IFE , + 6341 033523 561 00 0 00 777776 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6342 033524 270 00 0 00 034063 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6343 033525 312 00 0 00 034130 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6344 STOP ^ + 6345 033526 254 04 0 00 033527 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6346 033527 324 00 0 00 033530 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6347 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6348 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6349 + 6350 ;********** + 6351 + 6352 + 6353 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6354 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6355 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6356 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6357 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6358 + 6359 046002 SN=SN+1 + 6360 777775 XX=&777777 + 6361 IFE , +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-1 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0157 + + 6362 033530 561 00 0 00 777775 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6363 033531 270 00 0 00 034064 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6364 033532 312 00 0 00 034131 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6365 STOP ^ + 6366 033533 254 04 0 00 033534 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6367 033534 324 00 0 00 033535 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6368 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6369 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6370 + 6371 ;********** + 6372 + 6373 + 6374 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6375 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6376 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6377 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6378 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6379 + 6380 046003 SN=SN+1 + 6381 777773 XX=&777777 + 6382 IFE , + 6383 033535 561 00 0 00 777773 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6384 033536 270 00 0 00 034065 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6385 033537 312 00 0 00 034132 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6386 STOP ^ + 6387 033540 254 04 0 00 033541 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6388 033541 324 00 0 00 033542 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6389 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6390 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6391 + 6392 ;********** + 6393 + 6394 + 6395 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6396 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6397 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6398 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6399 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6400 + 6401 046004 SN=SN+1 + 6402 777767 XX=&777777 + 6403 IFE , + 6404 033542 561 00 0 00 777767 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6405 033543 270 00 0 00 034066 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6406 033544 312 00 0 00 034133 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6407 STOP ^ + 6408 033545 254 04 0 00 033546 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6409 033546 324 00 0 00 033547 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6410 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6411 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6412 + 6413 ;********** + 6414 + 6415 + 6416 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-2 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0158 + + 6417 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6418 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6419 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6420 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6421 + 6422 046005 SN=SN+1 + 6423 777757 XX=&777777 + 6424 IFE , + 6425 033547 561 00 0 00 777757 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6426 033550 270 00 0 00 034067 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6427 033551 312 00 0 00 034134 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6428 STOP ^ + 6429 033552 254 04 0 00 033553 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6430 033553 324 00 0 00 033554 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6431 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6432 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6433 + 6434 ;********** + 6435 + 6436 + 6437 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6438 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6439 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6440 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6441 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6442 + 6443 046006 SN=SN+1 + 6444 777737 XX=&777777 + 6445 IFE , + 6446 033554 561 00 0 00 777737 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6447 033555 270 00 0 00 034070 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6448 033556 312 00 0 00 034135 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6449 STOP ^ + 6450 033557 254 04 0 00 033560 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6451 033560 324 00 0 00 033561 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6452 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6453 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6454 + 6455 ;********** + 6456 + 6457 + 6458 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6459 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6460 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6461 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6462 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6463 + 6464 046007 SN=SN+1 + 6465 777677 XX=&777777 + 6466 IFE , + 6467 033561 561 00 0 00 777677 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6468 033562 270 00 0 00 034071 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6469 033563 312 00 0 00 034136 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6470 STOP ^ + 6471 033564 254 04 0 00 033565 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-3 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0159 + + 6472 033565 324 00 0 00 033566 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6473 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6474 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6475 + 6476 ;********** + 6477 + 6478 + 6479 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6480 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6481 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6482 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6483 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6484 + 6485 046010 SN=SN+1 + 6486 777577 XX=&777777 + 6487 IFE , + 6488 033566 561 00 0 00 777577 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6489 033567 270 00 0 00 034072 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6490 033570 312 00 0 00 034137 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6491 STOP ^ + 6492 033571 254 04 0 00 033572 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6493 033572 324 00 0 00 033573 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6494 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6495 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6496 + 6497 ;********** + 6498 + 6499 + 6500 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6501 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6502 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6503 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6504 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6505 + 6506 046011 SN=SN+1 + 6507 777377 XX=&777777 + 6508 IFE , + 6509 033573 561 00 0 00 777377 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6510 033574 270 00 0 00 034073 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6511 033575 312 00 0 00 034140 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6512 STOP ^ + 6513 033576 254 04 0 00 033577 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6514 033577 324 00 0 00 033600 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6515 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6516 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6517 + 6518 ;********** + 6519 + 6520 + 6521 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6522 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6523 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6524 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6525 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6526 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-4 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0160 + + 6527 046012 SN=SN+1 + 6528 776777 XX=&777777 + 6529 IFE , + 6530 033600 561 00 0 00 776777 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6531 033601 270 00 0 00 034074 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6532 033602 312 00 0 00 034141 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6533 STOP ^ + 6534 033603 254 04 0 00 033604 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6535 033604 324 00 0 00 033605 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6536 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6537 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6538 + 6539 ;********** + 6540 + 6541 + 6542 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6543 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6544 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6545 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6546 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6547 + 6548 046013 SN=SN+1 + 6549 775777 XX=&777777 + 6550 IFE , + 6551 033605 561 00 0 00 775777 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6552 033606 270 00 0 00 034075 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6553 033607 312 00 0 00 034142 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6554 STOP ^ + 6555 033610 254 04 0 00 033611 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6556 033611 324 00 0 00 033612 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 ;********** + 6561 + 6562 + 6563 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6564 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6565 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6566 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6567 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6568 + 6569 046014 SN=SN+1 + 6570 773777 XX=&777777 + 6571 IFE , + 6572 033612 561 00 0 00 773777 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6573 033613 270 00 0 00 034076 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6574 033614 312 00 0 00 034143 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6575 STOP ^ + 6576 033615 254 04 0 00 033616 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6577 033616 324 00 0 00 033617 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6578 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6579 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6580 + 6581 ;********** +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-5 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0161 + + 6582 + 6583 + 6584 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6585 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6586 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6587 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6588 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6589 + 6590 046015 SN=SN+1 + 6591 767777 XX=&777777 + 6592 IFE , + 6593 033617 561 00 0 00 767777 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6594 033620 270 00 0 00 034077 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6595 033621 312 00 0 00 034144 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6596 STOP ^ + 6597 033622 254 04 0 00 033623 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6598 033623 324 00 0 00 033624 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6599 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6600 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6601 + 6602 ;********** + 6603 + 6604 + 6605 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6606 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6607 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6608 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6609 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6610 + 6611 046016 SN=SN+1 + 6612 757777 XX=&777777 + 6613 IFE , + 6614 033624 561 00 0 00 757777 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6615 033625 270 00 0 00 034100 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6616 033626 312 00 0 00 034145 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6617 STOP ^ + 6618 033627 254 04 0 00 033630 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6619 033630 324 00 0 00 033631 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6620 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6621 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6622 + 6623 ;********** + 6624 + 6625 + 6626 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6627 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6628 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6629 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6630 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6631 + 6632 046017 SN=SN+1 + 6633 737777 XX=&777777 + 6634 IFE , + 6635 033631 561 00 0 00 737777 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6636 033632 270 00 0 00 034101 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-6 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0162 + + 6637 033633 312 00 0 00 034146 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6638 STOP ^ + 6639 033634 254 04 0 00 033635 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6640 033635 324 00 0 00 033636 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6641 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6642 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6643 + 6644 ;********** + 6645 + 6646 + 6647 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6648 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6649 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6650 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6651 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6652 + 6653 046020 SN=SN+1 + 6654 677777 XX=&777777 + 6655 IFE , + 6656 033636 561 00 0 00 677777 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6657 033637 270 00 0 00 034102 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6658 033640 312 00 0 00 034147 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6659 STOP ^ + 6660 033641 254 04 0 00 033642 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6661 033642 324 00 0 00 033643 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6662 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6663 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6664 + 6665 ;********** + 6666 + 6667 + 6668 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6669 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6670 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6671 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6672 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6673 + 6674 046021 SN=SN+1 + 6675 577777 XX=&777777 + 6676 IFE , + 6677 033643 561 00 0 00 577777 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6678 033644 270 00 0 00 034103 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6679 033645 312 00 0 00 034150 CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + 6680 STOP ^ + 6681 033646 254 04 0 00 033647 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6682 033647 324 00 0 00 033650 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6683 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6684 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6685 + 6686 ;********** + 6687 + 6688 PAGE +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-7 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0163 + + 6689 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6690 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6691 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6692 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6693 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6694 + 6695 046022 SN=SN+1 + 6696 377777 XX=&777777 + 6697 033650 561 00 0 00 377777 HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + 6698 033651 270 00 0 00 034104 ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + 6699 033652 312 00 0 00 034151 CAME [-2,,-2] ;CHECK ADDER UPON FAILURE + 6700 STOP ^ + 6701 033653 254 04 0 00 033654 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6702 033654 324 00 0 00 033655 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6703 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6704 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6705 + 6706 ;********** + 6707 + 6708 000000 XX=0 + 6709 + 6710 REPEAT ^D18,< + 6711 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6712 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6713 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6714 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6715 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6716 + 6717 SN=SN+1 + 6718 XX=&777777 + 6719 IFE , + 6720 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6721 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6722 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6723 STOP + 6724 + 6725 ;********** + 6726 > + 6727 + 6728 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6729 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6730 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6731 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6732 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6733 + 6734 046023 SN=SN+1 + 6735 000001 XX=&777777 + 6736 777776 IFE , + 6737 033655 525 00 0 00 777776 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6738 033656 270 00 0 00 034105 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6739Q 033657 312 00 0 00 034152 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6740 STOP ^ + 6741 033660 254 04 0 00 033661 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6742 033661 324 00 0 00 033662 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-8 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0164 + + 6743 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6744 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6745 + 6746 ;********** + 6747 + 6748 + 6749 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6750 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6751 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6752 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6753 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6754 + 6755 046024 SN=SN+1 + 6756 777775 XX=&777777 + 6757 IFE , + 6758 033662 525 00 0 00 777775 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6759 033663 270 00 0 00 034106 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6760Q 033664 312 00 0 00 034153 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6761 STOP ^ + 6762 033665 254 04 0 00 033666 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6763 033666 324 00 0 00 033667 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6764 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6765 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6766 + 6767 ;********** + 6768 + 6769 + 6770 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6771 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6772 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6773 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6774 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6775 + 6776 046025 SN=SN+1 + 6777 777773 XX=&777777 + 6778 IFE , + 6779 033667 525 00 0 00 777773 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6780 033670 270 00 0 00 034107 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6781Q 033671 312 00 0 00 034154 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6782 STOP ^ + 6783 033672 254 04 0 00 033673 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6784 033673 324 00 0 00 033674 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6785 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6786 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6787 + 6788 ;********** + 6789 + 6790 + 6791 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6792 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6793 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6794 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6795 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-9 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0165 + + 6796 + 6797 046026 SN=SN+1 + 6798 777767 XX=&777777 + 6799 IFE , + 6800 033674 525 00 0 00 777767 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6801 033675 270 00 0 00 034110 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6802Q 033676 312 00 0 00 034155 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6803 STOP ^ + 6804 033677 254 04 0 00 033700 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6805 033700 324 00 0 00 033701 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6806 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6807 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6808 + 6809 ;********** + 6810 + 6811 + 6812 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6813 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6814 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6815 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6816 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6817 + 6818 046027 SN=SN+1 + 6819 777757 XX=&777777 + 6820 IFE , + 6821 033701 525 00 0 00 777757 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6822 033702 270 00 0 00 034111 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6823Q 033703 312 00 0 00 034156 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6824 STOP ^ + 6825 033704 254 04 0 00 033705 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6826 033705 324 00 0 00 033706 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6827 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6828 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6829 + 6830 ;********** + 6831 + 6832 + 6833 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6834 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6835 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6836 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6837 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6838 + 6839 046030 SN=SN+1 + 6840 777737 XX=&777777 + 6841 IFE , + 6842 033706 525 00 0 00 777737 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6843 033707 270 00 0 00 034112 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6844Q 033710 312 00 0 00 034157 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6845 STOP ^ + 6846 033711 254 04 0 00 033712 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6847 033712 324 00 0 00 033713 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-10 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0166 + + 6848 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6849 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6850 + 6851 ;********** + 6852 + 6853 + 6854 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6855 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6856 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6857 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6858 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6859 + 6860 046031 SN=SN+1 + 6861 777677 XX=&777777 + 6862 IFE , + 6863 033713 525 00 0 00 777677 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6864 033714 270 00 0 00 034113 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6865Q 033715 312 00 0 00 034160 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6866 STOP ^ + 6867 033716 254 04 0 00 033717 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6868 033717 324 00 0 00 033720 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6869 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6870 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6871 + 6872 ;********** + 6873 + 6874 + 6875 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6876 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6877 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6878 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6879 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6880 + 6881 046032 SN=SN+1 + 6882 777577 XX=&777777 + 6883 IFE , + 6884 033720 525 00 0 00 777577 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6885 033721 270 00 0 00 034114 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6886Q 033722 312 00 0 00 034161 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6887 STOP ^ + 6888 033723 254 04 0 00 033724 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6889 033724 324 00 0 00 033725 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6890 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6891 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6892 + 6893 ;********** + 6894 + 6895 + 6896 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6897 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6898 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6899 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6900 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-11 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0167 + + 6901 + 6902 046033 SN=SN+1 + 6903 777377 XX=&777777 + 6904 IFE , + 6905 033725 525 00 0 00 777377 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6906 033726 270 00 0 00 034115 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6907Q 033727 312 00 0 00 034162 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6908 STOP ^ + 6909 033730 254 04 0 00 033731 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6910 033731 324 00 0 00 033732 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6911 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6912 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6913 + 6914 ;********** + 6915 + 6916 + 6917 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6918 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6919 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6920 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6921 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6922 + 6923 046034 SN=SN+1 + 6924 776777 XX=&777777 + 6925 IFE , + 6926 033732 525 00 0 00 776777 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6927 033733 270 00 0 00 034116 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6928Q 033734 312 00 0 00 034163 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6929 STOP ^ + 6930 033735 254 04 0 00 033736 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6931 033736 324 00 0 00 033737 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6932 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6933 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6934 + 6935 ;********** + 6936 + 6937 + 6938 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6939 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6940 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6941 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6942 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6943 + 6944 046035 SN=SN+1 + 6945 775777 XX=&777777 + 6946 IFE , + 6947 033737 525 00 0 00 775777 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6948 033740 270 00 0 00 034117 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6949Q 033741 312 00 0 00 034164 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6950 STOP ^ + 6951 033742 254 04 0 00 033743 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6952 033743 324 00 0 00 033744 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-12 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0168 + + 6953 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6954 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6955 + 6956 ;********** + 6957 + 6958 + 6959 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6960 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6961 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6962 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6963 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6964 + 6965 046036 SN=SN+1 + 6966 773777 XX=&777777 + 6967 IFE , + 6968 033744 525 00 0 00 773777 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6969 033745 270 00 0 00 034120 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6970Q 033746 312 00 0 00 034165 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6971 STOP ^ + 6972 033747 254 04 0 00 033750 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6973 033750 324 00 0 00 033751 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6974 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6975 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6976 + 6977 ;********** + 6978 + 6979 + 6980 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 6981 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 6982 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 6983 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 6984 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 6985 + 6986 046037 SN=SN+1 + 6987 767777 XX=&777777 + 6988 IFE , + 6989 033751 525 00 0 00 767777 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 6990 033752 270 00 0 00 034121 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 6991Q 033753 312 00 0 00 034166 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 6992 STOP ^ + 6993 033754 254 04 0 00 033755 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 6994 033755 324 00 0 00 033756 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 6995 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 6996 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 6997 + 6998 ;********** + 6999 + 7000 + 7001 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 7002 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 7003 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 7004 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 7005 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-13 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0169 + + 7006 + 7007 046040 SN=SN+1 + 7008 757777 XX=&777777 + 7009 IFE , + 7010 033756 525 00 0 00 757777 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 7011 033757 270 00 0 00 034122 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 7012Q 033760 312 00 0 00 034167 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 7013 STOP ^ + 7014 033761 254 04 0 00 033762 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7015 033762 324 00 0 00 033763 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7016 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7017 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7018 + 7019 ;********** + 7020 + 7021 + 7022 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 7023 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 7024 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 7025 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 7026 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 7027 + 7028 046041 SN=SN+1 + 7029 737777 XX=&777777 + 7030 IFE , + 7031 033763 525 00 0 00 737777 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 7032 033764 270 00 0 00 034123 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 7033Q 033765 312 00 0 00 034170 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 7034 STOP ^ + 7035 033766 254 04 0 00 033767 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7036 033767 324 00 0 00 033770 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7037 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7038 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7039 + 7040 ;********** + 7041 + 7042 + 7043 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 7044 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 7045 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 7046 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 7047 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 7048 + 7049 046042 SN=SN+1 + 7050 677777 XX=&777777 + 7051 IFE , + 7052 033770 525 00 0 00 677777 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 7053 033771 270 00 0 00 034124 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 7054Q 033772 312 00 0 00 034171 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 7055 STOP ^ + 7056 033773 254 04 0 00 033774 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7057 033774 324 00 0 00 033775 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 90-14 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0170 + + 7058 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7059 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7060 + 7061 ;********** + 7062 + 7063 + 7064 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 7065 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 7066 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 7067 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 7068 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 7069 + 7070 046043 SN=SN+1 + 7071 577777 XX=&777777 + 7072 IFE , + 7073 033775 525 00 0 00 577777 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 7074 033776 270 00 0 00 034125 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 7075Q 033777 312 00 0 00 034172 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 7076 STOP ^ + 7077 034000 254 04 0 00 034001 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7078 034001 324 00 0 00 034002 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7079 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7080 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7081 + 7082 ;********** + 7083 + 7084 + 7085 ;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO + 7086 ;ADDED TO A FLOATING ZERO IS A FLOATING ZERO + 7087 ;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. + 7088 ;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. + 7089 ;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + 7090 + 7091 046044 SN=SN+1 + 7092 377777 XX=&777777 + 7093 IFE , + 7094 034002 525 00 0 00 377777 HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + 7095 034003 270 00 0 00 034126 ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + 7096 034004 312 00 0 00 034063 CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + 7097 STOP ^ + 7098 034005 254 04 0 00 034006 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 7099 034006 324 00 0 00 034007 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO + 7100 ;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION + 7101 ;IN THE SUBTEST) TO LOOP ON ERROR^ + 7102 + 7103 ;********** + 7104 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 91 +DAKACM MAC 19-JAN-77 13:40 SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT SEQ 0171 + + 7105 034007 254 00 0 00 030057 JRST BEGEND + 7106 SUBTTL *STOR* RESERVED STORAGE, JAN 18,1977 + 7107 + 7108 ;PROGRAM LITERALS + 7109 + 7110 XLIST + 7111 IFNDEF $LPAPER, + 7112 034010 LIT + 7113 034010 000001 000001 + 7114 034011 254 00 0 00 030741 + 7115 034012 777777 777777 + 7116 034013 777777 000000 + 7117 034014 000000 000000 + 7118 034015 000000 777777 + 7119 034016 707070 707070 + 7120 034017 000000 000001 + 7121 034020 000000 000002 + 7122 034021 000000 000004 + 7123 034022 000000 000010 + 7124 034023 000000 000020 + 7125 034024 000000 000040 + 7126 034025 000000 000100 + 7127 034026 000000 000200 + 7128 034027 000000 000400 + 7129 034030 000000 001000 + 7130 034031 000000 002000 + 7131 034032 000000 004000 + 7132 034033 000000 010000 + 7133 034034 000000 020000 + 7134 034035 000000 040000 + 7135 034036 000000 100000 + 7136 034037 000000 200000 + 7137 034040 000000 400000 + 7138 034041 000001 000000 + 7139 034042 000002 000000 + 7140 034043 000004 000000 + 7141 034044 000010 000000 + 7142 034045 000020 000000 + 7143 034046 000040 000000 + 7144 034047 000100 000000 + 7145 034050 000200 000000 + 7146 034051 000400 000000 + 7147 034052 001000 000000 + 7148 034053 002000 000000 + 7149 034054 004000 000000 + 7150 034055 010000 000000 + 7151 034056 020000 000000 + 7152 034057 040000 000000 + 7153 034060 100000 000000 + 7154 034061 200000 000000 + 7155 034062 400000 000000 + 7156 034063 777777 777776 + 7157 034064 777777 777775 + 7158 034065 777777 777773 + 7159 034066 777777 777767 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 1 +STOR KLM 18-JAN-77 11:42 *STOR* RESERVED STORAGE, JAN 18,1977 SEQ 0172 + + 7160 034067 777777 777757 + 7161 034070 777777 777737 + 7162 034071 777777 777677 + 7163 034072 777777 777577 + 7164 034073 777777 777377 + 7165 034074 777777 776777 + 7166 034075 777777 775777 + 7167 034076 777777 773777 + 7168 034077 777777 767777 + 7169 034100 777777 757777 + 7170 034101 777777 737777 + 7171 034102 777777 677777 + 7172 034103 777777 577777 + 7173 034104 777777 377777 + 7174 034105 777776 777777 + 7175 034106 777775 777777 + 7176 034107 777773 777777 + 7177 034110 777767 777777 + 7178 034111 777757 777777 + 7179 034112 777737 777777 + 7180 034113 777677 777777 + 7181 034114 777577 777777 + 7182 034115 777377 777777 + 7183 034116 776777 777777 + 7184 034117 775777 777777 + 7185 034120 773777 777777 + 7186 034121 767777 777777 + 7187 034122 757777 777777 + 7188 034123 737777 777777 + 7189 034124 677777 777777 + 7190 034125 577777 777777 + 7191 034126 377777 777777 + 7192 034127 000000 000000 + 7193 034130 777777 777774 + 7194 034131 777777 777772 + 7195 034132 777777 777766 + 7196 034133 777777 777756 + 7197 034134 777777 777736 + 7198 034135 777777 777676 + 7199 034136 777777 777576 + 7200 034137 777777 777376 + 7201 034140 777777 776776 + 7202 034141 777777 775776 + 7203 034142 777777 773776 + 7204 034143 777777 767776 + 7205 034144 777777 757776 + 7206 034145 777777 737776 + 7207 034146 777777 677776 + 7208 034147 777777 577776 + 7209 034150 777777 377776 + 7210 034151 777776 777776 + 7211 034152 777775 777776 + 7212 034153 777773 777776 + 7213 034154 777767 777776 + 7214 034155 777757 777776 +DAKAC PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) 0,2 MACRO %52(537) 14:24 19-JAN-77 PAGE 1-1 +STOR KLM 18-JAN-77 11:42 *STOR* RESERVED STORAGE, JAN 18,1977 SEQ 0173 + + 7215 034156 777737 777776 + 7216 034157 777677 777776 + 7217 034160 777577 777776 + 7218 034161 777377 777776 + 7219 034162 776777 777776 + 7220 034163 775777 777776 + 7221 034164 773777 777776 + 7222 034165 767777 777776 + 7223 034166 757777 777776 + 7224 034167 737777 777776 + 7225 034170 677777 777776 + 7226 034171 577777 777776 + 7227 034172 377777 777776 + 7228 LIST + 7229 034173 000000 000000 ENDSLD: 0 + 7230 + 7231 IFDEF DEBUG,< + 7232 034174 PATCH: BLOCK DEBUG ;PATCHING AREA + 7233 > + 7234 + 7235 ;PROGRAM VARIABLES + 7236 034274 VAR + 7237 + 7238 IFDEF PGMEND,< + 7239 034274 000000 000000 END: 0 + 7240 030000 END BEGIN > + +%18 WARNINGS GIVEN +NO ERRORS DETECTED + +PROGRAM BREAK IS 000000 +ABSLUTE BREAK IS 034275 +CPU TIME USED 00:28.959 + +11K CORE USED diff --git a/apps/pdp10/diags/klad/dakac/DAKAC.MAC.txt b/apps/pdp10/diags/klad/dakac/DAKAC.MAC.txt new file mode 100644 index 000000000..15be2e06f --- /dev/null +++ b/apps/pdp10/diags/klad/dakac/DAKAC.MAC.txt @@ -0,0 +1,2652 @@ +SUBTTL DIAGNOSTIC SECTION + + LALL + +START: ;SETZM USER# + ;JSP 0,.+1 ;GET FLAGS + ;TLNE USERF ;IN USER MODE + ;SETOM USER ;YES SET USER CONTROLL WORD + ;SKIPN MONFLG ;SPECIAL USER MODE + ;SETZM USER ;YES CLEAR USER CONTROLL WORD + ;SKIPN USER + ;JRST STARTA + ;SKIPL MONCTL + ;TTCALL 3,PGMNAM ;MENTION OUR NAME + JRST STARTA + +PGMNAM: ASCIZ/ +PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) [DAKAC] +/ +STARTA: JRST .+1 +SUBTTL TEST OF LOGICAL TEST INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT TDN DOES NOT MODIFY THE AC BECAUSE +;TDN IS A NO-OP +;FIRST, THE AC IS PRELOADED WITH 0. THEN, +;TDN IS EXECUTED. THE AC IS THEN CHECKED FOR +;NO MODIFICATION. IF C(AC) IS UNALTERED, THE TEST PASSES +B12600: SETZ ;PRELOAD AC WITH 0 + TDN [-1] ;*TDN IS A NO-OP + CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TDN SKIPS + CAIE ;PASS TEST IF C(AC) IS UNMODIFIED BY TDN + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD FM + EN + +;********** + +;THIS TEST VERIFIES THAT TSN DOES NOT MODIFY THE AC BECAUSE +;TSN IS A NO-OP +;FIRST, THE AC IS PRELOADED WITH -1. THEN, +;TSN IS EXECUTED. THE AC IS THEN CHECKED FOR +;NO MODIFICATION. IF C(AC) IS UNALTERED, THIS TEST PASSES + +B12700: SETO ;PRELOAD AC WITH -1,,-1 + TSN [XWD -1,0] ;*TSN IS A NO-OP + CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TSN SKIPS + CAME [-1] ;PASS TEST IF C(AC) IS UNMODIFIED BY TSN + STOP + +;********** +;THIS TEST VERIFIES THAT TRN DOE NOT MODIFY THE AC BECAUSE +;TRN IS A NO-OP. +;FIRST, THE AC IS PRELOADED WITH 0. THEN, +;TRN IS EXECUTED. THE AC IS THEN CHECKED FOR +;NO MODIFICATION. IF C(AC) IS UNALTERED, THIS TEST PASSES + +B13000: SETZ ;PRELOAD AC WITH 0 + TRN 123456 ;*TRN IS A NO-OP + CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TRN SKIPS + CAIE ;PASS TEST IF C(AC) IS UNMODIFIED BY TRN + STOP + +;********** + +;THIS TEST VERIFIES THAT TLN DOES NOT MODIFY THE AC BECAUSE +;TLN IS A NO-OP. +;FIRST,THE AC IS PRELOADED WITH -1,,-1. THEN, +;TRN IS EXECUTED. THE AC IS THEN CHECKED FOR +;NO MODIFICATION. IF C(AC) IS UNALTERED, THIS TEST PASSES + +B13100: SETO ;PRELOAD AC WITH -1,,-1 + TLN 123456 ;*TRN IS A NO-OP + CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TRN SKIPS + CAME ;PASS TEST IF C(AC) IS UNMODIFIED BY TRN + STOP + +;********** +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC) -1,,-1, THE TEST PASSES. + +B13200: SETZ ;PRELOAD AC WITH 0 + TDO [-1] ;*TDO SHOULD PLACE ALL ONES IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;0 SW: ET1 +;0 ET1: BR AR EN +;0 ET1: AD BR - EN +;0 ET1: AD EQV + +;********** + +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THIS AC IS CHECKED FOR ZERO. IF C(AC) IS ZERO, THE TEST PASSES. + +B13300: SETZ ;PRELOAD AC WITH 0 + TDO ;*TDO SHOULD PLACE ALL ZERO IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + SKIPE ;PASS TEST IF C(AC) ZERO + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 ET1: AD AR + EN + +;********** +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC, +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR ITS CONTENTS ZERO. IF C(AC) IS ZERO, THE TEST PASSES. + +B13400: SETZ ;PRELOAD AC WITH 0 + TDO [0] ;*TDO SHOULD PLACE ALL ZERO IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + SKIPE ;PASS TEST IF C(AC) IS ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. +;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B13600: SETO ;PRELOAD AC WITH -1,,-1 + TDO ;*TDO SHOULD PLACE ALL ONES IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + CAME [-1] ;PASS TEST IF C(AC) -1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B14000: SETO ;PRELOAD AC WITH -1,,-1 + TDO [0] ;*TDO SHOULD PLACE ALL ONES IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET1: AD FM - EN +;0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT TDZ PLACES ZERO IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC) 0, THE TEST PASSES. + +B14100: SETZ ;PRELOAD AC WITH 0 + TDZ ;*TDZ SHOULD PLACE ALL ZERO IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD FM + EN + +;********** +;THIS TEST VERIFIES THAT TDZ PLACES ZERO IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1,,-1 AND C(E)=-1,,0. +;HENCE, THE RESULT IN THE AC SHOULD BE 0,,-1. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)= 0,,-1, THE TEST PASSES. + +B14200: SETO ;PRELOAD AC WITH -1,,-1 + TDZ [XWD -1,0] ;*TDZ SHOULD PLACE 0,,-1 IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + CAME [0,-1] ;PASS TEST IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-E SW: FCE +;-1,,-1 FC: AD AR -EN +;-1,,0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B14400: SETO ;PRELOAD AC WITH -1,,-1 + TDZ ;*TDZ SHOULD PLACE ALL ZERO IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B14500: SETZ ;PRELOAD AC WITH 0 + TDZ [-1] ;*TDZ SHOULD PLACE ALL ZEROS IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + SKIPE ;PASS TEST IS C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. +;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B14600: SETO ;PRELOAD AC WITH -1,,-1 + TDZ [0] ;*TDZ SHOULD PLACE ALL ONES IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP +;********** +;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=-1 AND C(E)=0,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,0. +;THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + +B14700: SETO ;PRELOAD AC WITH -1,,-1 + TDC [XWD 0,-1] ;*TDC SHOULD PLACE -1,,0 INTO THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + CAME [-1,,0] ;PASS TEST IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-E SW: FCE +;0 FC: AD AR - EN +;0,,-1 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B15000: SETZ ;PRELOAD AC, E WITH 0 + TDC ;*TDC SHOULD PLACE 0 INTO THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC:AD FM + EN + +;********** +;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST FAILS + +B15400: SETO ;PRELOAD AC WITH -1,,-1 + TDC ;*TDC SHOULD PLACE 0 INTO THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B15500: SETZ ;PRELOAD AC WITH 0 + TDC [-1] ;*TDC SHOULD PLACE -1,,-1 INTO THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD EQV + +;********** +;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=-1 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B15600: SETO ;PRELOAD AC WITH -1,,-1 + TDC [0] ;*TDC SHOULD PLACE -1,,-1 INTO THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT +;SEQUENTIAL INSTRUCTION. IF TDNA DOES NOT +;SKIP, THIS TEST FAILS. + +B15700: SETZ ;PRESET AC, E TO 0 + TDNA ;*TDNA SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: ET1 +;0 FC: AB PC EN +;0 ET1: BR AR EN +;0 ET1: PC CLOCK +;0 ET2: MC INST FETCH EN + +;********** +;THIS TEST VERIFIES THAT TDN NEVER SKIPS +;NEXT SEQUENTIAL INSTRUCTION. +;THIS TEST FAILS IF TDN SKIPS. + +B16000: SETO ;PRESET AC, E TO -1,,-1 + TDN ;*TDN SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDN PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE +;NEXT SEQUENTIAL INSTRUCTION. +;THIS TEST FAILS IF TDN SKIPS. + +B16100: SETZ ;PRESET AC, E TO 0 + TDN ;*TDN SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDN PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED +;BY C(E), ARE ZERO. +;IN THIS TEST C(AC) = -1..0 AND C(E) = 707070..707070. +;HENCE, TDNE SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION. +;IF TDNE SKIPS, THIS TEST FAILS + +B16200: MOVE [XWD -1,0] ;PRELOAD AC WITH -1..0 + TDNE [707070707070] ;*TDNE SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDNE PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 SW:FCE +;-1,,0 SW: PC CHANGE +;-1,,-1 FC: AD AR + EN +;E ET2: MC INST FETCH EN + +;********** + +;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED +;BY C(E), ARE ZERO. +;IN THIS CASE, AC=E AND C(AC)=0. +;HENCE, TDNE SHOULD SKIP THE NEXT SEQUENTIAL INSTRUCTION +;IF TDNE DOES NOT SKIP, THIS TEST FAILS. + +B16300: SETZ ;PRELOAD AC, E WITH 0 + TDNE ;*TDNE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: ET1 +;0 ET1: PC CLOCK + +;********** +;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED +;BY C(E) ARE ZERO. +;IN THIS TEST AC=E AND C(AC)=C(E)=0. HENCE TDNN +;SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION +;IF TDNN SKIPS, THE TEST FAILS. + +B16400: SETZ ;PRELOAD AC,E WITH 0 + TDNN ;*TDNN SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;SKIP HALT IF TDNE PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: PC CHANGE +;0 FC: AB PC EN +;0 ET2: MC INST FETCH EN + +;********** + +;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT +;SEQUENTIAL INSTRUCTION. IF TDNA DOES NOT +;SKIP, THIS TEST FAILS. + +B16500: SETO ;PRESET AC, E TO 0 + TDNA ;*TDNA SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), +;ARE ZERO +;IN THIS TEST C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE, TDNN +;SHOULD SKIP THE NEXT INSTRUCTION. IF IT DOES NOT SKIP, THIS TEST FAILS. + +B16600: MOVE [XWD -1,0] ;PRESET AC TO -1,,0 + TDNN [707070707070] ;*TDNN SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 SW: FCE +;-1,,0 SW: ET1 +;-1,,0 ET1: PC CLOCK + +;********** + +;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED +;BY C(E), ARE ZERO. +;IN THIS TEST, C(AC)=-1,,-1 AND C(E)=0. HENCE, TDNE SHOULD SKIP +;THE NEXT SEQUENTIAL INSTRUCTION. +;IF TDNE DOES NOT SKIP, THIS TEST FAILS + +B16700: SETO ;PRESET AC TO ALL ONES + TDNE [0] ;*TDNE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED +;BY C(E), ARE ZERO. +;IN THIS TEST C(AC)=0 AND C(E)=-1,,-1, HENCE, TDNE SHOULD SKIP +;THE NEXT SEQUENTIAL INSTRUCTION. +;IF TDNE DOES NOT SKIP, THIS TEST FAILS + +B17000: SETZ ;PRESET AC TO 0 + TDNE [-1] ;*TDNE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD FM + EN + +;********** + +;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE NEXT SEQUENTIAL INSTRUCTION. +;THIS TEST FAILS IF TDN SKIPS + +B17300: SETO ;PRESET AC TO -1,,-1 + TDN [0] ;*TDN SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDN PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE NEXT SEQUENTIAL INSTRUCTION. +;THIS TEST FAILS IF TDN SKIPS + +B17400: SETZ ;PRESET AC TO 0 + TDN [-1] ;*TDN SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDN PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT SEQUENTIAL INSTRUCTION +;THIS TEST FAILS IF TDNA DOES NOT SKIP + +B17700: SETO ;PRESET AC TO -1,,-1 + TDNA [0] ;*TDNA SHOULD SKIP + STOP + +;********** +;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT SEQUENTIAL INSTRUCTION +;THIS TEST FAILS IF TDNA DOES NOT SKIP + +B20000: SETZ ;PRESET AC TO 0 + TDNA [-1] ;*TDNA SHOULD SKIP + STOP + +;********** + +;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. +;IN THIS TEST AC=E AND C(AC)=C(E)=-1,,-1. HENCE TDNE SHOULD NOT SKIP. +;IF TDNE SKIPS, THIS TEST FAILS. + +B20400: SETO ;PRESET AC,E TO -1,,-1 + TDNE ;*TDNE SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDNE PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. +;IN THIS TEST, AC=E AND C(AC)=C(E)=-1,,-1. HENCE TDNN SHOULD SKIP +;IF TDNN DOES NOT SKIP, THIS TEST FAILS + +B20600: SETO ;PRESET AC,E TO -1,,-1 + TDNN ;*TDNN SHOULD SKIP THE NEXT SEQUENTIAL INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. +;IN THIS TEST, C(AC)=0 AND C(E)=-1,,-1. HENCE TDNN SHOULD NOT SKIP +;IF TDNN SKIPS, THIS TEST FAILS + +B20700: SETZ ;PRESET AC TO 0 + TDNN [-1] ;*TDNN SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION + SKIPA ;SKIP HALT IF TDNN PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD FM + EN + +;********** +;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. +;IN THIS TEST, C(AC)=-1,,-1 AND C(E)=0. HENCE TDNN SHOULD NOT SKIP +;IF TDNN SKIPS, THIS TEST FAILS + +B21000: SETO ;PRESET AC TO -1,,-1 + TDNN [0] ;*TDNN SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION + SKIPA ;SKIP HALT IF TDNN PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD AR + EN + +;********** + +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT EFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 +;THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + +B21100: SETZ ;PRELOAD AC WITH 0 + TDO [XWD -1,0] ;*TDO SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, +;THE RESULT IN THE AC SHOULD BE 0,,-1. THE AC IS +;CHECKED FOR 0,,-1. THIS TEST PASSES IF C(AC)=0,,-1 + +B21400: SETZ ;PRESET AC WITH 0 + TSO [XWD -1,0] ;*TSO SHOULD PLACE 0,,-1 INTO THE AC + CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;0 SW: ET0 +;0 SW: ET1 +;0 FC: AD FM + EN +;0 FC: AD AR + EN +;0 ET0: AR SWAP +;0 ET0: AD FM + EN +;0 ET0: AD AR + EN +;0 ET1: BR AR EN +;0 ET1: AD BR - EN +;-1,,-1 ET1: AD AR + EN +;0 ET1: AD EQV + +;********** + +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS +;CHECKED FOR -1,,0. THIS TEST PASSES IF C(AC)=-1,,0 + +B21500: SETZ ;PRESET AC WITH 0 + TSO [XWD 0,-1] ;*TSO SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS +;CHECKED FOR ITS CONTENTS NON-ZERO. THIS TEST PASSES IF C(AC) IS NON-ZERO + +B21600: SETZ ;PRELOAD AC,E WITH 0 + TSO ;*TSO SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,-1. THE AC IS +;CHECKED FOR -1,,-1. THIS TEST PASSES IF C(AC) -1,,-1 + +B21700: SETO ;PRELOAD AC,E WITH -1,,-1 + TSO ;*TSO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS +;CHECKED FOR -1,,0. THIS TEST PASSES IF C(AC)=-1,,0 + +B22200: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + TSO [XWD 0,-1] ;*TSO SHOULD PLACE -1,,0 INTO THE AC + CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, +;THE RESULT IN THE AC SHOULD BE 0,,-1. THE AC IS +;CHECKED FOR 0,,-1. THIS TEST PASSES IF C(AC)=0,,-1 + +B22300: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + TSO [0] ;*TSO SHOULD PLACE 0,,-1 INTO THE AC + CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET1: AD FM - EN +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS +;CHECKED FOR -1,,0. THIS TEST PASSES IF C(AC)=-1,,0 + +B22400: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + TSO [0] ;*TSO SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MARKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,-1. THE AC IS +;CHECKED FOR -1,,-1. THIS TEST PASSES IF C(AC)=-1,,-1 + +B22500: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + TSO [-1] ;*TSO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MARKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,-1. THE AC IS +;CHECKED FOR -1,,-1. THIS TEST PASSES IF C(AC)=-1,,-1 + +B22600: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + TSO [-1] ;*TSO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +SUBTTL TEST OF HWT INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B22700: SETZ ;PRELOAD AC,E WITH 0 + HLL ;*HLL SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC: AD AR + EN +;0,,-1 FC: AD RT FM + EN + +;********** + +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, +;THIS TEST PASSES. + +B23000: SETO ;PRELOAD AC WITH -1,,-1 + HLL [0] ;*HLL SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 SW: FCE +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B23200: SETO ;PRELOAD AC,E WITH -1,,-1 + HLL ;*HLL SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, +;THIS TEST PASSES + +B23400: SETZ ;PRELOAD AC WITH 0 + HLL [-1] ;*HLL SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, +;THIS TEST PASSES. + +B23600: SETZ ;PRELOAD AC WITH 0 + HLL [XWD -1,0] ;*HLL SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, +;THIS TEST PASSES. + +B23700: SETO ;PRELOAD AC WITH -1,,-1 + HLL [XWD 0,-1] ;*HLL SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B24000: SETZ ;PRELOAD AC,E WITH 0 + HLLZ ;*HLLZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC: AD LT AR + EN + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B24300: SETO ;PRELOAD AC WITH -1,,-1 + HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;-1,,-1 ET2: AR LT AD EN + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO +;IF C(AC) IS NON-ZERO, THIS TEST PASSES. + +B24400: SETZ ;PRELOAD AC WITH -1,,-1 + HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR ZERO +;IF C(AC) IS ZERO, THIS TEST PASSES. + +B24500: SETO ;PRELOAD AC WITH -1,,-1 + HLLZ [0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + SKIPE ;PASS IF C(AC) IS ZERO. + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR ZERO +;IF C(AC) IS ZERO, THIS TEST PASSES. + +B24600: SETZ ;PRELOAD AC WITH 0 + HLLZ [0] ;*HLLZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC) IS ZERO. + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. +;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B24700: SETO ;PRELOAD AC WITH -1,,-1 + HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC: AD LT AR + EN +;0,,-1 ET2: AR LT AD EN + +;********** +;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. +;IN THIS CASE C(AC)=0 AND E=0,,-1. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B25000: SETZ ;PRELOAD AC WITH 0 + HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B25100: SETO ;PRELOAD AC WITH -1,,-1 + HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0 THIS TEST PASSES. + +B25200: SETZ ;PRELOAD AC WITH 0 + HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B25300: MOVEI -1 ;PRELOAD AC WITH -1,,-1 + HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0 THIS TEST PASSES. + +B25400: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR ZERO. +;IF C(AC) IS ZERO, THIS TEST PASSES. + +B25500: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HLLZ [0] ;*HLLZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC) IS ZERO. + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR ZERO. +;IF C(AC) IS ZERO, THIS TEST PASSES. + +B25600: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLLZ [0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + SKIPE ;PASS IF C(AC) IS ZERO. + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B25700: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. +;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B26000: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B26100: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. +;IN THIS CASE C(AC)=-1,,0 AND E=0,,-1. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B26200: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B26300: SETZ ;PRELOAD AC WITH 0 + HRR ;*HRR SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 FC: AD RT AR + EN +;-1,,0 FC: AD LT FM + EN + +;********** +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B26500: SETO ;PRELOAD AC WITH -1,,-1 + HRR ;*HRR SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 SW: FCE + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B26600: SETO ;PRELOAD AC WITH -1,,-1 + HRR [XWD -1,0] ;*HRR SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRI PLACES E INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B26700: SETO ;PRELOAD AC WITH -1,,-1 + HRRI -1 ;*HRRI SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B27000: SETO ;PRELOAD AC WITH -1,,-1 + HRR [0] ;*HRR SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B27100: SETZ ;PRELOAD AC WITH 0 + HRR [0] ;*HRR SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B27200: SETZ ;PRELOAD AC WITH 0 + HRR [-1] ;*HRR SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRI PLACES E INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B27300: SETZ ;PRELOAD AC WITH 0 + HRRI -1 ;*HRRI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD LT FM + EN + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B27400: SETZ ;PRELOAD AC WITH 0 + HRR [XWD -1,0] ;*HRR SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B27500: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRR [XWD -1,0] ;*HRR SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRRI PLACES E INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE C(AC)=-1,,0 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B27600: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRRI -1 ;*HRRI SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRI PLACES E INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B27700: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRRI -1 ;*HRRI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B30000: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRR [XWD -1,0] ;*HRR SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B30100: SETZ ;PRELOAD AC,E WITH 0 + HRRZ ;*HRRZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 FC: AD RT AR + EN + +;********** + +;THIS TEST VERIFIES THAT HRRZI PLACES E INTO +;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + +B30400: SETO ;PRELOAD AC WITH -1,,-1 + HRRZI -1 ;*HRRZI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZI PLACES E INTO +;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B30500: SETO ;PRELOAD AC WITH -1,,-1 + HRRZI 0 ;*HRRZI SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 FC: AD RT AR + EN + +;********** + +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B30600: SETO ;PRELOAD AC WITH -1,,-1 + HRRZ [XWD -1,0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;-1,,0 ET2: AR RT AD EN + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B30700: SETO ;PRELOAD AC WITH -1,,-1 + HRRZ [-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B31000: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRRZ [-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B31100: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRRZ [0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + CAIE 0 ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B31200: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRRZ [-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B31300: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRRZ [0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + CAIE 0 ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B31400: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRRZ [XWD -1,0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,0 AND C(E)=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B31500: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRRZ [XWD 0,-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRRZI PLACES E INTO +;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + +B31600: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRRZI -1 ;*HRRZI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B31700: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRRZ [XWD -1,0] ;*HRRZ SHOULD PLACE 0 INTO THE AC,0] + CAIE 0 ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B32000: SETZ ;PRELOAD AC WITH 0 + HRL ;*HRL SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B32100: SETO ;PRELOAD AC WITH -1,,-1 + HRL [-1] ;*HRL SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E,,-1 SW: FCE +;0,,-1 FC: AD RT FM + EN +;0,,-1 ET2: AR LT AR RT EN +;-1,,0 ET2: AR RT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B32200: SETO ;PRELOAD AC WITH -1,,-1 + HRL [0] ;*HRL SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B32300: SETO ;PRELOAD AC WITH -1,,-1 + HLR [0] ;*HLR SHOULD PLACE -1,,0 INTO THE AC + CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B32600: SETZ ;PRELOAD AC WITH 0 + HRL [-1] ;*HRL SHOULD PLACE -1,,0 INTO THE AC + CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B32700: SETZ ;PRELOAD AC WITH 0 + HLR [-1] ;*HLR SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;-1,,-1 FC: AD LT FM + EN +;0 ET2: AR RT AR LT EN + +;********** + +;THIS TEST VERIFIES THAT HRLI PLACES E INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B33000: SETZ ;PRELOAD AC WITH -1,,-1 + HRLI -1 ;*HRLI SHOULD PLACE -1,,-1 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD RT FM + EN +;0 ET2: AR LT AR RT EN + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B33100: SETZ ;PRELOAD AC WITH -1,,-1 + HLR [XWD -1,0] ;*HLR SHOULD PLACE -1,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B33200: SETZ ;PRELOAD AC WITH 0 + HRL [XWD -1,0] ;*HRL SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF +;OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0 +;IF C(AC)=0, THIS TEST PASSES. + +B33300: SETZ ;PRELOAD AC WITH 0 + HLRI -1 ;*HLRI SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC:AD LT FM + EN + +;********** + +;THIS TEST VERIFIES THAT HRLI PLACES E INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=-1,,-1 AND E=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B33400: SETO ;PRELOAD AC WITH -1,,-1 + HRLI -1 ;*HRLI SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 ET2: AR RT AD EN + + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B33500: SETO ;PRELOAD AC WITH -1,,-1 + HLR [XWD -1,0] ;*HLR SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B33600: SETO ;PRELOAD AC WITH -1,,-1 + HRL [XWD -1,0] ;*HRL SHOULD PLACE 0,,-1 INTO THE AC + CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF +;OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0 +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B33700: SETO ;PRELOAD AC WITH -1,,-1 + HLRI -1 ;*HLRI SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B34000: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRL [0] ;*HRL SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF +;OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=0,,-1 AND E=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0 +;IF C(AC)=0, THIS TEST PASSES. + +B34100: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HLRI ;*HLRI SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B34200: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRL [-1] ;*HRL SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B34300: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HLR [-1] ;*HLR SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B34400: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRL [0] ;*HRL SHOULD PLACE 0 INTO THE AC + CAIE 0 ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B34500: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLR [0] ;*HLR SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B34600: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRL [-1] ;*HRL SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1 HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B34700: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLR [-1] ;*HLR SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO +;THE LEFT HALF OF E. THE RIGHT HALF OF E IS UNAFFECTED. +;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN E +;SHOULD BE 0. E IS CHECKED FOR 0. IF C(E)=0, THIS TEXT PASSES. + +B35000: SETZ ;PRELOAD AC,E WITH 0 + HLLM ;*HLLM SHOULD PLACE 0 INTO E + SKIPE ;PASS IF C(E)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 0 FC: AD FM + EN +;0,,-1 0,,-1 ET0: AD RT BR + EN +;B35000 0,,-1 ET0: BR AR EN +;-1,,0 0,,-1 ET0: AD LT AR + EN + +;********** +;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO +;THE LEFT HALF OF E. THE RIGHT HALF OF E IS UNAFFECTED. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN E +;SHOULD BE 0,,-1. E IS CHECKED FOR 0,,-1. IF C(E)=0,,-1, THIS TEST PASSES. + +B35500: SETZ ;PRELOAD AC WITH 0 + SETO 1, ;PRELOAD E WITH -1,,-1 + HLLM 1 ;*HLLM SHOULD PLACE 0,,-1 INTO E + CAIE 1,- 1 ;PASS IF C(E) =0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 -1,,-1 SW: FCE PSE +;0 0 SW: ET0 +;0 -1,,-1 ET0: AR AD EN +;0 0 ET2: AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO +;THE LEFT HALF OF E. THE RIGHT HALF OF E IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN E +;SHOULD BE -1,,0. E IS CHECKED FOR -1,,0. IF C(E)=-1,,0, THIS TEST PASSES + +B35600: SETO ;PRELOAD AC WITH -1,,-1 + SETZ 1, ;PRELOAD E WITH 0 + HLLM 1 ;*HLLM SHOULD PLACE -1,,0 INTO E + CAME 1,[XWD -1,0] ;PASS IF C(E) = -1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRM PLACES THE RIGHT HALF OF C(AC) INTO +;THE RIGHT HALF OF E. THE LEFT HALF OF E IS UNAFFECTED. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN E +;SHOULD BE -1,,0. E IS CHECKED FOR -1,,0 +;IF C(E) = -1,,0, THIS TEST PASSES. + +B35700: SETZ ;PRELOAD AC WITH 0 + SETO 1, ;PRELOAD E WITH -1,,-1 + HRRM 1 ;*HRRM SHOULD PLACE -1,,0 INTO E + CAME 1,[XWD -1,0] ;PASS IF C(E) = -1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 -1,,-1 SW: FCE PSE +;0 0 SW: ET0 +;0 -1,,-1 FC: AD FM + EN +;-1,,-1 -1,,-1 ET0: AD LT BR + EN +;0 -1,,-1 ET0: AD RT AR + EN +;0 0 ET0: BR AR EN +;0 -1,,-1 ET0: AR AD EN +;0 0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT HRRM PLACES THE RIGHT HALF OF C(AC) INTO +;THE RIGHT HALF OF E. THE LEFT HALF OF E IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN E +;SHOULD BE 0,,-1. E IS CHECKED FOR = 0,,-1 +;IF C(E) = 0,,-1, THIS TEST PASSES. + +B36000: SETO ;PRELOAD AC WITH -1,,-1 + SETZ 1, ;PRELOAD E WITH 0 + HRRM 1 ;*HRRM SHOULD PLACE 0,,-1 INTO E + CAIE 1,-1 ;PASS IF C(E) = 0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B36100: SETO ;PRELOAD AC WITH -1,,-1 + HLLO ;*HLLO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS OF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 SW: FCE + +;********** + +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B36200: SETZ ;PRELOAD AC WITH 0 + HLLO [XWD 0,-1] ;*HLLO SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD LT AR + EN + +;********** +;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B36300: SETO ;PRELOAD AC,E WITH -1,,-1 + HRRO ;*HRRO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 SW: FCE + +;********** + +;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B36400: SETZ ;PRELOAD AC WITH 0 + HRRO [XWD -1,0] ;*HRRO SHOULD PLACE -1,,0 INTO THE AC + CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD RT AR + EN + +;********** +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B36500: SETZ ;PRELOAD AC WITH 0 + HLLO [0] ;*HLLO SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B36600: SETZ ;PRELOAD AC WITH 0 + HRRO [0] ;*HRRO SHOULD PLACE -1,,0 INTO THE AC + CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT HLLOI ALWAYS PLACES 0,,-1 INTO THE AC. +;IN THIS CASE, C(AC)=0 AND E=0. +;THE RESULT IN THE AC SHOULD BE 0,,-1. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + +B37100: SETZ ;PRELOAD AC WITH 0 + HLLOI ;*HLLOI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD LT AR + EN +;0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND E=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1, THIS TEST PASSES + +B37200: SETZ ;PRELOAD AC WITH 0 + HRROI ;*HRROI SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD RT AR + EN +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B37300: SETZ ;PRELOAD AC WITH 0 + HLLO [XWD -1,0] ;*HLLO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B37400: SETZ ;PRELOAD AC WITH 0 + HRROI -1 ;*HRRIO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLOI ALWAYS PLACES 0,,-1 INTO THE AC. +;IN THIS CASE, C(AC)=0 AND E=0. +;THE RESULT IN THE AC SHOULD BE 0,,-1. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + +B37500: SETO ;PRELOAD AC WITH -1,,-1 + HLLOI ;*HLLOI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND E=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + +B37600: SETO ;PRELOAD AC WITH -1,,-1 + HRROI ;*HRRIO SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B37700: SETO ;PRELOAD AC WITH -1,,-1 + HLLO [XWD -1,0] ;*HLLO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B40000: SETO ;PRELOAD AC WITH -1,,-1 + HRROI -1 ;*HRRIO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0,,-1 AND E=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + +B40100: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRROI ;*HRRIO SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B40200: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLLO [XWD 0,-1] ;*HLLO SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRLZ PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC. +;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE FINAL RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B40300: SETZ ;PRELOAD AC WITH 0 + HRLZ ;*HRLZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B40400: SETZ ;PRELOAD AC WITH 0 + HLRZ ;*HLRZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRLZI PLACES E INTO THE LEFT HALF OF THE AC +;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0 +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B40700: SETZ ;PRELOAD AC WITH 0 + HRLZI -1 ;*HRLZI SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR LT AR RT EN + +;********** + +;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B41000: SETZ ;PRELOAD AC WITH 0 + HLRZ [XWD -1,0] ;*HLRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;-1,,0 ET2: AR RT AR LT EN + +;********** +;THIS TEST VERIFIES THAT HRLZI PLACES E INTO THE LEFT HALF OF THE AC +;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B41100: SETO ;PRELOAD AC WITH -1,,-1 + HRLZI -1 ;*HRLZI SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + STOP + +;********** + +;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B41200: SETO ;PRELOAD AC WITH -1,,-1 + HLRZ [XWD -1,0] ;*HLRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B41500: SETZ ;PRELOAD AC WITH 0 + HLLE ;*HLLE SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC: AD LT AR + EN + +;********** + +;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B41600: SETZ ;PRELOAD AC WITH 0 + HLLE [-1] ;*HLLE SHOULD PLACE -1,,-1 INTO THE AC + CAME [XWD -1,-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;-1,,-1 ET2: AR LT AD EN +;-1,,0 ET2: AR0(1): AR RT AD EN + +;********** +;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC. +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B42000: SETZ ;PRELOAD AC WITH 0 + HRRE [-1] ;*HRRE SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1,,-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B42200: SETZ ;PRELOAD AC WITH 0 + HLLE [XWD -1,0] ;*HLLE SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC. +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B42300: SETZ ;PRELOAD AC,E WITH 0 + HRRE ;*HRRE SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;-1,,0 ET2: AR RT AD EN +;0,,-1 ET2: AR18(1): AR LT AD EN +;0,,-1 FC: AR RT AR + EN + +;********** + +;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC. +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B42500: SETZ ;PRELOAD AC WITH 0 + HRRE [XWD -1,0] ;*HRRE SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRREI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES THE LEFTMOST BIT OF E INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B42700: SETZ ;PRELOAD AC WITH 0 + HRREI -1 ;*HRREI SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 ET2: AR RT AD EN +;0,,-1 ET2: AR18(1): AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HLLEI ALWAYS CLEARS THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. +;IF C(AC)=0, THIS TEST PASSES. + +B43000: SETO ;PRELOAD AC WITH -1,,-1 + HLLEI -1 ;*HLLEI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC: AD LT AR + EN +;0,,-1 ET2: AR LT AD EN + +;********** +;THIS TEST VERIFIES THAT HLLEI ALWAYS CLEARS THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,400000. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. +;IF C(AC) = ZERO, THIS TEST PASSES. + +B43100: SETO ;PRELOAD AC WITH -1,,-1 + HLLEI 400000 ;*HLLEI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0. + STOP + +;********** + +;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + +B43400: SETZ ;PRELOAD AC WITH 0 + HRLE ;*HRLE SHOULD PLACE 0 INTO THE AC + SKIPE ;FAIL IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRLEI PLACES E INTO THE LEFT HALF OF THE AC +;AND PLACES THE LEFTMOST BIT OF E INTO ALL BITS OF THE RIGHT HALF OF THE AC +;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC SHOULD -1,,-1 +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=1,,-1, THIS TEST PASSES. + +B43500: SETZ ;PRELOAD AC WITH 0 + HRLEI -1 ;*HRLEI SHOULD PLACE -1,,-1 INTO THE AC + CAME [XWD -1,-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 ET2: AR LT AR RT EN +;-1,,0 ET2: AR 18(1): AR RT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + +B43600: HRLE [0] ;*HRLE SHOULD PLACE 0 INTO THE AC + SKIPE ;FAIL IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E,,0 SW: FCE + +;********** +;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + +B43700: HRLE [-1] ;PRELOAD AC WITH 0 + CAME [-1] ;*HRLE SHOULD PLACE 0 INTO THE AC + STOP ;FAIL IF C(AC)=0,,-1 + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 ET2: AR LT AR RT EN +;-1,,0 ET2: AR18(1): AR RT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + +B44000: HRLE [XWD -1,0] ;PRELOAD AC WITH 0 + SKIPE ;*HRLE SHOULD PLACE 0 INTO THE AC + STOP ;FAIL IF C(AC)=0,,-1 + +;********** +;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + +B44100: HRLE [XWD 0,-1] ;PRELOAD AC WITH 0 + CAME [-1] ;*HRLE SHOULD PLACE 0 INTO THE AC + STOP ;FAIL IF C(AC)=0,,-1 + +;********** + +;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(AC=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + + +B44200: SETZ ;PRELOAD AC WITH 0 + HLRE ;*HLRE SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(AC=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + + +B44300: SETZ ;PRELOAD AC WITH 0 + HLRE [-1] ;*HLRE SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;-1,,0 ET2: AR RT AR LT EN +;0,,-1 ET2: AR0(1): AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HLREI CLEARS THE AC +;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1 +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THEN TEST PASSES + +B44500: SETO ;PRELOAD AC WITH -1,,-1 + HLREI -1 ;*HLREI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,1 ET2: AR RT AR LT EN + +;********** +;THIS TEST VERIFIES THAT HLREI CLEARS THE AC +;IN THIS CASE C(AC)=0 AND E=0 +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES + +B44600: HLREI ;*HLREI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + + +B44700: HLRE [XWD -1,0] ;*HLRE SHOULD PLACE -1,,0 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(E)=0,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B45000: HLRE [XWD 0,-1] ;*HLRE SHOULD PLACE 0,,-1 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B45100: HLRE [-1] ;*HLRE SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLREM PLACES THE LEFT HALF OF C(AC) +;INTO THE RIGHT HALF OF E +;AND PLACES BIT 0 OF C(AC) INTO ALL BITS OF THE LEFT HALF OF E. +;IN THIS CASE, C(AC)=1,,0 AND C(E)=0. HENCE, THE RESULT IN E SHOULD BE -1,,-1. +;E IS CHECKED FOR -1,,-1. IF C(E)=-1,,-1, THIS TEST PASSES + +B45200: SETZ ;PRELOAD E WITH 0 + MOVE 1,[XWD -1,0] ;PRELOAD AC WITH -1,,0 + HLREM 1, ;*HLREM SHOULD PLACE -1,,-1 INTO E + CAME [-1] ;PASS IF C(E)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 -1,,0 SW: SCE +;0 -1,,0 SW: ET0 +;0 -1,,0 ET0: AR AD EN +;-1,,0 -1,,0 ET2: AR RT AR + EN +;0,,-1 -1,,0 ET2: AR0(1): AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRLM PLACES THE RIGHT HALF OF C(AC) INTO THE LEFT HALF OF E. +;THE RIGHT HALF OF E IS UNAFFECTED +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN E SHOULD BE -1,,0. +;E IS CHECKED FOR -1,,0. IF C(E)=-1,,0, THIS TEST PASSES. + +B45400: SETZ ;PRELOAD E WITH 0 + MOVEI 1,-1 ;PRELOAD AC WITH 0,,-1 + HRLM 1, ;*HRLM SHOULD PLACE -1,,0 INTO E + CAME [XWD -1,0] ;PASS IF C(E)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 0,,-1 SW: FCE PSE +;0,,-1 0,,-1 SW: ET0 +;-1,,-1 0,,-1 ET0: AD RT BR + EN +;-1,,B45400 0,,-1 ET0: BR AR EN +;0 0,,-1 ET0: AR AD EN +;0 0,,-1 ET2: AR LT AR RT EN + +;********** +SUBTTL SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 + +;********** + +SN=45500 + XX=0 + +B45500: REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE +;IS THE FLOATING ONE. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=XX+XX + IFE XX, + HRRZI XX ;PRELOAD AC WITH FLOATING ONE + ADD [0] ;ADD ZERO TO A FLOATING ONE + CAME [XX] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +PAGE + XX=0 + + REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE +;IS THE FLOATING ONE. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=XX+XX + IFE XX, + HRLZI XX ;PRELOAD AC WITH FLOATING ONE + ADD [0] ;ADD ZERO TO A FLOATING ONE + CAME [XX,,0] ;CHECK ADDER UPON FALIRE + STOP + +;********** +> +SUBTTL SUPPLEMENTARY ADDER TESTS - O + FLT 0 + +;********** + +SN=45600 +B45600: REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO +;IS THE FLOATING ZERO. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=&777777 + IFE , + SETZ ;PRELOAD AC WITH 0 + ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +PAGE + XX=0 + + REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO +;IS THE FLOATING ZERO. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=&777777 + IFE , + SETZ ;PRELOAD AC WITH 0 + ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +SUBTTL SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 + +;********** + +SN=45700 + XX=0 + +B45700: REPEAT ^D17,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE +;ADDED TO A FLOATING ONE IS A FLOATING ONE +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=XX+XX + IFE XX, + HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + ADD [XX] ;ADD A FLOATING ONE TO ITSELF + CAME [XX+XX] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +PAGE +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE +;ADDED TO A FLOATING ONE IS A FLOATING ONE +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. +SN=SN+1 + XX=XX+XX + HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + ADD [XX] ;ADD A FLOATING ONE TO ITSELF + CAME [1,,0] ;CHECK ADDRESS UPON FAILURE + STOP + +;********** + + XX=0 + + REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE +;ADDED TO A FLOATING ONE IS A FLOATING ONE +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=XX+XX + IFE XX, + HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +SUBTTL SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT + +;********** + +SN=46000 + XX=0 + +B46000: REPEAT ^D17,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO +;ADDED TO A FLOATING ZERO IS A FLOATING ZERO +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=&777777 + IFE , + HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +PAGE +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO +;ADDED TO A FLOATING ZERO IS A FLOATING ZERO +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=&777777 + HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + CAME [-2,,-2] ;CHECK ADDER UPON FAILURE + STOP + +;********** + + XX=0 + + REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO +;ADDED TO A FLOATING ZERO IS A FLOATING ZERO +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=&777777 + IFE , + HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> + ;JRST BEGEND diff --git a/apps/pdp10/diags/klad/dakac/DAKACM.MAC.txt b/apps/pdp10/diags/klad/dakac/DAKACM.MAC.txt new file mode 100644 index 000000000..043aeb7bb --- /dev/null +++ b/apps/pdp10/diags/klad/dakac/DAKACM.MAC.txt @@ -0,0 +1,2652 @@ +SUBTTL DIAGNOSTIC SECTION + + LALL + +START: SETZM USER# + JSP 0,.+1 ;GET FLAGS + TLNE USERF ;IN USER MODE + SETOM USER ;YES SET USER CONTROLL WORD + SKIPN MONFLG ;SPECIAL USER MODE + SETZM USER ;YES CLEAR USER CONTROLL WORD + SKIPN USER + JRST STARTA + SKIPL MONCTL + TTCALL 3,PGMNAM ;MENTION OUR NAME + JRST STARTA + +PGMNAM: ASCIZ/ +PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) [DAKAC] +/ +STARTA: JRST .+1 +SUBTTL TEST OF LOGICAL TEST INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT TDN DOES NOT MODIFY THE AC BECAUSE +;TDN IS A NO-OP +;FIRST, THE AC IS PRELOADED WITH 0. THEN, +;TDN IS EXECUTED. THE AC IS THEN CHECKED FOR +;NO MODIFICATION. IF C(AC) IS UNALTERED, THE TEST PASSES +B12600: SETZ ;PRELOAD AC WITH 0 + TDN [-1] ;*TDN IS A NO-OP + CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TDN SKIPS + CAIE ;PASS TEST IF C(AC) IS UNMODIFIED BY TDN + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD FM + EN + +;********** + +;THIS TEST VERIFIES THAT TSN DOES NOT MODIFY THE AC BECAUSE +;TSN IS A NO-OP +;FIRST, THE AC IS PRELOADED WITH -1. THEN, +;TSN IS EXECUTED. THE AC IS THEN CHECKED FOR +;NO MODIFICATION. IF C(AC) IS UNALTERED, THIS TEST PASSES + +B12700: SETO ;PRELOAD AC WITH -1,,-1 + TSN [XWD -1,0] ;*TSN IS A NO-OP + CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TSN SKIPS + CAME [-1] ;PASS TEST IF C(AC) IS UNMODIFIED BY TSN + STOP + +;********** +;THIS TEST VERIFIES THAT TRN DOE NOT MODIFY THE AC BECAUSE +;TRN IS A NO-OP. +;FIRST, THE AC IS PRELOADED WITH 0. THEN, +;TRN IS EXECUTED. THE AC IS THEN CHECKED FOR +;NO MODIFICATION. IF C(AC) IS UNALTERED, THIS TEST PASSES + +B13000: SETZ ;PRELOAD AC WITH 0 + TRN 123456 ;*TRN IS A NO-OP + CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TRN SKIPS + CAIE ;PASS TEST IF C(AC) IS UNMODIFIED BY TRN + STOP + +;********** + +;THIS TEST VERIFIES THAT TLN DOES NOT MODIFY THE AC BECAUSE +;TLN IS A NO-OP. +;FIRST,THE AC IS PRELOADED WITH -1,,-1. THEN, +;TRN IS EXECUTED. THE AC IS THEN CHECKED FOR +;NO MODIFICATION. IF C(AC) IS UNALTERED, THIS TEST PASSES + +B13100: SETO ;PRELOAD AC WITH -1,,-1 + TLN 123456 ;*TRN IS A NO-OP + CAM ;CAM IS A NO-OP. IT IS HERE IN CASE TRN SKIPS + CAME ;PASS TEST IF C(AC) IS UNMODIFIED BY TRN + STOP + +;********** +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC) -1,,-1, THE TEST PASSES. + +B13200: SETZ ;PRELOAD AC WITH 0 + TDO [-1] ;*TDO SHOULD PLACE ALL ONES IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;0 SW: ET1 +;0 ET1: BR AR EN +;0 ET1: AD BR - EN +;0 ET1: AD EQV + +;********** + +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THIS AC IS CHECKED FOR ZERO. IF C(AC) IS ZERO, THE TEST PASSES. + +B13300: SETZ ;PRELOAD AC WITH 0 + TDO ;*TDO SHOULD PLACE ALL ZERO IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + SKIPE ;PASS TEST IF C(AC) ZERO + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 ET1: AD AR + EN + +;********** +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC, +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR ITS CONTENTS ZERO. IF C(AC) IS ZERO, THE TEST PASSES. + +B13400: SETZ ;PRELOAD AC WITH 0 + TDO [0] ;*TDO SHOULD PLACE ALL ZERO IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + SKIPE ;PASS TEST IF C(AC) IS ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. +;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B13600: SETO ;PRELOAD AC WITH -1,,-1 + TDO ;*TDO SHOULD PLACE ALL ONES IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + CAME [-1] ;PASS TEST IF C(AC) -1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B14000: SETO ;PRELOAD AC WITH -1,,-1 + TDO [0] ;*TDO SHOULD PLACE ALL ONES IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO SKIPS + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET1: AD FM - EN +;0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT TDZ PLACES ZERO IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC) 0, THE TEST PASSES. + +B14100: SETZ ;PRELOAD AC WITH 0 + TDZ ;*TDZ SHOULD PLACE ALL ZERO IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD FM + EN + +;********** +;THIS TEST VERIFIES THAT TDZ PLACES ZERO IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1,,-1 AND C(E)=-1,,0. +;HENCE, THE RESULT IN THE AC SHOULD BE 0,,-1. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)= 0,,-1, THE TEST PASSES. + +B14200: SETO ;PRELOAD AC WITH -1,,-1 + TDZ [XWD -1,0] ;*TDZ SHOULD PLACE 0,,-1 IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + CAME [0,-1] ;PASS TEST IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-E SW: FCE +;-1,,-1 FC: AD AR -EN +;-1,,0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B14400: SETO ;PRELOAD AC WITH -1,,-1 + TDZ ;*TDZ SHOULD PLACE ALL ZERO IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES. + +B14500: SETZ ;PRELOAD AC WITH 0 + TDZ [-1] ;*TDZ SHOULD PLACE ALL ZEROS IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + SKIPE ;PASS TEST IS C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. +;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED -1,,-1. IF C(AC)=-1,,-1, THE TEST PASSES. + +B14600: SETO ;PRELOAD AC WITH -1,,-1 + TDZ [0] ;*TDZ SHOULD PLACE ALL ONES IN THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDO + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP +;********** +;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=-1 AND C(E)=0,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,0. +;THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + +B14700: SETO ;PRELOAD AC WITH -1,,-1 + TDC [XWD 0,-1] ;*TDC SHOULD PLACE -1,,0 INTO THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + CAME [-1,,0] ;PASS TEST IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-E SW: FCE +;0 FC: AD AR - EN +;0,,-1 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B15000: SETZ ;PRELOAD AC, E WITH 0 + TDC ;*TDC SHOULD PLACE 0 INTO THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC:AD FM + EN + +;********** +;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST FAILS + +B15400: SETO ;PRELOAD AC WITH -1,,-1 + TDC ;*TDC SHOULD PLACE 0 INTO THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + SKIPE ;PASS TEST IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B15500: SETZ ;PRELOAD AC WITH 0 + TDC [-1] ;*TDC SHOULD PLACE -1,,-1 INTO THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD EQV + +;********** +;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE, C(AC)=-1 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B15600: SETO ;PRELOAD AC WITH -1,,-1 + TDC [0] ;*TDC SHOULD PLACE -1,,-1 INTO THE AC + CAI ;CAI IS A NO-OP. IT IS HERE IN CASE TDC SKIPS + CAME [-1] ;PASS TEST IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT +;SEQUENTIAL INSTRUCTION. IF TDNA DOES NOT +;SKIP, THIS TEST FAILS. + +B15700: SETZ ;PRESET AC, E TO 0 + TDNA ;*TDNA SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: ET1 +;0 FC: AB PC EN +;0 ET1: BR AR EN +;0 ET1: PC CLOCK +;0 ET2: MC INST FETCH EN + +;********** +;THIS TEST VERIFIES THAT TDN NEVER SKIPS +;NEXT SEQUENTIAL INSTRUCTION. +;THIS TEST FAILS IF TDN SKIPS. + +B16000: SETO ;PRESET AC, E TO -1,,-1 + TDN ;*TDN SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDN PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE +;NEXT SEQUENTIAL INSTRUCTION. +;THIS TEST FAILS IF TDN SKIPS. + +B16100: SETZ ;PRESET AC, E TO 0 + TDN ;*TDN SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDN PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED +;BY C(E), ARE ZERO. +;IN THIS TEST C(AC) = -1..0 AND C(E) = 707070..707070. +;HENCE, TDNE SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION. +;IF TDNE SKIPS, THIS TEST FAILS + +B16200: MOVE [XWD -1,0] ;PRELOAD AC WITH -1..0 + TDNE [707070707070] ;*TDNE SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDNE PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 SW:FCE +;-1,,0 SW: PC CHANGE +;-1,,-1 FC: AD AR + EN +;E ET2: MC INST FETCH EN + +;********** + +;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED +;BY C(E), ARE ZERO. +;IN THIS CASE, AC=E AND C(AC)=0. +;HENCE, TDNE SHOULD SKIP THE NEXT SEQUENTIAL INSTRUCTION +;IF TDNE DOES NOT SKIP, THIS TEST FAILS. + +B16300: SETZ ;PRELOAD AC, E WITH 0 + TDNE ;*TDNE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: ET1 +;0 ET1: PC CLOCK + +;********** +;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED +;BY C(E) ARE ZERO. +;IN THIS TEST AC=E AND C(AC)=C(E)=0. HENCE TDNN +;SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION +;IF TDNN SKIPS, THE TEST FAILS. + +B16400: SETZ ;PRELOAD AC,E WITH 0 + TDNN ;*TDNN SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;SKIP HALT IF TDNE PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: PC CHANGE +;0 FC: AB PC EN +;0 ET2: MC INST FETCH EN + +;********** + +;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT +;SEQUENTIAL INSTRUCTION. IF TDNA DOES NOT +;SKIP, THIS TEST FAILS. + +B16500: SETO ;PRESET AC, E TO 0 + TDNA ;*TDNA SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), +;ARE ZERO +;IN THIS TEST C(AC)=-1,,0 AND C(E)=707070,,707070. HENCE, TDNN +;SHOULD SKIP THE NEXT INSTRUCTION. IF IT DOES NOT SKIP, THIS TEST FAILS. + +B16600: MOVE [XWD -1,0] ;PRESET AC TO -1,,0 + TDNN [707070707070] ;*TDNN SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 SW: FCE +;-1,,0 SW: ET1 +;-1,,0 ET1: PC CLOCK + +;********** + +;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED +;BY C(E), ARE ZERO. +;IN THIS TEST, C(AC)=-1,,-1 AND C(E)=0. HENCE, TDNE SHOULD SKIP +;THE NEXT SEQUENTIAL INSTRUCTION. +;IF TDNE DOES NOT SKIP, THIS TEST FAILS + +B16700: SETO ;PRESET AC TO ALL ONES + TDNE [0] ;*TDNE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED +;BY C(E), ARE ZERO. +;IN THIS TEST C(AC)=0 AND C(E)=-1,,-1, HENCE, TDNE SHOULD SKIP +;THE NEXT SEQUENTIAL INSTRUCTION. +;IF TDNE DOES NOT SKIP, THIS TEST FAILS + +B17000: SETZ ;PRESET AC TO 0 + TDNE [-1] ;*TDNE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD FM + EN + +;********** + +;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE NEXT SEQUENTIAL INSTRUCTION. +;THIS TEST FAILS IF TDN SKIPS + +B17300: SETO ;PRESET AC TO -1,,-1 + TDN [0] ;*TDN SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDN PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE NEXT SEQUENTIAL INSTRUCTION. +;THIS TEST FAILS IF TDN SKIPS + +B17400: SETZ ;PRESET AC TO 0 + TDN [-1] ;*TDN SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDN PASSES + STOP + +;********** + +;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT SEQUENTIAL INSTRUCTION +;THIS TEST FAILS IF TDNA DOES NOT SKIP + +B17700: SETO ;PRESET AC TO -1,,-1 + TDNA [0] ;*TDNA SHOULD SKIP + STOP + +;********** +;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT SEQUENTIAL INSTRUCTION +;THIS TEST FAILS IF TDNA DOES NOT SKIP + +B20000: SETZ ;PRESET AC TO 0 + TDNA [-1] ;*TDNA SHOULD SKIP + STOP + +;********** + +;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. +;IN THIS TEST AC=E AND C(AC)=C(E)=-1,,-1. HENCE TDNE SHOULD NOT SKIP. +;IF TDNE SKIPS, THIS TEST FAILS. + +B20400: SETO ;PRESET AC,E TO -1,,-1 + TDNE ;*TDNE SHOULD NOT SKIP + SKIPA ;SKIP HALT IF TDNE PASSES + STOP + +;********** +;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. +;IN THIS TEST, AC=E AND C(AC)=C(E)=-1,,-1. HENCE TDNN SHOULD SKIP +;IF TDNN DOES NOT SKIP, THIS TEST FAILS + +B20600: SETO ;PRESET AC,E TO -1,,-1 + TDNN ;*TDNN SHOULD SKIP THE NEXT SEQUENTIAL INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. +;IN THIS TEST, C(AC)=0 AND C(E)=-1,,-1. HENCE TDNN SHOULD NOT SKIP +;IF TDNN SKIPS, THIS TEST FAILS + +B20700: SETZ ;PRESET AC TO 0 + TDNN [-1] ;*TDNN SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION + SKIPA ;SKIP HALT IF TDNN PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 FC: AD FM + EN + +;********** +;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN +;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO. +;IN THIS TEST, C(AC)=-1,,-1 AND C(E)=0. HENCE TDNN SHOULD NOT SKIP +;IF TDNN SKIPS, THIS TEST FAILS + +B21000: SETO ;PRESET AC TO -1,,-1 + TDNN [0] ;*TDNN SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION + SKIPA ;SKIP HALT IF TDNN PASSES + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD AR + EN + +;********** + +;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY C(E) AND DOES NOT EFFECT THE UNMASKED BITS OF THE AC. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,0 +;THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + +B21100: SETZ ;PRELOAD AC WITH 0 + TDO [XWD -1,0] ;*TDO SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, +;THE RESULT IN THE AC SHOULD BE 0,,-1. THE AC IS +;CHECKED FOR 0,,-1. THIS TEST PASSES IF C(AC)=0,,-1 + +B21400: SETZ ;PRESET AC WITH 0 + TSO [XWD -1,0] ;*TSO SHOULD PLACE 0,,-1 INTO THE AC + CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;0 SW: ET0 +;0 SW: ET1 +;0 FC: AD FM + EN +;0 FC: AD AR + EN +;0 ET0: AR SWAP +;0 ET0: AD FM + EN +;0 ET0: AD AR + EN +;0 ET1: BR AR EN +;0 ET1: AD BR - EN +;-1,,-1 ET1: AD AR + EN +;0 ET1: AD EQV + +;********** + +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS +;CHECKED FOR -1,,0. THIS TEST PASSES IF C(AC)=-1,,0 + +B21500: SETZ ;PRESET AC WITH 0 + TSO [XWD 0,-1] ;*TSO SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS +;CHECKED FOR ITS CONTENTS NON-ZERO. THIS TEST PASSES IF C(AC) IS NON-ZERO + +B21600: SETZ ;PRELOAD AC,E WITH 0 + TSO ;*TSO SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,-1. THE AC IS +;CHECKED FOR -1,,-1. THIS TEST PASSES IF C(AC) -1,,-1 + +B21700: SETO ;PRELOAD AC,E WITH -1,,-1 + TSO ;*TSO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS +;CHECKED FOR -1,,0. THIS TEST PASSES IF C(AC)=-1,,0 + +B22200: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + TSO [XWD 0,-1] ;*TSO SHOULD PLACE -1,,0 INTO THE AC + CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, +;THE RESULT IN THE AC SHOULD BE 0,,-1. THE AC IS +;CHECKED FOR 0,,-1. THIS TEST PASSES IF C(AC)=0,,-1 + +B22300: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + TSO [0] ;*TSO SHOULD PLACE 0,,-1 INTO THE AC + CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET1: AD FM - EN +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,0. THE AC IS +;CHECKED FOR -1,,0. THIS TEST PASSES IF C(AC)=-1,,0 + +B22400: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + TSO [0] ;*TSO SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MARKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,-1. THE AC IS +;CHECKED FOR -1,,-1. THIS TEST PASSES IF C(AC)=-1,,-1 + +B22500: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + TSO [-1] ;*TSO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC +;WHICH ARE MARKED BY BOTH HALVES OF C(E) SWAPPED. +;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, +;THE RESULT IN THE AC SHOULD BE -1,,-1. THE AC IS +;CHECKED FOR -1,,-1. THIS TEST PASSES IF C(AC)=-1,,-1 + +B22600: MOVE [XWD -1,0] ;PRELOAD AC WITH -1,,0 + TSO [-1] ;*TSO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +SUBTTL TEST OF HWT INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B22700: SETZ ;PRELOAD AC,E WITH 0 + HLL ;*HLL SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC: AD AR + EN +;0,,-1 FC: AD RT FM + EN + +;********** + +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, +;THIS TEST PASSES. + +B23000: SETO ;PRELOAD AC WITH -1,,-1 + HLL [0] ;*HLL SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 SW: FCE +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B23200: SETO ;PRELOAD AC,E WITH -1,,-1 + HLL ;*HLL SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, +;THIS TEST PASSES + +B23400: SETZ ;PRELOAD AC WITH 0 + HLL [-1] ;*HLL SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, +;THIS TEST PASSES. + +B23600: SETZ ;PRELOAD AC WITH 0 + HLL [XWD -1,0] ;*HLL SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, +;THIS TEST PASSES. + +B23700: SETO ;PRELOAD AC WITH -1,,-1 + HLL [XWD 0,-1] ;*HLL SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B24000: SETZ ;PRELOAD AC,E WITH 0 + HLLZ ;*HLLZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC: AD LT AR + EN + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B24300: SETO ;PRELOAD AC WITH -1,,-1 + HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;-1,,-1 ET2: AR LT AD EN + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO +;IF C(AC) IS NON-ZERO, THIS TEST PASSES. + +B24400: SETZ ;PRELOAD AC WITH -1,,-1 + HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR ZERO +;IF C(AC) IS ZERO, THIS TEST PASSES. + +B24500: SETO ;PRELOAD AC WITH -1,,-1 + HLLZ [0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + SKIPE ;PASS IF C(AC) IS ZERO. + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR ZERO +;IF C(AC) IS ZERO, THIS TEST PASSES. + +B24600: SETZ ;PRELOAD AC WITH 0 + HLLZ [0] ;*HLLZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC) IS ZERO. + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. +;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B24700: SETO ;PRELOAD AC WITH -1,,-1 + HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC: AD LT AR + EN +;0,,-1 ET2: AR LT AD EN + +;********** +;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. +;IN THIS CASE C(AC)=0 AND E=0,,-1. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B25000: SETZ ;PRELOAD AC WITH 0 + HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B25100: SETO ;PRELOAD AC WITH -1,,-1 + HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0 THIS TEST PASSES. + +B25200: SETZ ;PRELOAD AC WITH 0 + HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B25300: MOVEI -1 ;PRELOAD AC WITH -1,,-1 + HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0 THIS TEST PASSES. + +B25400: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLLZ [-1] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR ZERO. +;IF C(AC) IS ZERO, THIS TEST PASSES. + +B25500: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HLLZ [0] ;*HLLZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC) IS ZERO. + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR ZERO. +;IF C(AC) IS ZERO, THIS TEST PASSES. + +B25600: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLLZ [0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + SKIPE ;PASS IF C(AC) IS ZERO. + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B25700: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. +;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B26000: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B26100: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLLZ [XWD -1,0] ;*HLLZ SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC. +;IN THIS CASE C(AC)=-1,,0 AND E=0,,-1. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B26200: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLLZI -1 ;*HLLZI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B26300: SETZ ;PRELOAD AC WITH 0 + HRR ;*HRR SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 FC: AD RT AR + EN +;-1,,0 FC: AD LT FM + EN + +;********** +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B26500: SETO ;PRELOAD AC WITH -1,,-1 + HRR ;*HRR SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 SW: FCE + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B26600: SETO ;PRELOAD AC WITH -1,,-1 + HRR [XWD -1,0] ;*HRR SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRI PLACES E INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B26700: SETO ;PRELOAD AC WITH -1,,-1 + HRRI -1 ;*HRRI SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B27000: SETO ;PRELOAD AC WITH -1,,-1 + HRR [0] ;*HRR SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B27100: SETZ ;PRELOAD AC WITH 0 + HRR [0] ;*HRR SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B27200: SETZ ;PRELOAD AC WITH 0 + HRR [-1] ;*HRR SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRI PLACES E INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B27300: SETZ ;PRELOAD AC WITH 0 + HRRI -1 ;*HRRI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD LT FM + EN + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B27400: SETZ ;PRELOAD AC WITH 0 + HRR [XWD -1,0] ;*HRR SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B27500: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRR [XWD -1,0] ;*HRR SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRRI PLACES E INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE C(AC)=-1,,0 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B27600: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRRI -1 ;*HRRI SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRI PLACES E INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B27700: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRRI -1 ;*HRRI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B30000: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRR [XWD -1,0] ;*HRR SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B30100: SETZ ;PRELOAD AC,E WITH 0 + HRRZ ;*HRRZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 FC: AD RT AR + EN + +;********** + +;THIS TEST VERIFIES THAT HRRZI PLACES E INTO +;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + +B30400: SETO ;PRELOAD AC WITH -1,,-1 + HRRZI -1 ;*HRRZI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZI PLACES E INTO +;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B30500: SETO ;PRELOAD AC WITH -1,,-1 + HRRZI 0 ;*HRRZI SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 FC: AD RT AR + EN + +;********** + +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B30600: SETO ;PRELOAD AC WITH -1,,-1 + HRRZ [XWD -1,0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;-1,,0 ET2: AR RT AD EN + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B30700: SETO ;PRELOAD AC WITH -1,,-1 + HRRZ [-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B31000: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRRZ [-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B31100: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRRZ [0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + CAIE 0 ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B31200: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRRZ [-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B31300: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRRZ [0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + CAIE 0 ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B31400: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRRZ [XWD -1,0] ;*HRRZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,0 AND C(E)=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B31500: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRRZ [XWD 0,-1] ;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRRZI PLACES E INTO +;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + +B31600: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRRZI -1 ;*HRRZI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO +;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC +;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B31700: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRRZ [XWD -1,0] ;*HRRZ SHOULD PLACE 0 INTO THE AC,0] + CAIE 0 ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B32000: SETZ ;PRELOAD AC WITH 0 + HRL ;*HRL SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B32100: SETO ;PRELOAD AC WITH -1,,-1 + HRL [-1] ;*HRL SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E,,-1 SW: FCE +;0,,-1 FC: AD RT FM + EN +;0,,-1 ET2: AR LT AR RT EN +;-1,,0 ET2: AR RT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B32200: SETO ;PRELOAD AC WITH -1,,-1 + HRL [0] ;*HRL SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B32300: SETO ;PRELOAD AC WITH -1,,-1 + HLR [0] ;*HLR SHOULD PLACE -1,,0 INTO THE AC + CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B32600: SETZ ;PRELOAD AC WITH 0 + HRL [-1] ;*HRL SHOULD PLACE -1,,0 INTO THE AC + CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B32700: SETZ ;PRELOAD AC WITH 0 + HLR [-1] ;*HLR SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;-1,,-1 FC: AD LT FM + EN +;0 ET2: AR RT AR LT EN + +;********** + +;THIS TEST VERIFIES THAT HRLI PLACES E INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B33000: SETZ ;PRELOAD AC WITH -1,,-1 + HRLI -1 ;*HRLI SHOULD PLACE -1,,-1 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD RT FM + EN +;0 ET2: AR LT AR RT EN + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B33100: SETZ ;PRELOAD AC WITH -1,,-1 + HLR [XWD -1,0] ;*HLR SHOULD PLACE -1,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B33200: SETZ ;PRELOAD AC WITH 0 + HRL [XWD -1,0] ;*HRL SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF +;OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0 +;IF C(AC)=0, THIS TEST PASSES. + +B33300: SETZ ;PRELOAD AC WITH 0 + HLRI -1 ;*HLRI SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC:AD LT FM + EN + +;********** + +;THIS TEST VERIFIES THAT HRLI PLACES E INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE C(AC)=-1,,-1 AND E=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B33400: SETO ;PRELOAD AC WITH -1,,-1 + HRLI -1 ;*HRLI SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 ET2: AR RT AD EN + + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B33500: SETO ;PRELOAD AC WITH -1,,-1 + HLR [XWD -1,0] ;*HLR SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B33600: SETO ;PRELOAD AC WITH -1,,-1 + HRL [XWD -1,0] ;*HRL SHOULD PLACE 0,,-1 INTO THE AC + CAME [XWD 0,-1] ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF +;OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0 +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B33700: SETO ;PRELOAD AC WITH -1,,-1 + HLRI -1 ;*HLRI SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B34000: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRL [0] ;*HRL SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF +;OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=0,,-1 AND E=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0 +;IF C(AC)=0, THIS TEST PASSES. + +B34100: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HLRI ;*HLRI SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B34200: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRL [-1] ;*HRL SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B34300: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HLR [-1] ;*HLR SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B34400: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRL [0] ;*HRL SHOULD PLACE 0 INTO THE AC + CAIE 0 ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B34500: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLR [0] ;*HLR SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC. THE RIGHT HALF OF THE AC IS UNAFFECTED +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B34600: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HRL [-1] ;*HRL SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC. THE LEFT HALF OF THE AC IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1 HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B34700: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLR [-1] ;*HLR SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO +;THE LEFT HALF OF E. THE RIGHT HALF OF E IS UNAFFECTED. +;IN THIS CASE, AC=E AND C(AC)= C(E)=0. HENCE, THE RESULT IN E +;SHOULD BE 0. E IS CHECKED FOR 0. IF C(E)=0, THIS TEXT PASSES. + +B35000: SETZ ;PRELOAD AC,E WITH 0 + HLLM ;*HLLM SHOULD PLACE 0 INTO E + SKIPE ;PASS IF C(E)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 0 FC: AD FM + EN +;0,,-1 0,,-1 ET0: AD RT BR + EN +;B35000 0,,-1 ET0: BR AR EN +;-1,,0 0,,-1 ET0: AD LT AR + EN + +;********** +;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO +;THE LEFT HALF OF E. THE RIGHT HALF OF E IS UNAFFECTED. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN E +;SHOULD BE 0,,-1. E IS CHECKED FOR 0,,-1. IF C(E)=0,,-1, THIS TEST PASSES. + +B35500: SETZ ;PRELOAD AC WITH 0 + SETO 1, ;PRELOAD E WITH -1,,-1 + HLLM 1 ;*HLLM SHOULD PLACE 0,,-1 INTO E + CAIE 1,- 1 ;PASS IF C(E) =0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 -1,,-1 SW: FCE PSE +;0 0 SW: ET0 +;0 -1,,-1 ET0: AR AD EN +;0 0 ET2: AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO +;THE LEFT HALF OF E. THE RIGHT HALF OF E IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN E +;SHOULD BE -1,,0. E IS CHECKED FOR -1,,0. IF C(E)=-1,,0, THIS TEST PASSES + +B35600: SETO ;PRELOAD AC WITH -1,,-1 + SETZ 1, ;PRELOAD E WITH 0 + HLLM 1 ;*HLLM SHOULD PLACE -1,,0 INTO E + CAME 1,[XWD -1,0] ;PASS IF C(E) = -1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRM PLACES THE RIGHT HALF OF C(AC) INTO +;THE RIGHT HALF OF E. THE LEFT HALF OF E IS UNAFFECTED. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN E +;SHOULD BE -1,,0. E IS CHECKED FOR -1,,0 +;IF C(E) = -1,,0, THIS TEST PASSES. + +B35700: SETZ ;PRELOAD AC WITH 0 + SETO 1, ;PRELOAD E WITH -1,,-1 + HRRM 1 ;*HRRM SHOULD PLACE -1,,0 INTO E + CAME 1,[XWD -1,0] ;PASS IF C(E) = -1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 -1,,-1 SW: FCE PSE +;0 0 SW: ET0 +;0 -1,,-1 FC: AD FM + EN +;-1,,-1 -1,,-1 ET0: AD LT BR + EN +;0 -1,,-1 ET0: AD RT AR + EN +;0 0 ET0: BR AR EN +;0 -1,,-1 ET0: AR AD EN +;0 0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT HRRM PLACES THE RIGHT HALF OF C(AC) INTO +;THE RIGHT HALF OF E. THE LEFT HALF OF E IS UNAFFECTED. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0. HENCE, THE RESULT IN E +;SHOULD BE 0,,-1. E IS CHECKED FOR = 0,,-1 +;IF C(E) = 0,,-1, THIS TEST PASSES. + +B36000: SETO ;PRELOAD AC WITH -1,,-1 + SETZ 1, ;PRELOAD E WITH 0 + HRRM 1 ;*HRRM SHOULD PLACE 0,,-1 INTO E + CAIE 1,-1 ;PASS IF C(E) = 0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B36100: SETO ;PRELOAD AC WITH -1,,-1 + HLLO ;*HLLO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS OF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,-1 SW: FCE + +;********** + +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B36200: SETZ ;PRELOAD AC WITH 0 + HLLO [XWD 0,-1] ;*HLLO SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD LT AR + EN + +;********** +;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B36300: SETO ;PRELOAD AC,E WITH -1,,-1 + HRRO ;*HRRO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 SW: FCE + +;********** + +;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B36400: SETZ ;PRELOAD AC WITH 0 + HRRO [XWD -1,0] ;*HRRO SHOULD PLACE -1,,0 INTO THE AC + CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD RT AR + EN + +;********** +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B36500: SETZ ;PRELOAD AC WITH 0 + HLLO [0] ;*HLLO SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO +;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + +B36600: SETZ ;PRELOAD AC WITH 0 + HRRO [0] ;*HRRO SHOULD PLACE -1,,0 INTO THE AC + CAME [-1,,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT HLLOI ALWAYS PLACES 0,,-1 INTO THE AC. +;IN THIS CASE, C(AC)=0 AND E=0. +;THE RESULT IN THE AC SHOULD BE 0,,-1. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + +B37100: SETZ ;PRELOAD AC WITH 0 + HLLOI ;*HLLOI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD LT AR + EN +;0 ET2: AR AD EN + +;********** + +;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND E=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1, THIS TEST PASSES + +B37200: SETZ ;PRELOAD AC WITH 0 + HRROI ;*HRROI SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,-1 FC: AD RT AR + EN +;0 ET2: AR AD EN + +;********** +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B37300: SETZ ;PRELOAD AC WITH 0 + HLLO [XWD -1,0] ;*HLLO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B37400: SETZ ;PRELOAD AC WITH 0 + HRROI -1 ;*HRRIO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLOI ALWAYS PLACES 0,,-1 INTO THE AC. +;IN THIS CASE, C(AC)=0 AND E=0. +;THE RESULT IN THE AC SHOULD BE 0,,-1. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES + +B37500: SETO ;PRELOAD AC WITH -1,,-1 + HLLOI ;*HLLOI SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND E=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + +B37600: SETO ;PRELOAD AC WITH -1,,-1 + HRROI ;*HRRIO SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B37700: SETO ;PRELOAD AC WITH -1,,-1 + HLLO [XWD -1,0] ;*HLLO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,-1. THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B40000: SETO ;PRELOAD AC WITH -1,,-1 + HRROI -1 ;*HRRIO SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES ONES INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0,,-1 AND E=0. HENCE, THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES + +B40100: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + HRROI ;*HRRIO SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO +;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B40200: MOVSI -1 ;PRELOAD AC WITH -1,,0 + HLLO [XWD 0,-1] ;*HLLO SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRLZ PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC. +;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE FINAL RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B40300: SETZ ;PRELOAD AC WITH 0 + HRLZ ;*HRLZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0. THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B40400: SETZ ;PRELOAD AC WITH 0 + HLRZ ;*HLRZ SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRLZI PLACES E INTO THE LEFT HALF OF THE AC +;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0 +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B40700: SETZ ;PRELOAD AC WITH 0 + HRLZI -1 ;*HRLZI SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 ET2: AR LT AR RT EN + +;********** + +;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B41000: SETZ ;PRELOAD AC WITH 0 + HLRZ [XWD -1,0] ;*HLRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;-1,,0 ET2: AR RT AR LT EN + +;********** +;THIS TEST VERIFIES THAT HRLZI PLACES E INTO THE LEFT HALF OF THE AC +;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. HENCE THE RESULT IN THE AC +;SHOULD BE -1,,0. THE AC IS CHECKED FOR -1,,0. +;IF C(AC)=-1,,0, THIS TEST PASSES. + +B41100: SETO ;PRELOAD AC WITH -1,,-1 + HRLZI -1 ;*HRLZI SHOULD PLACE -1,,0 INTO THE AC + CAME [XWD -1,0] ;PASS IF C(AC)=-1,,0. + STOP + +;********** + +;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-1. THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST PASSES. + +B41200: SETO ;PRELOAD AC WITH -1,,-1 + HLRZ [XWD -1,0] ;*HLRZ SHOULD PLACE 0,,-1 INTO THE AC + CAIE -1 ;PASS IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B41500: SETZ ;PRELOAD AC WITH 0 + HLLE ;*HLLE SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC: AD LT AR + EN + +;********** + +;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B41600: SETZ ;PRELOAD AC WITH 0 + HLLE [-1] ;*HLLE SHOULD PLACE -1,,-1 INTO THE AC + CAME [XWD -1,-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;-1,,-1 ET2: AR LT AD EN +;-1,,0 ET2: AR0(1): AR RT AD EN + +;********** +;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC. +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B42000: SETZ ;PRELOAD AC WITH 0 + HRRE [-1] ;*HRRE SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1,,-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B42200: SETZ ;PRELOAD AC WITH 0 + HLLE [XWD -1,0] ;*HLLE SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC. +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC. +;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B42300: SETZ ;PRELOAD AC,E WITH 0 + HRRE ;*HRRE SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E SW: FCE +;-1,,0 ET2: AR RT AD EN +;0,,-1 ET2: AR18(1): AR LT AD EN +;0,,-1 FC: AR RT AR + EN + +;********** + +;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC. +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC. +;IN THIS CASE C(AC)=0 AND C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES. + +B42500: SETZ ;PRELOAD AC WITH 0 + HRRE [XWD -1,0] ;*HRRE SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HRREI PLACES E INTO THE RIGHT HALF OF THE AC +;AND PLACES THE LEFTMOST BIT OF E INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES. + +B42700: SETZ ;PRELOAD AC WITH 0 + HRREI -1 ;*HRREI SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 ET2: AR RT AD EN +;0,,-1 ET2: AR18(1): AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HLLEI ALWAYS CLEARS THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. +;IF C(AC)=0, THIS TEST PASSES. + +B43000: SETO ;PRELOAD AC WITH -1,,-1 + HLLEI -1 ;*HLLEI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 FC: AD LT AR + EN +;0,,-1 ET2: AR LT AD EN + +;********** +;THIS TEST VERIFIES THAT HLLEI ALWAYS CLEARS THE AC. +;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,400000. +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. +;IF C(AC) = ZERO, THIS TEST PASSES. + +B43100: SETO ;PRELOAD AC WITH -1,,-1 + HLLEI 400000 ;*HLLEI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0. + STOP + +;********** + +;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + +B43400: SETZ ;PRELOAD AC WITH 0 + HRLE ;*HRLE SHOULD PLACE 0 INTO THE AC + SKIPE ;FAIL IF C(AC)=0,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HRLEI PLACES E INTO THE LEFT HALF OF THE AC +;AND PLACES THE LEFTMOST BIT OF E INTO ALL BITS OF THE RIGHT HALF OF THE AC +;IN THIS CASE, C(AC)=0 AND E=0,,-1. HENCE, THE RESULT IN THE AC SHOULD -1,,-1 +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=1,,-1, THIS TEST PASSES. + +B43500: SETZ ;PRELOAD AC WITH 0 + HRLEI -1 ;*HRLEI SHOULD PLACE -1,,-1 INTO THE AC + CAME [XWD -1,-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 ET2: AR LT AR RT EN +;-1,,0 ET2: AR 18(1): AR RT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + +B43600: HRLE [0] ;*HRLE SHOULD PLACE 0 INTO THE AC + SKIPE ;FAIL IF C(AC)=0,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;E,,0 SW: FCE + +;********** +;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + +B43700: HRLE [-1] ;PRELOAD AC WITH 0 + CAME [-1] ;*HRLE SHOULD PLACE 0 INTO THE AC + STOP ;FAIL IF C(AC)=0,,-1 + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;-1,,0 ET2: AR LT AR RT EN +;-1,,0 ET2: AR18(1): AR RT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + +B44000: HRLE [XWD -1,0] ;PRELOAD AC WITH 0 + SKIPE ;*HRLE SHOULD PLACE 0 INTO THE AC + STOP ;FAIL IF C(AC)=0,,-1 + +;********** +;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E) +;INTO THE LEFT HALF OF THE AC +;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0,,-1. IF C(AC)=0,,-1, THIS TEST FAILS + +B44100: HRLE [XWD 0,-1] ;PRELOAD AC WITH 0 + CAME [-1] ;*HRLE SHOULD PLACE 0 INTO THE AC + STOP ;FAIL IF C(AC)=0,,-1 + +;********** + +;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(AC=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + + +B44200: SETZ ;PRELOAD AC WITH 0 + HLRE ;*HLRE SHOULD PLACE 0 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(AC=0 AND C(E)=0. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + + +B44300: SETZ ;PRELOAD AC WITH 0 + HLRE [-1] ;*HLRE SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 SW: FCE +;-1,,0 ET2: AR RT AR LT EN +;0,,-1 ET2: AR0(1): AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HLREI CLEARS THE AC +;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1 +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THEN TEST PASSES + +B44500: SETO ;PRELOAD AC WITH -1,,-1 + HLREI -1 ;*HLREI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0,,1 ET2: AR RT AR LT EN + +;********** +;THIS TEST VERIFIES THAT HLREI CLEARS THE AC +;IN THIS CASE C(AC)=0 AND E=0 +;THE RESULT IN THE AC SHOULD BE 0 +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THE TEST PASSES + +B44600: HLREI ;*HLREI SHOULD CLEAR THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(E)=-1,,0. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + + +B44700: HLRE [XWD -1,0] ;*HLRE SHOULD PLACE -1,,0 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(E)=0,,-1. HENCE, THE RESULT IN THE AC SHOULD BE 0. +;THE AC IS CHECKED FOR 0. IF C(AC)=0, THIS TEST PASSES + +B45000: HLRE [XWD 0,-1] ;*HLRE SHOULD PLACE 0,,-1 INTO THE AC + SKIPE ;PASS IF C(AC)=0 + STOP + +;********** + +;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E) +;INTO THE RIGHT HALF OF THE AC +;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC +;IN THIS CASE, C(E)=-1,,-1. HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1. +;THE AC IS CHECKED FOR -1,,-1. IF C(AC)=-1,,-1, THIS TEST PASSES + +B45100: HLRE [-1] ;*HLRE SHOULD PLACE -1,,-1 INTO THE AC + CAME [-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT HLREM PLACES THE LEFT HALF OF C(AC) +;INTO THE RIGHT HALF OF E +;AND PLACES BIT 0 OF C(AC) INTO ALL BITS OF THE LEFT HALF OF E. +;IN THIS CASE, C(AC)=1,,0 AND C(E)=0. HENCE, THE RESULT IN E SHOULD BE -1,,-1. +;E IS CHECKED FOR -1,,-1. IF C(E)=-1,,-1, THIS TEST PASSES + +B45200: SETZ ;PRELOAD E WITH 0 + MOVE 1,[XWD -1,0] ;PRELOAD AC WITH -1,,0 + HLREM 1, ;*HLREM SHOULD PLACE -1,,-1 INTO E + CAME [-1] ;PASS IF C(E)=-1,,-1 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 -1,,0 SW: SCE +;0 -1,,0 SW: ET0 +;0 -1,,0 ET0: AR AD EN +;-1,,0 -1,,0 ET2: AR RT AR + EN +;0,,-1 -1,,0 ET2: AR0(1): AR LT AD EN + +;********** + +;THIS TEST VERIFIES THAT HRLM PLACES THE RIGHT HALF OF C(AC) INTO THE LEFT HALF OF E. +;THE RIGHT HALF OF E IS UNAFFECTED +;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0. HENCE, THE RESULT IN E SHOULD BE -1,,0. +;E IS CHECKED FOR -1,,0. IF C(E)=-1,,0, THIS TEST PASSES. + +B45400: SETZ ;PRELOAD E WITH 0 + MOVEI 1,-1 ;PRELOAD AC WITH 0,,-1 + HRLM 1, ;*HRLM SHOULD PLACE -1,,0 INTO E + CAME [XWD -1,0] ;PASS IF C(E)=-1,,0 + STOP + +;***** FAILURE ANALYSIS ***** +;C(AC0) C(AC1) FAILING SIGNAL + +;0 0,,-1 SW: FCE PSE +;0,,-1 0,,-1 SW: ET0 +;-1,,-1 0,,-1 ET0: AD RT BR + EN +;-1,,B45400 0,,-1 ET0: BR AR EN +;0 0,,-1 ET0: AR AD EN +;0 0,,-1 ET2: AR LT AR RT EN + +;********** +SUBTTL SUPPLEMENTARY ADDER TESTS - FLT 1 + 0 + +;********** + +SN=45500 + XX=0 + +B45500: REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE +;IS THE FLOATING ONE. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=XX+XX + IFE XX, + HRRZI XX ;PRELOAD AC WITH FLOATING ONE + ADD [0] ;ADD ZERO TO A FLOATING ONE + CAME [XX] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +PAGE + XX=0 + + REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE +;IS THE FLOATING ONE. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=XX+XX + IFE XX, + HRLZI XX ;PRELOAD AC WITH FLOATING ONE + ADD [0] ;ADD ZERO TO A FLOATING ONE + CAME [XX,,0] ;CHECK ADDER UPON FALIRE + STOP + +;********** +> +SUBTTL SUPPLEMENTARY ADDER TESTS - O + FLT 0 + +;********** + +SN=45600 +B45600: REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO +;IS THE FLOATING ZERO. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=&777777 + IFE , + SETZ ;PRELOAD AC WITH 0 + ADD [-1,,XX] ;ADD A FLOATING ZERO TO ZERO + CAME [-1,,XX] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +PAGE + XX=0 + + REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO +;IS THE FLOATING ZERO. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=&777777 + IFE , + SETZ ;PRELOAD AC WITH 0 + ADD [XX,,-1] ;ADD A FLOATING ZERO TO ZERO + CAME [XX,,-1] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +SUBTTL SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1 + +;********** + +SN=45700 + XX=0 + +B45700: REPEAT ^D17,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE +;ADDED TO A FLOATING ONE IS A FLOATING ONE +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=XX+XX + IFE XX, + HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + ADD [XX] ;ADD A FLOATING ONE TO ITSELF + CAME [XX+XX] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +PAGE +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE +;ADDED TO A FLOATING ONE IS A FLOATING ONE +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. +SN=SN+1 + XX=XX+XX + HRRZI XX ;PRELOAD AC WITH A FLOATING ONE + ADD [XX] ;ADD A FLOATING ONE TO ITSELF + CAME [1,,0] ;CHECK ADDRESS UPON FAILURE + STOP + +;********** + + XX=0 + + REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE +;ADDED TO A FLOATING ONE IS A FLOATING ONE +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=XX+XX + IFE XX, + HRLZI XX ;PRELOAD AC WITH A FLOATING ONE + ADD [XX,,0] ;ADD A FLOATING ONE TO ITSELF + CAME [XX+XX,,0] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +SUBTTL SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT + +;********** + +SN=46000 + XX=0 + +B46000: REPEAT ^D17,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO +;ADDED TO A FLOATING ZERO IS A FLOATING ZERO +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=&777777 + IFE , + HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + CAME [-1,,&777777] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> +PAGE +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO +;ADDED TO A FLOATING ZERO IS A FLOATING ZERO +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=&777777 + HRROI XX ;PRELOAD AC WITH A FLOATING ZERO + ADD [-1,,XX] ;ADD A FLOATING ZERO TO ITSELF + CAME [-2,,-2] ;CHECK ADDER UPON FAILURE + STOP + +;********** + + XX=0 + + REPEAT ^D18,< +;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO +;ADDED TO A FLOATING ZERO IS A FLOATING ZERO +;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO. +;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER. +;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY. + +SN=SN+1 + XX=&777777 + IFE , + HRLOI XX ;PRELOAD AC WITH A FLOATING ZERO + ADD [XX,,-1] ;ADD A FLOATING ZERO TO ITSELF + CAME [XX+XX+1,,-2] ;CHECK ADDER UPON FAILURE + STOP + +;********** +> + JRST BEGEND diff --git a/apps/pdp10/diags/klad/dakac/README.md b/apps/pdp10/diags/klad/dakac/README.md new file mode 100644 index 000000000..870792225 --- /dev/null +++ b/apps/pdp10/diags/klad/dakac/README.md @@ -0,0 +1,273 @@ +--- +layout: page +title: PDP-10 KA10 Basic Instruction Diagnostic #3 +permalink: /apps/pdp10/diags/klad/dakac/ +machines: + - id: testka10 + type: pdp10 + config: /devices/pdp10/machine/ka10/test/debugger/machine.xml + debugger: true + commands: a 30724 DAKAC.MAC +--- + +PDP-10 KA10 Basic Instruction Diagnostic #3 +------------------------------------------- + +The *PDP-10 KA10 Basic Instruction Diagnostic #3* (MAINDEC-10-DAKAC-B-D) test code has been extracted from +[DAKACM.MAC](DAKACM.MAC.txt) [[original](http://pdp-10.trailing-edge.com/klad_sources/01/klad.sources/dakacm.mac.html)] +for use with the [PDP-10 Test Machine with Debugger](/devices/pdp10/machine/ka10/test/debugger/) below. + +Resources for this test include: + +- [Instructions](#dakactxt) +- [History](#dakachst) +- [Source Code](#dakacmac) +- [MACRO-10 Listing](DAKAC.LST.txt) +- [Additional Information](http://archive.pcjs.org/apps/pdp10/diags/klad/dakac/DAKAC.SEQ.txt) + +{% include machine.html id="testka10" %} + +The Debugger's assemble ("a") command can be used to test the new built-in +[MACRO-10 Mini-Assembler](/modules/pdp10/lib/macro10.js), which supports a subset +of the [MACRO-10](http://archive.pcjs.org/pubs/dec/pdp10/tops10/02_1973AsmRef_macro.pdf) assembly language. +This command: + + a 30724 DAKAC.MAC + +will automatically read the [DAKAC.MAC](DAKAC.MAC.txt) source file (a slightly modified copy of [DAKACM.MAC](DAKACM.MAC.txt)), +assemble it, and then load the binary output at the specified address. + +--- + +DAKAC.TXT +--------- + +``` +MAINDEC-10-DAKAC.TXT + + + + + + IDENTIFICATION + -------------- + + PRODUCT CODE: MAINDEC-10-DAKAC-B-D + + PRODUCT NAME: DECSYSTEM10 PDP-10 KA10 BASIC + INSTRUCTION DIAGNOSTIC (3) + + FUNCTION: LOGICAL, HALF WORD, ADDER + + VERSION: 0.2 + + DATE RELEASED: JANUARY 1977 + + MAINTAINED BY: DIAGNOSTIC ENGINEERING GROUP + + AUTHOR: JOHN R. KIRCHOFF + +COPYRIGHT(C) 1976,1977 +DIGITAL EQUIPMENT CORPORATION +MARLBORO, MASS. 01752 + +THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY +ON A SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH +THE INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE, +OR ANY OTHER COPIES THEREOF, MAY NOT BE PROVIDED OR OTHERWISE +MADE AVAILABLE TO ANY OTHER PERSON EXECPT FOR USE ON SUCH SYSTEM +AND TO ONE WHO AGREES TO THESE LICENSE TERMS. TITLE TO AND +OWNERSHIP OF THE SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC. + +THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE WITHOUT +NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL +EQUIPMENT CORPORATION. + +DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS +SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC. + MAINDEC-10-DAKAC.TXT + PAGE 2 + + + TABLE OF CONTENTS + ----------------- + +1.0 ABSTRACT + +2.0 REQUIREMENTS + +2.1 EQUIPMENT + +2.2 STORAGE + +2.3 PRELIMINARY PROGRAMS + +3.0 PROGRAM PROCEDURES + +3.1 LOADING PROCEDURE + +3.2 STARTING PROCEDURE + +3.3 OPERATING PROCEDURE + +4.0 ERRORS + +5.0 ITERATION COUNTER + +6.0 CYCLE TIME + +7.0 OPERATIONAL VARIATIONS + +8.0 MISCELLANEOUS + +9.0 LISTING + MAINDEC-10-DAKAC.TXT + PAGE 3 + + +1.0 ABSTRACT + + THIS PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC IS THE + THIRD IN A SERIES OF PDP-10 KA10 PROCESSOR DIAGNOSTICS. + THE DIAGNOSTIC TESTS SOME FOLLOWING INSTRUCTIONS. + LOGICAL TEST, HALF WORD INSTRUCTIONS AND THE ADDER. + +2.0 REQUIREMENTS + +2.1 EQUIPMENT + + A PDP-10 KA10 WITH A MINIMUM OF 32K OF MEMORY + + PAPER-TAPE READER + DECTAPE (OPTIONAL) + CONSOLE TELETYPE + +2.2 STORAGE + + THE PROGRAM RUNS WITHIN 32K OF MEMORY. + +2.3 PRELIMINARY PROGRAMS + + CONSOLE FUNCTIONS WORKING PROPERLY + PAPER-TAPE OR DECTAPE READ-IN WORKING PROPERLY + PREVIOUS PROCESSOR DIAGNOSTICS + MAINDEC-10-DAKAC.TXT + PAGE 4 + + +3.0 PROGRAM PROCEDURES + +3.1 LOADING PROCEDURE + + PAPER TAPE - HARDWARE READ-IN (READER DEVICE CODE 104) + DECTAPE - LOAD WITH DIAMON (DECTAPE DEVICE CODE 320) + +3.2 STARTING PROCEDURE + + STAND-ALONE STARTING ADDRESS IS 30000. + + IF THE DIAGNOSTIC FAILS TO START CORRECTLY TRY STARTING AT THE + FIRST TEST INSTEAD OF AT THE BEGINNING OF THE CONTROL SEQUENCE. + (SEE LISTING). + +3.3 OPERATING PROCEDURE + + ONCE STARTED THE PROGRAM WILL CYCLE CONTINUALLY UNTIL STOPPED + OR AN ERROR OCCURS. + +4.0 ERRORS + + ERRORS ARE IN THE FORM OF HALT INSTRUCTIONS. THE LISTING + SHOULD BE CONSULTED TO DETERMINE THE CAUSE OF THE ERROR. A + NO OPERATION (JUMP) INSTRUCTION FOLLOWS EACH HALT. THIS + MAY BE USEFUL IN CONSTRUCTING A SCOPE LOOP TO CYCLE ON THE + FAILING INSTRUCTION. + +5.0 ITERATION COUNTER + + THE ITERATION COUNT OF THE PROGRAM IS DISPLAYED IN THE MEM- + ORY INDICATORS (MI). THIS COUNT IS A DECREMENTING COUNT AND + INITIALLY STARTS AT -1 IN STAND-ALONE OPERATION. + +6.0 CYCLE TIME + + THE CYCLE TIME OF THE PROGRAM IS IN THE MILLISECOND RANGE AND + IS THEREFORE SUITABLE FOR TAKING MARGINS, VIBRATION TESTS, ETC. + + MAINDEC-10-DAKAC.TXT + PAGE 5 + + +7.0 OPERATIONAL VARIATIONS + + A. DIAGNOSTIC MONITOR + + THE PROGRAM IS USABLE WITH THE DIAGNOSTIC MONITOR TO PRO- + VIDE RELIABILITY TESTS, ACCEPTANCE TESTS, AND/OR TO PRO- + VIDE A QUICK METHOD OF ISOLATION OF A FAULT TO A PARTICULAR + AREA OF THE PROCESSOR. CERTAIN PROCEDURES ARE USED WHEN + THE PROGRAM IS USED IN THIS MANNER. THEY ARE: + + 1. THE DIAGNOSTIC MONITOR TRANSFERS CONTROL TO THE PRO- + GRAM AND STARTS IT AT LOCATION 30002. + + 2. MONCTL - LOCATION 30043 IS USED AS THE DIAGNOSTIC MON- + ITOR CONTROL FLAG WORD. + + B. USER MODE + + THE PROGRAM WILL OPERATE IN USER MODE AND AS SUCH PROVIDES + ASSURANCE THAT THE PROCESSOR IS PERFORMING ALL FUNCTIONS + CORRECTLY. USER MODE STARTING ADDRESS IS 30000. + + C. SYSTEM EXERCISER + + STARTING ADDRESS IS 30003. NO DATA SWITCHES ARE USED BY + THIS PROGRAM. + +8.0 MISCELLANEOUS + + NONE + +9.0 LISTING +``` + +DAKAC.HST +--------- + + THIS IS A HISTORY OF THE DEVELOPMENT OF MAINDEC-10-DAKAC + + ************************************************************************ + + PRODUCT CODE: MAINDEC-10-DAKAC + + PRODUCT NAME: BASIC INSTRUCTION DIAGNOSTIC #3 + + DATE RELEASED: JANUARY 1977 + + VERSION: 0.2 + + UPDATE AUTHOR: JOHN R. KIRCHOFF + + CHANGES MADE: + + 1. UPGRADE TO ALLOW COMPATABILITY WITH THE SUBROUTINE PACKAGE. + + ************************************************************************ + + ORIGINAL VERSION: 0.1 + + ORIGINAL AUTHOR: RICHARD MALISKA + + ORIGINAL RELEASE: 16-MAR-72 + + ************************************************************************ + +DAKAC.MAC +--------- + +[[Download](DAKAC.MAC.txt)] + +{% highlight text %} +{% include_relative DAKAC.MAC.txt %} +{% endhighlight %} diff --git a/apps/pdp10/diags/klad/dakad/DAKAD.MAC.txt b/apps/pdp10/diags/klad/dakad/DAKAD.MAC.txt index 07414bb0d..d726f2cc7 100644 --- a/apps/pdp10/diags/klad/dakad/DAKAD.MAC.txt +++ b/apps/pdp10/diags/klad/dakad/DAKAD.MAC.txt @@ -35,16 +35,16 @@ DEFINE SFLAG (A)< JRST 2,.+1(1) ;SET A FLAG> SUBTTL DIAGNOSTIC SECTION -START: SETZM USER# ;CLEAR USER CONTROL WORD - JSP 0,.+1 ;GET FLAGS - TLNE USERF ;IN USER MODE? - SETOM USER ;YES, SET USER CONTROL WORD - SKIPN MONFLG ;SPECIAL USER MODE? - SETZM USER ;YES, CLEAR USER CONTROL WORD - SKIPN USER - JRST C00 - SKIPL MONCTL - TTCALL 3,PGMNAM ;MENTION OUR NAME +START: ;SETZM USER# ;CLEAR USER CONTROL WORD + ;JSP 0,.+1 ;GET FLAGS + ;TLNE USERF ;IN USER MODE? + ;SETOM USER ;YES, SET USER CONTROL WORD + ;SKIPN MONFLG ;SPECIAL USER MODE? + ;SETZM USER ;YES, CLEAR USER CONTROL WORD + ;SKIPN USER + ;JRST C00 + ;SKIPL MONCTL + ;TTCALL 3,PGMNAM ;MENTION OUR NAME JRST STARTA PGMNAM: ASCIZ/ @@ -2051,4 +2051,4 @@ C22700: SETZM 2 ;INITIALIZE AC ;********** - JRST BEGEND + ;JRST BEGEND diff --git a/apps/pdp10/diags/klad/dakad/MYDAKAD.MAC.txt b/apps/pdp10/diags/klad/dakad/DAKADM.MAC.txt similarity index 99% rename from apps/pdp10/diags/klad/dakad/MYDAKAD.MAC.txt rename to apps/pdp10/diags/klad/dakad/DAKADM.MAC.txt index 00d53d9a3..07414bb0d 100644 --- a/apps/pdp10/diags/klad/dakad/MYDAKAD.MAC.txt +++ b/apps/pdp10/diags/klad/dakad/DAKADM.MAC.txt @@ -35,16 +35,16 @@ DEFINE SFLAG (A)< JRST 2,.+1(1) ;SET A FLAG> SUBTTL DIAGNOSTIC SECTION -START: ;SETZM USER# ;CLEAR USER CONTROL WORD - ;JSP 0,.+1 ;GET FLAGS - ;TLNE USERF ;IN USER MODE? - ;SETOM USER ;YES, SET USER CONTROL WORD - ;SKIPN MONFLG ;SPECIAL USER MODE? - ;SETZM USER ;YES, CLEAR USER CONTROL WORD - ;SKIPN USER - ;JRST C00 - ;SKIPL MONCTL - ;TTCALL 3,PGMNAM ;MENTION OUR NAME +START: SETZM USER# ;CLEAR USER CONTROL WORD + JSP 0,.+1 ;GET FLAGS + TLNE USERF ;IN USER MODE? + SETOM USER ;YES, SET USER CONTROL WORD + SKIPN MONFLG ;SPECIAL USER MODE? + SETZM USER ;YES, CLEAR USER CONTROL WORD + SKIPN USER + JRST C00 + SKIPL MONCTL + TTCALL 3,PGMNAM ;MENTION OUR NAME JRST STARTA PGMNAM: ASCIZ/ @@ -2051,4 +2051,4 @@ C22700: SETZM 2 ;INITIALIZE AC ;********** -; JRST BEGEND + JRST BEGEND diff --git a/apps/pdp10/diags/klad/dakad/README.md b/apps/pdp10/diags/klad/dakad/README.md index 425f1cd9d..bb416d238 100644 --- a/apps/pdp10/diags/klad/dakad/README.md +++ b/apps/pdp10/diags/klad/dakad/README.md @@ -7,14 +7,14 @@ machines: type: pdp10 config: /devices/pdp10/machine/ka10/test/debugger/machine.xml debugger: true - commands: a 30724 MYDAKAD.MAC + commands: a 30724 DAKAD.MAC --- PDP-10 KA10 Basic Instruction Diagnostic #4 ------------------------------------------- The *PDP-10 KA10 Basic Instruction Diagnostic #4* (MAINDEC-10-DAKAD-B-D) test code has been extracted from -[DAKAD.MAC](DAKAD.MAC.txt) [[original](http://pdp-10.trailing-edge.com/klad_sources/01/klad.sources/dakadm.mac.html)] +[DAKADM.MAC](DAKADM.MAC.txt) [[original](http://pdp-10.trailing-edge.com/klad_sources/01/klad.sources/dakadm.mac.html)] for use with the [PDP-10 Test Machine with Debugger](/devices/pdp10/machine/ka10/test/debugger/) below. Resources for this test include: @@ -32,9 +32,9 @@ The Debugger's assemble ("a") command can be used to test the new built-in of the [MACRO-10](http://archive.pcjs.org/pubs/dec/pdp10/tops10/02_1973AsmRef_macro.pdf) assembly language. This command: - a 30724 MYDAKAD.MAC + a 30724 DAKAD.MAC -will automatically read the [MYDAKAD.MAC](MYDAKAD.MAC.txt) source file (a slightly modified copy of [DAKAD.MAC](DAKAD.MAC.txt)), +will automatically read the [DAKAD.MAC](DAKAD.MAC.txt) source file (a slightly modified copy of [DAKADM.MAC](DAKADM.MAC.txt)), assemble it, and then load the binary output at the specified address. Use the command `db 30724` to dump the first few words of binary data: @@ -246,7 +246,6 @@ SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC. NONE 9.0 LISTING - ``` DAKAD.HST diff --git a/apps/pdp10/tests/opcodes/OPTEST02.simh b/apps/pdp10/tests/opcodes/OPTEST02.simh new file mode 100644 index 000000000..89a822168 --- /dev/null +++ b/apps/pdp10/tests/opcodes/OPTEST02.simh @@ -0,0 +1,12 @@ +dep 100 JFCL 17,101 +dep 101 MOVEI 1,1 +dep 102 SUBI 1,1 +dep 103 JFCL 17,104 +dep 104 SUBI 1,1 +dep 105 MOVSI 1,400000 +dep 106 ADDI 1,1 +dep 107 SUBI 1,1 +dep 110 JFCL 17,111 +dep 111 SUBI 1,1 +dep pc 100 +do t diff --git a/apps/pdp10/tests/opcodes/OPTEST02.txt b/apps/pdp10/tests/opcodes/OPTEST02.txt new file mode 100644 index 000000000..fe2cdae10 --- /dev/null +++ b/apps/pdp10/tests/opcodes/OPTEST02.txt @@ -0,0 +1,11 @@ +A 100; +JFCL 17,101; +MOVEI 1,1; +SUBI 1,1; +JFCL 17,104; +SUBI 1,1; +MOVSI 1,400000; +ADDI 1,1; +SUBI 1,1; +JFCL 17,111; +SUBI 1,1; diff --git a/modules/pdp10/lib/cpuops.js b/modules/pdp10/lib/cpuops.js index a28f139ba..fb50fb749 100644 --- a/modules/pdp10/lib/cpuops.js +++ b/modules/pdp10/lib/cpuops.js @@ -2160,7 +2160,7 @@ PDP10.opBLT = function(op, acc) */ PDP10.opAOBJP = function(op, acc) { - var dst = (this.readWord(acc) + 0o000001000001) % PDP10.WORD_MASK; + var dst = (this.readWord(acc) + 0o000001000001) % PDP10.WORD_LIMIT; this.writeWord(acc, dst); if (dst < PDP10.INT_LIMIT) this.setPC(this.regEA); }; @@ -2184,7 +2184,7 @@ PDP10.opAOBJP = function(op, acc) */ PDP10.opAOBJN = function(op, acc) { - var dst = (this.readWord(acc) + 0o000001000001) % PDP10.WORD_MASK; + var dst = (this.readWord(acc) + 0o000001000001) % PDP10.WORD_LIMIT; this.writeWord(acc, dst); if (dst >= PDP10.INT_LIMIT) this.setPC(this.regEA); }; @@ -6500,7 +6500,7 @@ PDP10.CLR = function(dst, src) */ PDP10.CMP = function(dst, src) { - return (dst < PDP10.INT_LIMIT? dst : dst - PDP10.WORD_LIMIT) - (src < PDP10.INT_LIMIT? src : src - PDP10.INT_LIMIT); + return (dst < PDP10.INT_LIMIT? dst : dst - PDP10.WORD_LIMIT) - (src < PDP10.INT_LIMIT? src : src - PDP10.WORD_LIMIT); }; /** diff --git a/modules/pdp10/lib/debugger.js b/modules/pdp10/lib/debugger.js index 06ace0387..4ec44b4a5 100644 --- a/modules/pdp10/lib/debugger.js +++ b/modules/pdp10/lib/debugger.js @@ -172,7 +172,6 @@ class DebuggerPDP10 extends Debugger { this.nStep = 0; this.sCmdTracePrev = null; this.sCmdDumpPrev = null; - this.fIgnoreNextCheckFault = false; // TODO: Does this serve any purpose on a PDP-11? this.nSuppressBreaks = 0; this.cInstructions = this.cInstructionsStart = 0; this.nCycles = this.nCyclesStart = this.msStart = 0; @@ -2607,7 +2606,7 @@ class DebuggerPDP10 extends Debugger { } var sOptions = asArgs[0].substr(1); - var match = sOpcode.match(/^(['"]?)(.*\.mac)\1$/i); + var match = sOpcode.match(/^(['"]?)(.*\.mac|.*\.html)\1$/i); if (match) { var dbg = this; if (this.macro10) { @@ -3327,9 +3326,6 @@ class DebuggerPDP10 extends Debugger { */ doRun(sCmd, sAddr, sOptions, fQuiet) { - if (sCmd == "gt") { - this.fIgnoreNextCheckFault = true; - } if (sAddr !== undefined) { var dbgAddr = this.parseAddr(sAddr); if (!dbgAddr) return; diff --git a/modules/pdp10/lib/macro10.js b/modules/pdp10/lib/macro10.js index 317f83284..09850b75e 100644 --- a/modules/pdp10/lib/macro10.js +++ b/modules/pdp10/lib/macro10.js @@ -348,7 +348,7 @@ class Macro10 { * If the "preprocess" option is set, then just return the plain text we retrieved. */ if (this.sOptions.indexOf('p') >= 0) { - this.println(this.asLines.join()); + this.println(this.asLines.join("")); return 0; } @@ -577,6 +577,7 @@ class Macro10 { this.addMacro(sOperator, sRemainder); break; + case Macro10.PSEUDO_OP.LALL: // TODO case Macro10.PSEUDO_OP.PAGE: // TODO case Macro10.PSEUDO_OP.SUBTTL: // TODO case Macro10.PSEUDO_OP.TITLE: // TODO @@ -1417,6 +1418,7 @@ Macro10.PSEUDO_OP = { IFN: "IFN", IRP: "IRP", IRPC: "IRPC", + LALL: "LALL", LITERAL: "LITERAL", // this is a pseudo-pseudo-op, used for internal purposes PAGE: "PAGE", REPEAT: "REPEAT",