diff --git a/apps/pdp10/diags/klad/README.md b/apps/pdp10/diags/klad/README.md index a58cca5af..b44775e5a 100644 --- a/apps/pdp10/diags/klad/README.md +++ b/apps/pdp10/diags/klad/README.md @@ -10,7 +10,8 @@ PDP-10 KLAD Diagnostics 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/) +- [KA10 Basic Instruction Diagnostic #1 (MAINDEC-10-DAKAA)](dakaa/) +- [KA10 Basic Instruction Diagnostic #2 (MAINDEC-10-DAKAB)](dakab/) +- [KA10 Basic Instruction Diagnostic #3 (MAINDEC-10-DAKAC)](dakac/) +- [KA10 Basic Instruction Diagnostic #4 (MAINDEC-10-DAKAD)](dakad/) +- [KA10 Basic Instruction Diagnostic #5 (MAINDEC-10-DAKAE)](dakae/) diff --git a/apps/pdp10/diags/klad/dakaa/README.md b/apps/pdp10/diags/klad/dakaa/README.md index c39febd1d..4cc55d93c 100644 --- a/apps/pdp10/diags/klad/dakaa/README.md +++ b/apps/pdp10/diags/klad/dakaa/README.md @@ -13,7 +13,7 @@ machines: 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 +The *PDP-10 KA10 Basic Instruction Diagnostic #1* (MAINDEC-10-DAKAA) test code has been extracted from [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. diff --git a/apps/pdp10/diags/klad/dakac/DAKAC.MAC.txt b/apps/pdp10/diags/klad/dakac/DAKAC.MAC.txt index 6e4503259..5af64de68 100644 --- a/apps/pdp10/diags/klad/dakac/DAKAC.MAC.txt +++ b/apps/pdp10/diags/klad/dakac/DAKAC.MAC.txt @@ -1714,7 +1714,7 @@ B35000: SETZ ;PRELOAD AC,E WITH 0 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 + CAIE 1,-1 ;PASS IF C(E) =0,,-1 STOP ;***** FAILURE ANALYSIS ***** diff --git a/apps/pdp10/diags/klad/dakad/DAKAD.MAC.txt b/apps/pdp10/diags/klad/dakad/DAKAD.MAC.txt index d726f2cc7..8f6ad01a7 100644 --- a/apps/pdp10/diags/klad/dakad/DAKAD.MAC.txt +++ b/apps/pdp10/diags/klad/dakad/DAKAD.MAC.txt @@ -14,7 +14,6 @@ EXIOT=4000 ;USER PRIV I/O FLAG FXU=100 ;FLOATING UNDERFLOW DCK=40 ;DIVIDE CHECK - ;MACROS ; STOP - USED FOR SCOPE LOOP, IF INSTRUCTION FAILS, CHANGE (JUMPA .+1) @@ -33,6 +32,7 @@ DEFINE SFLAG (A)< MOVSI 1,A JFCL 17,.+1 ;RESET ALL FLAGS JRST 2,.+1(1) ;SET A FLAG> + SUBTTL DIAGNOSTIC SECTION START: ;SETZM USER# ;CLEAR USER CONTROL WORD diff --git a/apps/pdp10/diags/klad/dakae/DAKAE.LST.txt b/apps/pdp10/diags/klad/dakae/DAKAE.LST.txt new file mode 100644 index 000000000..9f89017bd --- /dev/null +++ b/apps/pdp10/diags/klad/dakae/DAKAE.LST.txt @@ -0,0 +1,5687 @@ +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 1 +DAKAET MAC 21-Dec-78 14:28 *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, AUG 1,1977 SEQ 0007 + + 1 ;DAKAE + 2 + 3 + 4 + 5 000003 DECVER==3 + 6 000000 MCNVER==0 + 7 + 8 XLIST + 9 LIST + 10 LALL + 11 NAME \MCNVER,\DECVER^ + 12 + 13 TITLE DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 + 14 ^ + 15 + 16 ;TEST DESIGNED FOR INITIAL DEBUGGING OF PROCESSOR HARDWARE + 17 ;AND TO DETECT (SOLID) FAILURES IN THE FIELD. + 18 + 19 ;COPYRIGHT 1972,1977,1978 + 20 ;DIGITAL EQUIPMENT CORPORATION + 21 ;MARLBORO, MASS. 01752 + 22 + 23 ;DICK MALISKA + 24 ;JOHN R. KIRCHOFF + 25 ;BILL SCORZELLI + 26 + 27 000137 LOC 137 + 28 000137 000000 000003 MCNVER,,DECVER + 29 + 30 NOSYM +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 2 +DAKAET MAC 21-Dec-78 14:28 DIAGNOSTIC PARAMETERS SEQ 0008 + + 31 SUBTTL DIAGNOSTIC PARAMETERS + 32 + 33 ;PARAMETER DEFINITIONS + 34 000001 EXCASB==1 + 35 000001 USRASB==1 + 36 000001 PGMEND==1 + 37 000100 DEBUG==100 + 38 + 39 ;FLAG DEFINITIONS + 40 010000 USERF=10000 ;USER MODE FLAG + 41 + 42 + 43 ;MACROS + 44 + 45 ;SPECIAL FEATURE PARAMETERS + 46 + 47 030674 SADR1=START + 48 030674 SADR2=START + 49 030674 SADR3=START + 50 030674 SADR4=START + 51 254000 030674 SADR5=JRST START + 52 254000 030674 SADR6=JRST START + 53 254000 030674 SADR7=JRST START + 54 254000 030674 SADR8=JRST START + 55 254000 030674 SADR9=JRST START + 56 254000 030674 SADR10=JRST START + 57 254000 030674 SADR11=JRST START + 58 + 59 000000 PAREA0=0 + 60 000000 PAREA1=0 + 61 000000 PAREA2=0 + 62 444153 414500 PAREA3=SIXBIT/DAKAE/ + 63 645560 000000 PAREA4=SIXBIT/TMP/ + 64 000000 PAREA5=0 + 65 000000 PAREA6=0 + 66 001000 ITERAT==1000 + 67 000001 PGMEND==1 +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 3 +DAKAET MAC 21-Dec-78 14:28 DIAGNOSTIC PARAMETERS SEQ 0009 + + 68 SUBTTL DIAGNOSTIC PARAMETERS + 69 + 70 ;ACCUMULATOR ASSIGNMENTS + 71 + 72 ;CONTROL WORDS + 73 + 74 400000 AROV=400000 ;ARITHMETIC OVERFLOW + 75 200000 CRY0=200000 ;CARRY 0 + 76 100000 CRY1=100000 ;CARRY 1 + 77 040000 FOV=40000 ;FLOATING OVERFLOW + 78 020000 BIS=20000 ;BYTE INTERRUPT + 79 010000 USERF=10000 ;USER MODE FLAG + 80 004000 EXIOT=4000 ;USER PRIV I/O FLAG + 81 000100 FXU=100 ;FLOATING UNDERFLOW + 82 000040 DCK=40 ;DIVIDE CHECK + 83 + 84 + 85 ;MACROS + 86 + 87 ; STOP - USED FOR SCOPE LOOP, IF INSTRUCTION FAILS, CHANGE (JUMPA .+1) + 88 ; TO A (JUMPA X) TO CYCLE ON FAILING INSTRUCTION + 89 + 90 DEFINE STOP (A)< + 91 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 92 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 93 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 94 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 95 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1> + 96 + 97 ; SFLAG - USED TO CLEAR ALL FLAGS THEN TO SET REQUESTED FLAG + 98 + 99 DEFINE SFLAG (A)< + 100 MOVSI 1,A + 101 JFCL 17,.+1 ;RESET ALL FLAGS + 102 JRST 2,.+1(1) ;SET A FLAG> +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 1 +PARAM KLM 1-Aug-77 08:33 *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, AUG 1,1977 SEQ 0010 + + 103 SUBTTL *PARAM* CONSOLE DATA SWITCH ASSIGNMENTS, AUG 1,1977 + 104 + 105 DEFINE S,<;*********************************************************************> + 106 + 107 S^;*********************************************************************^ + 108 ;*DATA SWITCHES (READ FROM CONSOLE IN EXEC MODE OR TYPED IN IN USER MODE) + 109 ;*LEFT HALF SWITCHES ARE PRE-ASSIGNED FOR SUBROUTINE PACKAGE USE + 110 ;*AND CONTROL LOOPING, PRINTING (TTY OR OTHER DEVICE) AND MISC. FUNCTIONS + 111 S^;*********************************************************************^ + 112 + 113 400000 ABORT== 400000 ;ABORT PROGRAM ON PASS COMPLETION + 114 200000 RSTART==200000 ;RESTART TEST, PRINT TOTALS + 115 100000 TOTALS==100000 ;PRINT TOTALS, CONTINUE + 116 + 117 040000 NOPNT== 040000 ;INHIBIT ALL PRINT/TYPE OUT (EXCEPT FORCED) + 118 020000 PNTLPT==020000 ;PRINT ALL DATA ON LPT (LOGICAL DEVICE, USER MODE) + 119 010000 DING== 010000 ;RING BELL ON ERROR + 120 + 121 004000 LOOPER==004000 ;ENTER EXERCISE/CHECK LOOP ON ERROR + 122 002000 ERSTOP==002000 ;HALT ON TEST ERROR + 123 001000 PALERS==001000 ;PRINT ALL ERRORS + 124 + 125 000400 RELIAB==000400 ;RELIABILITY MODE + 126 000200 TXTINH==000200 ;INHIBIT ERROR TEXT + 127 000100 INHPAG==000100 ;INHIBIT PAGING + 128 + 129 000040 MODDVC==000040 ;MODIFY DEVICE CODE + 130 000020 INHCSH==000020 ;INHIBIT CACHE + 131 000010 OPRSEL==000010 ;OPERATOR SELECTION + 132 + 133 000004 CHAIN== 000004 ;CHAIN CONTROL SWITCH + 134 + 135 000002 KAHZ50==000002 ;KA10 50 HERTZ POWER + 136 + 137 ;SWITCH 17 RESERVED !!! +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 2 +PARAM KLM 1-Aug-77 08:33 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 SEQ 0011 + + 138 SUBTTL *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 + 139 + 140 S^;*********************************************************************^ + 141 ;*SPECIAL SUBPROGRAM LINKAGES + 142 S^;*********************************************************************^ + 143 + 144 027772 FSELNK= 27772 ;FILE SELECT LINK + 145 027773 FRDLNK= 27773 ;FILE READ LINK + 146 027774 LDLNK= 27774 ;LOAD LINKAGE ADDRESS + 147 027775 DDTLNK= 27775 ;DDT LINKAGE ADDRESS + 148 027776 MODLNK= 27776 ;OPERATIONAL MODE CHECK LINKAGE ADDRESS + 149 027777 SUBLNK= 27777 ;SUBROUTINE LINKAGE ADDRESS + 150 + 151 S^;*********************************************************************^ + 152 ;*SPECIAL SUBROUTINE FATAL HALTS + 153 ;*USED TO REPORT ERRORS THAT CAUSE THE SUBROUTINES TO BE UNUSABLE + 154 S^;*********************************************************************^ + 155 + 156 ;ADDRESS TAG REASON + 157 ;--------------------- + 158 + 159 ; 1010 NOEXEC ;PROGRAM NOT CODED FOR EXEC MODE OPERATION + 160 ; 1011 PLERR ;FATAL PUSH LIST POINTER ERROR + 161 ; 1012 PLERR1 ;INITIAL PUSH LIST POINTER ERROR + 162 ; 1013 MUOERR ;MUUO WITH LUUO HANDLER WIPED OUT + 163 ; 1014 DTEBER ;DTE20 INTERRUPT WITHOUT DOORBELL + 164 ; 1015 DTECER ;DTE20 CLOCK INTERRUPT WITHOUT FLAG SET + 165 ; 1016 CPIERR ;CPU INITIALIZATION ERROR + 166 ; 1017 EOPERR ;END OF PROGRAM ERROR + 167 ; 1020 LUOERR ;INTERRUPT WITH LUUO HANDLER WIPED OUT + 168 + 169 S^;*********************************************************************^ +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 3 +PARAM KLM 1-Aug-77 08:33 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 SEQ 0012 + + 170 S^;*********************************************************************^ + 171 ;OPERATOR DEFINITIONS (NON-UUO'S) + 172 S^;*********************************************************************^ + 173 + 174 260740 000000 OPDEF GO [PUSHJ P,] ;SUBROUTINE CALL + 175 263740 000000 OPDEF RTN [POPJ P,] ;SUBROUTINE RETURN + 176 261740 000000 OPDEF PUT [PUSH P,] ;PUT DATA ON PUSH LIST + 177 262740 000000 OPDEF GET [POP P,] ;GET DATA FROM PUSH LIST + 178 254000 000000 OPDEF PJRST [JRST ] ;JRST TO ROUTINE THAT RTN'S + 179 254200 000000 OPDEF HALT [JRST 4,] ;DEFINITION FOR DDT + 180 254100 000000 OPDEF JRSTF [JRST 2,] ;DEFINITION FOR DDT + 181 254500 000000 OPDEF JEN [JRST 12,] ;DEFINITION FOR DDT + 182 + 183 S^;*********************************************************************^ + 184 ;*SUBROUTINE INITIALIZATION CALL + 185 S^;*********************************************************************^ + 186 + 187 265000 030011 OPDEF PGMINT [JSP 0,SBINIT] ;SUBROUTINE INITIALIZATION + 188 + 189 S^;*********************************************************************^ + 190 ;*HALTING UUO'S (A MORE GRACEFUL HALT THAN SIMPLY USING THE HALT INSTRUCTION). + 191 S^;*********************************************************************^ + 192 + 193 037640 000004 OPDEF FATAL [37B8!15B12!4] ;FATAL PROGRAMMING HALT + 194 037600 000004 OPDEF ERRHLT [37B8!14B12!4] ;PROGRAM ERROR HALT + 195 + 196 S^;*********************************************************************^ + 197 ;*TERMINAL INPUT UUO'S + 198 ;*ALWAYS COME FROM THE CONSOLE TERMINAL IN EXEC MODE OR THE + 199 ;*CONTROLLING TERMINAL (REAL TERMINAL OR PTY) IN USER MODE. + 200 S^;*********************************************************************^ + 201 + 202 037000 000003 OPDEF TTICHR [37B8!0B12!3] ;TTY, INPUT ANY CHARACTER + 203 037040 000003 OPDEF TTIYES [37B8!1B12!3] ;TTY, NORMAL RETURN Y + 204 037100 000003 OPDEF TTINO [37B8!2B12!3] ;TTY, NORMAL RETURN N + 205 037140 000003 OPDEF TTIOCT [37B8!3B12!3] ;TTY, INPUT OCTAL WORD + 206 037200 000003 OPDEF TTIDEC [37B8!4B12!3] ;TTY, INPUT DECIMAL WORD + 207 037240 000003 OPDEF TTICNV [37B8!5B12!3] ;TTY, INPUT CONVERTABLE WORD + 208 037300 000003 OPDEF TTLOOK [37B8!6B12!3] ;TTY, KEYBOARD CHECK + 209 037340 000003 OPDEF TTALTM [37B8!7B12!3] ;TTY, ALT-MODE CHECK + 210 037400 000003 OPDEF TTSIXB [37B8!10B12!3] ;TTY, INPUT SIXBIT WORD + 211 037440 000003 OPDEF TTYINP [37B8!11B12!3] ;TTY, IMAGE MODE INPUT + 212 037500 000003 OPDEF TTICLR [37B8!12B12!3] ;TTY, CLEAR INPUT +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 4 +PARAM KLM 1-Aug-77 08:33 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 SEQ 0013 + + 213 ;*TERMINAL OUTPUT UUO'S. + 214 + 215 037000 000000 OPDEF PNTA [37B8!0B12!0] ;PRINT ASCII WORD + 216 037000 000001 OPDEF PNTAF [37B8!0B12!1] ;PRINT ASCII WORD FORCED + 217 037740 000000 OPDEF PNTAL [37B8!17B12!0] ;PRINT ASCIZ LINE + 218 037740 000001 OPDEF PNTALF [37B8!17B12!1] ;PRINT ASCIZ LINE FORCED + 219 037600 000003 OPDEF PSIXL [37B8!14B12!3] ;PRINT SIXBIT'Z LINE + 220 037640 000003 OPDEF PSIXLF [37B8!15B12!3] ;PRINT SIXBIT'Z LINE FORCED + 221 037000 000000 OPDEF PNTMSG [37B8!0B12!0] ;PRINT MESSAGE IMMEDIATE + 222 037040 000000 OPDEF PNTMSF [37B8!1B12!0] ;PRINT MESSAGE IMMEDIATE FORCED + 223 037100 000000 OPDEF PSIXM [37B8!2B12!0] ;PRINT SIXBIT'Z MSG IMMEDIATE + 224 037200 000000 OPDEF PSIXMF [37B8!4B12!0] ;PRINT SIXBIT'Z MSG IMM FORCED + 225 037000 000000 OPDEF PNTCI [37B8!0B12!0] ;PRINT CHARACTER IMMEDIATE + 226 037040 000000 OPDEF PNTCIF [37B8!1B12!0] ;PRINT CHARACTER IMMEDIATE FORCED + 227 037500 000000 OPDEF PNTCHR [37B8!12B12!0] ;PRINT CHARACTER + 228 037500 000001 OPDEF PNTCHF [37B8!12B12!1] ;PRINT CHARACTER FORCED + 229 037040 000000 OPDEF PNT1 [37B8!1B12!0] ;PRINT ONE OCTAL DIGIT + 230 037040 000001 OPDEF PNT1F [37B8!1B12!1] ;PRINT 1 OCTAL DIGIT FORCED + 231 037100 000000 OPDEF PNT2 [37B8!2B12!0] ;PRINT TWO OCTAL DIGITS + 232 037100 000001 OPDEF PNT2F [37B8!2B12!1] ;PRINT 2 OCTAL DIGITS FORCED + 233 037140 000000 OPDEF PNT3 [37B8!3B12!0] ;PRINT THREE OCTAL DIGITS + 234 037140 000001 OPDEF PNT3F [37B8!3B12!1] ;PRINT THREE OCTAL DIGITS FORCED + 235 037200 000000 OPDEF PNT4 [37B8!4B12!0] ;PRINT FOUR OCTAL DIGITS + 236 037200 000001 OPDEF PNT4F [37B8!4B12!1] ;PRINT FOUR OCTAL DIGITS FORCED + 237 037240 000000 OPDEF PNT5 [37B8!5B12!0] ;PRINT FIVE OCTAL DIGITS + 238 037240 000001 OPDEF PNT5F [37B8!5B12!1] ;PRINT FIVE OCTAL DIGITS FORCED + 239 037300 000000 OPDEF PNT6 [37B8!6B12!0] ;PRINT SIX OCTAL DIGITS + 240 037300 000001 OPDEF PNT6F [37B8!6B12!1] ;PRINT SIX OCTAL DIGITS FORCED + 241 037340 000000 OPDEF PNT7 [37B8!7B12!0] ;PRINT 7 OCTAL DIGITS + 242 037340 000001 OPDEF PNT7F [37B8!7B12!1] ;PRINT 7 OCTAL DIGITS FORCED + 243 037440 000000 OPDEF PNT11 [37B8!11B12!0] ;PRINT 11 OCTAL DIGITS + 244 037440 000001 OPDEF PNT11F [37B8!11B12!1] ;PRINT 11 OCTAL DIGITS FORCED. + 245 037400 000000 OPDEF PNTADR [37B8!10B12!0] ;PRINT PHYSICAL ADDRESS + 246 037400 000001 OPDEF PNTADF [37B8!10B12!1] ;PRINT PHYSICAL ADDRESS FORCED + 247 037600 000000 OPDEF PNTOCT [37B8!14B12!0] ;PRINT FULL WORD OCTAL + 248 037600 000001 OPDEF PNTOTF [37B8!14B12!1] ;PRINT FULL WORD OCTAL FORCED + 249 037540 000000 OPDEF PNTHW [37B8!13B12!0] ;PRINT OCTAL HALF WORDS, 6 SP 6 + 250 037540 000001 OPDEF PNTHWF [37B8!13B12!1] ;PRINT OCTAL HALF WORDS, 6 SP 6 FORCED + 251 037700 000003 OPDEF PNTOCS [37B8!16B12!3] ;PRINT OCTAL, SUPPRESS LEADING 0'S + 252 037740 000003 OPDEF PNTOCF [37B8!17B12!3] ;PRINT OCTAL, SUPPRESS LEADING 0'S FORCED + 253 037640 000000 OPDEF PNTDEC [37B8!15B12!0] ;PRINT DECIMAL, SUPRESS LEADING 0'S + 254 037640 000001 OPDEF PNTDCF [37B8!15B12!1] ;PRINT DECIMAL, SUPRESS LEADING 0'S FORCED + 255 037700 000000 OPDEF PNTDS [37B8!16B12!0] ;PRINT DECIMAL, SPACES FOR LD 0'S + 256 037700 000001 OPDEF PNTDSF [37B8!16B12!1] ;PRINT DECIMAL, SPACES FOR LD 0'S FORCED +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 5 +PARAM KLM 1-Aug-77 08:33 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 SEQ 0014 + + 257 037200 000002 OPDEF PNTNM [37B8!4B12!2] ;PRINT PROGRAM NAME + 258 037000 000002 OPDEF PNTSIX [37B8!0B12!2] ;PRINT SIXBIT WORD + 259 037040 000002 OPDEF PNTSXF [37B8!1B12!2] ;PRINT SIXBIT WORD FORCED + 260 037240 000002 OPDEF DROPDV [37B8!5B12!2] ;CLOSE LOGICAL FILE, USER MODE + 261 037100 000002 OPDEF PNTCW [37B8!2B12!2] ;PRINT DF10 CONTROL WORD + 262 037140 000002 OPDEF PNTCWF [37B8!3B12!2] ;PRINT DF10 CONTROL WORD FORCED + 263 037000 030242 OPDEF PCRL [37B8!0B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED + 264 037040 030242 OPDEF PCRLF [37B8!1B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED FORCED + 265 037000 000040 OPDEF PSP [37B8!0B12!40] ;PRINT SPACE + 266 037040 000040 OPDEF PSPF [37B8!1B12!40] ;PRINT SPACE FORCED + 267 037000 030243 OPDEF PCRL2 [37B8!0B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE) + 268 037040 030243 OPDEF PCRL2F [37B8!1B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE) FORCED + 269 037040 000007 OPDEF PBELL [37B8!1B12!7] ;PRINT TTY BELL + 270 + 271 037040 000026 OPDEF PFORCE [37B8!1B12!26] ;PRINT FORCE, CONTROL O OVERRIDE + 272 + 273 DEFINE PMSG (ARG),< + 274 PSIXM [SIXBIT\ARG'_\]> + 275 + 276 DEFINE PMSGF (ARG),< + 277 PSIXMF [SIXBIT\ARG'_\]> + 278 + 279 ;*SIXBTZ -- MACRO TO GENERATE SIXBIT DATA FOR PRINTING + 280 ;* CONSERVES CORE OVER ASCIZ + 281 + 282 DEFINE SIXBTZ (ARG),< [SIXBIT\ARG'_\]> + 283 + 284 ;*CONSOLE SWITCH INPUT UUO. + 285 ;*READS CONSOLE SWITCHES IF IN EXEC MODE OR ASKS FOR THEM IF + 286 ;* USER MODE. + 287 + 288 037400 000002 OPDEF SWITCH [37B8!10B12!2] ;INPUT CONSOLE SWITCHES + 289 + 290 ;*CLOCK INITIALIZATION UUO - TO SET DESIRED CLOCK OPERATION + 291 ;*EITHER IGNORE CLOCK, ONLY LET IT TICK OR CAUSE INTERRUPT TO OCCUR. + 292 + 293 037540 000004 OPDEF CLOKOP [37B8!13B12!4] ;CLOCK OPERATION UUO - PDP-11 CLOCK + 294 037200 000004 OPDEF MTROP [37B8!4B12!4] ;CLOCK OPERATION UUO - DK20 METER + 295 + 296 ;*KL10 ONLY CACHE OPERATION UUO'S + 297 + 298 037040 000004 OPDEF CINVAL [37B8!1B12!4] ;CACHE INVALIDATE + 299 037100 000004 OPDEF CFLUSH [37B8!2B12!4] ;CACHE FLUSH + 300 037140 000004 OPDEF CWRTBI [37B8!3B12!4] ;CACHE WRITE-BACK & INVALIDATE +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 6 +PARAM KLM 1-Aug-77 08:33 *PARAM* PROGRAM/SUBROUTINE PARAMETERS, FEB 26,1976 SEQ 0015 + + 301 ;*END OF PASS/PROGRAM UUOS + 302 + 303 ;PERFORMS THE END OF PASS FUNCTIONS. INCREMENT PASS COUNT, + 304 ;*DECREMENT ITERATION COUNT, CHECK IF FINISHED WITH THIS PROGRAM ETC. + 305 + 306 037500 000004 OPDEF ENDUUO [37B8!12B12!4] ;UUO TO DISPLAY LIGHTS + 307 037700 000004 OPDEF EOPUUO [37B8!16B12!4] ;END OF PROGRAM UUO + 308 + 309 ;*MEMORY MANAGEMENT UUO'S + 310 ;*UUO'S TO PERFORM VARIOUS MEMORY FUNCTIONS. MAPPING, ZEROING, PAGING, + 311 ;*ADDRESS CONVERSION, ETC... + 312 + 313 037000 000004 OPDEF MAPMEM [37B8!0B12!4] ;MAP MEMORY + 314 037500 000002 OPDEF MEMZRO [37B8!12B12!2] ;ZERO MEMORY + 315 037440 000002 OPDEF MEMSEG [37B8!11B12!2] ;SETUP MEMORY SEGMENT + 316 037540 000002 OPDEF MAPADR [37B8!13B12!2] ;VIRTUAL TO PHYSICAL ADR CONVERT + 317 037640 000002 OPDEF MAPCNK [37B8!15B12!2] ;MAP MEMORY CHUNK + 318 037600 000002 OPDEF MAPSET [37B8!14B12!2] ;SET KI10 EXEC PAGE MAP + 319 037740 000002 OPDEF MAPPNT [37B8!17B12!2] ;PRINT MEMORY MAP + 320 + 321 ;*DEVICE CODE MODIFICATION UUO + 322 ;*ALLOWS THE MODIFICATION OF IOT'S TO ONE DEVICE TO BE CHANGED TO + 323 ;*IOT'S TO A DIFFERENT DEVICE CODE. + 324 + 325 037340 000002 OPDEF MODPCU [37B8!7B12!2] ;MODIFY PERHIPERAL CODE, USER + 326 037300 000002 OPDEF MODPCP [37B8!6B12!2] ;MODIFY PERHIPERAL CODE, PROGRAM + 327 + 328 030000 IFNDEF MODDVL, + 329 030000 IFNDEF MODDVU, + 330 + 331 ;*"DIAMON" FILE SELECTION AND READ UUOS + 332 + 333 037240 000004 OPDEF FSELECT [37B8!5B12!4] ;FILE SELECTION + 334 037300 000004 OPDEF FREAD [37B8!6B12!4] ;FILE READ - ASCII DATA + 335 037340 000004 OPDEF FRD36 [37B8!7B12!4] ;FILE READ - 36 BIT DATA + 336 037400 000004 OPDEF FRD8 [37B8!10B12!4] ;FILE READ - 8 BIT DATA + 337 + 338 ;*KI10 ONLY UUO FOR PRINTING MARGIN VALUES + 339 + 340 037700 000002 OPDEF PNTMGN [37B8!16B12!2] ;PRINT MARGIN VALUE + 341 + 342 XLIST + 343 IFNDEF KLOLD, + 368 + 369 ;*A MACRO TO REPORT AN ERROR AND NOT LOOP + 370 + 371 DEFINE ERROR1 (FORMAT,CORECT,ACTUAL,F,D,ERR)< + 372 SALL + 373 ERUUO FORMAT,[T,,[SIXBIT\F'_\] + 374 CORECT,,ACTUAL + 375 [SIXBIT\D'_\],,ERR] + 376 XALL> + 377 + 378 >;END OF KLOLD CONDITIONAL + 379 + 380 XLIST + 381 LIST +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 1 +FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0017 + + 382 SUBTTL *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 + 383 + 384 030000 LOC 30000 + 385 + 386 S^;*********************************************************************^ + 387 ;*PROGRAM STARTING ADDRESSES + 388 ;*THESE ADDRESSES CALL VARIOUS SPECIAL START ROUTINES AND OR OPTIONS + 389 ;*NORMAL START ADDRESS IS 30000 ALL OTHERS ARE SPECIAL. INVOKED BECAUSE + 390 ;*OF END OF PASS, POWER FAILURE, DDT START, RE-ENTERING(TYPICALLY USER + 391 ;*MODE), OR ANY NUMBER OF SPECIAL FEATURE TESTS. + 392 S^;*********************************************************************^ + 393 + 394 030000 254 00 1 00 027776 BEGIN: JRST @MODLNK ;STAND-ALONE START + 395 030001 254 00 0 00 030674 $START: JRST START ;MODE CHECK STARTING ADDRESS + 396 + 397 030002 254 00 1 00 027774 DIAGMN: JRST @LDLNK ;DIAGNOSTIC MONITOR START + 398 + 399 030003 254 00 1 00 027774 SYSEXR: JRST @LDLNK ;SYSTEM EXERCISER START + 400 + 401 030004 254 00 0 00 030674 SFSTRT: JRST SADR1 ;SPECIAL FEATURE START + 402 + 403 030005 254 00 0 00 030674 PFSTRT: JRST SADR2 ;POWER FAIL RESTART + 404 + 405 030006 254 00 0 00 030674 REENTR: JRST SADR3 ;REENTER START(USUALLY USER MODE ONLY) + 406 + 407 030007 SRTDDT: ;COMMONLY MISTAKEN NAME FOR "DDTSRT" + 408 030007 254 00 1 00 027775 DDTSRT: JRST @DDTLNK ;DDT START + 409 + 410 030010 254 00 0 00 030723 BEGIN1: JRST STARTA ;LOOP START(END OF PASS COMES HERE) + 411 030011 254 00 1 00 027777 SBINIT: JRST @SUBLNK ;PMGINT LINKAGE + 412 030012 000000 000000 RETURN: 0 ;RETURN ADDRESS STORAGE + 413 + 414 030013 254000 030674 START1: SADR7 ;OPTIONAL STARTING ADR/INSTRUCTIONS + 415 030014 254000 030674 START2: SADR8 ; " + 416 030015 254000 030674 START3: SADR9 ; " + 417 030016 254000 030674 START4: SADR10 ; " + 418 030017 254000 030674 START5: SADR11 ; " +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 2 +FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0018 + + 419 S^;*********************************************************************^ + 420 ;*PROGRAM FIXED PARAMETER AREA + 421 S^;*********************************************************************^ + 422 + 423 030020 444153 414500 PNTNAM: PAREA3 ;SIXBIT PROGRAM NAME + 424 030021 645560 000000 PNTEXT: PAREA4 ;SIXBIT PROGRAM EXTENSION + 425 030022 000000 000000 RANDBS: PAREA1 ;RANDOM BASE NUMBER + 426 030023 000000 000000 SWTEXR: PAREA2 ;SYSTEM EXERCISER SWITCHES + 427 030024 000000 001000 ITRCNT: ITERAT ;PROGRAM ITERATIONS + 428 030025 000000 030707 $PNAME: PGMNAM ;POINTER TO PROGRAMS NAME + 429 030026 000000 000003 $PVER: MCNVER,,DECVER ;MCN & DEC VERSION LEVEL + 430 030027 000000 030000 $MODVL: MODDVL ;DEVICE CODE CHANGE LOWER LIMIT + 431 030030 000000 030000 $MODVU: MODDVU ;DEVICE CODE CHANGE UPPER LIMIT + 432 030031 777777 777777 $EMODE: IFNDEF EXCASB,<0> IFDEF EXCASB,<-1> ;EXEC ALLOWED + 433 030032 777777 777777 $UMODE: IFNDEF USRASB,<0> IFDEF USRASB,<-1> ;USER ALLOWED + 434 030033 000000 000000 $DSKUP: IFNDEF DSKUPD,<0> IFDEF DSKUPD,<-1> ;DISK UPDATE MODE + 435 030034 000000 000000 $MMAP: IFNDEF MEMMAP,<0> IFDEF MEMMAP,<-1> ;ALLOW MEMORY RTNS + 436 030035 000000 000000 PAREA7: PAREA5 ;OPTIONAL PARAMETER + 437 030036 000000 000000 PAREA8: PAREA6 ;OPTIONAL PARAMETER + 438 + 439 S^;*********************************************************************^ + 440 ;*PROGRAM VARIABLE PARAMETER AREA + 441 S^;*********************************************************************^ + 442 + 443 030037 000000 000000 USER: 0 ; 0 = EXEC, -1 = USER MODE FLAG + 444 030040 000000 000000 KAIFLG: 0 ;PROCESSOR TYPE, 0 = KA10, -1 = KI10 + 445 030041 000000 000000 KLFLG: 0 ;PROCESSOR TYPE, 0 = KA/KI, -1 = KL10 + 446 030042 777777 777777 MONFLG: -1 ;DIAG MONITOR SPECIAL USER FLAG + 447 030043 000000 000000 MONCTL: 0 ;DIAG MON/SYS EXR FLAG + 448 030044 000000 000000 MONTEN: 0 ;-1= LOADED BY 10 + 449 030045 000000 000000 CLOCKF: 0 ;CLOCK TICKED FLAG + 450 030046 000000 000000 CONSW: 0 ;CONSOLE SWITCH SETTINGS + 451 030047 000000 000000 PASCNT: 0 ;PROGRAM PASS COUNT + 452 030050 000000 000000 RUNFLG: 0 ;PROGRAM RUN FLAG + 453 030051 000000 000000 TESTPC: 0 ;SUBTEST PC + 454 030052 000000 000000 ERRPC: 0 ;ERROR PC + 455 030053 000000 000000 ERRTLS: 0 ;ERROR TOTALS + 456 030054 000000 000000 TICKS: 0 ;PROGRAM RUNNING TIME + 457 030055 000000 000000 MARGIN: 0 ;KI10 MARGIN WORD VALUE + 458 030056 000000 000000 $ONETM: 0 ;SUBROUTINE INITIALIZATION FLAG +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 3 +FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0019 + + 459 S^;*********************************************************************^ + 460 ;*SPECIAL PROGRAM DISPATCH ADDRESSES + 461 S^;*********************************************************************^ + 462 + 463 030057 037 12 0 00 000004 BEGEND: ENDUUO ;END OF PASS + 464 030060 254 00 0 00 030010 $BEND1: JRST BEGIN1 ;KEEP RUNNING PROGRAM + 465 030061 037 16 0 00 000004 $BEND2: EOPUUO ;END OF PROGRAM - NO RETURN + 466 030062 254000 030674 CNTLC: SADR5 ;CONTROL C XFER ADDRESS + 467 030063 254000 030674 ALTMGO: SADR6 ;ALTMODE XFER ADDRESS + 468 030064 CPOPJ1: ;SKIP RETURN + 469 030064 350 00 0 17 000000 UUOSKP: AOS (P) ;SKIP RETURN FROM UUO + 470 030065 CPOPJ: ;NON-SKIP REGULAR RETURN + 471 030065 263 17 0 00 000000 UUOEXT: RTN ;UUO RETURN + 472 030066 255 00 0 00 000000 UUORTN: JFCL ;ADDITIONAL USERS UUO ROUTINE + 473 030067 255 00 0 00 000000 $UORTX: JFCL ;ADDITIONAL UUO LINKAGE + 474 030070 255 00 0 00 000000 $UUOER: JFCL ;INITED AS (JRST $UOERX) + 475 030071 255 00 0 00 000000 $ITRHL: JFCL ;ADDITIONAL INTERRUPT LINKAGE + 476 030072 255 00 0 00 000000 $ITRX1: JFCL ; " + 477 030073 255 00 0 00 000000 $USRHL: JFCL ; " + 478 030074 255 00 0 00 000000 $RSRTX: JFCL ;ADDITIONAL POWER FAIL LINKAGE + 479 030075 255 00 0 00 000000 $RSRTY: JFCL ; " + 480 030076 255 00 0 00 000000 RESRT1: JFCL ; INITED AS (JRST RESRTX) + 481 030077 255 00 0 00 000000 RESRT2: JFCL ; " + 482 030100 255 00 0 00 000000 $PARER: JFCL ;ADDITIONAL PARITY ERROR LINKAGE + 483 030101 255 00 0 00 000000 ERMORE: JFCL ;ADDITIONAL ERROR HANDLER LINKAGE + 484 030102 254 04 0 00 030102 HALT . ;IMPROPER TRANSFER HALT + 485 + 486 030103 000000 000000 $PSHER: 0 ;INITED AS (JRST PSHERR) + 487 030104 000000 000000 ITRCH1: 0 ;PC & FLAGS OF CURRENT INTERRUPT + 488 030105 000000 000000 0 ;INITED AS (JRST $ITRC1) + 489 + 490 S^;*********************************************************************^ + 491 ;*PROCESSOR CONTROL STORAGE + 492 S^;*********************************************************************^ + 493 + 494 030106 000000 000000 $ACC0: 0 ;INTERRUPT SAVED AC0 + 495 030107 000000 000000 $SVPI: 0 ;INTERRUPT SAVED PI + 496 030110 000000 000000 $SVAPR: 0 ;INTERRUPT SAVED APR + 497 030111 000000 000000 $SVPAG: 0 ;INTERRUPT SAVED PAG (DATAI) + 498 030112 000000 000000 $SPAG1: 0 ;INTERRUPT SAVED PAG (CONI) + 499 + 500 030113 000000 000000 $SVUUO: 0 ;CURRENT USERS UUO + 501 030114 000000 000000 $SVUPC: 0 ;PC OF CURRENT USERS UUO + 502 + 503 030115 000000 000000 REPTU: 0 ;REPEAT UUO ITERATIONS + 504 030116 000000 000000 SCOPE: 0 ;ERROR HANDLER SCOPE LOOP FLAG + 505 030117 000000 000000 %CORFLG:0 ; " CORRECT FLAG + 506 030120 000000 000000 %COREC: 0 ; " CORRECT DATA + 507 030121 000000 000000 %ACTFL: 0 ; " ACTUAL FLAG + 508 030122 000000 000000 %ACTUL: 0 ; " ACTUAL DATA + 509 030123 000000 000000 %DISCR: 0 ; " DISCREPENCY DATA +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 4 +FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0020 + + 510 S^;*********************************************************************^ + 511 ;*UUO DISPATCH TABLE + 512 S^;*********************************************************************^ + 513 XLIST + 514 LIST + 515 030124 030070 030070 UUODIS: LUUO1,,$UUOER + 516 030125 030070 030070 LUUO3,,LUUO2 + 517 030126 030070 030070 LUUO5,,LUUO4 + 518 030127 030070 030070 LUUO7,,LUUO6 + 519 030130 030070 030070 LUUO11,,LUUO10 + 520 030131 030070 030070 LUUO13,,LUUO12 + 521 030132 030070 030070 LUUO15,,LUUO14 + 522 030133 030070 030070 LUUO17,,LUUO16 + 523 030134 030070 030070 LUUO21,,LUUO20 + 524 030135 030070 030070 LUUO23,,LUUO22 + 525 030136 030070 030070 LUUO25,,LUUO24 + 526 030137 030070 030070 LUUO27,,LUUO26 + 527 030140 030070 030070 LUUO31,,LUUO30 + 528 030141 030070 030070 LUUO33,,LUUO32 + 529 + 530 S^;*********************************************************************^ + 531 ;*MEMORY MANAGMENT STORAGE + 532 S^;*********************************************************************^ + 533 + 534 030142 000000 000000 DF22F: 0 ;DF10 CONTROL FLAG, 0 = 18, -1 = 22 BIT + 535 030143 000000 000000 MAPNEW: 0 ;MEMORY MAPPING CONTROL FLAG, -1 = 4096K MAPPING + 536 030144 000000 000000 MEMTOT: 0 ;TOTAL MEMORY SIZE IN K (1024.) + 537 030145 000000 000000 MEMLOW: 0 ;LOWEST USABLE MEMORY + 538 030146 MEMSIZ: BLOCK ^D41 ;MEMORY SEGMENT POINTER TABLE + 539 + 540 S^;*********************************************************************^ + 541 ;*PRINT CONTROL STORAGE + 542 S^;*********************************************************************^ + 543 + 544 030217 000000 000000 PNTFLG: 0 ;PRINT FLAG, -1 WHILE IN PRINT ROUTINE + 545 030220 000000 000000 PNTENB: 0 ;PRINT ENABLE + 546 030221 000000 000000 PDISF: 0 ;PRINT DISABLED FLAG + 547 030222 000000 000000 PNTINH: 0 ;INHIBIT PRINT INPUT CHECKS + 548 030223 000000 000000 PNTSPC: 0 ;PRINT SPACE CONTROL + 549 030224 000000 000000 OPTIME: 0 ;TYPE-IN WAIT TIME + 550 030225 000000 000000 $TWCNT: 0 ;TIME WAITED + 551 030226 000000 000000 $DVOFF: 0 ;LOGICAL DEVICE INITED FLAG + 552 030227 000000 000000 TTYFIL: 0 ;TTY EXEC FILLERS FLAG + 553 030230 000000 000000 TTYSPD: 0 ;TTY EXEC BAUD RATE + 554 030231 000000 000000 $TTCHR: 0 ;ACTUAL TYPED IN CHAR + 555 030232 000000 000000 $CHRIN: 0 ;UPPER CASED & PARITY STRIPPED CHAR + 556 030233 000000 000000 $TYPNB: 0 ;TYPED IN NUMBER + 557 030234 000000 000000 $CRLF: 0 ;FREE CR/LF FLAG + 558 030235 000000 000000 $TABF: 0 ;TAB CONVERSION FLAG + 559 030236 000000 000000 $FFF: 0 ;FORM FEED CONVERSION FLAG + 560 030237 000000 000000 $VTF: 0 ;VERTICAL TAB CONVERSION FLAG + 561 030240 000000 000000 USRLFF: 0 ;USER LF FILLERS + 562 030241 000000 000000 USRCRF: 0 ;USER CR FILLERS +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 5 +FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0021 + + 563 S^;*********************************************************************^ + 564 ;*THE FOLLOWING MISCELLANEOUS PRINT CHARACTERS ARE INCLUDED + 565 ;*TO FACILITATE PRINTING AND ARE CALLED AS FOLLOWS: + 566 ;* MOVEI NAME + 567 ;* PNTA ;OR PNTAF + 568 S^;*********************************************************************^ + 569 + 570 030242 CRLF: ASCII/ + 571 030242 015 012 000 000 000 / + 572 030243 CRLF2: ASCII/ + 573 + 574 030243 015 012 015 012 000 / + 575 030244 054 000 000 000 000 COMMA: ASCII/,/ + 576 030245 056 000 000 000 000 PERIOD: ASCII/./ + 577 030246 040 000 000 000 000 SPACE: ASCII/ / + 578 030247 011 000 000 000 000 TAB: ASCII/ / + 579 030250 MINUS: + 580 030250 055 000 000 000 000 HYPEN: ASCII/-/ + 581 030251 053 000 000 000 000 PLUS: ASCII/+/ + 582 030252 052 000 000 000 000 AST: ASCII/*/ + 583 030253 100 000 000 000 000 ATSIN: ASCII/@/ + 584 030254 050 000 000 000 000 LFP: ASCII/(/ + 585 030255 051 000 000 000 000 RTP: ASCII/)/ + 586 030256 007 0000000000 BELL: BYTE (7) 007 + 587 030257 077 000 000 000 000 QUEST: ASCII/?/ + 588 030260 057 000 000 000 000 SLASH: ASCII!/! + 589 030261 044 000 000 000 000 DOLLAR: ASCII/$/ + 590 030262 000000 000012 RADIX: ^D10 ;DECIMAL PRINT RADIX + 591 030263 000000 000040 RADLSP: 40 ;DECIMAL PRINT LEADING CHAR + 592 030264 000000 000012 RADLSC: ^D10 ;DECIMAL PRINT LEADING CHAR COUNT + 593 + 594 S^;*********************************************************************^ + 595 ;*USER MODE OUTPUT FILE INFORMATION + 596 S^;*********************************************************************^ + 597 + 598 030265 $OBUF: BLOCK 3 ;LOGICAL FILE OUTPUT BUFFER HEADER + 599 030270 60 62 51 56 64 00 $OUTNM: SIXBIT /PRINT/ ;FILE NAME + 600 030271 60 56 64 00 00 00 $OUTEX: SIXBIT /PNT/ ;FILE NAME EXTENSION + 601 030272 BLOCK 2 + 602 + 603 S^;*********************************************************************^ + 604 ;*DISK UPDATE MODE FILE INFORMATION + 605 S^;*********************************************************************^ + 606 + 607 030274 $IBUF: BLOCK 3 + 608 030277 60 62 51 56 64 00 $INNM: SIXBIT /PRINT/ + 609 030300 60 56 64 00 00 00 $INEXT: SIXBIT /PNT/ + 610 030301 BLOCK 2 +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 6 +FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0022 + + 611 S^;*********************************************************************^ + 612 ;*PUSHDOWN LIST CONTROL INFORMATION + 613 S^;*********************************************************************^ + 614 + 615 030303 777577 030303 PLIST: PLIST-PLISTE,,PLIST + 616 030304 PLISTS: BLOCK 200 + 617 030504 000000 000000 PLISTE: 0 ;END OF PUSHDOWN LIST + 618 + 619 S^;*********************************************************************^ + 620 ;*POWER LINE CLOCK FREQUENCY FLAG + 621 S^;*********************************************************************^ + 622 + 623 030505 000000 000000 CYCL60: 0 ;0 = 60, -1 = 50 CYCLE + 624 + 625 S^;*********************************************************************^ + 626 ;*KL10 CACHE CONTROL FLAGS + 627 S^;*********************************************************************^ + 628 + 629 030506 000000 000000 CSHFLG: 0 ;ALLOW CACHE IF 0 + 630 030507 000000 000000 CSHMEM: 0 ;CACHE MEMORY SEGMENTS IF 0 + 631 + 632 S^;*********************************************************************^ + 633 ;*NUMBER INPUT DIGIT FLAG + 634 S^;*********************************************************************^ + 635 + 636 030510 000000 000000 TTNBRF: 0 ;-1 IF ANY DIGIT TYPED + 637 + 638 S^;*********************************************************************^ + 639 ;*KL10 & KI10 "INHPAG" SWITCH PAGING PREVENTION + 640 S^;*********************************************************************^ + 641 + 642 030511 000000 000000 PVPAGI: 0 ;IF NON-ZERO, OVERRIDE "INHPAG" SWITCH ACTION + 643 + 644 S^;*********************************************************************^ + 645 ;*ERROR REPORTING ROUTINE ADDITIONAL USERS CONTROL INSTRUCTIONS + 646 S^;*********************************************************************^ + 647 + 648 030512 000000 000000 %ERHI1: 0 ;IF NON-ZERO, XCT'D AT START OF %ERUUO + 649 030513 000000 000000 %ERHI2: 0 ;IF NON-ZERO, XCT'D AT END OF %ERUUO + 650 030514 000000 000000 %ERHI3: 0 ;IF NON-ZERO, XCT'D AFTER "PC" OF %ERUUO + 651 + 652 S^;*********************************************************************^ + 653 ;*SPECIAL USERS UUO INTERCEPT INSTRUCTION + 654 S^;*********************************************************************^ + 655 + 656 030515 000000 000000 $$UUO: 0 ;IF NON-ZERO, XCT'D AT START OF $UORTN +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 7 +FIXED KLM 19-Jul-77 16:36 *FIXED* FIXED CONTROL AND DISPATCH STORAGE, JULY 19,1977 SEQ 0023 + + 657 S^;*********************************************************************^ + 658 ;*USER MODE MONITOR TYPE FLAG + 659 S^;*********************************************************************^ + 660 + 661 030516 000000 000000 MONTYP: 0 ;0 = TOPS10, -1 = TOPS20 + 662 + 663 S^;*********************************************************************^ + 664 ;*SPECIAL USERS MUUO INTERCEPT INSTRUCTION + 665 S^;*********************************************************************^ + 666 + 667 030517 000000 000000 $$MUUO: 0 ;IF NON-ZERO, XCT'D AT START OF MUUOER + 668 + 669 S^;*********************************************************************^ + 670 ;*SPECIAL USERS USER MODE OUTPUT ERROR INTERCEPT INSTUCTION + 671 S^;*********************************************************************^ + 672 + 673 030520 000000 000000 $$OUTER:0 ;IF NON-ZERO, XCT'D AT END OF USER MODE ERROR + 674 + 675 S^;*********************************************************************^ + 676 ;*"SWITCH" CALL USAGE CONTROL + 677 S^;*********************************************************************^ + 678 + 679 030521 000000 000000 $$TOGGLE:0 ;IF NON-ZERO, USE C(CONSW) FOR SWITCHES + 680 + 681 S^;*********************************************************************^ + 682 ;*SPECIAL USERS ALTMODE SWITCH CALL INTERCEPT INSTRUCTIONS + 683 S^;*********************************************************************^ + 684 + 685 030522 000000 000000 $$TAX1: 0 ;IF NON-ZERO, XCT'D AT START OF ALTMODE SWITCH CALL + 686 030523 000000 000000 $$TAX2: 0 ;IF NON-ZERO, XCT'D AT END OF ALTMODE SWITCH CALL + 687 + 688 S^;*********************************************************************^ + 689 ;*SM10 (KS-10) PROCESSOR TYPE FLAG + 690 S^;*********************************************************************^ + 691 + 692 030524 000000 000000 SM10: 0 ;IF -1 THIS IS A KS-10 + 693 + 694 S^;*********************************************************************^ + 695 ;*RIGHT HALF SWITCHES PROMPT TABLE ADDRESS + 696 S^;*********************************************************************^ + 697 + 698 030525 000000 000000 SWPTAB: 0 ;0 = NO PROMPT, ADR = ADR OF SIXBIT PROMPT TABLE + 699 + 700 S^;*********************************************************************^ + 701 ;*SPECIAL FUTURE EXPANSION ROOM + 702 S^;*********************************************************************^ + 703 + 704 S^;*********************************************************************^ + 705 ;*END OF FIXED STORAGE + 706 S^;*********************************************************************^ + 707 + 708 030577 LOC 30577 + 709 030577 000000 000000 ENDFIX: 0 ;END OF FIXED STORAGE +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 1 +SPCCPU KLM 24-Oct-78 08:57 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0024 + + 710 SUBTTL *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 + 711 + 712 ;NEW DEFINITIONS USED BY THE KL10 SUBROUTINE PACKAGE + 713 + 714 000000 AC0= 0 + 715 030000 DIAGNOS=30000 ;PDP-10 DIAGNOSTIC START ADDRESS + 716 010000 DDT= 10000 ;PDP-10 DDT START ADDRESS + 717 020000 DIAMON= 20000 ;PDP-10 DIAMON LOADER START ADDRESS + 718 020000 DONG11= 1B22 ;11 DOORBELL (FROM THE 10) + 719 + 720 ;DTE20 DEVICE CODES + 721 + 722 000200 DTE== 200 ;DTE0 + 723 000204 DTE0== 204 + 724 000204 DTE1== 204 + 725 000210 DTE2== 210 + 726 000214 DTE3== 214 + 727 + 728 ;KL10 EPT COMMUNICATION AREA + 729 + 730 000440 $STD= 440 ;PDP-10 DIAGNOSTIC START ADDRESS + 731 000441 $DDT= 441 ;PDP-10 DDT START ADDRESS + 732 000442 $STL= 442 ;PDP-10 LOADER START ADDRESS + 733 000443 $STM= 443 ;PDP-10 MONITOR START ADDRESS + 734 + 735 000444 $DTFLG= 444 ;DTE20 OPERATION COMPLETE FLAG + 736 000445 $DTCLK= 445 ;DTE20 CLOCK INTERRUPT FLAG + 737 000446 $DTCI= 446 ;DTE20 CLOCK INTERRUPT INSTRUCTION + 738 000447 $DTT11= 447 ;DTE20 10 TO 11 ARGUMENT + 739 000450 $DTF11= 450 ;DTE20 11 TO 10 ARGUMENT + 740 000451 $DTCMD= 451 ;DTE20 TO 11 COMMAND WORD + 741 000452 $DTSEQ= 452 ;DTE20 OPERATION SEQUENCE NUMBER + 742 000453 $DTOPR= 453 ;DTE20 OPERATIONAL DTE # + 743 000454 $DTCHR= 454 ;DTE20 LAST TYPED CHARACTER + 744 000455 $DTMTD= 455 ;DTE20 MONITOR TTY OUTPUT COMPLETE FLAG + 745 000456 $DTMTI= 456 ;DTE20 MONITOR TTY INPUT FLAG + 746 + 747 000457 $DTSWR= 457 ;DTE20 CONSOLE SWITCH REGISTER +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 2 +SPCCPU KLM 24-Oct-78 08:57 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0025 + + 748 ;SPECIAL "FIXED" REASSIGNMENTS + 749 + 750 030600 $$LOC=. ;SAVE CURRENT LOCATION + 751 + 752 030000 LOC 30000 + 753 030000 254 00 0 00 030600 $$BEGIN:JRST $$START ;SETUP SPECIAL START + 754 030001 254 00 0 00 030600 JRST $$START ;"DIAMON" CHAIN START ADDRESS + 755 + 756 000440 LOC 440 + 757 000440 254 00 0 00 030000 $STD: JRST BEGIN ;SETUP FOR "STD" + 758 000443 LOC 443 + 759 000443 254 00 0 00 030626 $STM: JRST $SPEC ;SIMPLE RUN CONTROL + 760 + 761 030057 LOC 30057 + 762 030057 254 00 0 00 030631 $BEGEND:JRST $SPBEND ;SETUP SPECIAL "BEGEND" + 763 + 764 ;SPECIAL MUUO, TRAP & PAGE FAIL SETUP + 765 + 766 000420 LOC 420 + 767 000420 254 04 0 00 000420 $$420: HALT . ;KI10 PAGE FAIL + 768 000421 255 00 0 00 000000 $$421: JFCL ;OVERFLOW + 769 000422 254 04 0 00 000422 $$422: HALT . ;PUSHDOWN OVERFLOW + 770 000423 254 04 0 00 000423 $$423: HALT . ;TRAP 3 + 771 000424 000000 000000 $$424: 0 ;MMUO + 772 000425 000000 000000 $$425: 0 ;MMUO PC + 773 000426 000000 000000 $$426: 0 ;KI10-PAGE FAIL, KL10-PROCESS CONTEXT + 774 000427 254 04 0 00 000427 $$427: HALT . + 775 000430 000000 000427 $$430: 427 ;MMUO NEW PC'S + 776 000431 000000 000427 $$431: 427 + 777 000432 000000 000427 $$432: 427 + 778 000433 000000 000427 $$433: 427 + 779 000434 000000 000427 $$434: 427 + 780 000435 000000 000427 $$435: 427 + 781 000436 000000 000427 $$436: 427 + 782 000437 000000 000427 $$437: 427 + 783 + 784 000500 LOC 500 + 785 000500 000000 000000 $$500: 0 ;KL10 PAGE FAIL WORD + 786 000501 000000 000000 $$501: 0 ;KL10 PAGE FAIL PC + 787 000502 000000 000503 $$502: 503 ;KL10 PAGE FAIL NEW PC + 788 000503 254 04 0 00 000503 $$503: HALT . +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 3 +SPCCPU KLM 24-Oct-78 08:57 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0026 + + 789 030600 LOC $$LOC ;RESET CURRENT LOCATION + 790 + 791 ;SPECIAL STARTUP SEQUENCE + 792 + 793 030600 402 00 0 00 030037 $$START:SETZM USER + 794 030601 265 00 0 00 030602 JSP 0,.+1 ;IN USER MODE ? + 795 030602 603 00 0 00 010000 TLNE 0,USERF + 796 030603 476 00 0 00 030037 SETOM USER ;YES, SET CONTROL WORD + 797 030604 336 00 0 00 030042 SKIPN MONFLG ;SPECIAL USER MODE ? + 798 030605 402 00 0 00 030037 SETZM USER ;YES, RUN AS EXEC + 799 030606 332 00 0 00 030037 SKIPE USER + 800 030607 254 00 0 00 030674 JRST START ;USER MODE, DON'T NEED CPU TYPE + 801 + 802 030610 336 00 0 00 030044 $STKIL: SKIPN MONTEN ;LOADED BY "DIAMON" ? + 803 030611 476 00 0 00 030024 SETOM ITRCNT ;NO, RUN FOREVER + 804 030612 402 00 0 00 030041 SETZM KLFLG ;ASSUME KI10 + 805 030613 200 01 0 00 033460 MOVE 1,[1,,1] + 806 030614 251 01 0 00 000001 BLT 1,1 ;HOPE THIS WORKS + 807 030615 316 01 0 00 033460 CAMN 1,[1,,1] ;IF AC NE 1,,1 AFTER BLT, KL10 + 808 030616 254 00 0 00 030674 JRST START ;KI10, NO ADDITIONAL SETUP + 809 + 810 030617 402 00 0 00 000444 $STKL: SETZM $DTFLG + 811 030620 402 00 0 00 000445 SETZM $DTCLK + 812 030621 200 00 0 00 000453 MOVE $DTOPR ;GET DTE # + 813 030622 436 00 0 00 030657 ORM $$DTE0 ;INSERT IN DTE I/O INSTS + 814 030623 436 00 0 00 030670 ORM $$DTE2 + 815 030624 476 00 0 00 030041 SETOM KLFLG ;SET KL10 CONTROL FLAG + 816 030625 254 00 0 00 030674 JRST START + 817 + 818 030626 200 00 0 00 033461 $SPEC: MOVE [JRST STARTA] ;SIMPLE RUN CONTROL + 819 030627 202 00 0 00 030633 MOVEM $SPB1 + 820 030630 254 00 0 00 030674 JRST START +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 4 +SPCCPU KLM 24-Oct-78 08:57 *SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76 SEQ 0027 + + 821 ;SPECIAL "BEGEND" ROUTINE + 822 + 823 030631 350 00 0 00 030047 $SPBEND:AOS PASCNT ;INCREMENT PASS COUNT + 824 030632 370 00 0 00 030024 SOS ITRCNT ;DECREMENT ITERATION COUNT + 825 030633 336 00 0 00 030037 $SPB1: SKIPN USER + 826 030634 254 00 0 00 030642 JRST $SPBEX ;EXEC MODE + 827 + 828 030635 332 00 0 00 030024 $SPBUS: SKIPE ITRCNT ;USER MODE, COMPLETED ? + 829 030636 254 00 0 00 030723 JRST STARTA ;NO, KEEP RUNNING + 830 030637 336 00 0 00 030044 SKIPN MONTEN ;DONE, LOADED BY "DIAMON" ? + 831 030640 047 00 0 00 000012 EXIT ;NO, RETURN TO MONITOR + 832 030641 254 00 1 00 030012 JRST @RETURN ;YES, RETURN TO "DIAMON" + 833 + 834 030642 332 00 0 00 030041 $SPBEX: SKIPE KLFLG + 835 030643 254 00 0 00 030650 JRST $SPBKL ;KL10 & EXEC + 836 030644 7 004 14 0 00 030024 DATAO PI,ITRCNT ;KI10 & EXEC, DISPLAY ITER COUNT + 837 030645 332 00 0 00 030024 SKIPE ITRCNT + 838 030646 254 00 0 00 030723 JRST STARTA ;NOT COMPLETED YET + 839 030647 254 00 1 00 030012 JRST @RETURN ;DONE + 840 + 841 030650 336 00 0 00 030024 $SPBKL: SKIPN ITRCNT + 842 030651 254 00 0 00 030663 JRST $SPKLD ;KL10, EXEC & COMPLETED + 843 + 844 030652 335 00 0 00 030043 SKIPGE MONCTL + 845 030653 254 00 0 00 030723 JRST STARTA ;"DIAMON" CONTROL + 846 030654 201 00 0 00 000404 MOVEI 0,404 ;NOTIFY PDP-11 OF END OF PASS + 847 030655 202 00 0 00 000451 MOVEM 0,$DTCMD + 848 030656 402 00 0 00 000444 SETZM $DTFLG + 849 030657 7 200 20 0 00 020000 $$DTE0: CONO DTE,DONG11 + 850 030660 336 00 0 00 000444 SKIPN $DTFLG ;WAIT TILL 11 RESPONDS + 851 030661 254 00 0 00 030660 JRST .-1 + 852 030662 254 00 0 00 030723 JRST STARTA ;KEEP RUNNING + 853 + 854 ;SPECIAL KL10 COMPLETED ROUTINE + 855 + 856 030663 332 00 0 00 030044 $SPKLD: SKIPE MONTEN + 857 030664 254 00 1 00 030012 JRST @RETURN ;LOADED BY "DIAMON" + 858 + 859 030665 201 00 0 00 000403 MOVEI 0,403 ;NOTIFY PDP-11 OF COMPLETION + 860 030666 202 00 0 00 000451 MOVEM 0,$DTCMD + 861 030667 402 00 0 00 000444 SETZM $DTFLG + 862 030670 7 200 20 0 00 020000 $$DTE2: CONO DTE,DONG11 + 863 030671 336 00 0 00 000444 SKIPN $DTFLG ;SHOULD NEVER HAPPEN + 864 030672 254 00 0 00 030671 JRST .-1 ;11 NEVER RETURNS ON END OF PROGRAM + 865 030673 254 04 0 00 030000 HALT BEGIN ;IF IT DOES, HALT. +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 1 +DAKAEM MAC 28-Dec-78 13:35 DIAGNOSTIC SECTION SEQ 0028 + + 866 SUBTTL DIAGNOSTIC SECTION + 867 + 868 030674 402 00 0 00 030037 START: SETZM USER# ;CLEAR USER CONTROL WORD + 869 030675 265 00 0 00 030676 JSP 0,.+1 ;GET FLAGS + 870 030676 603 00 0 00 010000 TLNE USERF ;IN USER MODE? + 871 030677 476 00 0 00 030037 SETOM USER ;YES, SET USER CONTROL WORD + 872 030700 336 00 0 00 030042 SKIPN MONFLG ;SPECIAL USER MODE? + 873 030701 402 00 0 00 030037 SETZM USER ;YES, CLEAR USER CONTROL WORD + 874 030702 336 00 0 00 030037 SKIPN USER + 875 030703 254 00 0 00 030723 JRST STARTA + 876 030704 331 00 0 00 030043 SKIPL MONCTL + 877 030705 051 03 0 00 030707 TTCALL 3,PGMNAM ;MENTION OUR NAME + 878 030706 254 00 0 00 030723 JRST STARTA + 879 + 880 030707 PGMNAM: ASCIZ/ + 881 030707 015 012 120 104 120 PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) [DAKAE] + 882 030710 055 061 060 040 113 + 883 030711 101 061 060 040 102 + 884 030712 101 123 111 103 040 + 885 030713 111 116 123 124 122 + 886 030714 125 103 124 111 117 + 887 030715 116 040 104 111 101 + 888 030716 107 116 117 123 124 + 889 030717 111 103 040 050 065 + 890 030720 051 040 133 104 101 + 891 030721 113 101 105 135 015 + 892 030722 012 000 000 000 000 / + 893 + 894 + 895 ;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF + 896 ;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES + 897 ;IN THE FIELD. + 898 + 899 030723 254 00 0 00 030724 STARTA: JRST .+1 +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 2 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JSR INSTRUCTION SEQ 0029 + + 900 SUBTTL TEST OF JSR INSTRUCTION + 901 + 902 ;********** + 903 + 904 ;THIS TEST VERIFIES THAT JSR STORES THE FLAGS AND PC IN LOCATION E. + 905 ;IN THIS CASE, E IS CLEARED, CRY0 IS SET AND JSR IS EXECUTED. + 906 ;NEXT, E IS CHECKED FOR ITS CONTENTS NON-ZERO. IF C(E) IS NON-ZERO, + 907 ;THIS TEST PASSES. + 908 + 909 030724 C23000: SFLAG CRY0 ^;SET CRY0 FLAG + 910 + 911 030724 205 01 0 00 200000 MOVSI 1,CRY0 + 912 030725 255 17 0 00 030726 JFCL 17,.+1 ;RESET ALL FLAGS + 913 030726 254 02 0 01 030727 JRST 2,.+1(1) ;SET CRY0 FLAG + 914 030727 402 00 0 00 030731 SETZM .+2 ;PRELOAD E WITH 0 + 915 030730 264 00 0 00 030731 JSR .+1 ;*JSR SHOULD PLACE FLAGS AND PC INTO AC + 916 030731 000000 000000 0 ;E: PRESET TO 0, SHOULD RECEIVE FLAGS AND PC FROM JSR + 917 030732 336 00 0 00 030731 SKIPN .-1 ;PASS IF C(E) IS NON-ZERO. + 918 STOP^ + 919 030733 254 04 0 00 030734 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 920 030734 324 00 0 00 030735 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 921 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 922 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 923 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 924 + 925 ;********** + 926 + 927 ;THIS TEST VERIFIES THAT JSR IGNORES THE AC FIELD; + 928 ;HENCE, IT DOES NOT MODIFY THE SPECIFIED AC. + 929 ;IN THIS CASE, CRY0 IS SET. THE AC IS PRELOADED WITH -1,,-1 AND JSR IS EXECUTED. + 930 ;THE AC IS THEN CHECKED. IF C(AC)=-1,,-1, THIS TEST PASSES. + 931 + 932 030735 C23100: SFLAG CRY0 ^;SET CRY0 + 933 + 934 030735 205 01 0 00 200000 MOVSI 1,CRY0 + 935 030736 255 17 0 00 030737 JFCL 17,.+1 ;RESET ALL FLAGS + 936 030737 254 02 0 01 030740 JRST 2,.+1(1) ;SET CRY0 FLAG + 937 030740 474 01 0 00 000000 SETO 1, ;PRELOAD AC WITH -1,,-1 + 938 030741 264 01 0 00 030742 JSR 1,.+1 ;*JSR SHOULD NOT MODIFY THE AC + 939 030742 000000 000000 0 ;STORE PC + FLAGS HERE + 940 030743 312 01 0 00 033462 CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 + 941 STOP^ + 942 030744 254 04 0 00 030745 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 943 030745 324 00 0 00 030746 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 944 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 945 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 946 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 947 + 948 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 3 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JSR INSTRUCTION SEQ 0030 + + 949 ;THIS TEST VERIFIES THAT JSR STORES THE FLAGS IN E-LEFT HALF. + 950 ;IN THIS TEST, CRY0 IS SET, E IS CLEARED AND JSR IS EXECUTED. + 951 ;NEXT, C(E-LEFT) ARE PLACED INTO AC0 AND AC0 IS CHECKED FOR ITS CONTENTS NON-ZERO. + 952 ;IF C(AC0) ARE NON-ZERO, THIS TEST PASSES. + 953 + 954 030746 C23200: SFLAG CRY0 ^;SET CRY0 + 955 + 956 030746 205 01 0 00 200000 MOVSI 1,CRY0 + 957 030747 255 17 0 00 030750 JFCL 17,.+1 ;RESET ALL FLAGS + 958 030750 254 02 0 01 030751 JRST 2,.+1(1) ;SET CRY0 FLAG + 959 030751 402 00 0 00 030753 SETZM .+2 ;CLEAR E + 960 030752 264 00 0 00 030753 JSR .+1 ;*JSR SHOULD STORE FLAGS IN E + 961 030753 000000 000000 0 ;STORE FLAGS HERE (CRY0 MAKES THIS A MOVE INST) + 962 030754 510 00 0 00 030753 HLLZ .-1 ;PUT FLAGS INTO AC0 + 963 030755 336 00 0 00 000000 SKIPN ;PASS IF C(AC0) NON-ZERO + 964 STOP^ + 965 030756 254 04 0 00 030757 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 966 030757 324 00 0 00 030760 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 967 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 968 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 969 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 970 + 971 ;********** + 972 + 973 ;THIS TEST VERIFIES THAT JSR TRANSFERS CONTROL TO E+1. + 974 ;IN THIS CASE, CRY0 IS SET AND E AND AC0 CLEARED; THEN, JSR IS EXECUTED. + 975 ;IF JSR RESUMES CONTROL AT E INSTEAD OF E+1, AC0 WILL BE MODIFIED; + 976 ;HENCE, THE TEST WILL FAIL WHEN AC0 IS CHECKED FOR 0 BECAUSE + 977 ;C(E) IS DECODED AS A MOVE INSTRUCTION. + 978 + 979 030760 C23300: SFLAG CRY0 ^;SET CRY0 + 980 + 981 030760 205 01 0 00 200000 MOVSI 1,CRY0 + 982 030761 255 17 0 00 030762 JFCL 17,.+1 ;RESET ALL FLAGS + 983 030762 254 02 0 01 030763 JRST 2,.+1(1) ;SET CRY0 FLAG + 984 030763 403 00 0 00 030765 SETZB .+2 ;CLEAR AC0 AND E + 985 030764 264 00 0 00 030765 JSR .+1 ;*JSR SHOULD RESUME CONTROL AT E+1 + 986 030765 000000 000000 0 ;STORE FLAGS HERE (CRY0 MAKES THIS A MOVE INST) + 987 030766 332 00 0 00 000000 SKIPE 0 ;PASS IF C(AC0)=0 + 988 STOP^ + 989 030767 254 04 0 00 030770 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 990 030770 324 00 0 00 030771 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 991 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 992 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 993 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 994 + 995 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 4 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JSR INSTRUCTION SEQ 0031 + + 996 ;THIS TEST VERIFIES THAT JSR JUMPS TO E+1 + 997 ;IN THIS CASE, AC0 IS CLEARED AND CRY0 IS SET; THEN, JSR .+2 IS EXECUTED. + 998 ;IF JSR DID NOT JUMP, ONES ARE LOADED WITH AC0; AND THE TEST FAILS. + 999 ;OTHERWISE, AC0 REMAINS CLEAR AND THE TEST PASSES + 1000 + 1001 030771 C23400: SFLAG CRY0 ^;SET CRY0 + 1002 + 1003 030771 205 01 0 00 200000 MOVSI 1,CRY0 + 1004 030772 255 17 0 00 030773 JFCL 17,.+1 ;RESET ALL FLAGS + 1005 030773 254 02 0 01 030774 JRST 2,.+1(1) ;SET CRY0 FLAG + 1006 030774 400 00 0 00 000000 SETZ ;CLEAR AC0 + 1007 030775 264 00 0 00 030777 JSR .+2 ;*JSR SHOULD JUMP + 1008 030776 474 00 0 00 000000 SETO ;LOAD AC0 WITH ONES IF JSR FAILED TO JUMP + 1009 030777 000000 000000 0 ;STORE FLAGS HERE + 1010 031000 332 00 0 00 000000 SKIPE ;PASS IF JSR JUMPED CORRECTLY + 1011 STOP^ + 1012 031001 254 04 0 00 031002 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1013 031002 324 00 0 00 031003 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1014 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1015 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1016 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1017 + 1018 ;********** + 1019 + 1020 ;THIS TEST VERIFIES THAT JSR STORES THE PC IN E - RIGHT HALF. THE PC + 1021 ;IS ONE GREATER THAN THE LOCATION OF THE JSR INSTRUCTION. + 1022 ;THIS TEST WILL FAIL IF JSR STORES E INSTEAD OF PC IN E - RIGHT HALF. + 1023 ;IN CASE OF FAILURE, AR PC EN AT ET2 WAS FAULTY. + 1024 + 1025 031003 C23500: SFLAG 0 ^;CLEAR ALL FLAGS + 1026 + 1027 031003 205 01 0 00 000000 MOVSI 1,0 + 1028 031004 255 17 0 00 031005 JFCL 17,.+1 ;RESET ALL FLAGS + 1029 031005 254 02 0 01 031006 JRST 2,.+1(1) ;SET 0 FLAG + 1030 031006 264 00 0 00 031010 JSR .+2 ;*JSR SHOULD STORE PC+1 IN E - RIGHT + 1031 031007 254 04 0 00 031007 HALT . ;JSR SHOULD SKIP OVER THIS HALT + 1032 031010 000000 000000 0 ;STORE FLAGS AND PC HERE + 1033 031011 550 00 0 00 031010 HRRZ .-1 ;PUT STORED CONTENTS OF E - RIGHT INTO AC0 + 1034 031012 306 00 0 00 031010 CAIN .-2 ;FAIL IF C(AC0)=E + 1035 STOP^ + 1036 031013 254 04 0 00 031014 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1037 031014 324 00 0 00 031015 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1038 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1039 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1040 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1041 + 1042 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 5 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JSR INSTRUCTION SEQ 0032 + + 1043 ;THIS TEST VERIFIES THAT JSR STORES THE PC IN E - RIGHT HALF. THE PC + 1044 ;IS ONE GREATER THAN THE LOCATION OF THE JSR INSTRUCTION. + 1045 ;THIS TEST WILL PASS IF JSR STORES PC IN E - RIGHT HALF. + 1046 + 1047 031015 264 00 0 00 031017 C23600: JSR .+2 ;*JSR SHOULD STORE PC+1 IN E - RIGHT + 1048 031016 254 04 0 00 031016 HALT . ;JSR SHOULD SKIP OVER THIS HALT + 1049 031017 000000 000000 0 ;STORE FLAGS AND PC HERE + 1050 031020 550 00 0 00 031017 HRRZ .-1 ;PUT STORED CONTENTS OF E - RIGHT INTO AC0 + 1051 031021 302 00 0 00 031016 CAIE C23600+1 ;PASS IF C(AC0)=C23600+1 [PC] + 1052 STOP^ + 1053 031022 254 04 0 00 031023 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1054 031023 324 00 0 00 031024 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1055 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1056 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1057 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1058 + 1059 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 6 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0033 + + 1060 SUBTTL TEST OF JSA INSTRUCTION + 1061 + 1062 ;********** + 1063 + 1064 ;THIS TEST VERIFIES THAT JSA JUMPS TO LOCATION E+1. + 1065 ;IN THIS TEST, AC1 IS CLEARED AND A CAM 0,0 IS LOADED + 1066 ;INTO THE AC OF THE JSA INSTRUCTION. + 1067 ;IF JSA DOES NOT JUMP, AC1 WILL BE LOADED WITH ONES. AC1 IS CHECKED FOR ZEROS. + 1068 ;IF C(AC1)=0, THE TEST PASSES; OTHERWISE, THIS TEST FAILS BECAUSE JSA DID NOT JUMP. + 1069 + 1070 031024 400 01 0 00 000000 C23700: SETZ 1, ;CLEAR AC1 + 1071 031025 200 00 0 00 033463 MOVE [CAM] ;LOAD CAM INTO AC0 + 1072 031026 266 00 0 00 031030 JSA .+2 ;*JSA SHOULD JUMP TO E+1 + 1073 031027 474 00 0 00 000001 SETO 1 ;JSA SHOULD JUMP OVER THIS INSTRUCTION + 1074 031030 000000 000000 0 ;PASS IF JSA JUMPED + 1075 031031 332 00 0 00 000001 SKIPE 1 + 1076 STOP^ + 1077 031032 254 04 0 00 031033 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1078 031033 324 00 0 00 031034 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1079 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1080 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1081 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1082 + 1083 ;********** + 1084 + 1085 ;THIS TEST VERIFIES THAT JSA JUMPS TO LOCATION E+1. + 1086 ;IN THIS TEST, AC1 IS CLEARED AND A MOVEI 1,1234 IS LOADED + 1087 ;INTO THE AC OF THE JSA INSTRUCTION. + 1088 ;IF JSA DOES NOT JUMP, AC1 WILL BE LOADED WITH 0,,1234. AC1 IS CHECKED FOR ZEROS. + 1089 ;IF C(AC1)=0, THE TEST PASSES; OTHERWISE, THIS TEST FAILS BECAUSE JSA DID NOT JUMP. + 1090 + 1091 031034 400 01 0 00 000000 C24000: SETZ 1, ;CLEAR AC1 + 1092 031035 200 00 0 00 033464 MOVE [MOVEI 1,1234] ;LOAD MOVEI 1,1234 INTO AC + 1093 031036 266 00 0 00 031037 JSA .+1 ;*JSA SHOULD JUMP TO E+1 + 1094 031037 000000 000000 0 ;JSA SHOULD JUMP OVER THIS LOCATION + 1095 031040 306 01 0 00 001234 CAIN 1,1234 ;FAIL IF JSA DID NOT JUMP OVER PREVIOUS INSTRUCTION + 1096 STOP^ + 1097 031041 254 04 0 00 031042 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1098 031042 324 00 0 00 031043 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1099 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1100 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1101 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1102 + 1103 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 7 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0034 + + 1104 ;THIS TEST VERIFIES THAT JSA LOADS PC OF LOC OF JSA+1 INTO AC RIGHT. + 1105 ;THIS TEST WILL FAIL IF JSA LOADS E INTO AC RIGHT INSTEAD OF PC. + 1106 + 1107 031043 266 00 0 00 031045 C24100: JSA .+2 ;*JSA SHOULD LOAD PC INTO AC RIGHT + 1108 031044 254 04 0 00 031044 HALT . ;JSA SHOULD JUMP OVER THIS LOCATION + 1109 031045 000000 000000 0 ;JSA SHOULD JUMP OVER THIS LOCATION + 1110 031046 552 00 0 00 000001 HRRZM 1 ;PUT C(AC-RIGHT) INTO AC1 + 1111 031047 306 01 0 00 031045 CAIN 1,.-2 ;FAIL IF E WAS LOADED INTO AC-RIGHT INSTEAD OF PC + 1112 STOP^ + 1113 031050 254 04 0 00 031051 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1114 031051 324 00 0 00 031052 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1115 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1116 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1117 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1118 + 1119 ;********** + 1120 + 1121 ;THIS TEST VERIFIES THAT JSA PLACES C(AC) INTO E + 1122 ;THIS TEST WILL FAIL IF EITHER 0,,E OR 0,,PC IS LOADED + 1123 ;INTO E INSTEAD OF C(AC) + 1124 + 1125 031052 403 00 0 00 031054 C24200: SETZB .+2 ;CLEAR AC,E + 1126 031053 266 00 0 00 031054 JSA .+1 ;*JSA SHOULD LOAD C(AC) [ZEROS] INTO E + 1127 031054 000000 000000 0 ;JSA SHOULD PLACE ZEROS HERE + 1128 031055 200 01 0 00 031054 MOVE 1,.-1 ;SAVE C(AC) + 1129 031056 306 01 0 00 031054 CAIN 1,.-2 ;FAIL IF JSA LOADED 0,,E OR 0,,PC INTO E + 1130 STOP^ + 1131 031057 254 04 0 00 031060 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1132 031060 324 00 0 00 031061 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1133 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1134 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1135 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1136 + 1137 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 8 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0035 + + 1138 ;THIS TEST VERIFIES THAT JSA PLACES PC INTO AC-RIGHT + 1139 ;THIS TEST WILL FAIL IF PC IS NOT LOADED INTO AC-RIGHT + 1140 + 1141 031061 201 00 0 00 777777 C24300: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 1142 031062 266 00 0 00 031063 JSA .+1 ;*JSA SHOULD PLACE E,,PC INTO THE AC + 1143 031063 000000 000000 0 ;JSA SHOULD PLACE C(AC) HERE + 1144 031064 606 00 0 00 777777 TRNN -1 ;FAIL IF AR LT AR RT EN FAILED + 1145 STOP^ + 1146 031065 254 04 0 00 031066 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1147 031066 324 00 0 00 031067 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1148 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1149 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1150 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1151 + 1152 ;********** + 1153 + 1154 ;THIS TEST VERIFIES THAT JSA PLACES THE PC OF THE LOCATION OF JSA+1 IN AC-RIGHT + 1155 ;THIS TEST FAILS IF A PC WAS NOT LOADED INTO AC RIGHT + 1156 + 1157 031067 400 00 0 00 000000 C24400: SETZ ;CLEAR AC + 1158 031070 266 00 0 00 031071 JSA .+1 ;*JSA SHOULD LOAD PC INTO AC - RIGHT + 1159 031071 000000 000000 0 ;JSA SHOULD PLACE C(AC) HERE + 1160 031072 606 00 0 00 777777 TRNN -1 ;PASS IF AC - RIGHT IS NON-ZERO + 1161 STOP^ + 1162 031073 254 04 0 00 031074 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1163 031074 324 00 0 00 031075 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1164 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1165 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1166 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1167 + 1168 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 9 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0036 + + 1169 ;THIS TEST VERIFIES THAT JSA PLACES IN AC-LEFT + 1170 ;THIS TEST FAILS IF JSA LOADS PC INSTEAD OF E INTO AC-LEFT + 1171 + 1172 031075 266 00 0 00 031077 C24500: JSA .+2 ;*JSA SHOULD LOAD E INTO AC-LEFT + 1173 031076 254 04 0 00 031076 HALT . ;JSA SHOULD JUMP OVER THIS INSTRUCTION + 1174 031077 000000 000000 0 ;E: + 1175 031100 556 00 0 00 000001 HLRZM 1 ;SAVE C(AC - LEFT) + 1176 031101 306 01 0 00 031076 CAIN 1,.-3 ;FAIL IF JSA LOADED PC INSTEAD OF E INTO AC-LEFT + 1177 STOP^ + 1178 031102 254 04 0 00 031103 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1179 031103 324 00 0 00 031104 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1180 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1181 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1182 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1183 + 1184 ;********** + 1185 + 1186 ;THIS TEST VERIFIES THAT JSA LOADS E,,PC INTO THE AC + 1187 ;FIRST, THE AC IS PRELOADED WITH -1,,-1; THEN, JSA IS EXECUTED. + 1188 ;THE AC IS CHECKED FOR E,,PC. IF C(AC)=E,,PC, THIS TEST PASSES + 1189 + 1190 031104 474 00 0 00 000000 C24600: SETO ;PRELOAD AC WITH -1,,-1 + 1191 031105 266 00 0 00 031107 JSA .+2 ;*JSA SHOULD PLACE E,,PC INTO THE AC + 1192 031106 254 04 0 00 031106 HALT . ;JSA SHOULD JUMP OVER HERE, PC: + 1193 031107 000000 000000 0 ;JSA SHOULD STORE C(AC) HERE, E: + 1194 031110 312 00 0 00 033465 CAME [XWD .-1,.-2] ;PASS IF C(AC)=E,,PC + 1195 STOP^ + 1196 031111 254 04 0 00 031112 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1197 031112 324 00 0 00 031113 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1198 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1199 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1200 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1201 + 1202 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 10 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0037 + + 1203 ;THIS TEST VERIFIES THAT JSA LOADS E,,PC INTO THE AC + 1204 ;FIRST, THE AC IS PRELOADED WITH 0 JSA IS EXECUTED. + 1205 ;THE AC IS CHECKED FOR E,,PC. IF C(AC)=E,,PC, THIS TEST PASSES + 1206 + 1207 031113 400 00 0 00 000000 C24700: SETZ ;PRELOAD AC WITH 0 + 1208 031114 266 00 0 00 031116 JSA .+2 ;*JSA SHOULD PLACE E,,PC INTO THE AC + 1209 031115 254 04 0 00 031115 HALT . ;JSA SHOULD JUMP OVER HERE, PC: + 1210 031116 000000 000000 0 ;JSA SHOULD STORE C(AC) HERE, E: + 1211 031117 312 00 0 00 033466 CAME [XWD .-1,.-2] ;PASS IF C(AC)=E,,PC + 1212 STOP^ + 1213 031120 254 04 0 00 031121 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1214 031121 324 00 0 00 031122 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1215 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1216 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1217 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1218 + 1219 ;********** + 1220 + 1221 ;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. + 1222 ;AC IS FIRST CLEARED AND E IS PRELOADED WITH ONES; + 1223 ;THEN JSA IS EXECUTED. E IS CHECKED FOR ZEROS. IF C(E)=0, + 1224 ;THIS TEST PASSES. + 1225 + 1226 031122 400 00 0 00 000000 C25000: SETZ ;CLEAR AC + 1227 031123 476 00 0 00 031125 SETOM .+2 ;PRELOAD E WITH -1,,-1 + 1228 031124 266 00 0 00 031125 JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E + 1229 031125 000000 000000 0 ;E: SHOULD GET C(AC) FROM JSA + 1230 031126 332 00 0 00 031125 SKIPE .-1 ;PASS IF C(E)=0 + 1231 STOP^ + 1232 031127 254 04 0 00 031130 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1233 031130 324 00 0 00 031131 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1234 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1235 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1236 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1237 + 1238 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 11 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0038 + + 1239 ;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. + 1240 ;AC IS FIRST PRELOADED WITH -1,,-1 AND E IS CLEARED; + 1241 ;THEN, JSA IS EXECUTED. E IS CHECKED FOR -1,,-1. IF C(E)=-1,,-1, + 1242 ;THIS TEST PASSES. + 1243 + 1244 031131 477 00 0 00 000001 C25100: SETOB 1 ;PRELOAD AC -1,,-1 + 1245 031132 402 00 0 00 031134 SETZM .+2 ;PRELOAD E WITH 0 + 1246 031133 266 00 0 00 031134 JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E + 1247 031134 000000 000000 0 ;E: SHOULD GET C(AC) FROM JSA + 1248 031135 312 01 0 00 031134 CAME 1,.-1 ;PASS IF C(E)=-1,,-1 + 1249 STOP^ + 1250 031136 254 04 0 00 031137 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1251 031137 324 00 0 00 031140 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1252 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1253 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1254 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1255 + 1256 ;********** + 1257 + 1258 ;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. + 1259 ;AC IS FIRST CLEARED AND E IS PRELOADED WITH ONES; + 1260 ;THEN JSA IS EXECUTED. E IS CHECKED FOR ZEROS. IF C(E)=0, + 1261 ;THIS TEST PASSES. + 1262 + 1263 031140 201 00 0 00 777777 C25200: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + 1264 031141 266 00 0 00 031142 JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E + 1265 031142 000000 000000 0 ;E: SHOULD GET C(AC) FROM JSA + 1266 031143 200 01 0 00 031142 MOVE 1,.-1 ;PASS IF C(E)=0,,-1 + 1267 031144 302 01 0 00 777777 CAIE 1,-1 + 1268 STOP^ + 1269 031145 254 04 0 00 031146 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1270 031146 324 00 0 00 031147 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1271 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1272 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1273 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1274 + 1275 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 12 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JSA INSTRUCTION SEQ 0039 + + 1276 ;THIS TEST VERIFIES THAT JSA DOES NOT MODIFY AC+1 + 1277 ;IN THIS TEST, AC+1 IS PRELOADED WITH -1,,-1; THEN JSA IS EXECUTED + 1278 ;AC+1 IS THEN CHECKED FOR ITS ORIGINAL CONTENTS, -1,,-1. + 1279 ;IF C(AC+1)=-1,,-1, THIS TEST PASSES + 1280 + 1281 031147 476 00 0 00 000001 C25300: SETOM 1 ;PRELOAD AC+1 WITH -1,,-1 + 1282 031150 266 00 0 00 031151 JSA .+1 ;*JSA SHOULD NOT MODIFY AC+1 + 1283 031151 310 00 0 00 000000 CAM ;JSA SHOULD JUMP OVER THIS, E:PC: + 1284 031152 312 01 0 00 033462 CAME 1,[-1] ;PASS IF AC+1 WAS NOT MODIFIED BY JSA + 1285 STOP^ + 1286 031153 254 04 0 00 031154 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1287 031154 324 00 0 00 031155 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1288 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1289 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1290 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1291 + 1292 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 13 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JRA INSTRUCTION SEQ 0040 + + 1293 SUBTTL TEST OF JRA INSTRUCTION + 1294 + 1295 ;********** + 1296 + 1297 ;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E + 1298 ;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. + 1299 + 1300 031155 200 00 0 00 033467 C25400: MOVE [JRST .+4] ;PRELOAD AC0 WITH JRST .+4 + 1301 031156 205 01 0 00 031160 MOVSI 1,.+2 ;PRELOAD AC WITH E,,0 + 1302 031157 267 01 0 00 031160 JRA 1,.+1 ;*JRA SHOULD JUMP TO NEXT INSTRUCTION + 1303 031160 334 00 0 00 000000 SKIPA ;PASS IF JRA JUMPS TO E + 1304 STOP^ + 1305 031161 254 04 0 00 031162 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1306 031162 324 00 0 00 031163 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1307 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1308 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1309 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1310 + 1311 ;********** + 1312 + 1313 ;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E + 1314 ;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. + 1315 + 1316 031163 205 00 0 00 031166 C25500: MOVSI .+3 ;PRELOAD AC WITH E+1 + 1317 031164 267 00 0 00 031165 JRA .+1 ;*JRA SHOULD JUMP TO NEXT SEQUENTIAL INSTRUCTION + 1318 031165 334 00 0 00 000000 SKIPA ;PASS IF JRA JUMPS TO E + 1319 STOP^ + 1320 031166 254 04 0 00 031167 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1321 031167 324 00 0 00 031170 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1322 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1323 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1324 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1325 + 1326 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 14 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JRA INSTRUCTION SEQ 0041 + + 1327 ;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E + 1328 ;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. + 1329 + 1330 031170 403 00 0 00 000001 C25600: SETZB 1 ;PRELOAD AC0, AC1 WITH ZEROS + 1331 031171 267 00 0 00 031173 JRA .+2 ;*JRA SHOULD JUMP OVER NEXT SEQUENTIAL INSTRUCTION + 1332 031172 474 01 0 00 000000 SETO 1, ;LOAD AC1 WITH ONES IF JRA DOES NOT JUMP + 1333 031173 332 00 0 00 000001 SKIPE 1 ;PASS IF JRA JUMPED + 1334 STOP^ + 1335 031174 254 04 0 00 031175 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1336 031175 324 00 0 00 031176 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1337 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1338 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1339 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1340 + 1341 ;********** + 1342 + 1343 ;THIS TEST VERIFIES THAT JRA PLACES C(C(AC-LEFT)) INTO THE AC AND JUMPS TO E + 1344 ;THIS TEST FAILS IF JRA JUMPS TO E+1 OR DOES NOT LOAD THE AC CORRECTLY. + 1345 + 1346 031176 400 00 0 00 000000 C25700: SETZ ;CLEAR AC + 1347 031177 267 00 0 00 031200 JRA .+1 ;*JRA SHOULD PLACE 0 INTO THE AC AND JUMP .+1 + 1348 031200 332 00 0 00 000000 SKIPE ;PASS IF AC WAS LOADED CORRECTLY + 1349 ;AND JRA JUMPED CORRECTLY. + 1350 STOP^ + 1351 031201 254 04 0 00 031202 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1352 031202 324 00 0 00 031203 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1353 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1354 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1355 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1356 + 1357 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 15 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JRA INSTRUCTION SEQ 0042 + + 1358 ;THIS TEST VERIFIES THAT JRA PLACES C(C(AC-LEFT)) INTO THE AC + 1359 ;FIRST, THE AC IS PRELOADED WITH 1,,2 AND AC1 AND AC2 ARE + 1360 ;INITIALIZED WITH THEIR RESPECTIVE ADDRESSES; JRA IS EXECUTED, AND + 1361 ;THE AC IS CHECKED FOR 0,,1, THE ORIGINAL C(C(AC-LEFT)). IF C(AC)=0,,1, + 1362 ;THIS TEST PASSES + 1363 + 1364 031203 200 00 0 00 033470 C26200: MOVE [XWD 1,2] ;PRELOAD AC WITH 1,,2 + 1365 031204 201 01 0 00 000001 MOVEI 1,1 ;INITIALIZE AC1 WITH 0,,1 + 1366 031205 201 02 0 00 000002 MOVEI 2,2 ;INITIALIZE AC2 WITH 0,,2 + 1367 031206 267 00 0 00 031207 JRA .+1 ;*JRA SHOULD PLACE 0,,1 INTO THE AC + 1368 031207 302 00 0 00 000001 CAIE 1 ;PASS IF C(AC)=0,,1 + 1369 STOP^ + 1370 031210 254 04 0 00 031211 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1371 031211 324 00 0 00 031212 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1372 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1373 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1374 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1375 + 1376 ;********** + 1377 + 1378 ;THIS TEST VERIFIES THAT JRA CAN RESTORE AC0 FROM AC0 WHEN AC0 IS THE + 1379 ;SPECIFIED AC AND C(AC0-LEFT)=0. + 1380 ;FIRST, AC0 IS PRELOADED AND JRA IS EXECUTED. THEN, AC0 IS CHECKED FOR + 1381 ;ITS INITIAL CONTENTS. IF THE RESULT IN AC0, IS CORRECT, THIS TEST PASSES. + 1382 + 1383 031212 551 00 0 00 033471 C26300: HRRZI [135531,,246642] ;PRELOAD AC0 WITH 0,, LITERAL ADDRESS + 1384 031213 267 00 0 00 031214 JRA .+1 ;*JRA SHOULD PLACE C(AC0) INTO AC0 + 1385 031214 302 00 0 00 033471 CAIE [135531,,246642] ;PASS IF JRA PLACED C(AC0) INTO AC0 + 1386 STOP^ + 1387 031215 254 04 0 00 031216 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1388 031216 324 00 0 00 031217 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1389 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1390 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1391 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1392 + 1393 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 16 +DAKAEM MAC 28-Dec-78 13:35 TEST OF JRA INSTRUCTION SEQ 0043 + + 1394 ;THIS TEST VERIFIES THAT JRA CAN RESOTRE AC0 FROM MEMORY WHEN AC0 IS THE + 1395 ;SPECIFIED AC. + 1396 ;FIRST, AC0 IS PRELOADED WITH [LITERAL ADDRESS ,,0] AND JRA IS EXECUTED. THEN, + 1397 ;AC0 IS CHECKED FOR THE SPECIFIED LITERAL, 135246,,246135. IF + 1398 ;C(AC0)=135246,,246135, THE TEST PASSES. + 1399 + 1400 031217 515 00 0 00 033472 C26400: HRLZI [135246,,246135] ;PRELOAD AC0 WITH [LITERAL ADDRESS ,,0] + 1401 031220 267 00 0 00 031221 JRA .+1 ;*JRA SHOULD PLACE 135246,,246135 INTO AC0 + 1402 031221 312 00 0 00 033472 CAME [135246,,246135];PASS IF C(AC0)=135246,,246135 + 1403 STOP^ + 1404 031222 254 04 0 00 031223 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1405 031223 324 00 0 00 031224 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1406 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1407 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1408 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1409 + 1410 ;********** + 1411 + 1412 ;THIS TEST VERIFIES THAT JRA CAN RESOTRE AC0 FROM MEMORY WHEN AC0 IS THE + 1413 ;SPECIFIED AC. + 1414 ;FIRST, AC0 IS PRELOADED WITH [-1,, ADDRESS OF JCA INSTRUCTION] AND JRA IS EXECUTED. + 1415 ;THEN, AC0 IS CHECKED FOR THE JRA INSTRUCTION. IF + 1416 ;C(AC0)= THE JRA INSTRUCTION, THE TEST PASSES. + 1417 + 1418 031224 525 00 0 00 031225 C26500: HRLOI .+1 ;PRELOAD AC WITH -1,, ADDRESS OF JRA INSTRUCTION + 1419 031225 267 00 0 00 031226 JRA .+1 ;*JRA SHOULD PLACE ITSELF INTO AC0 + 1420 031226 312 00 0 00 031225 CAME .-1 ;PASS IF AC CONTAINS JRA INSTRUCTION + 1421 STOP^ + 1422 031227 254 04 0 00 031230 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1423 031230 324 00 0 00 031231 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1424 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1425 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1426 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1427 + 1428 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 17 +DAKAEM MAC 28-Dec-78 13:35 TESTS OF BIS FLAG SEQ 0044 + + 1429 SUBTTL TESTS OF BIS FLAG + 1430 + 1431 ;********** + 1432 + 1433 ;THIS TEST VERIFIES THAT JRST 2, CAN CLEAR BIS + 1434 ;FIRST, BIS IS SET VIA JRST 2, ;THEN, BIS IS CLEARED VIA JRST 2,. + 1435 ;THE FLAGS ARE SAVED AND BIS IS CHECKED. THIS TEST PASSES IF BIS IS RESET; + 1436 ;OTHERWISE JRST 2, FAILED TO RESET BIS. + 1437 + 1438 031231 C26600: SFLAG BIS ^;SET BIS FLAG + 1439 + 1440 031231 205 01 0 00 020000 MOVSI 1,BIS + 1441 031232 255 17 0 00 031233 JFCL 17,.+1 ;RESET ALL FLAGS + 1442 031233 254 02 0 01 031234 JRST 2,.+1(1) ;SET BIS FLAG + 1443 SFLAG ^;*RESET BIS FLAG + 1444 + 1445 031234 205 01 0 00 000000 MOVSI 1, + 1446 031235 255 17 0 00 031236 JFCL 17,.+1 ;RESET ALL FLAGS + 1447 031236 254 02 0 01 031237 JRST 2,.+1(1) ;SET FLAG + 1448 031237 265 00 0 00 031240 JSP .+1 ;SAVE FLAGS + 1449 031240 603 00 0 00 020037 TLNE BIS+37 ;PASS IF BIS FLAG IS RESET + 1450 STOP^ + 1451 031241 254 04 0 00 031242 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1452 031242 324 00 0 00 031243 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1453 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1454 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1455 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1456 + 1457 ;********** + 1458 + 1459 ;THIS TEST VERIFIES THAT JRST 2, CAN SET BIS. + 1460 ;FIRST, BIS IS SET VIA JRST 2, AND THE FLAGS ARE SAVED. + 1461 ;BIS IS THEN CHECKED. IF BIS IS SET, THIS TEST PASSES. + 1462 + 1463 031243 C26700: SFLAG BIS ^;*SET BIS FLAG VIA JRST + 1464 + 1465 031243 205 01 0 00 020000 MOVSI 1,BIS + 1466 031244 255 17 0 00 031245 JFCL 17,.+1 ;RESET ALL FLAGS + 1467 031245 254 02 0 01 031246 JRST 2,.+1(1) ;SET BIS FLAG + 1468 031246 265 00 0 00 031247 JSP .+1 ;SAVE FLAGS + 1469 031247 607 00 0 00 020000 TLNN BIS ;PASS IF BIS FLAG IS SET + 1470 STOP^ + 1471 031250 254 04 0 00 031251 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1472 031251 324 00 0 00 031252 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1473 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1474 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1475 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1476 + 1477 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 18 +DAKAEM MAC 28-Dec-78 13:35 TESTS OF BIS FLAG SEQ 0045 + + 1478 ;THIS TEST VERIFIES THAT JSR ALWAYS RESETS BIS. + 1479 ;FIRST BIS IS SET; THEN JSR IS EXECUTED. THE FLAGS ARE + 1480 ;THEN SAVED AND CHECKED. IF BIS WAS RESET VIA JSR, THIS TEST PASSES. + 1481 + 1482 031252 C27000: SFLAG BIS ^;SET BIS + 1483 + 1484 031252 205 01 0 00 020000 MOVSI 1,BIS + 1485 031253 255 17 0 00 031254 JFCL 17,.+1 ;RESET ALL FLAGS + 1486 031254 254 02 0 01 031255 JRST 2,.+1(1) ;SET BIS FLAG + 1487 031255 264 00 0 00 031256 JSR .+1 ;*JSR SHOULD RESET BIS + 1488 031256 000000 000000 0 ;JSR SAVES FLAGS HERE + 1489 031257 265 00 0 00 031260 JSP .+1 ;SAVE FLAGS + 1490 031260 603 00 0 00 020000 TLNE BIS ;PASS IF BIS FLAG IS RESET + 1491 STOP^ + 1492 031261 254 04 0 00 031262 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1493 031262 324 00 0 00 031263 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1494 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1495 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1496 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1497 + 1498 ;********** + 1499 + 1500 ;THIS TEST VERIFIES THAT JSP ALWAYS RESETS BIS. + 1501 ;FIRST BIS IS SET; THEN JSP IS EXECUTED. THE FLAGS ARE + 1502 ;THEN SAVED AND CHECKED. IF BIS WAS RESET VIA JSP, THIS TEST PASSES. + 1503 + 1504 031263 C27001: SFLAG BIS ^;SET BIS + 1505 + 1506 031263 205 01 0 00 020000 MOVSI 1,BIS + 1507 031264 255 17 0 00 031265 JFCL 17,.+1 ;RESET ALL FLAGS + 1508 031265 254 02 0 01 031266 JRST 2,.+1(1) ;SET BIS FLAG + 1509 031266 265 00 0 00 031267 JSP .+1 ;*JSP SHOULD RESET BIS + 1510 031267 265 00 0 00 031270 JSP .+1 ;SAVE FLAGS + 1511 031270 603 00 0 00 020000 TLNE BIS ;PASS IF BIS FLAG IS RESET + 1512 STOP^ + 1513 031271 254 04 0 00 031272 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1514 031272 324 00 0 00 031273 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1515 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1516 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1517 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1518 + 1519 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 19 +DAKAEM MAC 28-Dec-78 13:35 TESTS OF BIS FLAG SEQ 0046 + + 1520 ;THIS TEST VERIFIES THAT THE BITS IN POSITIONS 8, 9 AND 10 ARE CLEARABLE. + 1521 ;FIRST, THE ARITHMETIC FLAGS ARE CLEARED; + 1522 ;THEN, BITS 8, 9 AND 10 OF THE PC-WORD IS EXAMINED. + 1523 ;IF ANY OF THESE BITS ARE SET, THIS TEST FAILS BECAUSE THEY SHOULD BE CLEAR. + 1524 + 1525 031273 C27100: SFLAG ^;CLEAR ARITHMETIC FLAGS + 1526 + 1527 031273 205 01 0 00 000000 MOVSI 1, + 1528 031274 255 17 0 00 031275 JFCL 17,.+1 ;RESET ALL FLAGS + 1529 031275 254 02 0 01 031276 JRST 2,.+1(1) ;SET FLAG + 1530 031276 265 00 0 00 031277 JSP .+1 ;SAVE FLAGS + 1531 031277 603 00 0 00 001600 TLNE 1600 ;PASS IF THESE BITS ARE CLEAR + 1532 STOP^ + 1533 031300 254 04 0 00 031301 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1534 031301 324 00 0 00 031302 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1535 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1536 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1537 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1538 + 1539 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 20 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0047 + + 1540 SUBTTL TEST OF MSCL FWT INSTRUCTIONS + 1541 + 1542 ;********** + 1543 + 1544 ;THIS TEST VERIFIES THAT MOVEM PLACES C(AC) INTO E AND DOES + 1545 ;NOT MODIFY C(AC). + 1546 ;IN THIS CASE, C(AC)=252525,,252525 ANS C(E)=707070,,707070. + 1547 ;HENCE, THE RESULT IN E SHOULD BE 252525,,252525. + 1548 ;THE AC IS CHECKED FOR 252525,,252525. IF ANY OTHER NUMBER IS + 1549 ;FOUND IN THE AC, IT WAS CLOBBERED BY MOVEM, AND THIS TEST FAILS. + 1550 ;E IS CHECKED FOR 252525,,252525. IF ANY OTHER NUMBER IS FOUND + 1551 ;IN E, IT WAS UPDATED INCORRECTLY BY MOVEM. + 1552 + 1553 031302 200 00 0 00 033473 C50000: MOVE [252525,,252525] ;PRELOAD AC WITH 252525,,252525 + 1554 031303 200 01 0 00 033474 MOVE 1,[707070,,707070] ;PRELOAD E WITH 707070,,707070 + 1555 031304 202 00 0 00 000001 MOVEM 0,1 ;*MOVEM SHOULD PLACE 252525,,252525 + 1556 ;INTO E AND NOT AFFECT THE AC + 1557 031305 312 00 0 00 033473 CAME 0,[252525,,252525] ;PASS IF C(AC) IS NOT CLOBBERED + 1558 STOP^ + 1559 031306 254 04 0 00 031307 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1560 031307 324 00 0 00 031310 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1561 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1562 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1563 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1564 031310 312 01 0 00 033473 CAME 1,[252525,,252525] ;PASS IF E WAS UPDATED CORRECTLY + 1565 STOP^ + 1566 031311 254 04 0 00 031312 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1567 031312 324 00 0 00 031313 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1568 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1569 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1570 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1571 + 1572 ;********** + 1573 + 1574 ;THIS TEST VERIFIES THAT MOVES PLACES C(E) INTO THE AC IF AC IS NON-ZERO. + 1575 ;IN THIS CASE, C(AC)=707070,,707070 AND C(E)=123456,,123456. HENCE, BOTH + 1576 ;THE AC AND E SHOULD CONTAIN 123456,,123456 AFTER MOVES IS EXECUTED. + 1577 ;BOTH AC AND E ARE CHECKED FOR 123456,,123456. IF EITHER AC OR E + 1578 ;CONTAIN A DIFFERENT RESULT, THIS TEST FAILS + 1579 + 1580 031313 200 02 0 00 033474 C50100: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 1581 031314 200 01 0 00 033475 MOVE 1,[123456,,123456] ;PRELOAD E WITH 123456,,123456 + 1582 031315 203 02 0 00 000001 MOVES 2,1 ;*MOVES SHOULD PLACE 123456,,123456 + 1583 ;INTO BOTH AC AND E + 1584 031316 312 02 0 00 033475 CAME 2,[123456,,123456] ;PASS IF C(AC)=123456,,123456 + 1585 STOP^ + 1586 031317 254 04 0 00 031320 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1587 031320 324 00 0 00 031321 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1588 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1589 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1590 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1591 031321 312 01 0 00 033475 CAME 1,[123456,,123456] ;PASS IF C(E)=123456,,123456 + 1592 STOP^ + 1593 031322 254 04 0 00 031323 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1594 031323 324 00 0 00 031324 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 20-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0048 + + 1595 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1596 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1597 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1598 + 1599 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 21 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0049 + + 1600 ;THIS TEST VERIFIES THAT MOVES IS A NO-OP IF AC=0 + 1601 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=707070,,707070 + 1602 ;AFTER MOVES IS EXECUTED, AC AND E ARE CHECKED FOR THEIR ORIGINAL DATA. + 1603 ;IF EITHER C(AC) OR C(E) CHANGED AS A RESULT OF MOVES, THIS TEST FAILS. + 1604 + 1605 031324 200 01 0 00 033474 C50110: MOVE 1,[707070,,707070] ;PRELOAD E WITH 707070,,707070 + 1606 031325 474 00 0 00 000000 SETO ;PRELOAD AC WITH -1,,-1 + 1607 031326 203 00 0 00 000001 MOVES 0,1 ;*MOVES SHOULD FUNCTION AS A NO-OP + 1608 031327 312 00 0 00 033462 CAME 0,[-1,,-1] ;PASS IF C(AC) WAS NOT MODIFIED + 1609 STOP^ + 1610 031330 254 04 0 00 031331 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1611 031331 324 00 0 00 031332 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1612 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1613 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1614 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1615 031332 312 01 0 00 033474 CAME 1,[707070,,707070] ;PASS IF C(E) WAS NOT MODIFIED + 1616 STOP^ + 1617 031333 254 04 0 00 031334 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1618 031334 324 00 0 00 031335 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1619 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1620 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1621 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1622 + 1623 ;********** + 1624 + 1625 ;THIS TEST VERIFIES THAT MOVSI LOADS THE WORD E,0 INTO THE AC. + 1626 ;IN THIS CASE, C(AC)=707070,,707070 AND E=0,,-1. + 1627 ;HENCE, THE RESULT IN THE AC SHOULD BE -1,,0. + 1628 ;THE AC IS CHECKED FOR -1,,0. IF C(AC)=-1,,0, THIS TEST PASSES. + 1629 + 1630 031335 200 01 0 00 033474 C50200: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 1631 031336 205 01 0 00 777777 MOVSI 1,-1 ;*MOVSI SHOULD PLACE -1,,0 INTO THE AC + 1632 031337 312 01 0 00 033476 CAME 1,[-1,,0] ;PASS IF C(AC)=1,,0 + 1633 STOP^ + 1634 031340 254 04 0 00 031341 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1635 031341 324 00 0 00 031342 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1636 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1637 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1638 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1639 + 1640 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 22 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0050 + + 1641 ;THIS TEST VERIFIES THAT MOVNM PLACES THE NEGATIVE OF C(AC) + 1642 ;INTO E. IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-3. + 1643 ;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 AND THE RESULT + 1644 ;IN E SHOULD BE 0,,1 + 1645 + 1646 031342 474 01 0 00 000000 C50300: SETO 1, ;PRELOAD AC WITH -1,,-1 + 1647 031343 200 02 0 00 033477 MOVE 2,[-1,,-3] ;PRELOAD E WITH -1,,-3 + 1648 031344 212 01 0 00 000002 MOVNM 1,2 ;*MOVNM SHOULD PLACE 0,,1 INTO E + 1649 ;AND NOT AFFTECT C(AC) + 1650 031345 312 01 0 00 033462 CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 + 1651 STOP^ + 1652 031346 254 04 0 00 031347 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1653 031347 324 00 0 00 031350 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1654 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1655 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1656 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1657 031350 302 02 0 00 000001 CAIE 2,1 ;PASS IF C(E)=0,,1 + 1658 STOP^ + 1659 031351 254 04 0 00 031352 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1660 031352 324 00 0 00 031353 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1661 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1662 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1663 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1664 + 1665 ;********** + 1666 + 1667 ;THIS TEST VERIFIES THAT MOVNM PLACES THE NEGATIVE OF C(AC) + 1668 ;INTO E. IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-3. + 1669 ;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 AND THE RESULT + 1670 ;IN E SHOULD BE 0,,1 + 1671 + 1672 031353 474 01 0 00 000000 C50301: SETO 1, ;PRELOAD AC WITH -1,,-1 + 1673 031354 200 02 0 00 033477 MOVE 2,[-1,,-3] ;PRELOAD E WITH -1,,-3 + 1674 031355 202 02 0 00 031367 MOVEM 2,E50301 + 1675 031356 212 01 0 00 031367 MOVNM 1,E50301 ;*MOVNM SHOULD PLACE 0,,1 INTO E + 1676 ;AND NOT AFFTECT C(AC) + 1677 031357 312 01 0 00 033462 CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 + 1678 STOP^ + 1679 031360 254 04 0 00 031361 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1680 031361 324 00 0 00 031362 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1681 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1682 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1683 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1684 031362 200 02 0 00 031367 MOVE 2,E50301 + 1685 031363 302 02 0 00 000001 CAIE 2,1 ;PASS IF C(E)=0,,1 + 1686 STOP^ + 1687 031364 254 04 0 00 031365 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1688 031365 324 00 0 00 031366 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1689 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1690 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1691 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1692 + 1693 031366 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST + 1694 031367 000000 000000 E50301: 0 ;TESTED MEMORY LOCATION + 1695 +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 22-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0051 + + 1696 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 23 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0052 + + 1697 ;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E + 1698 ;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=0, + 1699 ;C(AC)=0 AND C(E)=0,,1 + 1700 ;HENCE, THE RESULT IN THE AC SHOULD BE 0 + 1701 ;AND THE RESULT IN E SHOULD BE -1,,-1 + 1702 + 1703 031370 400 00 0 00 000000 C50400: SETZ ;CLEAR AC + 1704 031371 201 02 0 00 000001 MOVEI 2,1 ;PRELOAD E WITH 0,,1 + 1705 031372 213 00 0 00 000002 MOVNS 0,2 ;*MOVNS SHOULD PLACE -1,,-1 INTO E + 1706 ;AND SHOULD NOT AFFECT THE AC + 1707 031373 332 00 0 00 000000 SKIPE ;PASS IF THE AC IS UNALTERED + 1708 STOP^ + 1709 031374 254 04 0 00 031375 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1710 031375 324 00 0 00 031376 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1711 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1712 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1713 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1714 031376 312 02 0 00 033462 CAME 2,[-1] ;PASS IF C(E)=-1,,-1 + 1715 STOP^ + 1716 031377 254 04 0 00 031400 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1717 031400 324 00 0 00 031401 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1718 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1719 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1720 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1721 + 1722 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 24 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0053 + + 1723 ;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E + 1724 ;AND INTO THE AC IF THE AC IS NON-ZO. IN THIS CASE, AC=0, + 1725 ;C(AC)=0 AND C(E)=0,,1 + 1726 ;HENCE, THE RESULT IN THE AC SHOULD BE 0 + 1727 ;AND THE RESULT IN E SHOULD BE -1,,-1 + 1728 + 1729 031401 400 00 0 00 000000 C50401: SETZ ;CLEAR AC + 1730 031402 201 02 0 00 000001 MOVEI 2,1 ;PRELOAD E WITH 0,,1 + 1731 031403 202 02 0 00 031415 MOVEM 2,E50401 + 1732 031404 213 00 0 00 031415 MOVNS 0,E50401 ;*MOVNS SHOULD PLACE -1,,-1 INTO E + 1733 ;AND SHOULD NOT AFFECT THE AC + 1734 031405 332 00 0 00 000000 SKIPE ;PASS IF THE AC IS UNALTERED + 1735 STOP^ + 1736 031406 254 04 0 00 031407 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1737 031407 324 00 0 00 031410 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1738 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1739 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1740 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1741 031410 200 02 0 00 031415 MOVE 2,E50401 + 1742 031411 312 02 0 00 033462 CAME 2,[-1] ;PASS IF C(E)=-1,,-1 + 1743 STOP^ + 1744 031412 254 04 0 00 031413 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1745 031413 324 00 0 00 031414 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1746 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1747 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1748 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1749 + 1750 031414 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST + 1751 031415 000000 000000 E50401: 0 ;TESTED MEMORY LOCATION + 1752 + 1753 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 25 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0054 + + 1754 ;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E + 1755 ;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=1, + 1756 ;C(AC=0 AND C(E)=3 + 1757 ;HENCE, THE RESULT IN THE AC SHOULD BE -1,,3 + 1758 ;AND THE RESULT IN E SHOULD BE -1,,3. + 1759 + 1760 031416 400 01 0 00 000000 C50410: SETZ 1, ;CLEAR AC + 1761 031417 201 02 0 00 000003 MOVEI 2,3 ;PRELOAD WITH 0,,3 + 1762 031420 213 01 0 00 000002 MOVNS 1,2 ;*MOVNS SHOULD PLACE -1,,-3 INTO E + 1763 ;AND -1,,-3 INTO THE AC + 1764 031421 312 01 0 00 033477 CAME 1,[-1,,-3] ;PASS IF C(AC)=-1,,-3 + 1765 STOP^ + 1766 031422 254 04 0 00 031423 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1767 031423 324 00 0 00 031424 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1768 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1769 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1770 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1771 031424 312 02 0 00 033477 CAME 2,[-1,,-3] ;PASS IF C(E)=-1,,-3 + 1772 STOP^ + 1773 031425 254 04 0 00 031426 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1774 031426 324 00 0 00 031427 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1775 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1776 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1777 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1778 + 1779 ;********** + 1780 + 1781 ;THIS TEST VERIFIES THAT MOVMI MOVES THE WORD 0,,E INTO THE AC. + 1782 ;IN THIS CASE, C(AC)=0 AND E=0,,-2. HENCE, THE RESULT IN THE AC + 1783 ;SHOULD BE 0,,-2. + 1784 + 1785 031427 400 01 0 00 000000 C50500: SETZ 1, ;CLEAR AC + 1786 031430 215 01 0 00 777776 MOVMI 1,-2 ;*MOVMI SHOULD PLACE 0,,-2 INTO AC + 1787 031431 302 01 0 00 777776 CAIE 1,-2 ;PASS IF C(AC)=0,,-2 + 1788 STOP^ + 1789 031432 254 04 0 00 031433 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1790 031433 324 00 0 00 031434 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1791 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1792 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1793 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1794 + 1795 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 26 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0055 + + 1796 ;THIS TEST VERIFIES THAT MOVM MOVES THE MAGNITUDE OF C(E) NTO THE AC. + 1797 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-2. HENCE, THE RESULT IN THE AC + 1798 ;SHOULD BE 0,,2. + 1799 + 1800 031434 400 01 0 00 000000 C50501: SETZ 1, ;CLEAR AC + 1801 031435 200 03 0 00 033500 MOVE 3,[-2] ;PRELOAD E WITH -1,,-2 + 1802 031436 214 01 0 00 000003 MOVM 1,3 ;*MOVM SHOULD PLACE 0,,2 INTO AC + 1803 031437 302 01 0 00 000002 CAIE 1,2 ;PASS IF C(AC)=0,,2 + 1804 STOP^ + 1805 031440 254 04 0 00 031441 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1806 031441 324 00 0 00 031442 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1807 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1808 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1809 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1810 + 1811 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 27 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0056 + + 1812 ;THIS TEST VERIFIES THAT MOVMM PLACES THE MAGNITUDE OF C(AC) + 1813 ;INTO E. IN THIS CASE, C(AC)=-1,,-2 AND C(E)=0. HENCE, THE + 1814 ;RESULT IN E SHOULD BE 0,,2 AND C(AC) SHOULD REMAIN UNCHANGED. + 1815 + 1816 031442 200 01 0 00 033500 C50600: MOVE 1,[-1,,-2] ;PRELOAD AC WITH -1,,-2 + 1817 031443 400 02 0 00 000000 SETZ 2, ;CLEAR E + 1818 031444 216 01 0 00 000002 MOVMM 1,2 ;*MOVMM SHOULD PLACE 0,,2 INTO E + 1819 ;AND SHOULD NOT CHANGE C(AC) + 1820 031445 312 01 0 00 033500 CAME 1,[-1,,-2] ;PASS IF C(AC) IS NOT ALTERED + 1821 STOP^ + 1822 031446 254 04 0 00 031447 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1823 031447 324 00 0 00 031450 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1824 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1825 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1826 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1827 031450 302 02 0 00 000002 CAIE 2,2 ;PASS IF C(E)=0,,2 + 1828 STOP^ + 1829 031451 254 04 0 00 031452 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1830 031452 324 00 0 00 031453 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1831 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1832 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1833 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1834 + 1835 ;********** + 1836 + 1837 ;THIS TEST VERIFIES THAT MONMS PLACES THE MAGNITUDE OF C(E) INTO E + 1838 ;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=0, C(AC)=0 + 1839 ;AND C(E)=-1,,-2. + 1840 ;HENCE, THE RESULT IN THE AC SHOULD BE 0 AND THE RESULT IN + 1841 ;E SHOULD BE 0,,2. + 1842 + 1843 031453 400 00 0 00 000000 C50700: SETZ ;CLEAR AC + 1844 031454 200 02 0 00 033500 MOVE 2,[-1,,-2] ;PRELOAD E WITH -1,,-1 + 1845 031455 217 00 0 00 000002 MOVMS 0,2 ;*MOVMS SHOULD PLACE 0,,1 INTO E + 1846 ;AND SHOULD NOT CHANGE C(AC) + 1847 031456 332 00 0 00 000000 SKIPE ;PASS IF C(AC) IS UNALTERED + 1848 STOP^ + 1849 031457 254 04 0 00 031460 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1850 031460 324 00 0 00 031461 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1851 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1852 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1853 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1854 031461 302 02 0 00 000002 CAIE 2,2 ;PASS IF C(E)=0,,2 + 1855 STOP^ + 1856 031462 254 04 0 00 031463 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1857 031463 324 00 0 00 031464 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1858 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1859 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1860 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1861 + 1862 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 28 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL FWT INSTRUCTIONS SEQ 0057 + + 1863 ;THIS TEST VERIFIES THAT MOVMS PLACES THE MAGNITUDE OF C(E) INTO E + 1864 ;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=1, C(AC)=-1,,-1 + 1865 ;AND C(E)=-1,,-2. + 1866 ;HENCE, THE RESULT IN THE AC SHOULD BE 0,,2 AND THE RESULT + 1867 ;IN E SHOULD BE 0,,2. + 1868 + 1869 031464 474 01 0 00 000000 C50710: SETO 1, ;PRELOAD AC WITH -1,,-1 + 1870 031465 200 02 0 00 033500 MOVE 2,[-1,,-2] ;PRELOAD E WITH -1,,-2 + 1871 031466 217 01 0 00 000002 MOVMS 1,2 ;*MOVMS SHOULD PLACE 0,,2 INTO E + 1872 ;AND SHOULD PLACE 0,,2 INTO THE AC + 1873 031467 302 01 0 00 000002 CAIE 1,2 ;PASS IF C(AC)=0,,2 + 1874 STOP^ + 1875 031470 254 04 0 00 031471 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1876 031471 324 00 0 00 031472 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1877 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1878 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1879 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1880 031472 302 02 0 00 000002 CAIE 2,2 ;PASS IF C(E)=0,,2 + 1881 STOP^ + 1882 031473 254 04 0 00 031474 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1883 031474 324 00 0 00 031475 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1884 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1885 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1886 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1887 + 1888 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 29 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL ADD/SUB INSTRUCTIONS SEQ 0058 + + 1889 SUBTTL TEST OF MSCL ADD/SUB INSTRUCTIONS + 1890 + 1891 ;********** + 1892 + 1893 ;THIS TEST VERIFIES THAT SUBI SUBTRACTS THE WORD 0,,E FROM C(AC) + 1894 ;AND PLACES THE RESULT INTO THE AC. IN THIS CASE, C(AC)=70 AND + 1895 ;E=0,,2. HENCE, THE RESULT IN THE AC SHOULD BE 66. + 1896 + 1897 031475 201 01 0 00 000070 C51000: MOVEI 1,70 ;PRELOAD AC WITH 70 + 1898 031476 275 01 0 00 000002 SUBI 1,2 ;*SUBI SHOULD PLACE 66 INTO AC + 1899 031477 302 01 0 00 000066 CAIE 1,66 ;PASS IF C(AC)=66 + 1900 STOP^ + 1901 031500 254 04 0 00 031501 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1902 031501 324 00 0 00 031502 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1903 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1904 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1905 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1906 + 1907 ;********** + 1908 + 1909 ;THIS TEST VERIFIES THAT SUBM SUBTRACTS C(E) FROM C(AC) AND + 1910 ;PLACES THE RESULT INTO E. THE AC IS UNAFFECTED. IN THIS CASE, + 1911 ;C(AC)=100 AND C(E)=37. HENCE, THE RESULTS IN AC AND + 1912 ;E SHOULD BE 0,,100 AND 0,,41 RESPECTIVELY. + 1913 + 1914 031502 201 01 0 00 000100 C51100: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + 1915 031503 201 02 0 00 000037 MOVEI 2,37 ;PRELOAD E WITH 0,,37 + 1916 031504 276 01 0 00 000002 SUBM 1,2 ;*SUBM SHOULD PLACE + 1917 ;0,,41 INTO E AND NOT CHANGE C(AC) + 1918 031505 302 01 0 00 000100 CAIE 1,100 ;PASS IF C(AC) IS UNCHANGED + 1919 STOP^ + 1920 031506 254 04 0 00 031507 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1921 031507 324 00 0 00 031510 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1922 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1923 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1924 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1925 031510 302 02 0 00 000041 CAIE 2,41 ;PASS IF C(E)=0,,41 + 1926 STOP^ + 1927 031511 254 04 0 00 031512 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1928 031512 324 00 0 00 031513 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1929 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1930 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1931 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1932 + 1933 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 30 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL ADD/SUB INSTRUCTIONS SEQ 0059 + + 1934 ;THIS TEST VERIFIES THAT SUBM SUBTRACTS C(E) FROM C(AC) AND + 1935 ;PLACES THE RESULT INTO E. THE AC IS UNAFFECTED. IN THIS CASE, + 1936 ;C(AC)=100 AND C(E)=37. HENCE, THE RESULTS IN AC AND + 1937 ;E SHOULD BE 0,,100 AND 0,,41 RESPECTIVELY. + 1938 + 1939 031513 201 01 0 00 000100 C51101: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + 1940 031514 201 02 0 00 000037 MOVEI 2,37 ;PRELOAD E WITH 0,,37 + 1941 031515 202 02 0 00 031527 MOVEM 2,E51101 + 1942 031516 276 01 0 00 031527 SUBM 1,E51101 ;*SUBM SHOULD PLACE + 1943 ;0,,41 INTO E AND NOT CHANGE C(AC) + 1944 031517 302 01 0 00 000100 CAIE 1,100 ;PASS IF C(AC) IS UNCHANGED + 1945 STOP^ + 1946 031520 254 04 0 00 031521 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1947 031521 324 00 0 00 031522 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1948 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1949 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1950 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1951 031522 200 02 0 00 031527 MOVE 2,E51101 + 1952 031523 302 02 0 00 000041 CAIE 2,41 ;PASS IF C(E)=0,,41 + 1953 STOP^ + 1954 031524 254 04 0 00 031525 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1955 031525 324 00 0 00 031526 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1956 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1957 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1958 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1959 + 1960 031526 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST + 1961 031527 000000 000000 E51101: 0 ;TEST WORD MEMORY + 1962 + 1963 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 31 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL ADD/SUB INSTRUCTIONS SEQ 0060 + + 1964 ;THIS TEST VERIFIES THAT SUBB SUBTRACTS C(E) FROM C(AC) AND + 1965 ;PLACES THE RESULT INTO BOTH AC AND E. IN THIS CASE, + 1966 ;C(AC)=0,,100 AND C(E)=0,,37. HENCE, THE RESULT IN BOTH + 1967 ;AC AND E SHOULD BE 0,,41. + 1968 + 1969 031530 201 01 0 00 000100 C51200: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + 1970 031531 201 02 0 00 000037 MOVEI 2,37 ;PRELOAD E WITH O,,37 + 1971 031532 277 01 0 00 000002 SUBB 1,2 ;*SUBB SHOULD PLACE 0,,41 INTO BOTH AC AND E + 1972 031533 302 01 0 00 000041 CAIE 1,41 ;PASS IF C(AC)=0,,41 + 1973 STOP^ + 1974 031534 254 04 0 00 031535 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1975 031535 324 00 0 00 031536 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1976 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1977 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1978 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1979 031536 302 02 0 00 000041 CAIE 2,41 ;PASS IF C(E)=0,,41 + 1980 STOP^ + 1981 031537 254 04 0 00 031540 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 1982 031540 324 00 0 00 031541 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 1983 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 1984 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 1985 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 1986 + 1987 ;********** + 1988 + 1989 ;THIS TEST VERIFIES THAT SUBB SUBTRACTS C(E) FROM C(AC) AND + 1990 ;PLACES THE RESULT INTO BOTH AC AND E. IN THIS CASE, + 1991 ;C(AC)=0,,100 AND C(E)=0,,37. HENCE, THE RESULT IN BOTH + 1992 ;AC AND E SHOULD BE 0,,41. + 1993 + 1994 031541 201 01 0 00 000100 C51201: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + 1995 031542 201 02 0 00 000037 MOVEI 2,37 ;PRELOAD E WITH O,,37 + 1996 031543 202 02 0 00 031555 MOVEM 2,E51201 + 1997 031544 277 01 0 00 031555 SUBB 1,E51201 ;*SUBB SHOULD PLACE 0,,41 INTO BOTH AC AND E + 1998 031545 302 01 0 00 000041 CAIE 1,41 ;PASS IF C(AC)=0,,41 + 1999 STOP^ + 2000 031546 254 04 0 00 031547 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2001 031547 324 00 0 00 031550 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2002 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2003 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2004 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2005 031550 200 02 0 00 031555 MOVE 2,E51201 + 2006 031551 302 02 0 00 000041 CAIE 2,41 ;PASS IF C(E)=0,,41 + 2007 STOP^ + 2008 031552 254 04 0 00 031553 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2009 031553 324 00 0 00 031554 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2010 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2011 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2012 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2013 + 2014 031554 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST + 2015 031555 000000 000000 E51201: 0 ;TEST WORD MEMORY + 2016 + 2017 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 32 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0061 + + 2018 SUBTTL TEST OF MSCL CAIX INSTRUCTIONS + 2019 + 2020 ;********** + 2021 + 2022 ;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND + 2023 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E. + 2024 ;IN THIS CASE, C(AC)=0,,1 AND E=0,,2 + 2025 ;HENCE, CAIL SHOULD SKIP THE NEXT INSTRUCTION. + 2026 ;IF CAIL SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + 2027 + 2028 031556 201 01 0 00 000001 C51300: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + 2029 031557 301 01 0 00 000002 CAIL 1,2 ;*CAIL SHOULD SKIP THE NEXT INSTRUCTION + 2030 STOP^ + 2031 031560 254 04 0 00 031561 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2032 031561 324 00 0 00 031562 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2033 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2034 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2035 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2036 + 2037 ;********** + 2038 + 2039 ;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND + 2040 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E. + 2041 ;IN THIS CASE, C(AC)=0,,2 AND E=0,,2. + 2042 ;HENCE, CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION. + 2043 ;IF CAIL DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + 2044 + 2045 031562 201 01 0 00 000002 C51310: MOVEI 1,2 ;PRELOAD AC WITH 0,,2 + 2046 031563 301 01 0 00 000002 CAIL 1,2 ;*CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION + 2047 031564 334 00 0 00 000000 SKIPA ;PASS IF CAIL DOES NOT SKIP + 2048 STOP^ + 2049 031565 254 04 0 00 031566 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2050 031566 324 00 0 00 031567 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2051 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2052 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2053 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2054 + 2055 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 33 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0062 + + 2056 ;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND + 2057 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E + 2058 ;IN THIS CASE, C(AC)=0,,3 AND E=0,,2 + 2059 ;HENCE, CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION. + 2060 ;IF CAIL DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + 2061 + 2062 031567 201 01 0 00 000003 C51320: MOVEI 1,3 ;PRELOAD AC WITH 0,,3 + 2063 031570 301 01 0 00 000002 CAIL 1,2 ;*CAIL SHOULD SKIP THE NEXT INSTRUCTION + 2064 031571 334 00 0 00 000000 SKIPA ;PASS IF CAIL DOES NOT SKIP + 2065 STOP^ + 2066 031572 254 04 0 00 031573 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2067 031573 324 00 0 00 031574 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2068 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2069 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2070 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2071 + 2072 ;********** + 2073 + 2074 ;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND + 2075 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E + 2076 ;IN THIS CASE, C(AC)=-1,,-1 AND E=0 + 2077 ;HENCE, CAILE SHOULD SKIP THE NEXT INSTRUCTION + 2078 ;IF CAILE SKIPS THE NEXT INSTRUCTION, THE TEST PASSES + 2079 + 2080 031574 474 01 0 00 000000 C51400: SETO 1, ;PRELOAD AC WITH -1,,-1 + 2081 031575 303 01 0 00 000000 CAILE 1,0 ;*CAILE SHOULD SKIP THE NEXT INSTRUCTION + 2082 STOP^ + 2083 031576 254 04 0 00 031577 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2084 031577 324 00 0 00 031600 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2085 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2086 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2087 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2088 + 2089 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 34 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0063 + + 2090 ;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND + 2091 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E + 2092 ;IN THIS CASE, C(AC)=0 AND E=0 + 2093 ;HENCE, CAILE SHOULD SKIP THE NEXT INSTRUCTION. + 2094 ;IF CAILE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + 2095 + 2096 031600 400 01 0 00 000000 C51410: SETZ 1, ;PRELOAD AC WITH 0 + 2097 031601 303 01 0 00 000000 CAILE 1,0 ;*CAILE SHOULD SKIP THE NEXT INSTRUCTION. + 2098 STOP^ + 2099 031602 254 04 0 00 031603 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2100 031603 324 00 0 00 031604 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2101 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2102 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2103 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2104 + 2105 ;********** + 2106 + 2107 ;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND + 2108 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E + 2109 ;IN THIS CASE, C(AC)=0,,1 AND E=0 + 2110 ;HENCE, CAILE SHOULD NOT SKIP THE NEXT INSTRUCTION. + 2111 ;IF CAILE DOES NOT SKIP THE NEXT INSTRUCTION, THE TEST PASSES + 2112 + 2113 031604 201 01 0 00 000001 C51420: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + 2114 031605 303 01 0 00 000000 CAILE 1,0 ;*CAILE SHOULD NOT SKIP THE NEXT INSTRUCTION + 2115 031606 334 00 0 00 000000 SKIPA ;PASS IF CAILE DOES NOT SKIP + 2116 STOP^ + 2117 031607 254 04 0 00 031610 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2118 031610 324 00 0 00 031611 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2119 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2120 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2121 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2122 + 2123 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 35 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0064 + + 2124 ;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS + 2125 ;SKIPS THE NEXT INSTRUCTION + 2126 ;IN THIS CASE, C(AC)=-1,,-1 AND E=0 + 2127 ;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION + 2128 ;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + 2129 + 2130 031611 474 01 0 00 000000 C51500: SETO 1, ;PRELOAD AC WITH -1,,-1 + 2131 031612 304 01 0 00 000000 CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION + 2132 STOP^ + 2133 031613 254 04 0 00 031614 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2134 031614 324 00 0 00 031615 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2135 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2136 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2137 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2138 + 2139 ;********** + 2140 + 2141 ;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS + 2142 ;SKIPS THE NEXT INSTRUCTION + 2143 ;IN THIS CASE, C(AC)=0 AND E=0 + 2144 ;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION. + 2145 ;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + 2146 + 2147 031615 400 01 0 00 000000 C51510: SETZ 1, ;PRELOAD AC WITH 0 + 2148 031616 304 01 0 00 000000 CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION + 2149 STOP^ + 2150 031617 254 04 0 00 031620 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2151 031620 324 00 0 00 031621 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2152 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2153 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2154 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2155 + 2156 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 36 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0065 + + 2157 ;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS + 2158 ;SKIPS THE NEXT INSTRUCTION + 2159 ;IN THIS CASE, C(AC)=0,,1 AND E=0 + 2160 ;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION. + 2161 ;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + 2162 + 2163 031621 201 01 0 00 000001 C51520: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + 2164 031622 304 01 0 00 000000 CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION + 2165 STOP^ + 2166 031623 254 04 0 00 031624 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2167 031624 324 00 0 00 031625 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2168 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2169 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2170 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2171 + 2172 ;********** + 2173 + 2174 ;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND + 2175 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E. + 2176 ;IN THIS CASE, C(AC)=0,,5 AND E=0,,6 + 2177 ;HENCE, CAIGE SHOULD NOT SKIP THE NEXT INSTRUCTION. + 2178 ;IF CAIGE DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES + 2179 + 2180 031625 201 02 0 00 000005 C51600: MOVEI 2,5 ;PRELOAD AC WITH 0,,5 + 2181 031626 305 02 0 00 000006 CAIGE 2,6 ;*CAIGE SHOULD NOT SKIP THE NEXT INSTRUCTION + 2182 031627 334 00 0 00 000000 SKIPA ;PASS IF CAIGE DOES NOT SKIP + 2183 STOP^ + 2184 031630 254 04 0 00 031631 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2185 031631 324 00 0 00 031632 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2186 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2187 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2188 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2189 + 2190 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 37 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0066 + + 2191 ;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND + 2192 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E + 2193 ;IN THIS CASE, C(AC)=0,,6 AND E=0,,6 + 2194 ;HENCE, CAIGE SHOULD SKIP THE NEXT INSTRUCTION. + 2195 ;IF CAIGE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + 2196 + 2197 031632 201 02 0 00 000006 C51610: MOVEI 2,6 ;PRELOAD AC WITH 0,,6 + 2198 031633 305 00 0 00 000000 CAIGE ;*CAIGE SHOULD SKIP THE NEXT INSTRUCTION + 2199 STOP^ + 2200 031634 254 04 0 00 031635 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2201 031635 324 00 0 00 031636 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2202 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2203 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2204 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2205 + 2206 ;********** + 2207 + 2208 ;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND + 2209 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E. + 2210 ;IN THIS CASE, C(AC)=0,,7 AND E=0,,6 + 2211 ;HENCE, CAIGE SHOULD SKIP THE NEXT INSTRUCTION. + 2212 ;IF CAIGE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + 2213 + 2214 031636 201 02 0 00 000007 C51620: MOVEI 2,7 ;PRELOAD AC WITH 0,,7 + 2215 031637 305 02 0 00 000006 CAIGE 2,6 ;*CAIGE SHOULD SKIP THE NEXT INSTRUCTION + 2216 STOP^ + 2217 031640 254 04 0 00 031641 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2218 031641 324 00 0 00 031642 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2219 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2220 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2221 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2222 + 2223 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 38 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0067 + + 2224 ;THIS TEST VERIRIES THAT CAIN COMPARES C(AC) WITH E AND + 2225 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. + 2226 ;IN THIS CASE, C(AC)=0 AND E=0,,1 + 2227 ;HENCE, CAIN SHOULD SKIP THE NEXT INSTRUCTION. + 2228 ;IF CAIN SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + 2229 + 2230 031642 400 06 0 00 000000 C51700: SETZ 6, ;PRELOAD AC WITH 0 + 2231 031643 306 06 0 00 000001 CAIN 6,1 ;*CAIN SHOULD SKIP THE NEXT INSTRUCTION + 2232 STOP^ + 2233 031644 254 04 0 00 031645 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2234 031645 324 00 0 00 031646 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2235 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2236 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2237 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2238 + 2239 ;********** + 2240 + 2241 ;THIS TEST VERIFIES THAT CAIN COMPARES C(AC) WITH E AND + 2242 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. + 2243 ;IN THIS CASE, C(AC)=0,,1 AND E=0,,1 + 2244 ;HENCE, CAIN SHOULD NOT SKIP THE NEXT INSTRUCTION. + 2245 ;IF CAIN DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES + 2246 + 2247 031646 200 06 0 00 000001 C51710: MOVE 6,1 ;PRELOAD AC WITH 0,,1 + 2248 031647 306 06 0 00 000001 CAIN 6,1 ;*CAIN SHOULD NOT SKIP THE NEXT INSTRUCTION + 2249 031650 334 00 0 00 000000 SKIPA ;PASS IF CAIN SKIPS + 2250 STOP^ + 2251 031651 254 04 0 00 031652 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2252 031652 324 00 0 00 031653 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2253 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2254 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2255 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2256 + 2257 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 39 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0068 + + 2258 ;THIS TEST VERIFIES THAT CAIN COMPARES C(AC) WITH E AND + 2259 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. + 2260 ;IN THIS CASE, C(AC)=0,,2 AND E=0,,1 + 2261 ;HENCE, CAIN SHOULD SKIP THE NEXT INSTRUCTION. + 2262 ;IF CAIN SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + 2263 + 2264 031653 201 06 0 00 000002 C51720: MOVEI 6,2 ;PRELOAD AC WITH + 2265 031654 306 06 0 00 000001 CAIN 6,1 ;*CAIN SHOULD SKIP THE NEXT INSTRUCTION + 2266 STOP^ + 2267 031655 254 04 0 00 031656 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2268 031656 324 00 0 00 031657 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2269 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2270 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2271 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2272 + 2273 ;********** + 2274 + 2275 ;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND + 2276 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. + 2277 ;IN THIS CASE, C(AC)=0,,2 AND E=0,,3. + 2278 ;HENCE, CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION. + 2279 ;IF CAIG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES + 2280 + 2281 031657 201 11 0 00 000002 C52000: MOVEI 11,2 ;PRELOAD AC WITH 0,,2 + 2282 031660 307 11 0 00 000003 CAIG 11,3 ;*CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION + 2283 031661 334 00 0 00 000000 SKIPA ;PASS IF CAIG DID NOT SKIP + 2284 STOP^ + 2285 031662 254 04 0 00 031663 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2286 031663 324 00 0 00 031664 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2287 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2288 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2289 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2290 + 2291 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 40 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAIX INSTRUCTIONS SEQ 0069 + + 2292 ;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND + 2293 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. + 2294 ;IN THIS CASE, C(AC)=0,,3 AND E=0,,3. + 2295 ;HENCE, CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION. + 2296 ;IF CAIG DOES NOT SKIP THE NEXT INSTRUCTION, THE TEST PASSES. + 2297 + 2298 031664 201 11 0 00 000003 C52010: MOVEI 11,3 ;PRELOAD AC WITH 0,,3 + 2299 031665 307 11 0 00 000003 CAIG 11,3 ;*CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION + 2300 031666 334 00 0 00 000000 SKIPA ;PASS IF CAIG DID NOT SKIP + 2301 STOP^ + 2302 031667 254 04 0 00 031670 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2303 031670 324 00 0 00 031671 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2304 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2305 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2306 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2307 + 2308 ;********** + 2309 + 2310 ;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND + 2311 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. + 2312 ;IN THIS CASE, C(AC)=0,,4 AND E=0,,3. + 2313 ;HENCE, CAIG SHOULD SKIP THE NEXT INSTRUCTION. + 2314 ;IF CAIG SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + 2315 + 2316 031671 201 11 0 00 000004 C52020: MOVEI 11,4 ;PRELOAD AC WITH 0,,4 + 2317 031672 307 11 0 00 000003 CAIG 11,3 ;*CAIG SHOULD SKIP THE NEXT INSTRUCTION + 2318 STOP^ + 2319 031673 254 04 0 00 031674 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2320 031674 324 00 0 00 031675 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2321 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2322 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2323 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2324 + 2325 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 41 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAMX INSTRUCTIONS SEQ 0070 + + 2326 SUBTTL TEST OF MSCL CAMX INSTRUCTIONS + 2327 + 2328 ;********** + 2329 + 2330 ;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND + 2331 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAT OR EQUAL TO C(E). + 2332 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0 + 2333 ;HENCE, CAMLE SHOULD SKIP THE NEXT INSTRUCTION. + 2334 ;IF CAMLE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + 2335 + 2336 031675 474 01 0 00 000000 C52100: SETO 1, ;PRELOAD AC WITH -1,,-1 + 2337 031676 400 02 0 00 000000 SETZ 2, ;PRELOAD E WITH 0 + 2338 031677 313 01 0 00 000002 CAMLE 1,2 ;*CAMLE SHOULD SKIP THE NEXT INSTRUCTION + 2339 STOP^ + 2340 031700 254 04 0 00 031701 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2341 031701 324 00 0 00 031702 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2342 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2343 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2344 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2345 + 2346 ;********** + 2347 + 2348 ;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND + 2349 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO C(E). + 2350 ;IN THIS CASE, C(AC)=0 AND C(E)=0 + 2351 ;HENCE, CAMLE SHOULD SKIP THE NEXT INSTRUCTION. + 2352 ;IF CAMLE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + 2353 + 2354 031702 400 01 0 00 000000 C52110: SETZ 1, ;CLEAR AC + 2355 031703 313 01 0 00 033501 CAMLE 1,[0] ;*CAMLE SHOULD SKIP THE NEXT INSTRUCTION + 2356 STOP^ + 2357 031704 254 04 0 00 031705 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2358 031705 324 00 0 00 031706 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2359 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2360 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2361 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2362 + 2363 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 42 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAMX INSTRUCTIONS SEQ 0071 + + 2364 ;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND + 2365 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO C(E). + 2366 ;IN THIS CASE, C(AC)=0,,1 AND C(E)=0 + 2367 ;HENCE, CAMLE SHOULD NOT SKIP THE NEXT INSTRUCTION. + 2368 ;IF CAMLE DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + 2369 + 2370 031706 201 01 0 00 000001 C52120: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + 2371 031707 400 02 0 00 000000 SETZ 2, ;PRELOAD E WITH 0 + 2372 031710 313 01 0 00 000002 CAMLE 1,2 ;*CAMLE SHOULD NOT SKIP THE NEXT INSTRUCTION + 2373 031711 334 00 0 00 000000 SKIPA ;PASS IF CAMLE DOES NOT SKIP + 2374 STOP^ + 2375 031712 254 04 0 00 031713 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2376 031713 324 00 0 00 031714 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2377 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2378 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2379 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2380 + 2381 ;********** + 2382 + 2383 ;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND + 2384 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). + 2385 ;IN THIS CASE, C(AC)=-1,,-2 AND C(E)=-1,,-1. + 2386 ;HENCE, CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. + 2387 ;IF CAMG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + 2388 + 2389 031714 561 10 0 00 777776 C52200: HRROI 10,-2 ;PRELOAD AC WITH -1,,-2 + 2390 031715 317 10 0 00 033462 CAMG 10,[-1,,-1] ;*CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. + 2391 031716 334 00 0 00 000000 SKIPA ;PASS IF CAMG DOES NOT SKIP + 2392 STOP^ + 2393 031717 254 04 0 00 031720 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2394 031720 324 00 0 00 031721 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2395 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2396 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2397 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2398 ;********** + 2399 + 2400 ;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND + 2401 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). + 2402 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-2. + 2403 ;HENCE, CAMG SHOULD SKIP THE NEXT INSTRUCTION. + 2404 + 2405 031721 561 10 0 00 777777 C52205: HRROI 10,-1 ;PRELOAD AC WITH -1,,-1 + 2406 031722 317 10 0 00 033500 CAMG 10,[-1,,-2] ;*CAMG SHOULD SKIP THE NEXT INSTRUCTION. + 2407 STOP^ + 2408 031723 254 04 0 00 031724 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2409 031724 324 00 0 00 031725 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2410 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2411 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2412 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2413 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 43 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL CAMX INSTRUCTIONS SEQ 0072 + + 2414 ;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND + 2415 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). + 2416 ;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. + 2417 ;HENCE, CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. + 2418 ;IF CAMG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + 2419 031725 474 10 0 00 000000 C52210: SETO 10, ;PRELOAD AC WITH -1,,-1. + 2420 031726 317 10 0 00 033462 CAMG 10,[-1,,-1] ;*CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION + 2421 031727 334 00 0 00 000000 SKIPA ;PASS IF CAMG DOES NOT SKIP + 2422 STOP^ + 2423 031730 254 04 0 00 031731 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2424 031731 324 00 0 00 031732 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2425 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2426 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2427 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2428 + 2429 ;********** + 2430 + 2431 ;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND + 2432 ;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). + 2433 ;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. + 2434 ;HENCE, CAMG SHOULD SKIP THE NEXT INSTRUCTION. + 2435 ;IF CAMG SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + 2436 + 2437 031732 400 10 0 00 000000 C52220: SETZ 10, ;PRELOAD AC WITH 0 + 2438 031733 317 10 0 00 033462 CAMG 10,[-1,,-1] ;*CAMG SHOULD SKIP THE NEXT INSTRUCTION + 2439 STOP^ + 2440 031734 254 04 0 00 031735 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2441 031735 324 00 0 00 031736 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2442 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2443 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2444 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2445 + 2446 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 44 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL JUMPX INSTRUCTIONS SEQ 0073 + + 2447 SUBTTL TEST OF MSCL JUMPX INSTRUCTIONS + 2448 + 2449 ;********** + 2450 + 2451 ;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND + 2452 ;JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR + 2453 ;EQUAL TO 0. IN THIS CASE, C(AC)=-1,,-1. HENCE, JUMPLE SHOULD JUMP. + 2454 + 2455 031736 474 17 0 00 000000 C52300: SETO 17, ;PRELOAD AC WITH -1,,-1 + 2456 031737 323 17 0 00 031741 JUMPLE 17,.+2 ;*JUMPLE SHOULD JUMP + 2457 STOP^ + 2458 031740 254 04 0 00 031741 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2459 031741 324 00 0 00 031742 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2460 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2461 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2462 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2463 + 2464 ;********** + 2465 + 2466 ;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND + 2467 ;JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR + 2468 ;EQUAL TO 0. IN THIS CASE, C(AC)=0. HENCE, JUMPLE SHOULD JUMP. + 2469 + 2470 031742 400 17 0 00 000000 C52310: SETZ 17, ;PRELOAD AC WITH 0 + 2471 031743 323 17 0 00 031745 JUMPLE 17,.+2 ;*JUMPLE SHOULD JUMP + 2472 STOP^ + 2473 031744 254 04 0 00 031745 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2474 031745 324 00 0 00 031746 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2475 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2476 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2477 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2478 + 2479 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 45 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL JUMPX INSTRUCTIONS SEQ 0074 + + 2480 ;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND JUMPS + 2481 ;TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO + 2482 ;0. IN THIS CASE, C(AC)=0,,1. HENCE, JUMPLE SHOULD NOT JUMP. + 2483 + 2484 031746 201 17 0 00 000001 C52320: MOVEI 17,1 ;PRELOAD AC WITH 0,,1 + 2485 031747 320 17 0 00 031751 JUMP 17,.+2 ;*JUMPLE SHOULD NOT JUMP + 2486 031750 334 00 0 00 000000 SKIPA ;PASS IF JUMPLE DOES NOT JUMP + 2487 STOP^ + 2488 031751 254 04 0 00 031752 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2489 031752 324 00 0 00 031753 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2490 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2491 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2492 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2493 + 2494 ;********** + 2495 + 2496 ;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH 0 AND JUMPS TO + 2497 ;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. + 2498 ;IN THIS CASE, C(AC)=-1,,-1. HENCE, JUMPGE SHOULD NOT JUMP. + 2499 + 2500 031753 474 16 0 00 000000 C52400: SETO 16, ;PRELOAD AC WITH -1,,-1 + 2501 031754 325 16 0 00 031756 JUMPGE 16,.+2 ;*JUMPGE SHOULD NOT JUMP + 2502 031755 334 00 0 00 000000 SKIPA ;PASS IF JUMPGE DOES NOT JUMP + 2503 STOP^ + 2504 031756 254 04 0 00 031757 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2505 031757 324 00 0 00 031760 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2506 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2507 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2508 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2509 + 2510 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 46 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL JUMPX INSTRUCTIONS SEQ 0075 + + 2511 ;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH O AND JUMPS TO + 2512 ;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. + 2513 ;IN THIS CASE, C(AC)=0. HENCE, JUMPGE SHOULD JUMP. + 2514 + 2515 031760 400 16 0 00 000000 C52410: SETZ 16, ;PRELOAD AC WITH 0 + 2516 031761 325 16 0 00 031763 JUMPGE 16,.+2 ;*JUMPGE SHOULD JUMP + 2517 STOP^ + 2518 031762 254 04 0 00 031763 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2519 031763 324 00 0 00 031764 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2520 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2521 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2522 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2523 + 2524 ;********** + 2525 + 2526 ;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH 0 AND JUMPS TO + 2527 ;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. + 2528 ;IN THIS CASE, C(AC)=0,,1. HENCE, JUMPGE SHOULD JUMP. + 2529 + 2530 031764 201 16 0 00 000001 C52420: MOVEI 16,1 ;PRELOAD AC WITH 0,,1 + 2531 031765 325 16 0 00 031767 JUMPGE 16,.+2 ;*JUMPGE SHOULD JUMP + 2532 STOP^ + 2533 031766 254 04 0 00 031767 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2534 031767 324 00 0 00 031770 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2535 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2536 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2537 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2538 + 2539 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 47 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0076 + + 2540 SUBTTL TEST OF MSCL AOJX INSTRUCTIONS + 2541 + 2542 ;********** + 2543 + 2544 ;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND PLACES + 2545 ;THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS COMPARED + 2546 ;TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) + 2547 ;IS LESS THAN 0. IN THIS CASE, C(AC)=-1,,-2 BEFORE INCREMENTING. + 2548 ;HENCE, AOJL SHOULD JUMP. + 2549 + 2550 031770 561 15 0 00 777776 C52500: HRROI 15,-2 ;PRELOAD AC WITH -1,,-2 + 2551 031771 341 15 0 00 031773 AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) AND JUMP + 2552 STOP^ + 2553 031772 254 04 0 00 031773 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2554 031773 324 00 0 00 031774 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2555 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2556 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2557 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2558 031774 312 15 0 00 033462 CAME 15,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + 2559 STOP^ + 2560 031775 254 04 0 00 031776 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2561 031776 324 00 0 00 031777 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2562 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2563 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2564 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2565 + 2566 ;********** + 2567 + 2568 ;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND + 2569 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2570 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2571 ;SPECIFIED BY E IF C(AC) IS LESS THAN 0. + 2572 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING + 2573 ;HENCE, AOJ SHOULD NOT JUMP + 2574 + 2575 031777 474 15 0 00 000000 C52510: SETO 15, ;PRELOAD AC WITH + 2576 032000 341 15 0 00 032002 AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) + 2577 ;AND NOT JUMP + 2578 032001 334 00 0 00 000000 SKIPA ;PASS IF AOJL DID NOT JUMP + 2579 STOP^ + 2580 032002 254 04 0 00 032003 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2581 032003 324 00 0 00 032004 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2582 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2583 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2584 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2585 032004 302 15 0 00 000000 CAIE 15,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + 2586 STOP^ + 2587 032005 254 04 0 00 032006 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2588 032006 324 00 0 00 032007 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2589 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2590 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2591 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2592 + 2593 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 48 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0077 + + 2594 ;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND + 2595 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2596 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2597 ;SPECIFIED BY E IF C(AC) IS 0 BEFORE INCREMENTING + 2598 ;HENCE, AOJL SHOULD NOT JUMP + 2599 + 2600 032007 400 15 0 00 000000 C52520: SETZ 15, ;PRELOAD AC WITH 0 + 2601 032010 341 15 0 00 032012 AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) + 2602 ;AND NOT JUMP + 2603 032011 334 00 0 00 000000 SKIPA ;PASS IF AOJL DID NOT JUMP + 2604 STOP^ + 2605 032012 254 04 0 00 032013 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2606 032013 324 00 0 00 032014 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2607 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2608 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2609 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2610 032014 302 15 0 00 000001 CAIE 15,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + 2611 STOP^ + 2612 032015 254 04 0 00 032016 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2613 032016 324 00 0 00 032017 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2614 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2615 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2616 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2617 + 2618 ;********** + 2619 + 2620 ;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND + 2621 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2622 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2623 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0 + 2624 ;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING + 2625 ;HENCE, AOJE SHOULD NOT JUMP + 2626 + 2627 032017 561 14 0 00 777776 C52600: HRROI 14,-2 ;PRELOAD AC WITH -1,,-2 + 2628 032020 342 14 0 00 032022 AOJE 14,.+2 ;*AOJE SHOULD ADD 0,,1 TO C(AC) + 2629 ;AND NOT JUMP + 2630 032021 334 00 0 00 000000 SKIPA ;PASS IF AOJE DID NOT JUMP + 2631 STOP^ + 2632 032022 254 04 0 00 032023 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2633 032023 324 00 0 00 032024 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2634 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2635 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2636 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2637 032024 312 14 0 00 033462 CAME 14,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + 2638 STOP^ + 2639 032025 254 04 0 00 032026 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2640 032026 324 00 0 00 032027 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2641 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2642 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2643 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2644 + 2645 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 49 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0078 + + 2646 ;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND + 2647 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2648 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2649 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. + 2650 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING. + 2651 ;HENCE, AOJE SHOULD JUMP + 2652 + 2653 032027 474 14 0 00 000000 C52610: SETO 14, ;PRELOAD AC WITH -1,,-1 + 2654 032030 342 14 0 00 032032 AOJE 14,.+2 ;*AOJ SHOULD ADD 0,,1 TO C(AC) + 2655 ;AND JUMP + 2656 STOP^ + 2657 032031 254 04 0 00 032032 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2658 032032 324 00 0 00 032033 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2659 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2660 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2661 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2662 032033 302 14 0 00 000000 CAIE 14,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + 2663 STOP^ + 2664 032034 254 04 0 00 032035 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2665 032035 324 00 0 00 032036 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2666 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2667 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2668 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2669 + 2670 ;********** + 2671 + 2672 ;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND + 2673 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2674 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2675 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. + 2676 ;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING + 2677 ;HENCE, AOJE SHOULD NOT JUMP + 2678 + 2679 032036 400 14 0 00 000000 C52620: SETZ 14, ;PRELOAD AC WITH 0 + 2680 032037 342 14 0 00 032041 AOJE 14,.+2 ;*AOJE SHOULD ADD 0,11 TO C(AC) + 2681 ;AND NOT JUMP + 2682 032040 334 00 0 00 000000 SKIPA ;PASS IF AOJE DID NOT JUMP + 2683 STOP^ + 2684 032041 254 04 0 00 032042 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2685 032042 324 00 0 00 032043 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2686 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2687 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2688 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2689 032043 302 14 0 00 000001 CAIE 14,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + 2690 STOP^ + 2691 032044 254 04 0 00 032045 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2692 032045 324 00 0 00 032046 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2693 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2694 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2695 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2696 + 2697 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 50 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0079 + + 2698 ;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND + 2699 ;PLACES THE RESULT BACK INTO TLE$EC. THE RESULT IN THE AC IS + 2700 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2701 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. + 2702 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING + 2703 ;HENCE, AOJLE SHOULD + 2704 + 2705 032046 561 13 0 00 777776 C52700: HRROI 13,-2 ;PRELOAD AC WITH -1,,-2 + 2706 032047 343 13 0 00 032051 AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) + 2707 ;AND JUMP + 2708 STOP^ + 2709 032050 254 04 0 00 032051 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2710 032051 324 00 0 00 032052 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2711 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2712 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2713 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2714 032052 312 13 0 00 033462 CAME 13,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + 2715 STOP^ + 2716 032053 254 04 0 00 032054 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2717 032054 324 00 0 00 032055 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2718 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2719 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2720 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2721 + 2722 ;********** + 2723 + 2724 ;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND + 2725 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2726 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2727 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0 + 2728 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING + 2729 ;HENCE, AOJLE SHOULD JUMP. + 2730 + 2731 032055 474 13 0 00 000000 C52710: SETO 13, ;PRELOAD AC WITH -1,,-1 + 2732 032056 343 13 0 00 032060 AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) + 2733 ;AND JUMP + 2734 STOP^ + 2735 032057 254 04 0 00 032060 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2736 032060 324 00 0 00 032061 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2737 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2738 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2739 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2740 032061 302 13 0 00 000000 CAIE 13,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + 2741 STOP^ + 2742 032062 254 04 0 00 032063 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2743 032063 324 00 0 00 032064 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2744 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2745 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2746 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2747 + 2748 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 51 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0080 + + 2749 ;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND + 2750 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2751 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2752 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. + 2753 ;IN THIS CASE, C(AC) IS 0 + 2754 ;HENCE, AOJLE SHOULD NOT JUMP. + 2755 + 2756 032064 400 13 0 00 000000 C52720: SETZ 13, ;PRELOAD AC WITH 0 + 2757 032065 343 13 0 00 032067 AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) + 2758 ;AND NOT JUMP + 2759 032066 334 00 0 00 000000 SKIPA ;PASS IF AOJLE DID NOT JUMP + 2760 STOP^ + 2761 032067 254 04 0 00 032070 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2762 032070 324 00 0 00 032071 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2763 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2764 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2765 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2766 032071 302 13 0 00 000001 CAIE 13,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + 2767 STOP^ + 2768 032072 254 04 0 00 032073 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2769 032073 324 00 0 00 032074 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2770 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2771 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2772 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2773 + 2774 ;********** + 2775 + 2776 ;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND + 2777 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2778 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION + 2779 ;SPECIFIED BY E. + 2780 ;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING + 2781 ;HENCE, AOJA SHOULD JUMP + 2782 + 2783 032074 561 12 0 00 777776 C53000: HRROI 12,-2 ;PRELOAD AC WITH -1,,-2 + 2784 032075 344 12 0 00 032077 AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) + 2785 ;AND JUMP + 2786 STOP^ + 2787 032076 254 04 0 00 032077 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2788 032077 324 00 0 00 032100 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2789 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2790 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2791 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2792 032100 312 12 0 00 033462 CAME 12,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + 2793 STOP^ + 2794 032101 254 04 0 00 032102 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2795 032102 324 00 0 00 032103 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2796 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2797 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2798 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2799 + 2800 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 52 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0081 + + 2801 ;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND + 2802 ;PLACES THE RESULT BACK INTO AC. THE RESULT IN THE AC IS + 2803 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION + 2804 ;SPECIFIED BY E. + 2805 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING + 2806 ;HENCE, AOJA SHOULD JUMP + 2807 + 2808 032103 474 12 0 00 000000 C53010: SETO 12, ;PRELOAD AC WITH -1,,-1 + 2809 032104 344 12 0 00 032106 AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) + 2810 ;AND JUMP + 2811 STOP^ + 2812 032105 254 04 0 00 032106 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2813 032106 324 00 0 00 032107 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2814 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2815 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2816 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2817 032107 302 12 0 00 000000 CAIE 12,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + 2818 STOP^ + 2819 032110 254 04 0 00 032111 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2820 032111 324 00 0 00 032112 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2821 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2822 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2823 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2824 + 2825 ;********** + 2826 + 2827 ;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND + 2828 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2829 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION + 2830 ;SPECIFIED BY E. + 2831 ;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING + 2832 ;HENCE, AOJA SHOULD JUMP + 2833 + 2834 032112 400 12 0 00 000000 C53020: SETZ 12, ;PRELOAD AC WITH 0 + 2835 032113 344 12 0 00 032115 AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) + 2836 ;AND JUMP + 2837 STOP^ + 2838 032114 254 04 0 00 032115 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2839 032115 324 00 0 00 032116 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2840 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2841 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2842 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2843 032116 302 12 0 00 000001 CAIE 12,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + 2844 STOP^ + 2845 032117 254 04 0 00 032120 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2846 032120 324 00 0 00 032121 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2847 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2848 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2849 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2850 + 2851 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 53 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0082 + + 2852 ;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND + 2853 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2854 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2855 ;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 + 2856 ;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING + 2857 ;HENCE, AOJGE SHOULD NOT JUMP + 2858 + 2859 032121 561 11 0 00 777776 C53100: HRROI 11,-2 ;PRELOAD AC WITH -1,,-2 + 2860 032122 345 11 0 00 032124 AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) + 2861 ;AND NOT JUMP + 2862 032123 334 00 0 00 000000 SKIPA ;PASS IF AOJGE DID NOT JUMP + 2863 STOP^ + 2864 032124 254 04 0 00 032125 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2865 032125 324 00 0 00 032126 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2866 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2867 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2868 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2869 032126 312 11 0 00 033462 CAME 11,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + 2870 STOP^ + 2871 032127 254 04 0 00 032130 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2872 032130 324 00 0 00 032131 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2873 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2874 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2875 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2876 + 2877 ;********** + 2878 + 2879 ;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND + 2880 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2881 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2882 ;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. + 2883 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING + 2884 ;HENCE, AOJ SHOULD JUMP + 2885 + 2886 032131 474 11 0 00 000000 C53110: SETO 11, ;PRELOAD AC WITH -1,,-1 + 2887 032132 345 11 0 00 032134 AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) + 2888 ;AND JUMP + 2889 STOP^ + 2890 032133 254 04 0 00 032134 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2891 032134 324 00 0 00 032135 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2892 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2893 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2894 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2895 032135 302 11 0 00 000000 CAIE 11,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + 2896 STOP^ + 2897 032136 254 04 0 00 032137 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2898 032137 324 00 0 00 032140 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2899 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2900 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2901 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2902 + 2903 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 54 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0083 + + 2904 ;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND + 2905 ;PLACES THE RESULT BACK INTO AC. THE RESULT IN THE AC IS + 2906 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2907 ;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 + 2908 ;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING + 2909 ;HENCE, AOJGE SHOULD JUMP + 2910 + 2911 032140 400 11 0 00 000000 C53120: SETZ 11, ;PRELOAD AC WITH 0 + 2912 032141 345 11 0 00 032143 AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) + 2913 ;AND JUMP + 2914 STOP^ + 2915 032142 254 04 0 00 032143 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2916 032143 324 00 0 00 032144 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2917 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2918 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2919 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2920 032144 302 11 0 00 000001 CAIE 11,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + 2921 STOP^ + 2922 032145 254 04 0 00 032146 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2923 032146 324 00 0 00 032147 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2924 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2925 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2926 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2927 + 2928 ;********** + 2929 + 2930 ;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND + 2931 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2932 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2933 ;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. + 2934 ;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING + 2935 ;HENCE, AOJN SHOULD JUMP + 2936 + 2937 032147 561 10 0 00 777776 C53200: HRROI 10,-2 ;PRELOAD AC WITH -1,,-2 + 2938 032150 346 10 0 00 032152 AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) + 2939 ;AND JUMP + 2940 STOP^ + 2941 032151 254 04 0 00 032152 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2942 032152 324 00 0 00 032153 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2943 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2944 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2945 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2946 032153 312 10 0 00 033462 CAME 10,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + 2947 STOP^ + 2948 032154 254 04 0 00 032155 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2949 032155 324 00 0 00 032156 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2950 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2951 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2952 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2953 + 2954 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 55 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0084 + + 2955 ;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND + 2956 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2957 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2958 ;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. + 2959 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING + 2960 ;HENCE, AOJ SHOULD NOT JUMP. + 2961 + 2962 032156 474 10 0 00 000000 C53210: SETO 10, ;PRELOAD AC WITH -1,,-1 + 2963 032157 346 10 0 00 032161 AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) + 2964 ;AND NOT JUMP + 2965 032160 334 00 0 00 000000 SKIPA ;PASS IF AOJN DID NOT JUMP + 2966 STOP^ + 2967 032161 254 04 0 00 032162 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2968 032162 324 00 0 00 032163 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2969 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2970 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2971 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2972 032163 302 10 0 00 000000 CAIE 10,0 ;PASS IF C(AC) INCREMENTED CORRRECTLY + 2973 STOP^ + 2974 032164 254 04 0 00 032165 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2975 032165 324 00 0 00 032166 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2976 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2977 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2978 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2979 + 2980 ;********** + 2981 + 2982 ;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND + 2983 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 2984 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 2985 ;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. + 2986 ;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING + 2987 ;HENCE, AOJN SHOULD JUMP. + 2988 + 2989 032166 400 10 0 00 000000 C53220: SETZ 10, ;PRELOAD AC WITH 0 + 2990 032167 346 10 0 00 032171 AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) + 2991 ;AND JUMP + 2992 STOP^ + 2993 032170 254 04 0 00 032171 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 2994 032171 324 00 0 00 032172 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 2995 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 2996 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 2997 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 2998 032172 302 10 0 00 000001 CAIE 10,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + 2999 STOP^ + 3000 032173 254 04 0 00 032174 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3001 032174 324 00 0 00 032175 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3002 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3003 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3004 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3005 + 3006 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 56 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0085 + + 3007 ;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND + 3008 ;PLACES THE RESULT BACK INTO THE AC. THE REAULT IN THE AC IS + 3009 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 3010 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0 + 3011 ;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INC + 3012 ;HENCE, AOJG SHOULD NOT JUMP + 3013 + 3014 032175 561 07 0 00 777776 C53300: HRROI 7,-2 ;PRELOAD AC WITH -1,,-2 + 3015 032176 347 07 0 00 032200 AOJG 7,.+2 ;*AOJG SHOULD ADD 0,11 TO C(AC) + 3016 ;AND NOT JUMP + 3017 032177 334 00 0 00 000000 SKIPA ;PASS IF AOJG DID NOT JUMP + 3018 STOP^ + 3019 032200 254 04 0 00 032201 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3020 032201 324 00 0 00 032202 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3021 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3022 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3023 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3024 032202 312 07 0 00 033462 CAME 7,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + 3025 STOP^ + 3026 032203 254 04 0 00 032204 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3027 032204 324 00 0 00 032205 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3028 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3029 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3030 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3031 + 3032 ;********** + 3033 + 3034 ;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND + 3035 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 3036 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 3037 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. + 3038 ;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING + 3039 ;HENCE, AOJG SHOULD NOT JUMP. + 3040 + 3041 032205 474 07 0 00 000000 C53310: SETO 7, ;PRELOAD AC WITH -1,,-1 + 3042 032206 347 07 0 00 032210 AOJG 7,.+2 ;*AOJG SHOULD ADD 0,,1 TO C(AC) + 3043 ;AND NOT JUMP + 3044 032207 334 00 0 00 000000 SKIPA ;PASS IF AOJG DID NOT JUMP + 3045 STOP^ + 3046 032210 254 04 0 00 032211 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3047 032211 324 00 0 00 032212 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3048 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3049 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3050 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3051 032212 302 07 0 00 000000 CAIE 7,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + 3052 STOP^ + 3053 032213 254 04 0 00 032214 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3054 032214 324 00 0 00 032215 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3055 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3056 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3057 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3058 + 3059 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 57 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOJX INSTRUCTIONS SEQ 0086 + + 3060 ;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND + 3061 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 3062 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 3063 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. + 3064 ;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING + 3065 ;HENCE, AOJG SHOULD JUMP + 3066 + 3067 032215 400 07 0 00 000000 C53320: SETZ 7, ;PRELOAD AC WITH 0 + 3068 032216 347 07 0 00 032220 AOJG 7,.+2 ;*AOJG SHOULD ADD 0,,1 TO C(AC) + 3069 ;AND JUMP + 3070 STOP^ + 3071 032217 254 04 0 00 032220 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3072 032220 324 00 0 00 032221 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3073 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3074 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3075 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3076 032221 302 07 0 00 000001 CAIE 7,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + 3077 STOP^ + 3078 032222 254 04 0 00 032223 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3079 032223 324 00 0 00 032224 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3080 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3081 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3082 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3083 + 3084 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 58 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0087 + + 3085 SUBTTL TEST OF MSCL AOSX INSTRUCTIONS + 3086 + 3087 ;********** + 3088 + 3089 ;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES + 3090 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3091 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0 + 3092 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3093 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-2 + 3094 ;BEFORE INCREMENTING. HENCE, AOSL SHOULD SKIP ; AND THE + 3095 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 3096 ;RESPECTIVELY. + 3097 + 3098 032224 200 06 0 00 033474 C53400: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3099 032225 561 07 0 00 777776 HRROI 7,-2 ;PRELOAD E WITH -1,,-2 + 3100 032226 351 06 0 00 000007 AOSL 6,7 ;*AOSL SHOULD ADD 0,,1 TO C(E), + 3101 ;UPDATE AC AND SKIP + 3102 STOP^ + 3103 032227 254 04 0 00 032230 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3104 032230 324 00 0 00 032231 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3105 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3106 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3107 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3108 032231 312 07 0 00 033462 CAME 7,[-1] ;PASS IF E INCREMENTED CORRECTLY + 3109 STOP^ + 3110 032232 254 04 0 00 032233 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3111 032233 324 00 0 00 032234 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3112 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3113 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3114 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3115 032234 312 06 0 00 033462 CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3116 STOP^ + 3117 032235 254 04 0 00 032236 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3118 032236 324 00 0 00 032237 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3119 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3120 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3121 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3122 + 3123 ;********** + 3124 + 3125 ;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES + 3126 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3127 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0 + 3128 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3129 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-2 + 3130 ;BEFORE INCREMENTING. HENCE, AOSL SHOULD SKIP ; AND THE + 3131 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 3132 ;RESPECTIVELY. + 3133 + 3134 032237 200 06 0 00 033474 C53401: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3135 032240 561 07 0 00 777776 HRROI 7,-2 ;PRELOAD E WITH -1,,-2 + 3136 032241 202 07 0 00 032255 MOVEM 7,E53401 + 3137 032242 351 06 0 00 032255 AOSL 6,E53401 ;*AOSL SHOULD ADD 0,,1 TO C(E), + 3138 ;UPDATE AC AND SKIP + 3139 STOP^ +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 58-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0088 + + 3140 032243 254 04 0 00 032244 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3141 032244 324 00 0 00 032245 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3142 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3143 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3144 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3145 032245 200 07 0 00 032255 MOVE 7,E53401 + 3146 032246 312 07 0 00 033462 CAME 7,[-1] ;PASS IF E INCREMENTED CORRECTLY + 3147 STOP^ + 3148 032247 254 04 0 00 032250 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3149 032250 324 00 0 00 032251 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3150 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3151 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3152 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3153 032251 312 06 0 00 033462 CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3154 STOP^ + 3155 032252 254 04 0 00 032253 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3156 032253 324 00 0 00 032254 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3157 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3158 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3159 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3160 + 3161 032254 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST + 3162 032255 000000 000000 E53401: 0 ;TEST WORD MEMORY + 3163 + 3164 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 59 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0089 + + 3165 ;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES + 3166 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3167 ;THE NEXT INSTRUCTION IF C(E) ISLESS THAN 0 + 3168 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3169 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-1 + 3170 ;BEFORE INCREMENTING. HENCE, AOSL SHOULD NOT SKIP; AND THE + 3171 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 + 3172 ;RESPECTIVELY. + 3173 + 3174 032256 200 06 0 00 033474 C53410: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3175 032257 474 07 0 00 000000 SETO 7, ;PRELOAD E WITH -1,,-1 + 3176 032260 351 06 0 00 000007 AOSL 6,7 ;*AOSL SHOULD ADD 00,1 TO C(E) + 3177 ;UPDATE AC AND NOT SKIP + 3178 032261 334 00 0 00 000000 SKIPA ;PASS IF AOSL DID NOT SKIP + 3179 STOP^ + 3180 032262 254 04 0 00 032263 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3181 032263 324 00 0 00 032264 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3182 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3183 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3184 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3185 032264 312 07 0 00 033501 CAME 7,[0] ;PASS IF E INCREMENTED CORRECTLY + 3186 STOP^ + 3187 032265 254 04 0 00 032266 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3188 032266 324 00 0 00 032267 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3189 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3190 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3191 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3192 032267 312 06 0 00 033501 CAME 6,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3193 STOP^ + 3194 032270 254 04 0 00 032271 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3195 032271 324 00 0 00 032272 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3196 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3197 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3198 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3199 + 3200 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 60 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0090 + + 3201 ;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES + 3202 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3203 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. + 3204 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3205 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0 + 3206 ;BEFORE INCREMENTING. HENCE, AOSL SHOULD NOT SKIP; AND THE + 3207 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 + 3208 ;RESPECTIVELY + 3209 + 3210 032272 200 06 0 00 033474 C53420: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3211 032273 400 07 0 00 000000 SETZ 7, ;PRELOAD E WITH 0 + 3212 032274 351 06 0 00 000007 AOSL 6,7 ;*AOSL SHOULD ADD 0,,1 TO C(E). + 3213 ;UPDATE AC AND NOT SKIP + 3214 032275 334 00 0 00 000000 SKIPA ;PASS IF AOSL DID NOT SKIP + 3215 STOP^ + 3216 032276 254 04 0 00 032277 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3217 032277 324 00 0 00 032300 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3218 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3219 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3220 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3221 032300 312 07 0 00 033502 CAME 7,[1] ;PASS IF E INCREMENTED CORRECTLY + 3222 STOP^ + 3223 032301 254 04 0 00 032302 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3224 032302 324 00 0 00 032303 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3225 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3226 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3227 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3228 032303 312 06 0 00 033502 CAME 6,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3229 STOP^ + 3230 032304 254 04 0 00 032305 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3231 032305 324 00 0 00 032306 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3232 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3233 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3234 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3235 + 3236 ;********** + 3237 + 3238 ;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES + 3239 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3240 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0. + 3241 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3242 ;IN THIS CASE, AC=5, C(AC)=707070,,707070AND C(E)=-1,,-2 + 3243 ;BEFORE INCREMENTING. HENCE, AOSE SHOULD NOT SKIP; AND THE + 3244 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 3245 ;RESPECTIVELY. + 3246 + 3247 032306 200 05 0 00 033474 C53500: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3248 032307 561 06 0 00 777776 HRROI 6,-2 ;PRELOAD E WITH -1,,-2 + 3249 032310 352 05 0 00 000006 AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), + 3250 ;UPDATE AC AND NOT SKIP + 3251 032311 334 00 0 00 000000 SKIPA ;PASS IF AOSE DID NOT SKIP + 3252 STOP^ + 3253 032312 254 04 0 00 032313 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3254 032313 324 00 0 00 032314 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3255 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 60-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0091 + + 3256 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3257 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3258 032314 312 06 0 00 033462 CAME 6,[-1] ;PASS IF E INCREMENTED CORRECTLY + 3259 STOP^ + 3260 032315 254 04 0 00 032316 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3261 032316 324 00 0 00 032317 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3262 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3263 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3264 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3265 032317 312 05 0 00 033462 CAME 5,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3266 STOP^ + 3267 032320 254 04 0 00 032321 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3268 032321 324 00 0 00 032322 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3269 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3270 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3271 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3272 + 3273 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 61 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0092 + + 3274 ;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES + 3275 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3276 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 + 3277 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3278 ;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=-1,,-1 + 3279 ;BEFORE INCREMENTING. HENCE, AOSE SHOULD SKIP; AND THE + 3280 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 + 3281 ;RESPECTIVELY. + 3282 + 3283 032322 200 05 0 00 033474 C53510: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3284 032323 474 06 0 00 000000 SETO 6, ;PRELOAD E WITH -1,,-1 + 3285 032324 352 05 0 00 000006 AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), + 3286 ;UPDATE AC AND SKIP + 3287 STOP^ + 3288 032325 254 04 0 00 032326 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3289 032326 324 00 0 00 032327 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3290 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3291 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3292 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3293 032327 312 06 0 00 033501 CAME 6,[0] ;PASS IF E INCREMENTED CORRECTLY + 3294 STOP^ + 3295 032330 254 04 0 00 032331 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3296 032331 324 00 0 00 032332 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3297 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3298 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3299 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3300 032332 312 05 0 00 033501 CAME 5,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3301 STOP^ + 3302 032333 254 04 0 00 032334 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3303 032334 324 00 0 00 032335 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3304 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3305 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3306 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3307 + 3308 ;********** + 3309 + 3310 ;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES + 3311 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3312 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 + 3313 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3314 ;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(AC)=0 + 3315 ;BEFORE INCREMENTING. HENCE, AOSE SHOULD NOT SKIP; AND THE + 3316 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 + 3317 ;RESPECTIVELY. + 3318 + 3319 032335 200 05 0 00 033474 C53520: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3320 032336 400 06 0 00 000000 SETZ 6, ;PRELOAD E WITH 0 + 3321 032337 352 05 0 00 000006 AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), + 3322 ;UPDATE AC AND NOT SKIP + 3323 032340 334 00 0 00 000000 SKIPA ;PASS IF AOSE DID NOT SKIP + 3324 STOP^ + 3325 032341 254 04 0 00 032342 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3326 032342 324 00 0 00 032343 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3327 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3328 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 61-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0093 + + 3329 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3330 032343 312 06 0 00 033502 CAME 6,[1] ;PASS IF E INCREMENTED CORRECTLY + 3331 STOP^ + 3332 032344 254 04 0 00 032345 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3333 032345 324 00 0 00 032346 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3334 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3335 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3336 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3337 032346 312 05 0 00 033502 CAME 5,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3338 STOP^ + 3339 032347 254 04 0 00 032350 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3340 032350 324 00 0 00 032351 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3341 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3342 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3343 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3344 + 3345 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 62 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0094 + + 3346 ;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES + 3347 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3348 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO0 + 3349 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3350 ;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=-1,,-2 + 3351 ;BEFORE INCREMENTING. HENCE, AOSLE SHOULD SKIP; AND THE + 3352 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 3353 ;RESPECTIVELY. + 3354 + 3355 032351 200 04 0 00 033474 C53600: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3356 032352 561 05 0 00 777776 HRROI 5,-2 ;PRELOAD E WITH -1,,-2 + 3357 032353 353 04 0 00 000005 AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E), + 3358 ;UPDATE AC AND SKIP ZERO + 3359 STOP^ + 3360 032354 254 04 0 00 032355 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3361 032355 324 00 0 00 032356 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3362 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3363 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3364 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3365 032356 312 05 0 00 033462 CAME 5,[-1] ;PASS IF E INCREMENTED CORRECTLY + 3366 STOP^ + 3367 032357 254 04 0 00 032360 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3368 032360 324 00 0 00 032361 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3369 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3370 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3371 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3372 032361 312 04 0 00 033462 CAME 4,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3373 STOP^ + 3374 032362 254 04 0 00 032363 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3375 032363 324 00 0 00 032364 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3376 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3377 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3378 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3379 + 3380 ;********** + 3381 + 3382 ;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES + 3383 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3384 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. + 3385 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3386 ;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=-1,,-1 + 3387 ;BEFORE INCREMENTING. HENCE, AOSLE SHOULD SKIP; AND THE + 3388 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 + 3389 ;RESPECTIVELY. + 3390 + 3391 032364 200 04 0 00 033474 C53610: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3392 032365 476 05 0 00 000000 SETOM 5, ;PRELOAD E WITH -1,,-1 + 3393 032366 353 04 0 00 000005 AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E) + 3394 ;UPDATE AC AND SKIP + 3395 STOP^ + 3396 032367 254 04 0 00 032370 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3397 032370 324 00 0 00 032371 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3398 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3399 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3400 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 62-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0095 + + 3401 032371 312 05 0 00 033501 CAME 5,[0] ;PASS IF E INCREMENTED CORRECTLY + 3402 STOP^ + 3403 032372 254 04 0 00 032373 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3404 032373 324 00 0 00 032374 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3405 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3406 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3407 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3408 032374 312 04 0 00 033501 CAME 4,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3409 STOP^ + 3410 032375 254 04 0 00 032376 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3411 032376 324 00 0 00 032377 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3412 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3413 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3414 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3415 + 3416 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 63 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0096 + + 3417 ;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES + 3418 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3419 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0 + 3420 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3421 ;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0 + 3422 ;BEFORE INCREMENTING. HENCE, AOSLE SHOULD NOT SKIP ; AND THE + 3423 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 + 3424 ;RESPECTIVELY. + 3425 + 3426 032377 200 04 0 00 033474 C53620: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3427 032400 400 00 0 00 000005 SETZ 5 ;PRELOAD E WITH 0 + 3428 032401 353 04 0 00 000005 AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E) + 3429 ;UPDATE AC AND NOT SKIP + 3430 032402 334 00 0 00 000000 SKIPA ;PASS IF AOSLE DID NOT SKIP + 3431 STOP^ + 3432 032403 254 04 0 00 032404 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3433 032404 324 00 0 00 032405 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3434 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3435 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3436 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3437 032405 312 05 0 00 033502 CAME 5,[1] ;PASS IF E INCREMENTED CORRECTLY + 3438 STOP^ + 3439 032406 254 04 0 00 032407 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3440 032407 324 00 0 00 032410 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3441 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3442 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3443 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3444 032410 312 04 0 00 033502 CAME 4,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3445 STOP^ + 3446 032411 254 04 0 00 032412 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3447 032412 324 00 0 00 032413 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3448 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3449 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3450 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3451 + 3452 ;********** + 3453 + 3454 ;THIS TEST VERIFIES THAT AOSA INCREMENTS C(E) BY 0,,1 AND PLACES + 3455 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS + 3456 ;THE NEXT INSTRUCTION. + 3457 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3458 ;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=-1,,-2 + 3459 ;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP ; AND THE + 3460 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 3461 ;RESPECTIVELY. + 3462 + 3463 032413 200 03 0 00 033474 C53700: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3464 032414 561 04 0 00 777776 HRROI 4,-2 ;PRELOAD E WITH -1,,-2 + 3465 032415 354 03 0 00 000004 AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), + 3466 ;UPDATE AC AND SKIP + 3467 STOP^ + 3468 032416 254 04 0 00 032417 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3469 032417 324 00 0 00 032420 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3470 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3471 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 63-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0097 + + 3472 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3473 032420 312 04 0 00 033462 CAME 4,[-1] ;PASS IF E INCREMENTED CORRECTLY + 3474 STOP^ + 3475 032421 254 04 0 00 032422 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3476 032422 324 00 0 00 032423 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3477 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3478 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3479 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3480 032423 312 03 0 00 033462 CAME 3,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3481 STOP^ + 3482 032424 254 04 0 00 032425 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3483 032425 324 00 0 00 032426 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3484 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3485 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3486 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3487 + 3488 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 64 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0098 + + 3489 ;THIS TEST VERIFIES THAT AOSA INCREMENTS C(E) BY 0,,1 AND PLACES + 3490 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS + 3491 ;THE NEXT INSTRUCTION. + 3492 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3493 ;;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=-1,,-1 + 3494 ;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP AND THE + 3495 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 + 3496 ;RESPECTIVELY + 3497 + 3498 032426 200 03 0 00 033474 C53710: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3499 032427 474 04 0 00 000000 SETO 4, ;PRELOAD E WITH -1,,-1 + 3500 032430 354 03 0 00 000004 AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), + 3501 ;UPDATE AC AND SKIP + 3502 STOP^ + 3503 032431 254 04 0 00 032432 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3504 032432 324 00 0 00 032433 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3505 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3506 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3507 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3508 032433 312 04 0 00 033501 CAME 4,[0] ;PASS IF E INCREMENTED CORRECTLY + 3509 STOP^ + 3510 032434 254 04 0 00 032435 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3511 032435 324 00 0 00 032436 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3512 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3513 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3514 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3515 032436 312 03 0 00 033501 CAME 3,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3516 STOP^ + 3517 032437 254 04 0 00 032440 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3518 032440 324 00 0 00 032441 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3519 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3520 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3521 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3522 + 3523 ;********** + 3524 + 3525 ;THIS TEST VERIFIES THAT AOS INCREMENTS C(E) BY 0,,1 AND PLACES + 3526 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS + 3527 ;THE NEXT INSTRUCTION. + 3528 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3529 ;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0 + 3530 ;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP ; AND THE + 3531 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 + 3532 ;RESPECTIVELY + 3533 + 3534 032441 200 03 0 00 033474 C53720: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3535 032442 400 04 0 00 000000 SETZ 4, ;PRELOAD E WITH 0 + 3536 032443 354 03 0 00 000004 AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), + 3537 ;UPDATE AC AND SKIP + 3538 STOP^ + 3539 032444 254 04 0 00 032445 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3540 032445 324 00 0 00 032446 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3541 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3542 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3543 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 64-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0099 + + 3544 032446 312 04 0 00 033502 CAME 4,[1] ;PASS IF E INCREMENTED CORRECTLY + 3545 STOP^ + 3546 032447 254 04 0 00 032450 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3547 032450 324 00 0 00 032451 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3548 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3549 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3550 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3551 032451 312 03 0 00 033502 CAME 3,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3552 STOP^ + 3553 032452 254 04 0 00 032453 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3554 032453 324 00 0 00 032454 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3555 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3556 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3557 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3558 + 3559 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 65 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0100 + + 3560 ;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES + 3561 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3562 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 + 3563 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3564 ;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=-1,,-2 + 3565 ;BEFORE INCREMENTING. HENCE, AOSGE SHOULD NOT SKIP; AND THE + 3566 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 3567 ;RESPECTIVELY + 3568 + 3569 032454 200 02 0 00 033474 C54000: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3570 032455 561 03 0 00 777776 HRROI 3,-2 ;PRELOAD E WITH -1,,-2 + 3571 032456 355 02 0 00 000003 AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), + 3572 ;UPDATE AC AND NOT SKIP + 3573 032457 334 00 0 00 000000 SKIPA ;PASS IF AOSGE DID NOT SKIP + 3574 STOP^ + 3575 032460 254 04 0 00 032461 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3576 032461 324 00 0 00 032462 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3577 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3578 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3579 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3580 032462 312 03 0 00 033462 CAME 3,[-1] ;PASS IF E INCREMENTED CORRECTLY + 3581 STOP^ + 3582 032463 254 04 0 00 032464 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3583 032464 324 00 0 00 032465 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3584 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3585 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3586 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3587 032465 312 02 0 00 033462 CAME 2,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3588 STOP^ + 3589 032466 254 04 0 00 032467 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3590 032467 324 00 0 00 032470 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3591 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3592 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3593 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3594 + 3595 ;********** + 3596 + 3597 ;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES + 3598 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3599 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 + 3600 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3601 ;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=-1,,-1 + 3602 ;BEFORE INCREMENTING. HENCE, AOSGE SHOULD SKIP; AND THE + 3603 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 + 3604 ;RESPECTIVELY + 3605 + 3606 032470 200 02 0 00 033474 C54010: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3607 032471 474 03 0 00 000000 SETO 3, ;PRELOAD E WITH 0 + 3608 032472 355 02 0 00 000003 AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), + 3609 ;UPDATE AC AND SKIP + 3610 STOP^ + 3611 032473 254 04 0 00 032474 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3612 032474 324 00 0 00 032475 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3613 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3614 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 65-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0101 + + 3615 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3616 032475 312 03 0 00 033501 CAME 3,[0] ;PASS IF E INCREMENTED CORRECTLY + 3617 STOP^ + 3618 032476 254 04 0 00 032477 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3619 032477 324 00 0 00 032500 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3620 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3621 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3622 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3623 032500 312 02 0 00 033501 CAME 2,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3624 STOP^ + 3625 032501 254 04 0 00 032502 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3626 032502 324 00 0 00 032503 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3627 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3628 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3629 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3630 + 3631 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 66 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0102 + + 3632 ;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES + 3633 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3634 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 + 3635 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3636 ;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=0 + 3637 ;BEFORE INCREMENTING. HENCE, AOSGE SHOULD SKIP; AND THE + 3638 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 + 3639 ;RESPECTIVELY + 3640 + 3641 032503 200 02 0 00 033474 C54020: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3642 032504 400 03 0 00 000000 SETZ 3, ;PRELOAD E WITH 0 + 3643 032505 355 02 0 00 000003 AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), + 3644 ;UPDATE AC AND SKIP + 3645 STOP^ + 3646 032506 254 04 0 00 032507 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3647 032507 324 00 0 00 032510 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3648 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3649 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3650 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3651 032510 312 03 0 00 033502 CAME 3,[1] ;PASS IF E INCREMENTED CORRECTLY + 3652 STOP^ + 3653 032511 254 04 0 00 032512 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3654 032512 324 00 0 00 032513 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3655 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3656 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3657 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3658 032513 312 02 0 00 033502 CAME 2,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3659 STOP^ + 3660 032514 254 04 0 00 032515 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3661 032515 324 00 0 00 032516 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3662 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3663 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3664 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3665 + 3666 ;********** + 3667 + 3668 ;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES + 3669 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3670 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO. + 3671 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3672 ;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=-1,,-2 + 3673 ;BEFORE INCREMENTING. HENCE, AOSN SHOULD NOT SKIP; AND THE + 3674 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 3675 ;RESPECTIVELY + 3676 + 3677 032516 200 01 0 00 033474 C54100: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3678 032517 561 02 0 00 777776 HRROI 2,-2 ;PRELOAD E WITH -1,,-2 + 3679 032520 356 01 0 00 000002 AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), + 3680 ;UPDATE AC AND SKIP + 3681 STOP^ + 3682 032521 254 04 0 00 032522 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3683 032522 324 00 0 00 032523 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3684 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3685 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3686 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 66-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0103 + + 3687 032523 312 02 0 00 033462 CAME 2,[-1] ;PASS IF E INCREMENTED CORRECTLY + 3688 STOP^ + 3689 032524 254 04 0 00 032525 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3690 032525 324 00 0 00 032526 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3691 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3692 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3693 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3694 032526 312 01 0 00 033462 CAME 1,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3695 STOP^ + 3696 032527 254 04 0 00 032530 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3697 032530 324 00 0 00 032531 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3698 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3699 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3700 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3701 + 3702 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 67 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0104 + + 3703 ;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES + 3704 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3705 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO + 3706 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3707 ;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=-1,,-1 + 3708 ;BEFORE INCREMENTING. HENCE, AOSN SHOULD NOT SKIP; AND THE + 3709 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 + 3710 ;RESPECTIVELY + 3711 + 3712 032531 200 01 0 00 033474 C54110: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3713 032532 474 02 0 00 000000 SETO 2, ;PRELOAD E WITH -1,,-1 + 3714 032533 356 01 0 00 000002 AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), + 3715 ;UPDATE AC AND NOT SKIP + 3716 032534 334 00 0 00 000000 SKIPA ;PASS IF AOSN DID NOT SKIP + 3717 STOP^ + 3718 032535 254 04 0 00 032536 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3719 032536 324 00 0 00 032537 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3720 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3721 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3722 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3723 032537 312 02 0 00 033501 CAME 2,[0] ;PASS IF E INCREMENTED CORRECTLY + 3724 STOP^ + 3725 032540 254 04 0 00 032541 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3726 032541 324 00 0 00 032542 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3727 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3728 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3729 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3730 032542 312 01 0 00 033501 CAME 1,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3731 STOP^ + 3732 032543 254 04 0 00 032544 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3733 032544 324 00 0 00 032545 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3734 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3735 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3736 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3737 + 3738 ;********** + 3739 + 3740 ;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES + 3741 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3742 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO + 3743 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3744 ;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=0 + 3745 ;BEFORE INCREMENTING. HENCE, AOSN SHOULD SKIP; AND THE + 3746 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 + 3747 ;RESPECTIVELY + 3748 + 3749 032545 200 01 0 00 033474 C54120: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3750 032546 400 02 0 00 000000 SETZ 2, ;PRELOAD E WITH 0 + 3751 032547 356 01 0 00 000002 AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), + 3752 ;UPDATE AC AND SKIP + 3753 STOP^ + 3754 032550 254 04 0 00 032551 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3755 032551 324 00 0 00 032552 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3756 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3757 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 67-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0105 + + 3758 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3759 032552 312 02 0 00 033502 CAME 2,[1] ;PASS IF E INCREMENTED CORRECTLY + 3760 STOP^ + 3761 032553 254 04 0 00 032554 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3762 032554 324 00 0 00 032555 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3763 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3764 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3765 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3766 032555 312 01 0 00 033502 CAME 1,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 3767 STOP^ + 3768 032556 254 04 0 00 032557 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3769 032557 324 00 0 00 032560 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3770 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3771 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3772 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3773 + 3774 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 68 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0106 + + 3775 ;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES + 3776 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3777 ;THE NEST INSTRUCTION IF C(E) IS GREATER THAN 0 + 3778 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3779 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=-1,,-2 + 3780 ;BEFORE INCREMENTING. HENCE, AOSG SHOULD NOT SKIP; AND THE + 3781 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND -1,,-1 + 3782 ;RESPECTIVELY + 3783 + 3784 032560 200 00 0 00 033474 C54200: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3785 032561 561 01 0 00 777776 HRROI 1,-2 ;PRELOAD E WITH -1,,-2 + 3786 032562 357 00 0 00 000001 AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), + 3787 ;AND NOT SKIP + 3788 032563 334 00 0 00 000000 SKIPA ;PASS IF AOSG DID NOT SKIP + 3789 STOP^ + 3790 032564 254 04 0 00 032565 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3791 032565 324 00 0 00 032566 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3792 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3793 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3794 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3795 032566 312 01 0 00 033462 CAME 1,[-1] ;PASS IF E INCREMENTED CORRECTLY + 3796 STOP^ + 3797 032567 254 04 0 00 032570 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3798 032570 324 00 0 00 032571 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3799 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3800 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3801 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3802 032571 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + 3803 STOP^ + 3804 032572 254 04 0 00 032573 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3805 032573 324 00 0 00 032574 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3806 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3807 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3808 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3809 + 3810 ;********** + 3811 + 3812 ;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES + 3813 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3814 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 + 3815 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3816 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=-1,,-1 + 3817 ;BEFORE INCREMENTING. HENCE, AOSG SHOULD NOT SKIP; AND THE + 3818 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 + 3819 ;RESPECTIVELY + 3820 + 3821 032574 200 00 0 00 033474 C54210: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3822 032575 474 01 0 00 000000 SETO 1, ;PRELOAD E WITH -1,,-1 + 3823 032576 357 00 0 00 000001 AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), + 3824 ;AND NOT SKIP + 3825 032577 334 00 0 00 000000 SKIPA ;PASS IF AOSG DID NOT SKIP + 3826 STOP^ + 3827 032600 254 04 0 00 032601 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3828 032601 324 00 0 00 032602 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3829 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 68-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0107 + + 3830 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3831 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3832 032602 312 01 0 00 033501 CAME 1,[0] ;PASS IF E INCREMENTED CORRECTLY + 3833 STOP^ + 3834 032603 254 04 0 00 032604 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3835 032604 324 00 0 00 032605 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3836 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3837 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3838 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3839 032605 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + 3840 STOP^ + 3841 032606 254 04 0 00 032607 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3842 032607 324 00 0 00 032610 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3843 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3844 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3845 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3846 + 3847 ;*********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 69 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL AOSX INSTRUCTIONS SEQ 0108 + + 3848 ;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES + 3849 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 3850 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 + 3851 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 3852 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0 + 3853 ;BEFORE INCREMENTING. HENCE, AOSG SHOULD SKIP; AND THE + 3854 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0,,1 + 3855 ;RESPECTIVELY + 3856 + 3857 032610 200 00 0 00 033474 C54220: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 3858 032611 400 01 0 00 000000 SETZ 1, ;PRELOAD E WITH 0 + 3859 032612 357 00 0 00 000001 AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), + 3860 ;AND SKIP + 3861 STOP^ + 3862 032613 254 04 0 00 032614 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3863 032614 324 00 0 00 032615 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3864 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3865 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3866 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3867 032615 312 01 0 00 033502 CAME 1,[1] ;PASS IF E INCREMENTED CORRECTLY + 3868 STOP^ + 3869 032616 254 04 0 00 032617 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3870 032617 324 00 0 00 032620 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3871 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3872 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3873 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3874 032620 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + 3875 STOP^ + 3876 032621 254 04 0 00 032622 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3877 032622 324 00 0 00 032623 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3878 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3879 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3880 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3881 + 3882 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 70 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0109 + + 3883 SUBTTL TEST OF MSCL SOJX INSTRUCTIONS + 3884 + 3885 ;********** + 3886 + 3887 ;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND + 3888 ;PLACES THE RESTULT BACK INTO THE AC. THE RESULT IN THE AC IS + 3889 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 3890 ;SPECIFIED BY E IF C(AC) IS LESS THAN 0. + 3891 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJL + 3892 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + 3893 + 3894 032623 201 17 0 00 000000 C54300: MOVEI 17,0 ;PRELOAD AC WITH 0 + 3895 032624 361 17 0 00 032626 SOJL 17,.+2 ;*SOJL SHOULD SUBTRACT 0,,1 FROM C(AC) + 3896 ;AND JUMP + 3897 STOP^ + 3898 032625 254 04 0 00 032626 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3899 032626 324 00 0 00 032627 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3900 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3901 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3902 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3903 032627 312 17 0 00 033462 CAME 17,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 3904 STOP^ + 3905 032630 254 04 0 00 032631 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3906 032631 324 00 0 00 032632 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3907 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3908 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3909 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3910 + 3911 ;*********** + 3912 + 3913 ;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND + 3914 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 3915 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 3916 ;SPECIFIED BY E IF C(AC) IS LESS THAN 0. + 3917 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJL + 3918 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. + 3919 + 3920 032632 201 17 0 00 000001 C54310: MOVEI 17,1 ;PRELOAD AC WITH 0,,1 + 3921 032633 361 17 0 00 032635 SOJL 17,.+2 ;*SOJL SHOULD SUBTRACT 0,,1 FROM C(AC) + 3922 032634 334 00 0 00 000000 SKIPA ;PASS IF SOJL DID NOT JUMP + 3923 STOP^ + 3924 032635 254 04 0 00 032636 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3925 032636 324 00 0 00 032637 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3926 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3927 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3928 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3929 032637 312 17 0 00 033501 CAME 17,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + 3930 STOP^ + 3931 032640 254 04 0 00 032641 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3932 032641 324 00 0 00 032642 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3933 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3934 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3935 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3936 + 3937 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 71 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0110 + + 3938 ;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND + 3939 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 3940 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 3941 ;SPECIFIED BY E IF C(AC) IS LESS THAN 0 + 3942 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJ + 3943 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + 3944 + 3945 032642 201 17 0 00 000002 C54320: MOVEI 17,2 ;PRELOAD AC WITH 0,,2 + 3946 032643 361 17 0 00 032645 SOJL 17,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + 3947 ;AND NOT JUMP. + 3948 032644 334 00 0 00 000000 SKIPA ;PASS IF SOJL DID NOT JUMP + 3949 STOP^ + 3950 032645 254 04 0 00 032646 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3951 032646 324 00 0 00 032647 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3952 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3953 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3954 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3955 032647 312 17 0 00 033502 CAME 17,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 3956 STOP^ + 3957 032650 254 04 0 00 032651 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3958 032651 324 00 0 00 032652 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3959 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3960 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3961 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3962 + 3963 ;********** + 3964 + 3965 ;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND + 3966 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 3967 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 3968 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. + 3969 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJE + 3970 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + 3971 + 3972 032652 201 16 0 00 000000 C54400: MOVEI 16,0 ;PRELOAD AC WITH 0 + 3973 032653 362 16 0 00 032655 SOJE 16,.+2 ;*SOJE SHOULD SUBTRACT 0,,1 FROM C(AC) + 3974 ;AND NOT JUMP. + 3975 032654 334 00 0 00 000000 SKIPA ;PASS IF SOJE DID NOT JUMP + 3976 STOP^ + 3977 032655 254 04 0 00 032656 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3978 032656 324 00 0 00 032657 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3979 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3980 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3981 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3982 032657 312 16 0 00 033462 CAME 16,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 3983 STOP^ + 3984 032660 254 04 0 00 032661 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 3985 032661 324 00 0 00 032662 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 3986 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 3987 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 3988 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 3989 + 3990 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 72 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0111 + + 3991 ;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND + 3992 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 3993 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 3994 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0 + 3995 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJ + 3996 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + 3997 + 3998 032662 201 16 0 00 000001 C54410: MOVEI 16,1 ;PRELOAD AC WITH 0,,1 + 3999 032663 362 16 0 00 032665 SOJE 16,.+2 ;*SOJE SHOULD SUBTRACT 0,,1 FROM C(AC) + 4000 ;AND JUMP + 4001 STOP^ + 4002 032664 254 04 0 00 032665 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4003 032665 324 00 0 00 032666 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4004 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4005 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4006 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4007 032666 312 16 0 00 033501 CAME 16,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4008 STOP^ + 4009 032667 254 04 0 00 032670 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4010 032670 324 00 0 00 032671 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4011 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4012 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4013 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4014 + 4015 ;********** + 4016 + 4017 ;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND + 4018 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4019 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 4020 ;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. + 4021 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJE + 4022 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + 4023 + 4024 032671 201 16 0 00 000002 C54420: MOVEI 16,2 ;PRELOAD AC WITH 0,,2 + 4025 032672 362 16 0 00 032674 SOJE 16,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + 4026 ;AND NOT JUMP. + 4027 032673 334 00 0 00 000000 SKIPA ;PASS IF SOJE DID NOT JUMP + 4028 STOP^ + 4029 032674 254 04 0 00 032675 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4030 032675 324 00 0 00 032676 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4031 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4032 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4033 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4034 032676 312 16 0 00 033502 CAME 16,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4035 STOP^ + 4036 032677 254 04 0 00 032700 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4037 032700 324 00 0 00 032701 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4038 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4039 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4040 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4041 + 4042 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 73 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0112 + + 4043 ;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND + 4044 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4045 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 4046 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0 + 4047 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJLE + 4048 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + 4049 + 4050 032701 201 15 0 00 000000 C54500: MOVEI 15,0 ;PRELOAD AC WITH 0 + 4051 032702 363 15 0 00 032704 SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) + 4052 ;AND JUMP + 4053 STOP^ + 4054 032703 254 04 0 00 032704 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4055 032704 324 00 0 00 032705 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4056 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4057 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4058 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4059 032705 312 15 0 00 033462 CAME 15,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4060 STOP^ + 4061 032706 254 04 0 00 032707 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4062 032707 324 00 0 00 032710 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4063 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4064 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4065 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4066 + 4067 ;********** + 4068 + 4069 ;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND + 4070 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4071 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 4072 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUALTO 0. + 4073 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJLE + 4074 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + 4075 + 4076 032710 201 15 0 00 000001 C54510: MOVEI 15,1 ;PRELOAD AC WITH 0,,1 + 4077 032711 363 15 0 00 032713 SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) + 4078 ;AND JUMP + 4079 STOP^ + 4080 032712 254 04 0 00 032713 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4081 032713 324 00 0 00 032714 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4082 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4083 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4084 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4085 032714 312 15 0 00 033501 CAME 15,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4086 STOP^ + 4087 032715 254 04 0 00 032716 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4088 032716 324 00 0 00 032717 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4089 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4090 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4091 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4092 + 4093 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 74 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0113 + + 4094 ;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND + 4095 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4096 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 4097 ;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. + 4098 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJLE + 4099 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + 4100 + 4101 032717 201 15 0 00 000002 C54520: MOVEI 15,2 ;PRELOAD AC WITH 0,,2 + 4102 032720 363 15 0 00 032722 SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) + 4103 ;AND NOT JUMP + 4104 032721 334 00 0 00 000000 SKIPA ;PASS IF SOJLE DID NOT JUMP + 4105 STOP^ + 4106 032722 254 04 0 00 032723 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4107 032723 324 00 0 00 032724 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4108 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4109 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4110 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4111 032724 312 15 0 00 033502 CAME 15,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4112 STOP^ + 4113 032725 254 04 0 00 032726 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4114 032726 324 00 0 00 032727 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4115 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4116 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4117 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4118 + 4119 ;********** + 4120 + 4121 ;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND + 4122 ;PLACES THE RESULT INTO THE AC. THE RESULT IN THE AC IS + 4123 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION + 4124 ;SPECIFIED BY E + 4125 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJA + 4126 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + 4127 + 4128 032727 201 14 0 00 000000 C54600: MOVEI 14,0 ;PRELOAD AC WITH 0 + 4129 032730 364 14 0 00 032732 SOJA 14,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + 4130 ;AND JUMP + 4131 STOP^ + 4132 032731 254 04 0 00 032732 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4133 032732 324 00 0 00 032733 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4134 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4135 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4136 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4137 032733 312 14 0 00 033462 CAME 14,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4138 STOP^ + 4139 032734 254 04 0 00 032735 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4140 032735 324 00 0 00 032736 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4141 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4142 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4143 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4144 + 4145 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 75 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0114 + + 4146 ;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND + 4147 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4148 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION + 4149 ;SPECIFIED BY E + 4150 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJA + 4151 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + 4152 + 4153 032736 201 14 0 00 000001 C54610: MOVEI 14,1 ;PRELOAD AC WITH 0,,1 + 4154 032737 364 14 0 00 032741 SOJA 14,.+2 ;*SOJA SHOULD SUBTRACT 0,,1 FROM C(AC) + 4155 ;AND JUMP + 4156 STOP^ + 4157 032740 254 04 0 00 032741 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4158 032741 324 00 0 00 032742 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4159 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4160 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4161 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4162 032742 312 14 0 00 033501 CAME 14,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4163 STOP^ + 4164 032743 254 04 0 00 032744 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4165 032744 324 00 0 00 032745 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4166 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4167 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4168 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4169 + 4170 ;********** + 4171 + 4172 ;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND + 4173 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4174 ;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION + 4175 ;SPECIFIED BY E + 4176 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJA + 4177 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + 4178 + 4179 032745 201 14 0 00 000002 C54620: MOVEI 14,2 ;PRELOAD AC WITH 0,,2 + 4180 032746 364 14 0 00 032750 SOJA 14,.+2 ;*SOJA SHOULD SUBTRACT 0,,1 FROM C(AC) + 4181 ;AND JUMP + 4182 STOP^ + 4183 032747 254 04 0 00 032750 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4184 032750 324 00 0 00 032751 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4185 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4186 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4187 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4188 032751 312 14 0 00 033502 CAME 14,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4189 STOP^ + 4190 032752 254 04 0 00 032753 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4191 032753 324 00 0 00 032754 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4192 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4193 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4194 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4195 + 4196 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 76 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0115 + + 4197 ;THIS TEST VERIFIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND + 4198 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4199 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 4200 ;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 + 4201 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJGE + 4202 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + 4203 + 4204 032754 201 13 0 00 000000 C54700: MOVEI 13,0 ;PRELOAD A C WITH 0 + 4205 032755 365 13 0 00 032757 SOJGE 13,.+2 ;*SOJGE SHOULD SUBTRACT 0,,1 FROM C(AC) + 4206 ;AND NOT JUMP + 4207 032756 334 00 0 00 000000 SKIPA ;PASS IF SOJGE DID NOT JUMP + 4208 STOP^ + 4209 032757 254 04 0 00 032760 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4210 032760 324 00 0 00 032761 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4211 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4212 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4213 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4214 032761 312 13 0 00 033462 CAME 13,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4215 STOP^ + 4216 032762 254 04 0 00 032763 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4217 032763 324 00 0 00 032764 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4218 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4219 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4220 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4221 + 4222 ;********** + 4223 + 4224 ;THIS TEST VERIFIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND + 4225 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4226 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 4227 ;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 + 4228 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJGE + 4229 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + 4230 + 4231 032764 201 13 0 00 000001 C54710: MOVEI 13,1 ;PRELOAD AC WITH 0,,1 + 4232 032765 365 13 0 00 032767 SOJGE 13,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + 4233 ;AND JUMP + 4234 STOP^ + 4235 032766 254 04 0 00 032767 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4236 032767 324 00 0 00 032770 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4237 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4238 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4239 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4240 032770 312 13 0 00 033501 CAME 13,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4241 STOP^ + 4242 032771 254 04 0 00 032772 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4243 032772 324 00 0 00 032773 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4244 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4245 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4246 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4247 + 4248 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 77 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0116 + + 4249 ;THIS TEST VERIRIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND PLACES THE + 4250 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS COMPARED + 4251 ;TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC IS + 4252 ;GREATER THAN OR EQUAL TO 0. IN THIS CASE, C(AC = 0,,2 BEFORE + 4253 ;DECREMENTING. HENCE, SOJGE SHOULD JUMP AND THE RESULT IN THE AC SHOULD + 4254 ;BE 0,,1. + 4255 + 4256 032773 201 13 0 00 000002 C54720: MOVEI 13,2 ;PRELOAD AC WITH 0,,2 + 4257 032774 365 13 0 00 032776 SOJGE 13,.+2 ;*SOJGE SHOULD SUBTRACT0,,1 FROM C(AC) + 4258 ;AND JUMP. + 4259 STOP^ + 4260 032775 254 04 0 00 032776 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4261 032776 324 00 0 00 032777 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4262 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4263 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4264 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4265 032777 312 13 0 00 033502 CAME 13,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4266 STOP^ + 4267 033000 254 04 0 00 033001 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4268 033001 324 00 0 00 033002 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4269 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4270 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4271 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4272 + 4273 ;********** + 4274 + 4275 ;THIS TEST VERIFIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND + 4276 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4277 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 4278 ;SPECIFIED BY E IF C(AC) IS NON-ZERO. + 4279 ;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE,SOJN + 4280 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1. + 4281 + 4282 033002 201 12 0 00 000000 C55000: MOVEI 12,0 ;PRELOAD AC WITH 0 + 4283 033003 366 12 0 00 033005 SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) + 4284 ;AND JUMP. + 4285 STOP^ + 4286 033004 254 04 0 00 033005 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4287 033005 324 00 0 00 033006 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4288 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4289 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4290 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4291 033006 312 12 0 00 033462 CAME 12,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4292 STOP^ + 4293 033007 254 04 0 00 033010 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4294 033010 324 00 0 00 033011 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4295 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4296 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4297 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4298 + 4299 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 78 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0117 + + 4300 ;THIS TEST VERIRIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND + 4301 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4302 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED + 4303 ;BY E IF C(AC) IS NON-ZERO. + 4304 ;IN THIS CASE, C(AC) = 0,,1 BEFORE DECREMENTING. HENCE, SOJN + 4305 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. + 4306 + 4307 033011 201 12 0 00 000001 C55010: MOVEI 12,1 ;PRELOAD AC WITH 0,,1 + 4308 033012 366 12 0 00 033014 SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) + 4309 ;AND NOT JUMP. + 4310 033013 334 00 0 00 000000 SKIPA ;PASS IF SOJN DID NOT JUMP + 4311 STOP^ + 4312 033014 254 04 0 00 033015 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4313 033015 324 00 0 00 033016 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4314 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4315 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4316 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4317 033016 312 12 0 00 033501 CAME 12,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4318 STOP^ + 4319 033017 254 04 0 00 033020 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4320 033020 324 00 0 00 033021 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4321 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4322 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4323 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4324 + 4325 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 79 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0118 + + 4326 ;THIS TEST VERIFIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND + 4327 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4328 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 4329 ;SPECIFIED BY E IF C(AC) IS NON-ZERO. + 4330 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJN + 4331 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1. + 4332 + 4333 033021 201 12 0 00 000002 C55020: MOVEI 12,2 ;PRELOAD AC WITH 0,,2 + 4334 033022 366 12 0 00 033024 SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) + 4335 ;AND JUMP. + 4336 STOP^ + 4337 033023 254 04 0 00 033024 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4338 033024 324 00 0 00 033025 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4339 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4340 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4341 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4342 033025 312 12 0 00 033502 CAME 12,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4343 STOP^ + 4344 033026 254 04 0 00 033027 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4345 033027 324 00 0 00 033030 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4346 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4347 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4348 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4349 + 4350 ;********** + 4351 + 4352 ;THIS TEST VERIFIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND + 4353 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4354 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 4355 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. + 4356 ;IN THIS CASE, C(AC) = 0 BEFORE DECREMENTING. HENCE, SOJG + 4357 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1. + 4358 + 4359 033030 201 11 0 00 000000 C55100: MOVEI 11,0 ;PRELOAD AC WITH 0 + 4360 033031 367 11 0 00 033033 SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT 0,,1 FROM C(AC) + 4361 ;AND NOT JUMP. + 4362 033032 334 00 0 00 000000 SKIPA ;PASS IF SOJG DID NOT JUMP + 4363 STOP^ + 4364 033033 254 04 0 00 033034 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4365 033034 324 00 0 00 033035 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4366 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4367 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4368 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4369 033035 312 11 0 00 033462 CAME 11,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4370 STOP^ + 4371 033036 254 04 0 00 033037 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4372 033037 324 00 0 00 033040 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4373 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4374 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4375 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4376 + 4377 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 80 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOJX INSTRUCTIONS SEQ 0119 + + 4378 ;THIS TEST VERIRIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND + 4379 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4380 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 4381 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. + 4382 ;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJG + 4383 ;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. + 4384 + 4385 033040 201 11 0 00 000001 C55110: MOVEI 11,1 ;PRELOAD AC WITH 0,,1 + 4386 033041 367 11 0 00 033043 SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT 0,,1 FROM C(AC) + 4387 ;AND NOT JUMP. + 4388 033042 334 00 0 00 000000 SKIPA ;PASS IF SOJG DID NOT JUMP + 4389 STOP^ + 4390 033043 254 04 0 00 033044 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4391 033044 324 00 0 00 033045 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4392 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4393 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4394 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4395 033045 312 11 0 00 033501 CAME 11,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4396 STOP^ + 4397 033046 254 04 0 00 033047 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4398 033047 324 00 0 00 033050 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4399 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4400 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4401 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4402 + 4403 ;********** + 4404 + 4405 ;THIS TEST VERIFIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND + 4406 ;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS + 4407 ;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION + 4408 ;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. + 4409 ;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJG + 4410 ;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1. + 4411 + 4412 033050 201 11 0 00 000002 C55120: MOVEI 11,2 ;PRELOAD AC WITH 0,,2 + 4413 033051 367 11 0 00 033053 SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT O,,1 FROM C(AC) + 4414 ;AND JUMP. + 4415 STOP^ + 4416 033052 254 04 0 00 033053 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4417 033053 324 00 0 00 033054 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4418 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4419 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4420 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4421 033054 312 11 0 00 033502 CAME 11,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + 4422 STOP^ + 4423 033055 254 04 0 00 033056 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4424 033056 324 00 0 00 033057 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4425 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4426 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4427 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4428 + 4429 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 81 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0120 + + 4430 SUBTTL TEST OF MSCL SOSX INSTRUCTIONS + 4431 + 4432 ;********** + 4433 + 4434 ;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES + 4435 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4436 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. + 4437 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4438 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0 + 4439 ;BEFORE INCREMENTING. HENCE, SOSL SHOULD SKIP; AND THE + 4440 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND -1,,-1 + 4441 ;RESPECTIVELY. + 4442 + 4443 033057 200 00 0 00 033474 C55200: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4444 033060 201 01 0 00 000000 MOVEI 1,0 ;PRELOAD E WITH 0 + 4445 033061 371 00 0 00 000001 SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E) + 4446 ;AND SKIP + 4447 STOP^ + 4448 033062 254 04 0 00 033063 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4449 033063 324 00 0 00 033064 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4450 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4451 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4452 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4453 033064 312 01 0 00 033462 CAME 1,[-1] ;PASS IF E DECREMENTED CORRECTLY + 4454 STOP^ + 4455 033065 254 04 0 00 033066 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4456 033066 324 00 0 00 033067 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4457 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4458 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4459 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4460 033067 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + 4461 STOP^ + 4462 033070 254 04 0 00 033071 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4463 033071 324 00 0 00 033072 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4464 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4465 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4466 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4467 + 4468 ;********** + 4469 + 4470 ;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES + 4471 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4472 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. + 4473 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4474 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0,,1 + 4475 ;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE + 4476 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 + 4477 ;RESPECTIVELY. + 4478 + 4479 033072 200 00 0 00 033474 C55210: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4480 033073 201 01 0 00 000001 MOVEI 1,1 ;PRELOAD E WITH 0,,1 + 4481 033074 371 00 0 00 000001 SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), + 4482 ;AND NOT SKIP. + 4483 033075 334 00 0 00 000000 SKIPA ;PASS IF SOSL DID NOT SKIP + 4484 STOP^ +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 81-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0121 + + 4485 033076 254 04 0 00 033077 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4486 033077 324 00 0 00 033100 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4487 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4488 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4489 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4490 033100 312 01 0 00 033501 CAME 1,[0] ;PASS IF E DECREMENTED CORRECTLY + 4491 STOP^ + 4492 033101 254 04 0 00 033102 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4493 033102 324 00 0 00 033103 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4494 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4495 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4496 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4497 033103 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + 4498 STOP^ + 4499 033104 254 04 0 00 033105 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4500 033105 324 00 0 00 033106 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4501 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4502 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4503 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4504 + 4505 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 82 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0122 + + 4506 ;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES + 4507 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4508 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. + 4509 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4510 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0,,1 + 4511 ;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE + 4512 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 + 4513 ;RESPECTIVELY. + 4514 + 4515 033106 200 00 0 00 033474 C55211: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4516 033107 201 01 0 00 000001 MOVEI 1,1 ;PRELOAD E WITH 0,,1 + 4517 033110 202 01 0 00 033125 MOVEM 1,E55211 + 4518 033111 371 00 0 00 033125 SOSL 0,E55211 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), + 4519 ;AND NOT SKIP. + 4520 033112 334 00 0 00 000000 SKIPA ;PASS IF SOSL DID NOT SKIP + 4521 STOP^ + 4522 033113 254 04 0 00 033114 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4523 033114 324 00 0 00 033115 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4524 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4525 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4526 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4527 033115 200 01 0 00 033125 MOVE 1,E55211 + 4528 033116 312 01 0 00 033501 CAME 1,[0] ;PASS IF E DECREMENTED CORRECTLY + 4529 STOP^ + 4530 033117 254 04 0 00 033120 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4531 033120 324 00 0 00 033121 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4532 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4533 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4534 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4535 033121 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + 4536 STOP^ + 4537 033122 254 04 0 00 033123 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4538 033123 324 00 0 00 033124 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4539 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4540 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4541 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4542 + 4543 033124 334 00 0 00 000000 SKIPA ;GO TO NEXT TEST + 4544 033125 000000 000000 E55211: 0 ;TEST WORD MEMORY + 4545 + 4546 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 83 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0123 + + 4547 ;THIS TEST VERIFIES THAT SOS DECREMENTS C(E) BY 0,,1 AND PLACES + 4548 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4549 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. + 4550 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4551 ;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E) 0,,2 + 4552 ;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE + 4553 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0,,1 + 4554 ;RESPECTIVELY. + 4555 + 4556 033126 200 00 0 00 033474 C55220: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4557 033127 201 01 0 00 000002 MOVEI 1,2 ;PRELOAD E WITH 0,,2 + 4558 033130 371 00 0 00 000001 SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), + 4559 ;AND NOT SKIP + 4560 + 4561 033131 334 00 0 00 000000 SKIPA ;PASS IF SOSL DID NOT SKIP + 4562 STOP^ + 4563 033132 254 04 0 00 033133 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4564 033133 324 00 0 00 033134 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4565 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4566 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4567 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4568 033134 312 01 0 00 033502 CAME 1,[1] ;PASS IF E DECREMENTED CORRECTLY + 4569 STOP^ + 4570 033135 254 04 0 00 033136 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4571 033136 324 00 0 00 033137 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4572 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4573 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4574 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4575 033137 312 00 0 00 033474 CAME 0,[707070,,707070] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4576 STOP^ + 4577 033140 254 04 0 00 033141 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4578 033141 324 00 0 00 033142 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4579 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4580 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4581 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4582 + 4583 ;********** + 4584 + 4585 ;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,,1 AND PLACES + 4586 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4587 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 + 4588 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4589 ;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0 + 4590 ;BEFORE INCREMENTING. HENCE, SOSE SHOULD NOT SKIP ; AND THE + 4591 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 4592 ;RESPECTIVELY. + 4593 + 4594 033142 200 10 0 00 033474 C55300: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4595 033143 201 11 0 00 000000 MOVEI 11,0 ;PRELOAD E WITH 0 + 4596 033144 372 10 0 00 000011 SOSE 10,11 ;*SOSE SHOULD SUBTRACT 0,,1 FROM C(E), + 4597 ;UPDATE AC AND NOT SKIP + 4598 + 4599 033145 334 00 0 00 000000 SKIPA ;PASS IF SOSE DID NOT SKIP + 4600 STOP^ + 4601 033146 254 04 0 00 033147 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 83-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0124 + + 4602 033147 324 00 0 00 033150 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4603 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4604 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4605 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4606 033150 312 11 0 00 033462 CAME 11,[-1] ;PASS IF E DECREMENTED CORRECTLY + 4607 STOP^ + 4608 033151 254 04 0 00 033152 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4609 033152 324 00 0 00 033153 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4610 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4611 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4612 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4613 033153 312 10 0 00 033462 CAME 10,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4614 STOP^ + 4615 033154 254 04 0 00 033155 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4616 033155 324 00 0 00 033156 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4617 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4618 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4619 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4620 + 4621 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 84 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0125 + + 4622 ;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,,1 AND PLACES + 4623 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4624 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 + 4625 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4626 ;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0,,1 + 4627 ;BEFORE INCREMENTING. HENCE, SOSE SHOULD SKIP ; AND THE + 4628 ;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 + 4629 ;RESPECTIVELY. + 4630 + 4631 033156 200 10 0 00 033474 C55310: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4632 033157 201 11 0 00 000001 MOVEI 11,1 ;PRELOAD E WITH 0,,1 + 4633 033160 372 10 0 00 000011 SOSE 10,11 ;*SOS SHOULD SUBTRACT 0,,1 FROM C(E) + 4634 ;UPDATE AC AND SKIP + 4635 STOP^ + 4636 033161 254 04 0 00 033162 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4637 033162 324 00 0 00 033163 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4638 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4639 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4640 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4641 033163 312 11 0 00 033501 CAME 11,[0] ;PASS IF E DECREMENTED CORRECTLY + 4642 STOP^ + 4643 033164 254 04 0 00 033165 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4644 033165 324 00 0 00 033166 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4645 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4646 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4647 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4648 033166 312 10 0 00 033501 CAME 10,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4649 STOP^ + 4650 033167 254 04 0 00 033170 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4651 033170 324 00 0 00 033171 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4652 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4653 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4654 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4655 + 4656 ;********** + 4657 + 4658 ;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,11 AND PLACES + 4659 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4660 ;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0. + 4661 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4662 ;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0,,2 + 4663 ;BEFORE INCREMENTING. HENCE, SOSE SHOULD NOT SKIP ; AND THE + 4664 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 + 4665 ;RESPECTIVELY. + 4666 + 4667 033171 200 10 0 00 033474 C55320: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4668 033172 201 11 0 00 000002 MOVEI 11,2 ;PRELOAD E WITH 0,,2 + 4669 033173 372 10 0 00 000011 SOSE 10,11 ;*SOSE SHOULD SUBTRACT 0,,1 FROM C(E), + 4670 ;UPDATE AC AND NOT SKIP + 4671 + 4672 033174 334 00 0 00 000000 SKIPA ;PASS IF SOSE DID NOT SKIP + 4673 STOP^ + 4674 033175 254 04 0 00 033176 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4675 033176 324 00 0 00 033177 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4676 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 84-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0126 + + 4677 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4678 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4679 033177 312 11 0 00 033502 CAME 11,[1] ;PASS IF E DECREMENTED CORRECTLY + 4680 STOP^ + 4681 033200 254 04 0 00 033201 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4682 033201 324 00 0 00 033202 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4683 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4684 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4685 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4686 033202 312 10 0 00 033502 CAME 10,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4687 STOP^ + 4688 033203 254 04 0 00 033204 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4689 033204 324 00 0 00 033205 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4690 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4691 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4692 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4693 + 4694 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 85 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0127 + + 4695 ;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES + 4696 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4697 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. + 4698 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4699 ;IN THIS CASE, AC=7, C(AC)=707070,,707070 AND C(E)=0 + 4700 ;BEFORE INCREMENTING. HENCE, SOSLE SHOULD SKIP ; AND THE + 4701 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 4702 ;RESPECTIVELY. + 4703 + 4704 033205 200 07 0 00 033474 C55400: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4705 033206 201 10 0 00 000000 MOVEI 10,0 ;PRELOAD E WITH 0 + 4706 033207 373 07 0 00 000010 SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), + 4707 ;UPDATE AC AND SKIP + 4708 STOP^ + 4709 033210 254 04 0 00 033211 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4710 033211 324 00 0 00 033212 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4711 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4712 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4713 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4714 033212 312 10 0 00 033462 CAME 10,[-1] ;PASS IF E DECREMENTED CORRECTLY + 4715 STOP^ + 4716 033213 254 04 0 00 033214 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4717 033214 324 00 0 00 033215 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4718 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4719 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4720 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4721 033215 312 07 0 00 033462 CAME 7,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4722 STOP^ + 4723 033216 254 04 0 00 033217 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4724 033217 324 00 0 00 033220 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4725 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4726 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4727 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4728 + 4729 ;********** + 4730 + 4731 ;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES + 4732 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4733 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. + 4734 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4735 ;IN THIS CASE, AC=7, C(AC)=070707,,070707 AND C(E)=0,,1 + 4736 ;BEFORE INCREMENTING. HENCE, SOSLE SHOULD SKIP ; AND THE + 4737 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 + 4738 ;RESPECTIVELY. + 4739 + 4740 033220 200 07 0 00 033474 C55410: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4741 033221 201 10 0 00 000001 MOVEI 10,1 ;PRELOAD E WITH 0,,1 + 4742 033222 373 07 0 00 000010 SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), + 4743 ;UPDATE AC AND SKIP + 4744 STOP^ + 4745 033223 254 04 0 00 033224 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4746 033224 324 00 0 00 033225 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4747 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4748 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4749 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 85-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0128 + + 4750 033225 312 10 0 00 033501 CAME 10,[0] ;PASS IF E DECREMENTED CORRECTLY + 4751 STOP^ + 4752 033226 254 04 0 00 033227 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4753 033227 324 00 0 00 033230 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4754 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4755 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4756 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4757 033230 312 07 0 00 033501 CAME 7,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4758 STOP^ + 4759 033231 254 04 0 00 033232 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4760 033232 324 00 0 00 033233 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4761 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4762 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4763 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4764 + 4765 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 86 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0129 + + 4766 ;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES + 4767 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4768 ;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. + 4769 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4770 ;IN THIS CASE, AC=7, C(AC)=707070,,707070 AND C(E)=0,,2 + 4771 ;BEFORE INCREMENTING. HENCE, SOSLE SHOULD NOT SKIP; AND THE + 4772 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 + 4773 ;RESPECTIVELY. + 4774 + 4775 033233 200 07 0 00 033474 C55420: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4776 033234 201 10 0 00 000002 MOVEI 10,2 ;PRELOAD E WITH 0,,2 + 4777 033235 373 07 0 00 000010 SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), + 4778 ;UPDATE AC AND NOT SKIP + 4779 033236 334 00 0 00 000000 SKIPA ;PASS IF SOSLE DID NOT SKIP + 4780 STOP^ + 4781 033237 254 04 0 00 033240 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4782 033240 324 00 0 00 033241 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4783 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4784 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4785 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4786 033241 312 10 0 00 033502 CAME 10,[1] ;PASS IF E DECREMENTED CORRECTLY + 4787 STOP^ + 4788 033242 254 04 0 00 033243 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4789 033243 324 00 0 00 033244 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4790 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4791 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4792 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4793 033244 312 07 0 00 033502 CAME 7,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4794 STOP^ + 4795 033245 254 04 0 00 033246 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4796 033246 324 00 0 00 033247 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4797 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4798 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4799 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4800 + 4801 ;********** + 4802 + 4803 ;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES + 4804 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS + 4805 ;THE NEXT INSTRUCTION. + 4806 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4807 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0 + 4808 ;BEFORE INCREMENTING. HENCE, SOSA SHOULD SKIP ; AND THE + 4809 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 4810 ;RESPECTIVELY. + 4811 + 4812 033247 200 06 0 00 033474 C55500: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4813 033250 201 07 0 00 000000 MOVEI 7,0 ;PRELOAD E WITH 0 + 4814 033251 374 06 0 00 000007 SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), + 4815 ;UPDATE AC AND SKIP + 4816 STOP^ + 4817 033252 254 04 0 00 033253 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4818 033253 324 00 0 00 033254 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4819 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4820 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 86-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0130 + + 4821 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4822 033254 312 07 0 00 033462 CAME 7,[-1] ;PASS IF E DECREMENTED CORRECTLY + 4823 STOP^ + 4824 033255 254 04 0 00 033256 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4825 033256 324 00 0 00 033257 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4826 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4827 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4828 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4829 033257 312 06 0 00 033462 CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4830 STOP^ + 4831 033260 254 04 0 00 033261 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4832 033261 324 00 0 00 033262 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4833 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4834 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4835 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4836 + 4837 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 87 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0131 + + 4838 ;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES + 4839 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS + 4840 ;THE NEXT INSTRUCTION. + 4841 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THEAC. + 4842 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0,,1 + 4843 ;BEFORE INCREMENTING. HENCE, SOSA SHOULD BE 0 AND 0 + 4844 ;RESPECTIVELY. + 4845 + 4846 033262 200 06 0 00 033474 C55510: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4847 033263 201 07 0 00 000001 MOVEI 7,1 ;PRELOAD E WITH 0,,1 + 4848 033264 374 06 0 00 000007 SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), + 4849 ;UPDATE AC AND SKIP + 4850 STOP^ + 4851 033265 254 04 0 00 033266 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4852 033266 324 00 0 00 033267 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4853 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4854 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4855 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4856 033267 312 07 0 00 033501 CAME 7,[0] ;PASS IF E DECREMENTED CORRECTLY + 4857 STOP^ + 4858 033270 254 04 0 00 033271 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4859 033271 324 00 0 00 033272 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4860 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4861 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4862 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4863 033272 312 06 0 00 033501 CAME 6,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4864 STOP^ + 4865 033273 254 04 0 00 033274 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4866 033274 324 00 0 00 033275 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4867 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4868 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4869 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4870 + 4871 ;********** + 4872 + 4873 ;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES + 4874 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS + 4875 ;THE NEXT INSTRUCTION. + 4876 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4877 ;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0,,2 + 4878 ;BEFORE INCREMENTING. HENCE, SOSA SHOULD SKIP ; AND THE + 4879 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 + 4880 ;RESPECTIVELY. + 4881 + 4882 033275 200 06 0 00 033474 C55520: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4883 033276 201 07 0 00 000002 MOVEI 7,2 ;PRELOAD E WITH 0,,2 + 4884 033277 374 06 0 00 000007 SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), + 4885 ;UPDATE AC AND SKIP + 4886 STOP^ + 4887 033300 254 04 0 00 033301 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4888 033301 324 00 0 00 033302 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4889 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4890 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4891 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4892 033302 312 07 0 00 033502 CAME 7,[1] ;PASS IF E DECREMENTED CORRECTLY +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 87-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0132 + + 4893 STOP^ + 4894 033303 254 04 0 00 033304 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4895 033304 324 00 0 00 033305 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4896 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4897 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4898 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4899 033305 312 06 0 00 033502 CAME 6,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4900 STOP^ + 4901 033306 254 04 0 00 033307 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4902 033307 324 00 0 00 033310 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4903 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4904 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4905 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4906 + 4907 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 88 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0133 + + 4908 ;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES + 4909 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4910 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0. + 4911 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4912 ;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0 + 4913 ;BEFORE INCREMENTING. HENCE, SOSGE SHOULD NOT SKIP ; AND THE + 4914 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 4915 ;RESPECTIVELY. + 4916 + 4917 033310 200 05 0 00 033474 C55600: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4918 033311 201 06 0 00 000000 MOVEI 6,0 ;PRELOAD E WITH 0 + 4919 033312 375 05 0 00 000006 SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), + 4920 ;UPDATE AC AND NOT SKIP + 4921 033313 334 00 0 00 000000 SKIPA ;PASS IF SOSGE DID NOT SKIP + 4922 STOP^ + 4923 033314 254 04 0 00 033315 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4924 033315 324 00 0 00 033316 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4925 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4926 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4927 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4928 033316 312 06 0 00 033462 CAME 6,[-1] ;PASS IF E DECREMENTED CORRECTLY + 4929 STOP^ + 4930 033317 254 04 0 00 033320 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4931 033320 324 00 0 00 033321 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4932 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4933 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4934 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4935 033321 312 05 0 00 033462 CAME 5,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4936 STOP^ + 4937 033322 254 04 0 00 033323 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4938 033323 324 00 0 00 033324 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4939 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4940 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4941 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4942 + 4943 ;********** + 4944 + 4945 ;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES + 4946 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4947 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0. + 4948 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4949 ;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0,,1 + 4950 ;BEFORE INCREMENTING. HENCE, SOSGE SHOULD SKIP ; AND THE + 4951 ;FINAL RESULTS IN ACAND E SHOULD BE 0 AND 0 + 4952 ;RESPECTIVELY. + 4953 + 4954 033324 200 05 0 00 033474 C55610: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4955 033325 201 06 0 00 000001 MOVEI 6,1 ;PRELOAD E WITH 0,,1 + 4956 033326 375 05 0 00 000006 SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), + 4957 ;UPDATE AC AND SKIP + 4958 STOP^ + 4959 033327 254 04 0 00 033330 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4960 033330 324 00 0 00 033331 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4961 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4962 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 88-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0134 + + 4963 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4964 033331 312 06 0 00 033501 CAME 6,[0] ;PASS IF E DECREMENTED CORRECTLY + 4965 STOP^ + 4966 033332 254 04 0 00 033333 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4967 033333 324 00 0 00 033334 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4968 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4969 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4970 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4971 033334 312 05 0 00 033501 CAME 5,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 4972 STOP^ + 4973 033335 254 04 0 00 033336 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4974 033336 324 00 0 00 033337 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4975 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4976 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4977 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4978 + 4979 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 89 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0135 + + 4980 ;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES + 4981 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 4982 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 + 4983 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 4984 ;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0,,2 + 4985 ;BEFORE INCREMENTING. HENCE, SOSGE SHOULD SKIP ; AND THE + 4986 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 + 4987 ;RESPECTIVELY. + 4988 + 4989 033337 200 05 0 00 033474 C55620: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 4990 033340 201 06 0 00 000002 MOVEI 6,2 ;PRELOAD E WITH 0,,2 + 4991 033341 375 05 0 00 000006 SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), + 4992 ;UPDATE AC AND SKIP + 4993 STOP^ + 4994 033342 254 04 0 00 033343 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 4995 033343 324 00 0 00 033344 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 4996 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 4997 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 4998 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 4999 033344 312 06 0 00 033502 CAME 6,[1] ;PASS IF E DECREMENTED CORRECTLY + 5000 STOP^ + 5001 033345 254 04 0 00 033346 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5002 033346 324 00 0 00 033347 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5003 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5004 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5005 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5006 033347 312 05 0 00 033502 CAME 5,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 5007 STOP^ + 5008 033350 254 04 0 00 033351 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5009 033351 324 00 0 00 033352 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5010 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5011 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5012 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5013 + 5014 ;********** + 5015 + 5016 ;THIS TEST VERIFIES SOSN DECREMENTS C(E) BY 0,,1 AND PLACES + 5017 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 5018 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO + 5019 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 5020 ;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0 + 5021 ;BEFORE INCREMENTING. HENCE, SOSN SHOULD SKIP ; AND THE + 5022 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 5023 ;RESPECTIVELY. + 5024 + 5025 033352 200 04 0 00 033474 C55700: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 5026 033353 201 05 0 00 000000 MOVEI 5,0 ;PRELOAD E WITH 0 + 5027 033354 376 04 0 00 000005 SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), + 5028 ;UPDATE AC AND SKIP + 5029 STOP^ + 5030 033355 254 04 0 00 033356 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5031 033356 324 00 0 00 033357 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5032 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5033 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5034 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 89-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0136 + + 5035 033357 312 05 0 00 033462 CAME 5,[-1] ;PASS IF E DECREMENTED CORRECTLY + 5036 STOP^ + 5037 033360 254 04 0 00 033361 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5038 033361 324 00 0 00 033362 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5039 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5040 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5041 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5042 033362 312 04 0 00 033462 CAME 4,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 5043 STOP^ + 5044 033363 254 04 0 00 033364 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5045 033364 324 00 0 00 033365 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5046 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5047 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5048 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5049 + 5050 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 90 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0137 + + 5051 ;THIS TEST VERIFIES THAT SOSN DECREMENTS C(E) BY 0,,1 AND PLACES + 5052 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 5053 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO + 5054 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC + 5055 ;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0,,1 + 5056 ;BEFORE INCREMENTING. HENCE, SOSN SHOULD NOT SKIP ; AND THE + 5057 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 + 5058 ;RESPECTIVELY. + 5059 + 5060 033365 200 04 0 00 033474 C55710: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 5061 033366 201 05 0 00 000001 MOVEI 5,1 ;PRELOAD E WITH 0,,1 + 5062 033367 376 04 0 00 000005 SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), + 5063 ;UPDATE AC AND NOT SKIP + 5064 033370 334 00 0 00 000000 SKIPA ;PASS IF SOSN DID NOT SKIP + 5065 STOP^ + 5066 033371 254 04 0 00 033372 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5067 033372 324 00 0 00 033373 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5068 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5069 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5070 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5071 033373 312 05 0 00 033501 CAME 5,[0] ;PASS IF E DECREMENTED CORRECTLY + 5072 STOP^ + 5073 033374 254 04 0 00 033375 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5074 033375 324 00 0 00 033376 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5075 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5076 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5077 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5078 033376 312 04 0 00 033501 CAME 4,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 5079 STOP^ + 5080 033377 254 04 0 00 033400 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5081 033400 324 00 0 00 033401 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5082 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5083 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5084 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5085 + 5086 ;********** + 5087 + 5088 ;THIS TEST VERIFIES THAT SOSN DECREMENTS C(E) BY 0,,1 AND PLACES + 5089 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 5090 ;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO + 5091 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 5092 ;INtTHIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0,,2 + 5093 ;BEFORE INCREMENTING. HENCE, SOSN SHOULD SKIP ; AND THE + 5094 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 + 5095 ;RESPECTIVELY + 5096 + 5097 033401 200 04 0 00 033474 C55720: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 5098 033402 201 05 0 00 000002 MOVEI 5,2 ;PRELOAD E WITH 0,,2 + 5099 033403 376 04 0 00 000005 SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), + 5100 ;UPDATE AC AND SKIP + 5101 STOP^ + 5102 033404 254 04 0 00 033405 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5103 033405 324 00 0 00 033406 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5104 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5105 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 90-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0138 + + 5106 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5107 033406 312 05 0 00 033502 CAME 5,[1] ;PASS IF E DECREMENTED CORRECTLY + 5108 STOP^ + 5109 033407 254 04 0 00 033410 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5110 033410 324 00 0 00 033411 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5111 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5112 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5113 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5114 033411 312 04 0 00 033502 CAME 4,[1] ;PASS IF ACWAS UPDATED IF AC NON-ZERO + 5115 STOP^ + 5116 033412 254 04 0 00 033413 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5117 033413 324 00 0 00 033414 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5118 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5119 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5120 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5121 + 5122 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 91 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0139 + + 5123 ;THIS TEST VERIFIESTHAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES + 5124 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 5125 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 + 5126 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 5127 ;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0 + 5128 ;BEFORE INCREMENTING. HENCE, SOSG SHOULD NOT SKIP ; AND THE + 5129 ;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 + 5130 ;RESPECTIVELY. + 5131 + 5132 033414 200 03 0 00 033474 C56000: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 5133 033415 201 04 0 00 000000 MOVEI 4,0 ;PRELOAD E WITH 0 + 5134 033416 377 03 0 00 000004 SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), + 5135 ;UPDATE AC AND NOT SKIP + 5136 033417 334 00 0 00 000000 SKIPA ;PASS IF SOSG DID NOT SKIP + 5137 STOP^ + 5138 033420 254 04 0 00 033421 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5139 033421 324 00 0 00 033422 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5140 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5141 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5142 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5143 033422 312 04 0 00 033462 CAME 4,[-1] ;PASS IF E DECREMENTED CORRECTLY + 5144 STOP^ + 5145 033423 254 04 0 00 033424 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5146 033424 324 00 0 00 033425 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5147 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5148 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5149 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5150 033425 312 03 0 00 033462 CAME 3,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 5151 STOP^ + 5152 033426 254 04 0 00 033427 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5153 033427 324 00 0 00 033430 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5154 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5155 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5156 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5157 + 5158 ;********** + 5159 + 5160 ;THIS TEST VERIFIES THAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES + 5161 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 5162 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0. + 5163 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 5164 ;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0,,1 + 5165 ;BEFORE INCREMENTING. HENCE, SOSG SHOULD NOT SKIP ; AND THE + 5166 ;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 + 5167 ;RESPECTIVELY. + 5168 + 5169 033430 200 03 0 00 033474 C56010: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 5170 033431 201 04 0 00 000001 MOVEI 4,1 ;PRELOAD E WITH 0,,1 + 5171 033432 377 03 0 00 000004 SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), + 5172 ;UPDATE AC AND NOT SKIP + 5173 033433 334 00 0 00 000000 SKIPA ;PASS IF SOSG DID NOT SKIP + 5174 STOP^ + 5175 033434 254 04 0 00 033435 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5176 033435 324 00 0 00 033436 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5177 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 91-1 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0140 + + 5178 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5179 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5180 033436 312 04 0 00 033501 CAME 4,[0] ;PASS IF E DECREMENTED CORRECTLY + 5181 STOP^ + 5182 033437 254 04 0 00 033440 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5183 033440 324 00 0 00 033441 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5184 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5185 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5186 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5187 033441 312 03 0 00 033501 CAME 3,[0] ;PASS IF AC WAS UPDATED IS AC NON-ZERO + 5188 STOP^ + 5189 033442 254 04 0 00 033443 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5190 033443 324 00 0 00 033444 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5191 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5192 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5193 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5194 + 5195 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 92 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0141 + + 5196 ;THIS TEST VERIFIES THAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES + 5197 ;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS + 5198 ;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 + 5199 ;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. + 5200 ;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0,,2 + 5201 ;BEFORE INCREMENTING. HENCE, SOSG SHOULD SKIP ; AND THE + 5202 ;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 011, + 5203 ;RESPECTIVELY. + 5204 + 5205 033444 200 03 0 00 033474 C56020: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + 5206 033445 201 04 0 00 000002 MOVEI 4,2 ;PRELOAD E WITH 0,,2 + 5207 033446 377 03 0 00 000004 SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), + 5208 ;UPDATE AC AND SKIP + 5209 STOP^ + 5210 033447 254 04 0 00 033450 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5211 033450 324 00 0 00 033451 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5212 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5213 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5214 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5215 033451 312 04 0 00 033502 CAME 4,[1] ;PASS IF E DECREMENTED CORRECTLY + 5216 STOP^ + 5217 033452 254 04 0 00 033453 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5218 033453 324 00 0 00 033454 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5219 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5220 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5221 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5222 033454 312 03 0 00 033502 CAME 3,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + 5223 STOP^ + 5224 033455 254 04 0 00 033456 HALT .+1 ;TEST FAILED IF PROGRAM HALTS HERE + 5225 033456 324 00 0 00 033457 JUMPA .+1 ;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) + 5226 ;TO JUMPA X(X IS THE ADDRESS OF THE FIRST + 5227 ;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR + 5228 ;AND CHANGE HALT INSTRUCTION TO JUMPA .+1^ + 5229 + 5230 ;********** +DAKAE PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) 0,3 MACRO %53(1020) 13:36 28-Dec-78 Page 93 +DAKAEM MAC 28-Dec-78 13:35 TEST OF MSCL SOSX INSTRUCTIONS SEQ 0142 + + 5231 + 5232 033457 254 00 0 00 030057 JRST BEGEND + 5233 SUBTTL *STOR* RESERVED STORAGE, JULY 19,1977 + 5234 + 5235 ;PROGRAM LITERALS + 5236 + 5237 XLIST + 5238 IFNDEF $LPAPER, + 5239 033460 LIT + 5240 033460 000001 000001 + 5241 033461 254 00 0 00 030723 + 5242 033462 777777 777777 + 5243 033463 310 00 0 00 000000 + 5244 033464 201 01 0 00 001234 + 5245 033465 031107 031106 + 5246 033466 031116 031115 + 5247 033467 254 00 0 00 031161 + 5248 033470 000001 000002 + 5249 033471 135531 246642 + 5250 033472 135246 246135 + 5251 033473 252525 252525 + 5252 033474 707070 707070 + 5253 033475 123456 123456 + 5254 033476 777777 000000 + 5255 033477 777777 777775 + 5256 033500 777777 777776 + 5257 033501 000000 000000 + 5258 033502 000000 000001 + 5259 LIST + 5260 033503 000000 000000 ENDSLD: 0 + 5261 + 5262 IFDEF DEBUG,< + 5263 033504 PATCH: BLOCK DEBUG ;PATCHING AREA + 5264 > + 5265 + 5266 ;PROGRAM VARIABLES + 5267 033604 VAR + 5268 + 5269 IFDEF PGMEND,< + 5270 033604 000000 000000 END: 0 + 5271 030000 END BEGIN > + +NO ERRORS DETECTED + +PROGRAM BREAK IS 000000 +ABSOLUTE BREAK IS 033605 +CPU TIME USED 00:18.474 + +20P CORE USED diff --git a/apps/pdp10/diags/klad/dakae/DAKAE.MAC.txt b/apps/pdp10/diags/klad/dakae/DAKAE.MAC.txt new file mode 100644 index 000000000..ad04e0213 --- /dev/null +++ b/apps/pdp10/diags/klad/dakae/DAKAE.MAC.txt @@ -0,0 +1,2772 @@ +;ACCUMULATOR ASSIGNMENTS + +;CONTROL WORDS + +AROV=400000 ;ARITHMETIC OVERFLOW +CRY0=200000 ;CARRY 0 +CRY1=100000 ;CARRY 1 +FOV=40000 ;FLOATING OVERFLOW +BIS=20000 ;BYTE INTERRUPT +USERF=10000 ;USER MODE FLAG +EXIOT=4000 ;USER PRIV I/O FLAG +FXU=100 ;FLOATING UNDERFLOW +DCK=40 ;DIVIDE CHECK + +;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> + +; SFLAG - USED TO CLEAR ALL FLAGS THEN TO SET REQUESTED FLAG + +DEFINE SFLAG (A)< + MOVSI 1,A + JFCL 17,.+1 ;RESET ALL FLAGS + 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 STARTA + ;SKIPL MONCTL + ;TTCALL 3,PGMNAM ;MENTION OUR NAME + JRST STARTA + +PGMNAM: ASCIZ/ +PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) [DAKAE] +/ + + +;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF +;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES +;IN THE FIELD. + +STARTA: JRST .+1 +SUBTTL TEST OF JSR INSTRUCTION + +;********** + +;THIS TEST VERIFIES THAT JSR STORES THE FLAGS AND PC IN LOCATION E. +;IN THIS CASE, E IS CLEARED, CRY0 IS SET AND JSR IS EXECUTED. +;NEXT, E IS CHECKED FOR ITS CONTENTS NON-ZERO. IF C(E) IS NON-ZERO, +;THIS TEST PASSES. + +C23000: SFLAG CRY0 ;SET CRY0 FLAG + SETZM .+2 ;PRELOAD E WITH 0 + JSR .+1 ;*JSR SHOULD PLACE FLAGS AND PC INTO AC + 0 ;E: PRESET TO 0, SHOULD RECEIVE FLAGS AND PC FROM JSR + SKIPN .-1 ;PASS IF C(E) IS NON-ZERO. + STOP + +;********** + +;THIS TEST VERIFIES THAT JSR IGNORES THE AC FIELD; +;HENCE, IT DOES NOT MODIFY THE SPECIFIED AC. +;IN THIS CASE, CRY0 IS SET. THE AC IS PRELOADED WITH -1,,-1 AND JSR IS EXECUTED. +;THE AC IS THEN CHECKED. IF C(AC)=-1,,-1, THIS TEST PASSES. + +C23100: SFLAG CRY0 ;SET CRY0 + SETO 1, ;PRELOAD AC WITH -1,,-1 + JSR 1,.+1 ;*JSR SHOULD NOT MODIFY THE AC + 0 ;STORE PC + FLAGS HERE + CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT JSR STORES THE FLAGS IN E-LEFT HALF. +;IN THIS TEST, CRY0 IS SET, E IS CLEARED AND JSR IS EXECUTED. +;NEXT, C(E-LEFT) ARE PLACED INTO AC0 AND AC0 IS CHECKED FOR ITS CONTENTS NON-ZERO. +;IF C(AC0) ARE NON-ZERO, THIS TEST PASSES. + +C23200: SFLAG CRY0 ;SET CRY0 + SETZM .+2 ;CLEAR E + JSR .+1 ;*JSR SHOULD STORE FLAGS IN E + 0 ;STORE FLAGS HERE (CRY0 MAKES THIS A MOVE INST) + HLLZ .-1 ;PUT FLAGS INTO AC0 + SKIPN ;PASS IF C(AC0) NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT JSR TRANSFERS CONTROL TO E+1. +;IN THIS CASE, CRY0 IS SET AND E AND AC0 CLEARED; THEN, JSR IS EXECUTED. +;IF JSR RESUMES CONTROL AT E INSTEAD OF E+1, AC0 WILL BE MODIFIED; +;HENCE, THE TEST WILL FAIL WHEN AC0 IS CHECKED FOR 0 BECAUSE +;C(E) IS DECODED AS A MOVE INSTRUCTION. + +C23300: SFLAG CRY0 ;SET CRY0 + SETZB .+2 ;CLEAR AC0 AND E + JSR .+1 ;*JSR SHOULD RESUME CONTROL AT E+1 + 0 ;STORE FLAGS HERE (CRY0 MAKES THIS A MOVE INST) + SKIPE 0 ;PASS IF C(AC0)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT JSR JUMPS TO E+1 +;IN THIS CASE, AC0 IS CLEARED AND CRY0 IS SET; THEN, JSR .+2 IS EXECUTED. +;IF JSR DID NOT JUMP, ONES ARE LOADED WITH AC0; AND THE TEST FAILS. +;OTHERWISE, AC0 REMAINS CLEAR AND THE TEST PASSES + +C23400: SFLAG CRY0 ;SET CRY0 + SETZ ;CLEAR AC0 + JSR .+2 ;*JSR SHOULD JUMP + SETO ;LOAD AC0 WITH ONES IF JSR FAILED TO JUMP + 0 ;STORE FLAGS HERE + SKIPE ;PASS IF JSR JUMPED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT JSR STORES THE PC IN E - RIGHT HALF. THE PC +;IS ONE GREATER THAN THE LOCATION OF THE JSR INSTRUCTION. +;THIS TEST WILL FAIL IF JSR STORES E INSTEAD OF PC IN E - RIGHT HALF. +;IN CASE OF FAILURE, AR PC EN AT ET2 WAS FAULTY. + +C23500: SFLAG 0 ;CLEAR ALL FLAGS + JSR .+2 ;*JSR SHOULD STORE PC+1 IN E - RIGHT + HALT . ;JSR SHOULD SKIP OVER THIS HALT + 0 ;STORE FLAGS AND PC HERE + HRRZ .-1 ;PUT STORED CONTENTS OF E - RIGHT INTO AC0 + CAIN .-2 ;FAIL IF C(AC0)=E + STOP + +;********** +;THIS TEST VERIFIES THAT JSR STORES THE PC IN E - RIGHT HALF. THE PC +;IS ONE GREATER THAN THE LOCATION OF THE JSR INSTRUCTION. +;THIS TEST WILL PASS IF JSR STORES PC IN E - RIGHT HALF. + +C23600: JSR .+2 ;*JSR SHOULD STORE PC+1 IN E - RIGHT + HALT . ;JSR SHOULD SKIP OVER THIS HALT + 0 ;STORE FLAGS AND PC HERE + HRRZ .-1 ;PUT STORED CONTENTS OF E - RIGHT INTO AC0 + CAIE C23600+1 ;PASS IF C(AC0)=C23600+1 [PC] + STOP + +;********** +SUBTTL TEST OF JSA INSTRUCTION + +;********** + +;THIS TEST VERIFIES THAT JSA JUMPS TO LOCATION E+1. +;IN THIS TEST, AC1 IS CLEARED AND A CAM 0,0 IS LOADED +;INTO THE AC OF THE JSA INSTRUCTION. +;IF JSA DOES NOT JUMP, AC1 WILL BE LOADED WITH ONES. AC1 IS CHECKED FOR ZEROS. +;IF C(AC1)=0, THE TEST PASSES; OTHERWISE, THIS TEST FAILS BECAUSE JSA DID NOT JUMP. + +C23700: SETZ 1, ;CLEAR AC1 + MOVE [CAM] ;LOAD CAM INTO AC0 + JSA .+2 ;*JSA SHOULD JUMP TO E+1 + SETO 1 ;JSA SHOULD JUMP OVER THIS INSTRUCTION + 0 ;PASS IF JSA JUMPED + SKIPE 1 + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA JUMPS TO LOCATION E+1. +;IN THIS TEST, AC1 IS CLEARED AND A MOVEI 1,1234 IS LOADED +;INTO THE AC OF THE JSA INSTRUCTION. +;IF JSA DOES NOT JUMP, AC1 WILL BE LOADED WITH 0,,1234. AC1 IS CHECKED FOR ZEROS. +;IF C(AC1)=0, THE TEST PASSES; OTHERWISE, THIS TEST FAILS BECAUSE JSA DID NOT JUMP. + +C24000: SETZ 1, ;CLEAR AC1 + MOVE [MOVEI 1,1234] ;LOAD MOVEI 1,1234 INTO AC + JSA .+1 ;*JSA SHOULD JUMP TO E+1 + 0 ;JSA SHOULD JUMP OVER THIS LOCATION + CAIN 1,1234 ;FAIL IF JSA DID NOT JUMP OVER PREVIOUS INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT JSA LOADS PC OF LOC OF JSA+1 INTO AC RIGHT. +;THIS TEST WILL FAIL IF JSA LOADS E INTO AC RIGHT INSTEAD OF PC. + +C24100: JSA .+2 ;*JSA SHOULD LOAD PC INTO AC RIGHT + HALT . ;JSA SHOULD JUMP OVER THIS LOCATION + 0 ;JSA SHOULD JUMP OVER THIS LOCATION + HRRZM 1 ;PUT C(AC-RIGHT) INTO AC1 + CAIN 1,.-2 ;FAIL IF E WAS LOADED INTO AC-RIGHT INSTEAD OF PC + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA PLACES C(AC) INTO E +;THIS TEST WILL FAIL IF EITHER 0,,E OR 0,,PC IS LOADED +;INTO E INSTEAD OF C(AC) + +C24200: SETZB .+2 ;CLEAR AC,E + JSA .+1 ;*JSA SHOULD LOAD C(AC) [ZEROS] INTO E + 0 ;JSA SHOULD PLACE ZEROS HERE + MOVE 1,.-1 ;SAVE C(AC) + CAIN 1,.-2 ;FAIL IF JSA LOADED 0,,E OR 0,,PC INTO E + STOP + +;********** +;THIS TEST VERIFIES THAT JSA PLACES PC INTO AC-RIGHT +;THIS TEST WILL FAIL IF PC IS NOT LOADED INTO AC-RIGHT + +C24300: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + JSA .+1 ;*JSA SHOULD PLACE E,,PC INTO THE AC + 0 ;JSA SHOULD PLACE C(AC) HERE + TRNN -1 ;FAIL IF AR LT AR RT EN FAILED + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA PLACES THE PC OF THE LOCATION OF JSA+1 IN AC-RIGHT +;THIS TEST FAILS IF A PC WAS NOT LOADED INTO AC RIGHT + +C24400: SETZ ;CLEAR AC + JSA .+1 ;*JSA SHOULD LOAD PC INTO AC - RIGHT + 0 ;JSA SHOULD PLACE C(AC) HERE + TRNN -1 ;PASS IF AC - RIGHT IS NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT JSA PLACES IN AC-LEFT +;THIS TEST FAILS IF JSA LOADS PC INSTEAD OF E INTO AC-LEFT + +C24500: JSA .+2 ;*JSA SHOULD LOAD E INTO AC-LEFT + HALT . ;JSA SHOULD JUMP OVER THIS INSTRUCTION + 0 ;E: + HLRZM 1 ;SAVE C(AC - LEFT) + CAIN 1,.-3 ;FAIL IF JSA LOADED PC INSTEAD OF E INTO AC-LEFT + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA LOADS E,,PC INTO THE AC +;FIRST, THE AC IS PRELOADED WITH -1,,-1; THEN, JSA IS EXECUTED. +;THE AC IS CHECKED FOR E,,PC. IF C(AC)=E,,PC, THIS TEST PASSES + +C24600: SETO ;PRELOAD AC WITH -1,,-1 + JSA .+2 ;*JSA SHOULD PLACE E,,PC INTO THE AC + HALT . ;JSA SHOULD JUMP OVER HERE, PC: + 0 ;JSA SHOULD STORE C(AC) HERE, E: + CAME [XWD .-1,.-2] ;PASS IF C(AC)=E,,PC + STOP + +;********** +;THIS TEST VERIFIES THAT JSA LOADS E,,PC INTO THE AC +;FIRST, THE AC IS PRELOADED WITH 0 JSA IS EXECUTED. +;THE AC IS CHECKED FOR E,,PC. IF C(AC)=E,,PC, THIS TEST PASSES + +C24700: SETZ ;PRELOAD AC WITH 0 + JSA .+2 ;*JSA SHOULD PLACE E,,PC INTO THE AC + HALT . ;JSA SHOULD JUMP OVER HERE, PC: + 0 ;JSA SHOULD STORE C(AC) HERE, E: + CAME [XWD .-1,.-2] ;PASS IF C(AC)=E,,PC + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. +;AC IS FIRST CLEARED AND E IS PRELOADED WITH ONES; +;THEN JSA IS EXECUTED. E IS CHECKED FOR ZEROS. IF C(E)=0, +;THIS TEST PASSES. + +C25000: SETZ ;CLEAR AC + SETOM .+2 ;PRELOAD E WITH -1,,-1 + JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E + 0 ;E: SHOULD GET C(AC) FROM JSA + SKIPE .-1 ;PASS IF C(E)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. +;AC IS FIRST PRELOADED WITH -1,,-1 AND E IS CLEARED; +;THEN, JSA IS EXECUTED. E IS CHECKED FOR -1,,-1. IF C(E)=-1,,-1, +;THIS TEST PASSES. + +C25100: SETOB 1 ;PRELOAD AC -1,,-1 + SETZM .+2 ;PRELOAD E WITH 0 + JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E + 0 ;E: SHOULD GET C(AC) FROM JSA + CAME 1,.-1 ;PASS IF C(E)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. +;AC IS FIRST CLEARED AND E IS PRELOADED WITH ONES; +;THEN JSA IS EXECUTED. E IS CHECKED FOR ZEROS. IF C(E)=0, +;THIS TEST PASSES. + +C25200: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E + 0 ;E: SHOULD GET C(AC) FROM JSA + MOVE 1,.-1 ;PASS IF C(E)=0,,-1 + CAIE 1,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT JSA DOES NOT MODIFY AC+1 +;IN THIS TEST, AC+1 IS PRELOADED WITH -1,,-1; THEN JSA IS EXECUTED +;AC+1 IS THEN CHECKED FOR ITS ORIGINAL CONTENTS, -1,,-1. +;IF C(AC+1)=-1,,-1, THIS TEST PASSES + +C25300: SETOM 1 ;PRELOAD AC+1 WITH -1,,-1 + JSA .+1 ;*JSA SHOULD NOT MODIFY AC+1 + CAM ;JSA SHOULD JUMP OVER THIS, E:PC: + CAME 1,[-1] ;PASS IF AC+1 WAS NOT MODIFIED BY JSA + STOP + +;********** +SUBTTL TEST OF JRA INSTRUCTION + +;********** + +;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E +;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. + +C25400: MOVE [JRST .+4] ;PRELOAD AC0 WITH JRST .+4 + MOVSI 1,.+2 ;PRELOAD AC WITH E,,0 + JRA 1,.+1 ;*JRA SHOULD JUMP TO NEXT INSTRUCTION + SKIPA ;PASS IF JRA JUMPS TO E + STOP + +;********** + +;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E +;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. + +C25500: MOVSI .+3 ;PRELOAD AC WITH E+1 + JRA .+1 ;*JRA SHOULD JUMP TO NEXT SEQUENTIAL INSTRUCTION + SKIPA ;PASS IF JRA JUMPS TO E + STOP + +;********** +;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E +;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. + +C25600: SETZB 1 ;PRELOAD AC0, AC1 WITH ZEROS + JRA .+2 ;*JRA SHOULD JUMP OVER NEXT SEQUENTIAL INSTRUCTION + SETO 1, ;LOAD AC1 WITH ONES IF JRA DOES NOT JUMP + SKIPE 1 ;PASS IF JRA JUMPED + STOP + +;********** + +;THIS TEST VERIFIES THAT JRA PLACES C(C(AC-LEFT)) INTO THE AC AND JUMPS TO E +;THIS TEST FAILS IF JRA JUMPS TO E+1 OR DOES NOT LOAD THE AC CORRECTLY. + +C25700: SETZ ;CLEAR AC + JRA .+1 ;*JRA SHOULD PLACE 0 INTO THE AC AND JUMP .+1 + SKIPE ;PASS IF AC WAS LOADED CORRECTLY + ;AND JRA JUMPED CORRECTLY. + STOP + +;********** +;THIS TEST VERIFIES THAT JRA PLACES C(C(AC-LEFT)) INTO THE AC +;FIRST, THE AC IS PRELOADED WITH 1,,2 AND AC1 AND AC2 ARE +;INITIALIZED WITH THEIR RESPECTIVE ADDRESSES; JRA IS EXECUTED, AND +;THE AC IS CHECKED FOR 0,,1, THE ORIGINAL C(C(AC-LEFT)). IF C(AC)=0,,1, +;THIS TEST PASSES + +C26200: MOVE [XWD 1,2] ;PRELOAD AC WITH 1,,2 + MOVEI 1,1 ;INITIALIZE AC1 WITH 0,,1 + MOVEI 2,2 ;INITIALIZE AC2 WITH 0,,2 + JRA .+1 ;*JRA SHOULD PLACE 0,,1 INTO THE AC + CAIE 1 ;PASS IF C(AC)=0,,1 + STOP + +;********** + +;THIS TEST VERIFIES THAT JRA CAN RESTORE AC0 FROM AC0 WHEN AC0 IS THE +;SPECIFIED AC AND C(AC0-LEFT)=0. +;FIRST, AC0 IS PRELOADED AND JRA IS EXECUTED. THEN, AC0 IS CHECKED FOR +;ITS INITIAL CONTENTS. IF THE RESULT IN AC0, IS CORRECT, THIS TEST PASSES. + +C26300: HRRZI [135531,,246642] ;PRELOAD AC0 WITH 0,, LITERAL ADDRESS + JRA .+1 ;*JRA SHOULD PLACE C(AC0) INTO AC0 + CAIE [135531,,246642] ;PASS IF JRA PLACED C(AC0) INTO AC0 + STOP + +;********** +;THIS TEST VERIFIES THAT JRA CAN RESOTRE AC0 FROM MEMORY WHEN AC0 IS THE +;SPECIFIED AC. +;FIRST, AC0 IS PRELOADED WITH [LITERAL ADDRESS ,,0] AND JRA IS EXECUTED. THEN, +;AC0 IS CHECKED FOR THE SPECIFIED LITERAL, 135246,,246135. IF +;C(AC0)=135246,,246135, THE TEST PASSES. + +C26400: HRLZI [135246,,246135] ;PRELOAD AC0 WITH [LITERAL ADDRESS ,,0] + JRA .+1 ;*JRA SHOULD PLACE 135246,,246135 INTO AC0 + CAME [135246,,246135];PASS IF C(AC0)=135246,,246135 + STOP + +;********** + +;THIS TEST VERIFIES THAT JRA CAN RESOTRE AC0 FROM MEMORY WHEN AC0 IS THE +;SPECIFIED AC. +;FIRST, AC0 IS PRELOADED WITH [-1,, ADDRESS OF JCA INSTRUCTION] AND JRA IS EXECUTED. +;THEN, AC0 IS CHECKED FOR THE JRA INSTRUCTION. IF +;C(AC0)= THE JRA INSTRUCTION, THE TEST PASSES. + +C26500: HRLOI .+1 ;PRELOAD AC WITH -1,, ADDRESS OF JRA INSTRUCTION + JRA .+1 ;*JRA SHOULD PLACE ITSELF INTO AC0 + CAME .-1 ;PASS IF AC CONTAINS JRA INSTRUCTION + STOP + +;********** +SUBTTL TESTS OF BIS FLAG + +;********** + +;THIS TEST VERIFIES THAT JRST 2, CAN CLEAR BIS +;FIRST, BIS IS SET VIA JRST 2, ;THEN, BIS IS CLEARED VIA JRST 2,. +;THE FLAGS ARE SAVED AND BIS IS CHECKED. THIS TEST PASSES IF BIS IS RESET; +;OTHERWISE JRST 2, FAILED TO RESET BIS. + +C26600: SFLAG BIS ;SET BIS FLAG + SFLAG ;*RESET BIS FLAG + JSP .+1 ;SAVE FLAGS + TLNE BIS+37 ;PASS IF BIS FLAG IS RESET + STOP + +;********** + +;THIS TEST VERIFIES THAT JRST 2, CAN SET BIS. +;FIRST, BIS IS SET VIA JRST 2, AND THE FLAGS ARE SAVED. +;BIS IS THEN CHECKED. IF BIS IS SET, THIS TEST PASSES. + +C26700: SFLAG BIS ;*SET BIS FLAG VIA JRST + JSP .+1 ;SAVE FLAGS + TLNN BIS ;PASS IF BIS FLAG IS SET + STOP + +;********** +;THIS TEST VERIFIES THAT JSR ALWAYS RESETS BIS. +;FIRST BIS IS SET; THEN JSR IS EXECUTED. THE FLAGS ARE +;THEN SAVED AND CHECKED. IF BIS WAS RESET VIA JSR, THIS TEST PASSES. + +C27000: SFLAG BIS ;SET BIS + JSR .+1 ;*JSR SHOULD RESET BIS + 0 ;JSR SAVES FLAGS HERE + JSP .+1 ;SAVE FLAGS + TLNE BIS ;PASS IF BIS FLAG IS RESET + STOP + +;********** + +;THIS TEST VERIFIES THAT JSP ALWAYS RESETS BIS. +;FIRST BIS IS SET; THEN JSP IS EXECUTED. THE FLAGS ARE +;THEN SAVED AND CHECKED. IF BIS WAS RESET VIA JSP, THIS TEST PASSES. + +C27001: SFLAG BIS ;SET BIS + JSP .+1 ;*JSP SHOULD RESET BIS + JSP .+1 ;SAVE FLAGS + TLNE BIS ;PASS IF BIS FLAG IS RESET + STOP + +;********** +;THIS TEST VERIFIES THAT THE BITS IN POSITIONS 8, 9 AND 10 ARE CLEARABLE. +;FIRST, THE ARITHMETIC FLAGS ARE CLEARED; +;THEN, BITS 8, 9 AND 10 OF THE PC-WORD IS EXAMINED. +;IF ANY OF THESE BITS ARE SET, THIS TEST FAILS BECAUSE THEY SHOULD BE CLEAR. + +C27100: SFLAG ;CLEAR ARITHMETIC FLAGS + JSP .+1 ;SAVE FLAGS + TLNE 1600 ;PASS IF THESE BITS ARE CLEAR + STOP + +;********** +SUBTTL TEST OF MSCL FWT INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT MOVEM PLACES C(AC) INTO E AND DOES +;NOT MODIFY C(AC). +;IN THIS CASE, C(AC)=252525,,252525 ANS C(E)=707070,,707070. +;HENCE, THE RESULT IN E SHOULD BE 252525,,252525. +;THE AC IS CHECKED FOR 252525,,252525. IF ANY OTHER NUMBER IS +;FOUND IN THE AC, IT WAS CLOBBERED BY MOVEM, AND THIS TEST FAILS. +;E IS CHECKED FOR 252525,,252525. IF ANY OTHER NUMBER IS FOUND +;IN E, IT WAS UPDATED INCORRECTLY BY MOVEM. + +C50000: MOVE [252525,,252525] ;PRELOAD AC WITH 252525,,252525 + MOVE 1,[707070,,707070] ;PRELOAD E WITH 707070,,707070 + MOVEM 0,1 ;*MOVEM SHOULD PLACE 252525,,252525 + ;INTO E AND NOT AFFECT THE AC + CAME 0,[252525,,252525] ;PASS IF C(AC) IS NOT CLOBBERED + STOP + CAME 1,[252525,,252525] ;PASS IF E WAS UPDATED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVES PLACES C(E) INTO THE AC IF AC IS NON-ZERO. +;IN THIS CASE, C(AC)=707070,,707070 AND C(E)=123456,,123456. HENCE, BOTH +;THE AC AND E SHOULD CONTAIN 123456,,123456 AFTER MOVES IS EXECUTED. +;BOTH AC AND E ARE CHECKED FOR 123456,,123456. IF EITHER AC OR E +;CONTAIN A DIFFERENT RESULT, THIS TEST FAILS + +C50100: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVE 1,[123456,,123456] ;PRELOAD E WITH 123456,,123456 + MOVES 2,1 ;*MOVES SHOULD PLACE 123456,,123456 + ;INTO BOTH AC AND E + CAME 2,[123456,,123456] ;PASS IF C(AC)=123456,,123456 + STOP + CAME 1,[123456,,123456] ;PASS IF C(E)=123456,,123456 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVES IS A NO-OP IF AC=0 +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=707070,,707070 +;AFTER MOVES IS EXECUTED, AC AND E ARE CHECKED FOR THEIR ORIGINAL DATA. +;IF EITHER C(AC) OR C(E) CHANGED AS A RESULT OF MOVES, THIS TEST FAILS. + +C50110: MOVE 1,[707070,,707070] ;PRELOAD E WITH 707070,,707070 + SETO ;PRELOAD AC WITH -1,,-1 + MOVES 0,1 ;*MOVES SHOULD FUNCTION AS A NO-OP + CAME 0,[-1,,-1] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + CAME 1,[707070,,707070] ;PASS IF C(E) WAS NOT MODIFIED + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVSI LOADS THE WORD E,0 INTO THE AC. +;IN THIS CASE, C(AC)=707070,,707070 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. + +C50200: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVSI 1,-1 ;*MOVSI SHOULD PLACE -1,,0 INTO THE AC + CAME 1,[-1,,0] ;PASS IF C(AC)=1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVNM PLACES THE NEGATIVE OF C(AC) +;INTO E. IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-3. +;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 AND THE RESULT +;IN E SHOULD BE 0,,1 + +C50300: SETO 1, ;PRELOAD AC WITH -1,,-1 + MOVE 2,[-1,,-3] ;PRELOAD E WITH -1,,-3 + MOVNM 1,2 ;*MOVNM SHOULD PLACE 0,,1 INTO E + ;AND NOT AFFTECT C(AC) + CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 + STOP + CAIE 2,1 ;PASS IF C(E)=0,,1 + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVNM PLACES THE NEGATIVE OF C(AC) +;INTO E. IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-3. +;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 AND THE RESULT +;IN E SHOULD BE 0,,1 + +C50301: SETO 1, ;PRELOAD AC WITH -1,,-1 + MOVE 2,[-1,,-3] ;PRELOAD E WITH -1,,-3 + MOVEM 2,E50301 + MOVNM 1,E50301 ;*MOVNM SHOULD PLACE 0,,1 INTO E + ;AND NOT AFFTECT C(AC) + CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 + STOP + MOVE 2,E50301 + CAIE 2,1 ;PASS IF C(E)=0,,1 + STOP + + SKIPA ;GO TO NEXT TEST +E50301: 0 ;TESTED MEMORY LOCATION + +;********** +;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E +;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=0, +;C(AC)=0 AND C(E)=0,,1 +;HENCE, THE RESULT IN THE AC SHOULD BE 0 +;AND THE RESULT IN E SHOULD BE -1,,-1 + +C50400: SETZ ;CLEAR AC + MOVEI 2,1 ;PRELOAD E WITH 0,,1 + MOVNS 0,2 ;*MOVNS SHOULD PLACE -1,,-1 INTO E + ;AND SHOULD NOT AFFECT THE AC + SKIPE ;PASS IF THE AC IS UNALTERED + STOP + CAME 2,[-1] ;PASS IF C(E)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E +;AND INTO THE AC IF THE AC IS NON-ZO. IN THIS CASE, AC=0, +;C(AC)=0 AND C(E)=0,,1 +;HENCE, THE RESULT IN THE AC SHOULD BE 0 +;AND THE RESULT IN E SHOULD BE -1,,-1 + +C50401: SETZ ;CLEAR AC + MOVEI 2,1 ;PRELOAD E WITH 0,,1 + MOVEM 2,E50401 + MOVNS 0,E50401 ;*MOVNS SHOULD PLACE -1,,-1 INTO E + ;AND SHOULD NOT AFFECT THE AC + SKIPE ;PASS IF THE AC IS UNALTERED + STOP + MOVE 2,E50401 + CAME 2,[-1] ;PASS IF C(E)=-1,,-1 + STOP + + SKIPA ;GO TO NEXT TEST +E50401: 0 ;TESTED MEMORY LOCATION + +;********** +;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E +;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=1, +;C(AC=0 AND C(E)=3 +;HENCE, THE RESULT IN THE AC SHOULD BE -1,,3 +;AND THE RESULT IN E SHOULD BE -1,,3. + +C50410: SETZ 1, ;CLEAR AC + MOVEI 2,3 ;PRELOAD WITH 0,,3 + MOVNS 1,2 ;*MOVNS SHOULD PLACE -1,,-3 INTO E + ;AND -1,,-3 INTO THE AC + CAME 1,[-1,,-3] ;PASS IF C(AC)=-1,,-3 + STOP + CAME 2,[-1,,-3] ;PASS IF C(E)=-1,,-3 + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVMI MOVES THE WORD 0,,E INTO THE AC. +;IN THIS CASE, C(AC)=0 AND E=0,,-2. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-2. + +C50500: SETZ 1, ;CLEAR AC + MOVMI 1,-2 ;*MOVMI SHOULD PLACE 0,,-2 INTO AC + CAIE 1,-2 ;PASS IF C(AC)=0,,-2 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVM MOVES THE MAGNITUDE OF C(E) NTO THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-2. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,2. + +C50501: SETZ 1, ;CLEAR AC + MOVE 3,[-2] ;PRELOAD E WITH -1,,-2 + MOVM 1,3 ;*MOVM SHOULD PLACE 0,,2 INTO AC + CAIE 1,2 ;PASS IF C(AC)=0,,2 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVMM PLACES THE MAGNITUDE OF C(AC) +;INTO E. IN THIS CASE, C(AC)=-1,,-2 AND C(E)=0. HENCE, THE +;RESULT IN E SHOULD BE 0,,2 AND C(AC) SHOULD REMAIN UNCHANGED. + +C50600: MOVE 1,[-1,,-2] ;PRELOAD AC WITH -1,,-2 + SETZ 2, ;CLEAR E + MOVMM 1,2 ;*MOVMM SHOULD PLACE 0,,2 INTO E + ;AND SHOULD NOT CHANGE C(AC) + CAME 1,[-1,,-2] ;PASS IF C(AC) IS NOT ALTERED + STOP + CAIE 2,2 ;PASS IF C(E)=0,,2 + STOP + +;********** + +;THIS TEST VERIFIES THAT MONMS PLACES THE MAGNITUDE OF C(E) INTO E +;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=0, C(AC)=0 +;AND C(E)=-1,,-2. +;HENCE, THE RESULT IN THE AC SHOULD BE 0 AND THE RESULT IN +;E SHOULD BE 0,,2. + +C50700: SETZ ;CLEAR AC + MOVE 2,[-1,,-2] ;PRELOAD E WITH -1,,-1 + MOVMS 0,2 ;*MOVMS SHOULD PLACE 0,,1 INTO E + ;AND SHOULD NOT CHANGE C(AC) + SKIPE ;PASS IF C(AC) IS UNALTERED + STOP + CAIE 2,2 ;PASS IF C(E)=0,,2 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVMS PLACES THE MAGNITUDE OF C(E) INTO E +;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=1, C(AC)=-1,,-1 +;AND C(E)=-1,,-2. +;HENCE, THE RESULT IN THE AC SHOULD BE 0,,2 AND THE RESULT +;IN E SHOULD BE 0,,2. + +C50710: SETO 1, ;PRELOAD AC WITH -1,,-1 + MOVE 2,[-1,,-2] ;PRELOAD E WITH -1,,-2 + MOVMS 1,2 ;*MOVMS SHOULD PLACE 0,,2 INTO E + ;AND SHOULD PLACE 0,,2 INTO THE AC + CAIE 1,2 ;PASS IF C(AC)=0,,2 + STOP + CAIE 2,2 ;PASS IF C(E)=0,,2 + STOP + +;********** +SUBTTL TEST OF MSCL ADD/SUB INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT SUBI SUBTRACTS THE WORD 0,,E FROM C(AC) +;AND PLACES THE RESULT INTO THE AC. IN THIS CASE, C(AC)=70 AND +;E=0,,2. HENCE, THE RESULT IN THE AC SHOULD BE 66. + +C51000: MOVEI 1,70 ;PRELOAD AC WITH 70 + SUBI 1,2 ;*SUBI SHOULD PLACE 66 INTO AC + CAIE 1,66 ;PASS IF C(AC)=66 + STOP + +;********** + +;THIS TEST VERIFIES THAT SUBM SUBTRACTS C(E) FROM C(AC) AND +;PLACES THE RESULT INTO E. THE AC IS UNAFFECTED. IN THIS CASE, +;C(AC)=100 AND C(E)=37. HENCE, THE RESULTS IN AC AND +;E SHOULD BE 0,,100 AND 0,,41 RESPECTIVELY. + +C51100: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + MOVEI 2,37 ;PRELOAD E WITH 0,,37 + SUBM 1,2 ;*SUBM SHOULD PLACE + ;0,,41 INTO E AND NOT CHANGE C(AC) + CAIE 1,100 ;PASS IF C(AC) IS UNCHANGED + STOP + CAIE 2,41 ;PASS IF C(E)=0,,41 + STOP + +;********** +;THIS TEST VERIFIES THAT SUBM SUBTRACTS C(E) FROM C(AC) AND +;PLACES THE RESULT INTO E. THE AC IS UNAFFECTED. IN THIS CASE, +;C(AC)=100 AND C(E)=37. HENCE, THE RESULTS IN AC AND +;E SHOULD BE 0,,100 AND 0,,41 RESPECTIVELY. + +C51101: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + MOVEI 2,37 ;PRELOAD E WITH 0,,37 + MOVEM 2,E51101 + SUBM 1,E51101 ;*SUBM SHOULD PLACE + ;0,,41 INTO E AND NOT CHANGE C(AC) + CAIE 1,100 ;PASS IF C(AC) IS UNCHANGED + STOP + MOVE 2,E51101 + CAIE 2,41 ;PASS IF C(E)=0,,41 + STOP + + SKIPA ;GO TO NEXT TEST +E51101: 0 ;TEST WORD MEMORY + +;********** +;THIS TEST VERIFIES THAT SUBB SUBTRACTS C(E) FROM C(AC) AND +;PLACES THE RESULT INTO BOTH AC AND E. IN THIS CASE, +;C(AC)=0,,100 AND C(E)=0,,37. HENCE, THE RESULT IN BOTH +;AC AND E SHOULD BE 0,,41. + +C51200: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + MOVEI 2,37 ;PRELOAD E WITH O,,37 + SUBB 1,2 ;*SUBB SHOULD PLACE 0,,41 INTO BOTH AC AND E + CAIE 1,41 ;PASS IF C(AC)=0,,41 + STOP + CAIE 2,41 ;PASS IF C(E)=0,,41 + STOP + +;********** + +;THIS TEST VERIFIES THAT SUBB SUBTRACTS C(E) FROM C(AC) AND +;PLACES THE RESULT INTO BOTH AC AND E. IN THIS CASE, +;C(AC)=0,,100 AND C(E)=0,,37. HENCE, THE RESULT IN BOTH +;AC AND E SHOULD BE 0,,41. + +C51201: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + MOVEI 2,37 ;PRELOAD E WITH O,,37 + MOVEM 2,E51201 + SUBB 1,E51201 ;*SUBB SHOULD PLACE 0,,41 INTO BOTH AC AND E + CAIE 1,41 ;PASS IF C(AC)=0,,41 + STOP + MOVE 2,E51201 + CAIE 2,41 ;PASS IF C(E)=0,,41 + STOP + + SKIPA ;GO TO NEXT TEST +E51201: 0 ;TEST WORD MEMORY + +;********** +SUBTTL TEST OF MSCL CAIX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E. +;IN THIS CASE, C(AC)=0,,1 AND E=0,,2 +;HENCE, CAIL SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIL SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C51300: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + CAIL 1,2 ;*CAIL SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E. +;IN THIS CASE, C(AC)=0,,2 AND E=0,,2. +;HENCE, CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIL DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51310: MOVEI 1,2 ;PRELOAD AC WITH 0,,2 + CAIL 1,2 ;*CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIL DOES NOT SKIP + STOP + +;********** +;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E +;IN THIS CASE, C(AC)=0,,3 AND E=0,,2 +;HENCE, CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIL DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51320: MOVEI 1,3 ;PRELOAD AC WITH 0,,3 + CAIL 1,2 ;*CAIL SHOULD SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIL DOES NOT SKIP + STOP + +;********** + +;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E +;IN THIS CASE, C(AC)=-1,,-1 AND E=0 +;HENCE, CAILE SHOULD SKIP THE NEXT INSTRUCTION +;IF CAILE SKIPS THE NEXT INSTRUCTION, THE TEST PASSES + +C51400: SETO 1, ;PRELOAD AC WITH -1,,-1 + CAILE 1,0 ;*CAILE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E +;IN THIS CASE, C(AC)=0 AND E=0 +;HENCE, CAILE SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAILE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51410: SETZ 1, ;PRELOAD AC WITH 0 + CAILE 1,0 ;*CAILE SHOULD SKIP THE NEXT INSTRUCTION. + STOP + +;********** + +;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E +;IN THIS CASE, C(AC)=0,,1 AND E=0 +;HENCE, CAILE SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAILE DOES NOT SKIP THE NEXT INSTRUCTION, THE TEST PASSES + +C51420: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + CAILE 1,0 ;*CAILE SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAILE DOES NOT SKIP + STOP + +;********** +;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS +;SKIPS THE NEXT INSTRUCTION +;IN THIS CASE, C(AC)=-1,,-1 AND E=0 +;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION +;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C51500: SETO 1, ;PRELOAD AC WITH -1,,-1 + CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS +;SKIPS THE NEXT INSTRUCTION +;IN THIS CASE, C(AC)=0 AND E=0 +;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C51510: SETZ 1, ;PRELOAD AC WITH 0 + CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS +;SKIPS THE NEXT INSTRUCTION +;IN THIS CASE, C(AC)=0,,1 AND E=0 +;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51520: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E. +;IN THIS CASE, C(AC)=0,,5 AND E=0,,6 +;HENCE, CAIGE SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIGE DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES + +C51600: MOVEI 2,5 ;PRELOAD AC WITH 0,,5 + CAIGE 2,6 ;*CAIGE SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIGE DOES NOT SKIP + STOP + +;********** +;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E +;IN THIS CASE, C(AC)=0,,6 AND E=0,,6 +;HENCE, CAIGE SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIGE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51610: MOVEI 2,6 ;PRELOAD AC WITH 0,,6 + CAIGE ;*CAIGE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E. +;IN THIS CASE, C(AC)=0,,7 AND E=0,,6 +;HENCE, CAIGE SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIGE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C51620: MOVEI 2,7 ;PRELOAD AC WITH 0,,7 + CAIGE 2,6 ;*CAIGE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIRIES THAT CAIN COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. +;IN THIS CASE, C(AC)=0 AND E=0,,1 +;HENCE, CAIN SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIN SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51700: SETZ 6, ;PRELOAD AC WITH 0 + CAIN 6,1 ;*CAIN SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIN COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. +;IN THIS CASE, C(AC)=0,,1 AND E=0,,1 +;HENCE, CAIN SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIN DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES + +C51710: MOVE 6,1 ;PRELOAD AC WITH 0,,1 + CAIN 6,1 ;*CAIN SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIN SKIPS + STOP + +;********** +;THIS TEST VERIFIES THAT CAIN COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. +;IN THIS CASE, C(AC)=0,,2 AND E=0,,1 +;HENCE, CAIN SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIN SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C51720: MOVEI 6,2 ;PRELOAD AC WITH + CAIN 6,1 ;*CAIN SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. +;IN THIS CASE, C(AC)=0,,2 AND E=0,,3. +;HENCE, CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES + +C52000: MOVEI 11,2 ;PRELOAD AC WITH 0,,2 + CAIG 11,3 ;*CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIG DID NOT SKIP + STOP + +;********** +;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. +;IN THIS CASE, C(AC)=0,,3 AND E=0,,3. +;HENCE, CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIG DOES NOT SKIP THE NEXT INSTRUCTION, THE TEST PASSES. + +C52010: MOVEI 11,3 ;PRELOAD AC WITH 0,,3 + CAIG 11,3 ;*CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIG DID NOT SKIP + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. +;IN THIS CASE, C(AC)=0,,4 AND E=0,,3. +;HENCE, CAIG SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIG SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C52020: MOVEI 11,4 ;PRELOAD AC WITH 0,,4 + CAIG 11,3 ;*CAIG SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +SUBTTL TEST OF MSCL CAMX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAT OR EQUAL TO C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0 +;HENCE, CAMLE SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAMLE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C52100: SETO 1, ;PRELOAD AC WITH -1,,-1 + SETZ 2, ;PRELOAD E WITH 0 + CAMLE 1,2 ;*CAMLE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=0 +;HENCE, CAMLE SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAMLE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C52110: SETZ 1, ;CLEAR AC + CAMLE 1,[0] ;*CAMLE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO C(E). +;IN THIS CASE, C(AC)=0,,1 AND C(E)=0 +;HENCE, CAMLE SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAMLE DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + +C52120: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + SETZ 2, ;PRELOAD E WITH 0 + CAMLE 1,2 ;*CAMLE SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAMLE DOES NOT SKIP + STOP + +;********** + +;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). +;IN THIS CASE, C(AC)=-1,,-2 AND C(E)=-1,,-1. +;HENCE, CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAMG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + +C52200: HRROI 10,-2 ;PRELOAD AC WITH -1,,-2 + CAMG 10,[-1,,-1] ;*CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. + SKIPA ;PASS IF CAMG DOES NOT SKIP + STOP +;********** + +;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-2. +;HENCE, CAMG SHOULD SKIP THE NEXT INSTRUCTION. + +C52205: HRROI 10,-1 ;PRELOAD AC WITH -1,,-1 + CAMG 10,[-1,,-2] ;*CAMG SHOULD SKIP THE NEXT INSTRUCTION. + STOP +;********** +;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. +;HENCE, CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAMG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. +C52210: SETO 10, ;PRELOAD AC WITH -1,,-1. + CAMG 10,[-1,,-1] ;*CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAMG DOES NOT SKIP + STOP + +;********** + +;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. +;HENCE, CAMG SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAMG SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C52220: SETZ 10, ;PRELOAD AC WITH 0 + CAMG 10,[-1,,-1] ;*CAMG SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +SUBTTL TEST OF MSCL JUMPX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND +;JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR +;EQUAL TO 0. IN THIS CASE, C(AC)=-1,,-1. HENCE, JUMPLE SHOULD JUMP. + +C52300: SETO 17, ;PRELOAD AC WITH -1,,-1 + JUMPLE 17,.+2 ;*JUMPLE SHOULD JUMP + STOP + +;********** + +;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND +;JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR +;EQUAL TO 0. IN THIS CASE, C(AC)=0. HENCE, JUMPLE SHOULD JUMP. + +C52310: SETZ 17, ;PRELOAD AC WITH 0 + JUMPLE 17,.+2 ;*JUMPLE SHOULD JUMP + STOP + +;********** +;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND JUMPS +;TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO +;0. IN THIS CASE, C(AC)=0,,1. HENCE, JUMPLE SHOULD NOT JUMP. + +C52320: MOVEI 17,1 ;PRELOAD AC WITH 0,,1 + JUMP 17,.+2 ;*JUMPLE SHOULD NOT JUMP + SKIPA ;PASS IF JUMPLE DOES NOT JUMP + STOP + +;********** + +;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH 0 AND JUMPS TO +;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC)=-1,,-1. HENCE, JUMPGE SHOULD NOT JUMP. + +C52400: SETO 16, ;PRELOAD AC WITH -1,,-1 + JUMPGE 16,.+2 ;*JUMPGE SHOULD NOT JUMP + SKIPA ;PASS IF JUMPGE DOES NOT JUMP + STOP + +;********** +;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH O AND JUMPS TO +;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC)=0. HENCE, JUMPGE SHOULD JUMP. + +C52410: SETZ 16, ;PRELOAD AC WITH 0 + JUMPGE 16,.+2 ;*JUMPGE SHOULD JUMP + STOP + +;********** + +;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH 0 AND JUMPS TO +;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC)=0,,1. HENCE, JUMPGE SHOULD JUMP. + +C52420: MOVEI 16,1 ;PRELOAD AC WITH 0,,1 + JUMPGE 16,.+2 ;*JUMPGE SHOULD JUMP + STOP + +;********** +SUBTTL TEST OF MSCL AOJX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND PLACES +;THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS COMPARED +;TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) +;IS LESS THAN 0. IN THIS CASE, C(AC)=-1,,-2 BEFORE INCREMENTING. +;HENCE, AOJL SHOULD JUMP. + +C52500: HRROI 15,-2 ;PRELOAD AC WITH -1,,-2 + AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) AND JUMP + STOP + CAME 15,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJ SHOULD NOT JUMP + +C52510: SETO 15, ;PRELOAD AC WITH + AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJL DID NOT JUMP + STOP + CAIE 15,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJL SHOULD NOT JUMP + +C52520: SETZ 15, ;PRELOAD AC WITH 0 + AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJL DID NOT JUMP + STOP + CAIE 15,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0 +;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING +;HENCE, AOJE SHOULD NOT JUMP + +C52600: HRROI 14,-2 ;PRELOAD AC WITH -1,,-2 + AOJE 14,.+2 ;*AOJE SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJE DID NOT JUMP + STOP + CAME 14,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING. +;HENCE, AOJE SHOULD JUMP + +C52610: SETO 14, ;PRELOAD AC WITH -1,,-1 + AOJE 14,.+2 ;*AOJ SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 14,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. +;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJE SHOULD NOT JUMP + +C52620: SETZ 14, ;PRELOAD AC WITH 0 + AOJE 14,.+2 ;*AOJE SHOULD ADD 0,11 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJE DID NOT JUMP + STOP + CAIE 14,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO TLE$EC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJLE SHOULD + +C52700: HRROI 13,-2 ;PRELOAD AC WITH -1,,-2 + AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAME 13,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJLE SHOULD JUMP. + +C52710: SETO 13, ;PRELOAD AC WITH -1,,-1 + AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 13,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC) IS 0 +;HENCE, AOJLE SHOULD NOT JUMP. + +C52720: SETZ 13, ;PRELOAD AC WITH 0 + AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJLE DID NOT JUMP + STOP + CAIE 13,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E. +;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING +;HENCE, AOJA SHOULD JUMP + +C53000: HRROI 12,-2 ;PRELOAD AC WITH -1,,-2 + AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAME 12,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJA SHOULD JUMP + +C53010: SETO 12, ;PRELOAD AC WITH -1,,-1 + AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 12,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E. +;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJA SHOULD JUMP + +C53020: SETZ 12, ;PRELOAD AC WITH 0 + AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 12,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING +;HENCE, AOJGE SHOULD NOT JUMP + +C53100: HRROI 11,-2 ;PRELOAD AC WITH -1,,-2 + AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJGE DID NOT JUMP + STOP + CAME 11,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJ SHOULD JUMP + +C53110: SETO 11, ;PRELOAD AC WITH -1,,-1 + AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 11,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJGE SHOULD JUMP + +C53120: SETZ 11, ;PRELOAD AC WITH 0 + AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 11,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. +;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING +;HENCE, AOJN SHOULD JUMP + +C53200: HRROI 10,-2 ;PRELOAD AC WITH -1,,-2 + AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAME 10,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJ SHOULD NOT JUMP. + +C53210: SETO 10, ;PRELOAD AC WITH -1,,-1 + AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJN DID NOT JUMP + STOP + CAIE 10,0 ;PASS IF C(AC) INCREMENTED CORRRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. +;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJN SHOULD JUMP. + +C53220: SETZ 10, ;PRELOAD AC WITH 0 + AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 10,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE REAULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0 +;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INC +;HENCE, AOJG SHOULD NOT JUMP + +C53300: HRROI 7,-2 ;PRELOAD AC WITH -1,,-2 + AOJG 7,.+2 ;*AOJG SHOULD ADD 0,11 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJG DID NOT JUMP + STOP + CAME 7,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJG SHOULD NOT JUMP. + +C53310: SETO 7, ;PRELOAD AC WITH -1,,-1 + AOJG 7,.+2 ;*AOJG SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJG DID NOT JUMP + STOP + CAIE 7,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. +;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJG SHOULD JUMP + +C53320: SETZ 7, ;PRELOAD AC WITH 0 + AOJG 7,.+2 ;*AOJG SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 7,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +SUBTTL TEST OF MSCL AOSX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSL SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C53400: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 7,-2 ;PRELOAD E WITH -1,,-2 + AOSL 6,7 ;*AOSL SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 7,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSL SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C53401: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 7,-2 ;PRELOAD E WITH -1,,-2 + MOVEM 7,E53401 + AOSL 6,E53401 ;*AOSL SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + MOVE 7,E53401 + CAME 7,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + + SKIPA ;GO TO NEXT TEST +E53401: 0 ;TEST WORD MEMORY + +;********** +;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) ISLESS THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSL SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C53410: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 7, ;PRELOAD E WITH -1,,-1 + AOSL 6,7 ;*AOSL SHOULD ADD 00,1 TO C(E) + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSL DID NOT SKIP + STOP + CAME 7,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 6,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSL SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY + +C53420: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 7, ;PRELOAD E WITH 0 + AOSL 6,7 ;*AOSL SHOULD ADD 0,,1 TO C(E). + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSL DID NOT SKIP + STOP + CAME 7,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 6,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSE SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C53500: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 6,-2 ;PRELOAD E WITH -1,,-2 + AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSE DID NOT SKIP + STOP + CAME 6,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 5,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSE SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C53510: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 6, ;PRELOAD E WITH -1,,-1 + AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 6,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 5,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(AC)=0 +;BEFORE INCREMENTING. HENCE, AOSE SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C53520: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 6, ;PRELOAD E WITH 0 + AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSE DID NOT SKIP + STOP + CAME 6,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 5,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSLE SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C53600: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 5,-2 ;PRELOAD E WITH -1,,-2 + AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP ZERO + STOP + CAME 5,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 4,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSLE SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C53610: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETOM 5, ;PRELOAD E WITH -1,,-1 + AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E) + ;UPDATE AC AND SKIP + STOP + CAME 5,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 4,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSLE SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C53620: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 5 ;PRELOAD E WITH 0 + AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E) + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSLE DID NOT SKIP + STOP + CAME 5,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 4,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSA INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C53700: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 4,-2 ;PRELOAD E WITH -1,,-2 + AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 4,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 3,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSA INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY + +C53710: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 4, ;PRELOAD E WITH -1,,-1 + AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 4,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 3,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOS INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY + +C53720: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 4, ;PRELOAD E WITH 0 + AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 4,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 3,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSGE SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY + +C54000: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 3,-2 ;PRELOAD E WITH -1,,-2 + AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSGE DID NOT SKIP + STOP + CAME 3,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 2,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSGE SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY + +C54010: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 3, ;PRELOAD E WITH 0 + AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 3,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 2,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSGE SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY + +C54020: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 3, ;PRELOAD E WITH 0 + AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 3,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 2,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSN SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY + +C54100: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 2,-2 ;PRELOAD E WITH -1,,-2 + AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 2,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 1,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSN SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY + +C54110: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 2, ;PRELOAD E WITH -1,,-1 + AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSN DID NOT SKIP + STOP + CAME 2,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 1,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSN SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY + +C54120: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 2, ;PRELOAD E WITH 0 + AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 2,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 1,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEST INSTRUCTION IF C(E) IS GREATER THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSG SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND -1,,-1 +;RESPECTIVELY + +C54200: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 1,-2 ;PRELOAD E WITH -1,,-2 + AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), + ;AND NOT SKIP + SKIPA ;PASS IF AOSG DID NOT SKIP + STOP + CAME 1,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSG SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 +;RESPECTIVELY + +C54210: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 1, ;PRELOAD E WITH -1,,-1 + AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), + ;AND NOT SKIP + SKIPA ;PASS IF AOSG DID NOT SKIP + STOP + CAME 1,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + +;*********** +;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSG SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0,,1 +;RESPECTIVELY + +C54220: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 1, ;PRELOAD E WITH 0 + AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), + ;AND SKIP + STOP + CAME 1,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + +;********** +SUBTTL TEST OF MSCL SOJX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESTULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN 0. +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJL +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + +C54300: MOVEI 17,0 ;PRELOAD AC WITH 0 + SOJL 17,.+2 ;*SOJL SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 17,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;*********** + +;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN 0. +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJL +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. + +C54310: MOVEI 17,1 ;PRELOAD AC WITH 0,,1 + SOJL 17,.+2 ;*SOJL SHOULD SUBTRACT 0,,1 FROM C(AC) + SKIPA ;PASS IF SOJL DID NOT JUMP + STOP + CAME 17,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN 0 +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJ +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + +C54320: MOVEI 17,2 ;PRELOAD AC WITH 0,,2 + SOJL 17,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJL DID NOT JUMP + STOP + CAME 17,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJE +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + +C54400: MOVEI 16,0 ;PRELOAD AC WITH 0 + SOJE 16,.+2 ;*SOJE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJE DID NOT JUMP + STOP + CAME 16,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0 +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJ +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + +C54410: MOVEI 16,1 ;PRELOAD AC WITH 0,,1 + SOJE 16,.+2 ;*SOJE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 16,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJE +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + +C54420: MOVEI 16,2 ;PRELOAD AC WITH 0,,2 + SOJE 16,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJE DID NOT JUMP + STOP + CAME 16,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJLE +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + +C54500: MOVEI 15,0 ;PRELOAD AC WITH 0 + SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 15,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUALTO 0. +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJLE +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + +C54510: MOVEI 15,1 ;PRELOAD AC WITH 0,,1 + SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 15,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJLE +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + +C54520: MOVEI 15,2 ;PRELOAD AC WITH 0,,2 + SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF SOJLE DID NOT JUMP + STOP + CAME 15,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJA +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + +C54600: MOVEI 14,0 ;PRELOAD AC WITH 0 + SOJA 14,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 14,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJA +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + +C54610: MOVEI 14,1 ;PRELOAD AC WITH 0,,1 + SOJA 14,.+2 ;*SOJA SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 14,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJA +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + +C54620: MOVEI 14,2 ;PRELOAD AC WITH 0,,2 + SOJA 14,.+2 ;*SOJA SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 14,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJGE +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + +C54700: MOVEI 13,0 ;PRELOAD A C WITH 0 + SOJGE 13,.+2 ;*SOJGE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF SOJGE DID NOT JUMP + STOP + CAME 13,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJGE +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + +C54710: MOVEI 13,1 ;PRELOAD AC WITH 0,,1 + SOJGE 13,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 13,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIRIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND PLACES THE +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS COMPARED +;TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC IS +;GREATER THAN OR EQUAL TO 0. IN THIS CASE, C(AC = 0,,2 BEFORE +;DECREMENTING. HENCE, SOJGE SHOULD JUMP AND THE RESULT IN THE AC SHOULD +;BE 0,,1. + +C54720: MOVEI 13,2 ;PRELOAD AC WITH 0,,2 + SOJGE 13,.+2 ;*SOJGE SHOULD SUBTRACT0,,1 FROM C(AC) + ;AND JUMP. + STOP + CAME 13,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS NON-ZERO. +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE,SOJN +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1. + +C55000: MOVEI 12,0 ;PRELOAD AC WITH 0 + SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP. + STOP + CAME 12,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIRIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED +;BY E IF C(AC) IS NON-ZERO. +;IN THIS CASE, C(AC) = 0,,1 BEFORE DECREMENTING. HENCE, SOJN +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. + +C55010: MOVEI 12,1 ;PRELOAD AC WITH 0,,1 + SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJN DID NOT JUMP + STOP + CAME 12,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS NON-ZERO. +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJN +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1. + +C55020: MOVEI 12,2 ;PRELOAD AC WITH 0,,2 + SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP. + STOP + CAME 12,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. +;IN THIS CASE, C(AC) = 0 BEFORE DECREMENTING. HENCE, SOJG +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1. + +C55100: MOVEI 11,0 ;PRELOAD AC WITH 0 + SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJG DID NOT JUMP + STOP + CAME 11,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIRIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJG +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. + +C55110: MOVEI 11,1 ;PRELOAD AC WITH 0,,1 + SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJG DID NOT JUMP + STOP + CAME 11,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJG +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1. + +C55120: MOVEI 11,2 ;PRELOAD AC WITH 0,,2 + SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT O,,1 FROM C(AC) + ;AND JUMP. + STOP + CAME 11,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +SUBTTL TEST OF MSCL SOSX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSL SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND -1,,-1 +;RESPECTIVELY. + +C55200: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 1,0 ;PRELOAD E WITH 0 + SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E) + ;AND SKIP + STOP + CAME 1,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 +;RESPECTIVELY. + +C55210: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 1,1 ;PRELOAD E WITH 0,,1 + SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), + ;AND NOT SKIP. + SKIPA ;PASS IF SOSL DID NOT SKIP + STOP + CAME 1,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + +;********** +;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 +;RESPECTIVELY. + +C55211: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 1,1 ;PRELOAD E WITH 0,,1 + MOVEM 1,E55211 + SOSL 0,E55211 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), + ;AND NOT SKIP. + SKIPA ;PASS IF SOSL DID NOT SKIP + STOP + MOVE 1,E55211 + CAME 1,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + + SKIPA ;GO TO NEXT TEST +E55211: 0 ;TEST WORD MEMORY + +;********** +;THIS TEST VERIFIES THAT SOS DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E) 0,,2 +;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0,,1 +;RESPECTIVELY. + +C55220: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 1,2 ;PRELOAD E WITH 0,,2 + SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), + ;AND NOT SKIP + + SKIPA ;PASS IF SOSL DID NOT SKIP + STOP + CAME 1,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSE SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C55300: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 11,0 ;PRELOAD E WITH 0 + SOSE 10,11 ;*SOSE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + + SKIPA ;PASS IF SOSE DID NOT SKIP + STOP + CAME 11,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 10,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSE SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 +;RESPECTIVELY. + +C55310: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 11,1 ;PRELOAD E WITH 0,,1 + SOSE 10,11 ;*SOS SHOULD SUBTRACT 0,,1 FROM C(E) + ;UPDATE AC AND SKIP + STOP + CAME 11,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 10,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,11 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSE SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C55320: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 11,2 ;PRELOAD E WITH 0,,2 + SOSE 10,11 ;*SOSE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + + SKIPA ;PASS IF SOSE DID NOT SKIP + STOP + CAME 11,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 10,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=7, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSLE SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C55400: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 10,0 ;PRELOAD E WITH 0 + SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 10,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 7,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=7, C(AC)=070707,,070707 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSLE SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C55410: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 10,1 ;PRELOAD E WITH 0,,1 + SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 10,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 7,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=7, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSLE SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C55420: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 10,2 ;PRELOAD E WITH 0,,2 + SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF SOSLE DID NOT SKIP + STOP + CAME 10,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 7,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSA SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C55500: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 7,0 ;PRELOAD E WITH 0 + SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 7,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THEAC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSA SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C55510: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 7,1 ;PRELOAD E WITH 0,,1 + SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 7,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 6,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSA SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C55520: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 7,2 ;PRELOAD E WITH 0,,2 + SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 7,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 6,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSGE SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C55600: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 6,0 ;PRELOAD E WITH 0 + SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF SOSGE DID NOT SKIP + STOP + CAME 6,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 5,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSGE SHOULD SKIP ; AND THE +;FINAL RESULTS IN ACAND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C55610: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 6,1 ;PRELOAD E WITH 0,,1 + SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 6,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 5,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSGE SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C55620: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 6,2 ;PRELOAD E WITH 0,,2 + SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 6,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 5,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES SOSN DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSN SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C55700: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 5,0 ;PRELOAD E WITH 0 + SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 5,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 4,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSN DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC +;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSN SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C55710: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 5,1 ;PRELOAD E WITH 0,,1 + SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF SOSN DID NOT SKIP + STOP + CAME 5,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 4,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSN DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;INtTHIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSN SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY + +C55720: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 5,2 ;PRELOAD E WITH 0,,2 + SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 5,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 4,[1] ;PASS IF ACWAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIESTHAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSG SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C56000: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 4,0 ;PRELOAD E WITH 0 + SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF SOSG DID NOT SKIP + STOP + CAME 4,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 3,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSG SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C56010: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 4,1 ;PRELOAD E WITH 0,,1 + SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF SOSG DID NOT SKIP + STOP + CAME 4,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 3,[0] ;PASS IF AC WAS UPDATED IS AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSG SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 011, +;RESPECTIVELY. + +C56020: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 4,2 ;PRELOAD E WITH 0,,2 + SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 4,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 3,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + + ;JRST BEGEND diff --git a/apps/pdp10/diags/klad/dakae/DAKAEM.MAC.txt b/apps/pdp10/diags/klad/dakae/DAKAEM.MAC.txt new file mode 100644 index 000000000..77d487cd1 --- /dev/null +++ b/apps/pdp10/diags/klad/dakae/DAKAEM.MAC.txt @@ -0,0 +1,2739 @@ +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 + JRST STARTA + +PGMNAM: ASCIZ/ +PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) [DAKAE] +/ + + +;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF +;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES +;IN THE FIELD. + +STARTA: JRST .+1 +SUBTTL TEST OF JSR INSTRUCTION + +;********** + +;THIS TEST VERIFIES THAT JSR STORES THE FLAGS AND PC IN LOCATION E. +;IN THIS CASE, E IS CLEARED, CRY0 IS SET AND JSR IS EXECUTED. +;NEXT, E IS CHECKED FOR ITS CONTENTS NON-ZERO. IF C(E) IS NON-ZERO, +;THIS TEST PASSES. + +C23000: SFLAG CRY0 ;SET CRY0 FLAG + SETZM .+2 ;PRELOAD E WITH 0 + JSR .+1 ;*JSR SHOULD PLACE FLAGS AND PC INTO AC + 0 ;E: PRESET TO 0, SHOULD RECEIVE FLAGS AND PC FROM JSR + SKIPN .-1 ;PASS IF C(E) IS NON-ZERO. + STOP + +;********** + +;THIS TEST VERIFIES THAT JSR IGNORES THE AC FIELD; +;HENCE, IT DOES NOT MODIFY THE SPECIFIED AC. +;IN THIS CASE, CRY0 IS SET. THE AC IS PRELOADED WITH -1,,-1 AND JSR IS EXECUTED. +;THE AC IS THEN CHECKED. IF C(AC)=-1,,-1, THIS TEST PASSES. + +C23100: SFLAG CRY0 ;SET CRY0 + SETO 1, ;PRELOAD AC WITH -1,,-1 + JSR 1,.+1 ;*JSR SHOULD NOT MODIFY THE AC + 0 ;STORE PC + FLAGS HERE + CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT JSR STORES THE FLAGS IN E-LEFT HALF. +;IN THIS TEST, CRY0 IS SET, E IS CLEARED AND JSR IS EXECUTED. +;NEXT, C(E-LEFT) ARE PLACED INTO AC0 AND AC0 IS CHECKED FOR ITS CONTENTS NON-ZERO. +;IF C(AC0) ARE NON-ZERO, THIS TEST PASSES. + +C23200: SFLAG CRY0 ;SET CRY0 + SETZM .+2 ;CLEAR E + JSR .+1 ;*JSR SHOULD STORE FLAGS IN E + 0 ;STORE FLAGS HERE (CRY0 MAKES THIS A MOVE INST) + HLLZ .-1 ;PUT FLAGS INTO AC0 + SKIPN ;PASS IF C(AC0) NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT JSR TRANSFERS CONTROL TO E+1. +;IN THIS CASE, CRY0 IS SET AND E AND AC0 CLEARED; THEN, JSR IS EXECUTED. +;IF JSR RESUMES CONTROL AT E INSTEAD OF E+1, AC0 WILL BE MODIFIED; +;HENCE, THE TEST WILL FAIL WHEN AC0 IS CHECKED FOR 0 BECAUSE +;C(E) IS DECODED AS A MOVE INSTRUCTION. + +C23300: SFLAG CRY0 ;SET CRY0 + SETZB .+2 ;CLEAR AC0 AND E + JSR .+1 ;*JSR SHOULD RESUME CONTROL AT E+1 + 0 ;STORE FLAGS HERE (CRY0 MAKES THIS A MOVE INST) + SKIPE 0 ;PASS IF C(AC0)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT JSR JUMPS TO E+1 +;IN THIS CASE, AC0 IS CLEARED AND CRY0 IS SET; THEN, JSR .+2 IS EXECUTED. +;IF JSR DID NOT JUMP, ONES ARE LOADED WITH AC0; AND THE TEST FAILS. +;OTHERWISE, AC0 REMAINS CLEAR AND THE TEST PASSES + +C23400: SFLAG CRY0 ;SET CRY0 + SETZ ;CLEAR AC0 + JSR .+2 ;*JSR SHOULD JUMP + SETO ;LOAD AC0 WITH ONES IF JSR FAILED TO JUMP + 0 ;STORE FLAGS HERE + SKIPE ;PASS IF JSR JUMPED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT JSR STORES THE PC IN E - RIGHT HALF. THE PC +;IS ONE GREATER THAN THE LOCATION OF THE JSR INSTRUCTION. +;THIS TEST WILL FAIL IF JSR STORES E INSTEAD OF PC IN E - RIGHT HALF. +;IN CASE OF FAILURE, AR PC EN AT ET2 WAS FAULTY. + +C23500: SFLAG 0 ;CLEAR ALL FLAGS + JSR .+2 ;*JSR SHOULD STORE PC+1 IN E - RIGHT + HALT . ;JSR SHOULD SKIP OVER THIS HALT + 0 ;STORE FLAGS AND PC HERE + HRRZ .-1 ;PUT STORED CONTENTS OF E - RIGHT INTO AC0 + CAIN .-2 ;FAIL IF C(AC0)=E + STOP + +;********** +;THIS TEST VERIFIES THAT JSR STORES THE PC IN E - RIGHT HALF. THE PC +;IS ONE GREATER THAN THE LOCATION OF THE JSR INSTRUCTION. +;THIS TEST WILL PASS IF JSR STORES PC IN E - RIGHT HALF. + +C23600: JSR .+2 ;*JSR SHOULD STORE PC+1 IN E - RIGHT + HALT . ;JSR SHOULD SKIP OVER THIS HALT + 0 ;STORE FLAGS AND PC HERE + HRRZ .-1 ;PUT STORED CONTENTS OF E - RIGHT INTO AC0 + CAIE C23600+1 ;PASS IF C(AC0)=C23600+1 [PC] + STOP + +;********** +SUBTTL TEST OF JSA INSTRUCTION + +;********** + +;THIS TEST VERIFIES THAT JSA JUMPS TO LOCATION E+1. +;IN THIS TEST, AC1 IS CLEARED AND A CAM 0,0 IS LOADED +;INTO THE AC OF THE JSA INSTRUCTION. +;IF JSA DOES NOT JUMP, AC1 WILL BE LOADED WITH ONES. AC1 IS CHECKED FOR ZEROS. +;IF C(AC1)=0, THE TEST PASSES; OTHERWISE, THIS TEST FAILS BECAUSE JSA DID NOT JUMP. + +C23700: SETZ 1, ;CLEAR AC1 + MOVE [CAM] ;LOAD CAM INTO AC0 + JSA .+2 ;*JSA SHOULD JUMP TO E+1 + SETO 1 ;JSA SHOULD JUMP OVER THIS INSTRUCTION + 0 ;PASS IF JSA JUMPED + SKIPE 1 + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA JUMPS TO LOCATION E+1. +;IN THIS TEST, AC1 IS CLEARED AND A MOVEI 1,1234 IS LOADED +;INTO THE AC OF THE JSA INSTRUCTION. +;IF JSA DOES NOT JUMP, AC1 WILL BE LOADED WITH 0,,1234. AC1 IS CHECKED FOR ZEROS. +;IF C(AC1)=0, THE TEST PASSES; OTHERWISE, THIS TEST FAILS BECAUSE JSA DID NOT JUMP. + +C24000: SETZ 1, ;CLEAR AC1 + MOVE [MOVEI 1,1234] ;LOAD MOVEI 1,1234 INTO AC + JSA .+1 ;*JSA SHOULD JUMP TO E+1 + 0 ;JSA SHOULD JUMP OVER THIS LOCATION + CAIN 1,1234 ;FAIL IF JSA DID NOT JUMP OVER PREVIOUS INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT JSA LOADS PC OF LOC OF JSA+1 INTO AC RIGHT. +;THIS TEST WILL FAIL IF JSA LOADS E INTO AC RIGHT INSTEAD OF PC. + +C24100: JSA .+2 ;*JSA SHOULD LOAD PC INTO AC RIGHT + HALT . ;JSA SHOULD JUMP OVER THIS LOCATION + 0 ;JSA SHOULD JUMP OVER THIS LOCATION + HRRZM 1 ;PUT C(AC-RIGHT) INTO AC1 + CAIN 1,.-2 ;FAIL IF E WAS LOADED INTO AC-RIGHT INSTEAD OF PC + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA PLACES C(AC) INTO E +;THIS TEST WILL FAIL IF EITHER 0,,E OR 0,,PC IS LOADED +;INTO E INSTEAD OF C(AC) + +C24200: SETZB .+2 ;CLEAR AC,E + JSA .+1 ;*JSA SHOULD LOAD C(AC) [ZEROS] INTO E + 0 ;JSA SHOULD PLACE ZEROS HERE + MOVE 1,.-1 ;SAVE C(AC) + CAIN 1,.-2 ;FAIL IF JSA LOADED 0,,E OR 0,,PC INTO E + STOP + +;********** +;THIS TEST VERIFIES THAT JSA PLACES PC INTO AC-RIGHT +;THIS TEST WILL FAIL IF PC IS NOT LOADED INTO AC-RIGHT + +C24300: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + JSA .+1 ;*JSA SHOULD PLACE E,,PC INTO THE AC + 0 ;JSA SHOULD PLACE C(AC) HERE + TRNN -1 ;FAIL IF AR LT AR RT EN FAILED + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA PLACES THE PC OF THE LOCATION OF JSA+1 IN AC-RIGHT +;THIS TEST FAILS IF A PC WAS NOT LOADED INTO AC RIGHT + +C24400: SETZ ;CLEAR AC + JSA .+1 ;*JSA SHOULD LOAD PC INTO AC - RIGHT + 0 ;JSA SHOULD PLACE C(AC) HERE + TRNN -1 ;PASS IF AC - RIGHT IS NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT JSA PLACES IN AC-LEFT +;THIS TEST FAILS IF JSA LOADS PC INSTEAD OF E INTO AC-LEFT + +C24500: JSA .+2 ;*JSA SHOULD LOAD E INTO AC-LEFT + HALT . ;JSA SHOULD JUMP OVER THIS INSTRUCTION + 0 ;E: + HLRZM 1 ;SAVE C(AC - LEFT) + CAIN 1,.-3 ;FAIL IF JSA LOADED PC INSTEAD OF E INTO AC-LEFT + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA LOADS E,,PC INTO THE AC +;FIRST, THE AC IS PRELOADED WITH -1,,-1; THEN, JSA IS EXECUTED. +;THE AC IS CHECKED FOR E,,PC. IF C(AC)=E,,PC, THIS TEST PASSES + +C24600: SETO ;PRELOAD AC WITH -1,,-1 + JSA .+2 ;*JSA SHOULD PLACE E,,PC INTO THE AC + HALT . ;JSA SHOULD JUMP OVER HERE, PC: + 0 ;JSA SHOULD STORE C(AC) HERE, E: + CAME [XWD .-1,.-2] ;PASS IF C(AC)=E,,PC + STOP + +;********** +;THIS TEST VERIFIES THAT JSA LOADS E,,PC INTO THE AC +;FIRST, THE AC IS PRELOADED WITH 0 JSA IS EXECUTED. +;THE AC IS CHECKED FOR E,,PC. IF C(AC)=E,,PC, THIS TEST PASSES + +C24700: SETZ ;PRELOAD AC WITH 0 + JSA .+2 ;*JSA SHOULD PLACE E,,PC INTO THE AC + HALT . ;JSA SHOULD JUMP OVER HERE, PC: + 0 ;JSA SHOULD STORE C(AC) HERE, E: + CAME [XWD .-1,.-2] ;PASS IF C(AC)=E,,PC + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. +;AC IS FIRST CLEARED AND E IS PRELOADED WITH ONES; +;THEN JSA IS EXECUTED. E IS CHECKED FOR ZEROS. IF C(E)=0, +;THIS TEST PASSES. + +C25000: SETZ ;CLEAR AC + SETOM .+2 ;PRELOAD E WITH -1,,-1 + JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E + 0 ;E: SHOULD GET C(AC) FROM JSA + SKIPE .-1 ;PASS IF C(E)=0 + STOP + +;********** +;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. +;AC IS FIRST PRELOADED WITH -1,,-1 AND E IS CLEARED; +;THEN, JSA IS EXECUTED. E IS CHECKED FOR -1,,-1. IF C(E)=-1,,-1, +;THIS TEST PASSES. + +C25100: SETOB 1 ;PRELOAD AC -1,,-1 + SETZM .+2 ;PRELOAD E WITH 0 + JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E + 0 ;E: SHOULD GET C(AC) FROM JSA + CAME 1,.-1 ;PASS IF C(E)=-1,,-1 + STOP + +;********** + +;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E. +;AC IS FIRST CLEARED AND E IS PRELOADED WITH ONES; +;THEN JSA IS EXECUTED. E IS CHECKED FOR ZEROS. IF C(E)=0, +;THIS TEST PASSES. + +C25200: MOVEI -1 ;PRELOAD AC WITH 0,,-1 + JSA .+1 ;*JSA SHOULD PLACE C(AC) INTO E + 0 ;E: SHOULD GET C(AC) FROM JSA + MOVE 1,.-1 ;PASS IF C(E)=0,,-1 + CAIE 1,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT JSA DOES NOT MODIFY AC+1 +;IN THIS TEST, AC+1 IS PRELOADED WITH -1,,-1; THEN JSA IS EXECUTED +;AC+1 IS THEN CHECKED FOR ITS ORIGINAL CONTENTS, -1,,-1. +;IF C(AC+1)=-1,,-1, THIS TEST PASSES + +C25300: SETOM 1 ;PRELOAD AC+1 WITH -1,,-1 + JSA .+1 ;*JSA SHOULD NOT MODIFY AC+1 + CAM ;JSA SHOULD JUMP OVER THIS, E:PC: + CAME 1,[-1] ;PASS IF AC+1 WAS NOT MODIFIED BY JSA + STOP + +;********** +SUBTTL TEST OF JRA INSTRUCTION + +;********** + +;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E +;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. + +C25400: MOVE [JRST .+4] ;PRELOAD AC0 WITH JRST .+4 + MOVSI 1,.+2 ;PRELOAD AC WITH E,,0 + JRA 1,.+1 ;*JRA SHOULD JUMP TO NEXT INSTRUCTION + SKIPA ;PASS IF JRA JUMPS TO E + STOP + +;********** + +;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E +;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. + +C25500: MOVSI .+3 ;PRELOAD AC WITH E+1 + JRA .+1 ;*JRA SHOULD JUMP TO NEXT SEQUENTIAL INSTRUCTION + SKIPA ;PASS IF JRA JUMPS TO E + STOP + +;********** +;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E +;THIS TEST FAILS IF JRA DOES NOT JUMP TO E. + +C25600: SETZB 1 ;PRELOAD AC0, AC1 WITH ZEROS + JRA .+2 ;*JRA SHOULD JUMP OVER NEXT SEQUENTIAL INSTRUCTION + SETO 1, ;LOAD AC1 WITH ONES IF JRA DOES NOT JUMP + SKIPE 1 ;PASS IF JRA JUMPED + STOP + +;********** + +;THIS TEST VERIFIES THAT JRA PLACES C(C(AC-LEFT)) INTO THE AC AND JUMPS TO E +;THIS TEST FAILS IF JRA JUMPS TO E+1 OR DOES NOT LOAD THE AC CORRECTLY. + +C25700: SETZ ;CLEAR AC + JRA .+1 ;*JRA SHOULD PLACE 0 INTO THE AC AND JUMP .+1 + SKIPE ;PASS IF AC WAS LOADED CORRECTLY + ;AND JRA JUMPED CORRECTLY. + STOP + +;********** +;THIS TEST VERIFIES THAT JRA PLACES C(C(AC-LEFT)) INTO THE AC +;FIRST, THE AC IS PRELOADED WITH 1,,2 AND AC1 AND AC2 ARE +;INITIALIZED WITH THEIR RESPECTIVE ADDRESSES; JRA IS EXECUTED, AND +;THE AC IS CHECKED FOR 0,,1, THE ORIGINAL C(C(AC-LEFT)). IF C(AC)=0,,1, +;THIS TEST PASSES + +C26200: MOVE [XWD 1,2] ;PRELOAD AC WITH 1,,2 + MOVEI 1,1 ;INITIALIZE AC1 WITH 0,,1 + MOVEI 2,2 ;INITIALIZE AC2 WITH 0,,2 + JRA .+1 ;*JRA SHOULD PLACE 0,,1 INTO THE AC + CAIE 1 ;PASS IF C(AC)=0,,1 + STOP + +;********** + +;THIS TEST VERIFIES THAT JRA CAN RESTORE AC0 FROM AC0 WHEN AC0 IS THE +;SPECIFIED AC AND C(AC0-LEFT)=0. +;FIRST, AC0 IS PRELOADED AND JRA IS EXECUTED. THEN, AC0 IS CHECKED FOR +;ITS INITIAL CONTENTS. IF THE RESULT IN AC0, IS CORRECT, THIS TEST PASSES. + +C26300: HRRZI [135531,,246642] ;PRELOAD AC0 WITH 0,, LITERAL ADDRESS + JRA .+1 ;*JRA SHOULD PLACE C(AC0) INTO AC0 + CAIE [135531,,246642] ;PASS IF JRA PLACED C(AC0) INTO AC0 + STOP + +;********** +;THIS TEST VERIFIES THAT JRA CAN RESOTRE AC0 FROM MEMORY WHEN AC0 IS THE +;SPECIFIED AC. +;FIRST, AC0 IS PRELOADED WITH [LITERAL ADDRESS ,,0] AND JRA IS EXECUTED. THEN, +;AC0 IS CHECKED FOR THE SPECIFIED LITERAL, 135246,,246135. IF +;C(AC0)=135246,,246135, THE TEST PASSES. + +C26400: HRLZI [135246,,246135] ;PRELOAD AC0 WITH [LITERAL ADDRESS ,,0] + JRA .+1 ;*JRA SHOULD PLACE 135246,,246135 INTO AC0 + CAME [135246,,246135];PASS IF C(AC0)=135246,,246135 + STOP + +;********** + +;THIS TEST VERIFIES THAT JRA CAN RESOTRE AC0 FROM MEMORY WHEN AC0 IS THE +;SPECIFIED AC. +;FIRST, AC0 IS PRELOADED WITH [-1,, ADDRESS OF JCA INSTRUCTION] AND JRA IS EXECUTED. +;THEN, AC0 IS CHECKED FOR THE JRA INSTRUCTION. IF +;C(AC0)= THE JRA INSTRUCTION, THE TEST PASSES. + +C26500: HRLOI .+1 ;PRELOAD AC WITH -1,, ADDRESS OF JRA INSTRUCTION + JRA .+1 ;*JRA SHOULD PLACE ITSELF INTO AC0 + CAME .-1 ;PASS IF AC CONTAINS JRA INSTRUCTION + STOP + +;********** +SUBTTL TESTS OF BIS FLAG + +;********** + +;THIS TEST VERIFIES THAT JRST 2, CAN CLEAR BIS +;FIRST, BIS IS SET VIA JRST 2, ;THEN, BIS IS CLEARED VIA JRST 2,. +;THE FLAGS ARE SAVED AND BIS IS CHECKED. THIS TEST PASSES IF BIS IS RESET; +;OTHERWISE JRST 2, FAILED TO RESET BIS. + +C26600: SFLAG BIS ;SET BIS FLAG + SFLAG ;*RESET BIS FLAG + JSP .+1 ;SAVE FLAGS + TLNE BIS+37 ;PASS IF BIS FLAG IS RESET + STOP + +;********** + +;THIS TEST VERIFIES THAT JRST 2, CAN SET BIS. +;FIRST, BIS IS SET VIA JRST 2, AND THE FLAGS ARE SAVED. +;BIS IS THEN CHECKED. IF BIS IS SET, THIS TEST PASSES. + +C26700: SFLAG BIS ;*SET BIS FLAG VIA JRST + JSP .+1 ;SAVE FLAGS + TLNN BIS ;PASS IF BIS FLAG IS SET + STOP + +;********** +;THIS TEST VERIFIES THAT JSR ALWAYS RESETS BIS. +;FIRST BIS IS SET; THEN JSR IS EXECUTED. THE FLAGS ARE +;THEN SAVED AND CHECKED. IF BIS WAS RESET VIA JSR, THIS TEST PASSES. + +C27000: SFLAG BIS ;SET BIS + JSR .+1 ;*JSR SHOULD RESET BIS + 0 ;JSR SAVES FLAGS HERE + JSP .+1 ;SAVE FLAGS + TLNE BIS ;PASS IF BIS FLAG IS RESET + STOP + +;********** + +;THIS TEST VERIFIES THAT JSP ALWAYS RESETS BIS. +;FIRST BIS IS SET; THEN JSP IS EXECUTED. THE FLAGS ARE +;THEN SAVED AND CHECKED. IF BIS WAS RESET VIA JSP, THIS TEST PASSES. + +C27001: SFLAG BIS ;SET BIS + JSP .+1 ;*JSP SHOULD RESET BIS + JSP .+1 ;SAVE FLAGS + TLNE BIS ;PASS IF BIS FLAG IS RESET + STOP + +;********** +;THIS TEST VERIFIES THAT THE BITS IN POSITIONS 8, 9 AND 10 ARE CLEARABLE. +;FIRST, THE ARITHMETIC FLAGS ARE CLEARED; +;THEN, BITS 8, 9 AND 10 OF THE PC-WORD IS EXAMINED. +;IF ANY OF THESE BITS ARE SET, THIS TEST FAILS BECAUSE THEY SHOULD BE CLEAR. + +C27100: SFLAG ;CLEAR ARITHMETIC FLAGS + JSP .+1 ;SAVE FLAGS + TLNE 1600 ;PASS IF THESE BITS ARE CLEAR + STOP + +;********** +SUBTTL TEST OF MSCL FWT INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT MOVEM PLACES C(AC) INTO E AND DOES +;NOT MODIFY C(AC). +;IN THIS CASE, C(AC)=252525,,252525 ANS C(E)=707070,,707070. +;HENCE, THE RESULT IN E SHOULD BE 252525,,252525. +;THE AC IS CHECKED FOR 252525,,252525. IF ANY OTHER NUMBER IS +;FOUND IN THE AC, IT WAS CLOBBERED BY MOVEM, AND THIS TEST FAILS. +;E IS CHECKED FOR 252525,,252525. IF ANY OTHER NUMBER IS FOUND +;IN E, IT WAS UPDATED INCORRECTLY BY MOVEM. + +C50000: MOVE [252525,,252525] ;PRELOAD AC WITH 252525,,252525 + MOVE 1,[707070,,707070] ;PRELOAD E WITH 707070,,707070 + MOVEM 0,1 ;*MOVEM SHOULD PLACE 252525,,252525 + ;INTO E AND NOT AFFECT THE AC + CAME 0,[252525,,252525] ;PASS IF C(AC) IS NOT CLOBBERED + STOP + CAME 1,[252525,,252525] ;PASS IF E WAS UPDATED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVES PLACES C(E) INTO THE AC IF AC IS NON-ZERO. +;IN THIS CASE, C(AC)=707070,,707070 AND C(E)=123456,,123456. HENCE, BOTH +;THE AC AND E SHOULD CONTAIN 123456,,123456 AFTER MOVES IS EXECUTED. +;BOTH AC AND E ARE CHECKED FOR 123456,,123456. IF EITHER AC OR E +;CONTAIN A DIFFERENT RESULT, THIS TEST FAILS + +C50100: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVE 1,[123456,,123456] ;PRELOAD E WITH 123456,,123456 + MOVES 2,1 ;*MOVES SHOULD PLACE 123456,,123456 + ;INTO BOTH AC AND E + CAME 2,[123456,,123456] ;PASS IF C(AC)=123456,,123456 + STOP + CAME 1,[123456,,123456] ;PASS IF C(E)=123456,,123456 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVES IS A NO-OP IF AC=0 +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=707070,,707070 +;AFTER MOVES IS EXECUTED, AC AND E ARE CHECKED FOR THEIR ORIGINAL DATA. +;IF EITHER C(AC) OR C(E) CHANGED AS A RESULT OF MOVES, THIS TEST FAILS. + +C50110: MOVE 1,[707070,,707070] ;PRELOAD E WITH 707070,,707070 + SETO ;PRELOAD AC WITH -1,,-1 + MOVES 0,1 ;*MOVES SHOULD FUNCTION AS A NO-OP + CAME 0,[-1,,-1] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + CAME 1,[707070,,707070] ;PASS IF C(E) WAS NOT MODIFIED + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVSI LOADS THE WORD E,0 INTO THE AC. +;IN THIS CASE, C(AC)=707070,,707070 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. + +C50200: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVSI 1,-1 ;*MOVSI SHOULD PLACE -1,,0 INTO THE AC + CAME 1,[-1,,0] ;PASS IF C(AC)=1,,0 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVNM PLACES THE NEGATIVE OF C(AC) +;INTO E. IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-3. +;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 AND THE RESULT +;IN E SHOULD BE 0,,1 + +C50300: SETO 1, ;PRELOAD AC WITH -1,,-1 + MOVE 2,[-1,,-3] ;PRELOAD E WITH -1,,-3 + MOVNM 1,2 ;*MOVNM SHOULD PLACE 0,,1 INTO E + ;AND NOT AFFTECT C(AC) + CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 + STOP + CAIE 2,1 ;PASS IF C(E)=0,,1 + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVNM PLACES THE NEGATIVE OF C(AC) +;INTO E. IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-3. +;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 AND THE RESULT +;IN E SHOULD BE 0,,1 + +C50301: SETO 1, ;PRELOAD AC WITH -1,,-1 + MOVE 2,[-1,,-3] ;PRELOAD E WITH -1,,-3 + MOVEM 2,E50301 + MOVNM 1,E50301 ;*MOVNM SHOULD PLACE 0,,1 INTO E + ;AND NOT AFFTECT C(AC) + CAME 1,[-1] ;PASS IF C(AC)=-1,,-1 + STOP + MOVE 2,E50301 + CAIE 2,1 ;PASS IF C(E)=0,,1 + STOP + + SKIPA ;GO TO NEXT TEST +E50301: 0 ;TESTED MEMORY LOCATION + +;********** +;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E +;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=0, +;C(AC)=0 AND C(E)=0,,1 +;HENCE, THE RESULT IN THE AC SHOULD BE 0 +;AND THE RESULT IN E SHOULD BE -1,,-1 + +C50400: SETZ ;CLEAR AC + MOVEI 2,1 ;PRELOAD E WITH 0,,1 + MOVNS 0,2 ;*MOVNS SHOULD PLACE -1,,-1 INTO E + ;AND SHOULD NOT AFFECT THE AC + SKIPE ;PASS IF THE AC IS UNALTERED + STOP + CAME 2,[-1] ;PASS IF C(E)=-1,,-1 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E +;AND INTO THE AC IF THE AC IS NON-ZO. IN THIS CASE, AC=0, +;C(AC)=0 AND C(E)=0,,1 +;HENCE, THE RESULT IN THE AC SHOULD BE 0 +;AND THE RESULT IN E SHOULD BE -1,,-1 + +C50401: SETZ ;CLEAR AC + MOVEI 2,1 ;PRELOAD E WITH 0,,1 + MOVEM 2,E50401 + MOVNS 0,E50401 ;*MOVNS SHOULD PLACE -1,,-1 INTO E + ;AND SHOULD NOT AFFECT THE AC + SKIPE ;PASS IF THE AC IS UNALTERED + STOP + MOVE 2,E50401 + CAME 2,[-1] ;PASS IF C(E)=-1,,-1 + STOP + + SKIPA ;GO TO NEXT TEST +E50401: 0 ;TESTED MEMORY LOCATION + +;********** +;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E +;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=1, +;C(AC=0 AND C(E)=3 +;HENCE, THE RESULT IN THE AC SHOULD BE -1,,3 +;AND THE RESULT IN E SHOULD BE -1,,3. + +C50410: SETZ 1, ;CLEAR AC + MOVEI 2,3 ;PRELOAD WITH 0,,3 + MOVNS 1,2 ;*MOVNS SHOULD PLACE -1,,-3 INTO E + ;AND -1,,-3 INTO THE AC + CAME 1,[-1,,-3] ;PASS IF C(AC)=-1,,-3 + STOP + CAME 2,[-1,,-3] ;PASS IF C(E)=-1,,-3 + STOP + +;********** + +;THIS TEST VERIFIES THAT MOVMI MOVES THE WORD 0,,E INTO THE AC. +;IN THIS CASE, C(AC)=0 AND E=0,,-2. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,-2. + +C50500: SETZ 1, ;CLEAR AC + MOVMI 1,-2 ;*MOVMI SHOULD PLACE 0,,-2 INTO AC + CAIE 1,-2 ;PASS IF C(AC)=0,,-2 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVM MOVES THE MAGNITUDE OF C(E) NTO THE AC. +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-2. HENCE, THE RESULT IN THE AC +;SHOULD BE 0,,2. + +C50501: SETZ 1, ;CLEAR AC + MOVE 3,[-2] ;PRELOAD E WITH -1,,-2 + MOVM 1,3 ;*MOVM SHOULD PLACE 0,,2 INTO AC + CAIE 1,2 ;PASS IF C(AC)=0,,2 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVMM PLACES THE MAGNITUDE OF C(AC) +;INTO E. IN THIS CASE, C(AC)=-1,,-2 AND C(E)=0. HENCE, THE +;RESULT IN E SHOULD BE 0,,2 AND C(AC) SHOULD REMAIN UNCHANGED. + +C50600: MOVE 1,[-1,,-2] ;PRELOAD AC WITH -1,,-2 + SETZ 2, ;CLEAR E + MOVMM 1,2 ;*MOVMM SHOULD PLACE 0,,2 INTO E + ;AND SHOULD NOT CHANGE C(AC) + CAME 1,[-1,,-2] ;PASS IF C(AC) IS NOT ALTERED + STOP + CAIE 2,2 ;PASS IF C(E)=0,,2 + STOP + +;********** + +;THIS TEST VERIFIES THAT MONMS PLACES THE MAGNITUDE OF C(E) INTO E +;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=0, C(AC)=0 +;AND C(E)=-1,,-2. +;HENCE, THE RESULT IN THE AC SHOULD BE 0 AND THE RESULT IN +;E SHOULD BE 0,,2. + +C50700: SETZ ;CLEAR AC + MOVE 2,[-1,,-2] ;PRELOAD E WITH -1,,-1 + MOVMS 0,2 ;*MOVMS SHOULD PLACE 0,,1 INTO E + ;AND SHOULD NOT CHANGE C(AC) + SKIPE ;PASS IF C(AC) IS UNALTERED + STOP + CAIE 2,2 ;PASS IF C(E)=0,,2 + STOP + +;********** +;THIS TEST VERIFIES THAT MOVMS PLACES THE MAGNITUDE OF C(E) INTO E +;AND INTO THE AC IF THE AC IS NON-ZERO. IN THIS CASE, AC=1, C(AC)=-1,,-1 +;AND C(E)=-1,,-2. +;HENCE, THE RESULT IN THE AC SHOULD BE 0,,2 AND THE RESULT +;IN E SHOULD BE 0,,2. + +C50710: SETO 1, ;PRELOAD AC WITH -1,,-1 + MOVE 2,[-1,,-2] ;PRELOAD E WITH -1,,-2 + MOVMS 1,2 ;*MOVMS SHOULD PLACE 0,,2 INTO E + ;AND SHOULD PLACE 0,,2 INTO THE AC + CAIE 1,2 ;PASS IF C(AC)=0,,2 + STOP + CAIE 2,2 ;PASS IF C(E)=0,,2 + STOP + +;********** +SUBTTL TEST OF MSCL ADD/SUB INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT SUBI SUBTRACTS THE WORD 0,,E FROM C(AC) +;AND PLACES THE RESULT INTO THE AC. IN THIS CASE, C(AC)=70 AND +;E=0,,2. HENCE, THE RESULT IN THE AC SHOULD BE 66. + +C51000: MOVEI 1,70 ;PRELOAD AC WITH 70 + SUBI 1,2 ;*SUBI SHOULD PLACE 66 INTO AC + CAIE 1,66 ;PASS IF C(AC)=66 + STOP + +;********** + +;THIS TEST VERIFIES THAT SUBM SUBTRACTS C(E) FROM C(AC) AND +;PLACES THE RESULT INTO E. THE AC IS UNAFFECTED. IN THIS CASE, +;C(AC)=100 AND C(E)=37. HENCE, THE RESULTS IN AC AND +;E SHOULD BE 0,,100 AND 0,,41 RESPECTIVELY. + +C51100: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + MOVEI 2,37 ;PRELOAD E WITH 0,,37 + SUBM 1,2 ;*SUBM SHOULD PLACE + ;0,,41 INTO E AND NOT CHANGE C(AC) + CAIE 1,100 ;PASS IF C(AC) IS UNCHANGED + STOP + CAIE 2,41 ;PASS IF C(E)=0,,41 + STOP + +;********** +;THIS TEST VERIFIES THAT SUBM SUBTRACTS C(E) FROM C(AC) AND +;PLACES THE RESULT INTO E. THE AC IS UNAFFECTED. IN THIS CASE, +;C(AC)=100 AND C(E)=37. HENCE, THE RESULTS IN AC AND +;E SHOULD BE 0,,100 AND 0,,41 RESPECTIVELY. + +C51101: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + MOVEI 2,37 ;PRELOAD E WITH 0,,37 + MOVEM 2,E51101 + SUBM 1,E51101 ;*SUBM SHOULD PLACE + ;0,,41 INTO E AND NOT CHANGE C(AC) + CAIE 1,100 ;PASS IF C(AC) IS UNCHANGED + STOP + MOVE 2,E51101 + CAIE 2,41 ;PASS IF C(E)=0,,41 + STOP + + SKIPA ;GO TO NEXT TEST +E51101: 0 ;TEST WORD MEMORY + +;********** +;THIS TEST VERIFIES THAT SUBB SUBTRACTS C(E) FROM C(AC) AND +;PLACES THE RESULT INTO BOTH AC AND E. IN THIS CASE, +;C(AC)=0,,100 AND C(E)=0,,37. HENCE, THE RESULT IN BOTH +;AC AND E SHOULD BE 0,,41. + +C51200: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + MOVEI 2,37 ;PRELOAD E WITH O,,37 + SUBB 1,2 ;*SUBB SHOULD PLACE 0,,41 INTO BOTH AC AND E + CAIE 1,41 ;PASS IF C(AC)=0,,41 + STOP + CAIE 2,41 ;PASS IF C(E)=0,,41 + STOP + +;********** + +;THIS TEST VERIFIES THAT SUBB SUBTRACTS C(E) FROM C(AC) AND +;PLACES THE RESULT INTO BOTH AC AND E. IN THIS CASE, +;C(AC)=0,,100 AND C(E)=0,,37. HENCE, THE RESULT IN BOTH +;AC AND E SHOULD BE 0,,41. + +C51201: MOVEI 1,100 ;PRELOAD AC WITH 0,,100 + MOVEI 2,37 ;PRELOAD E WITH O,,37 + MOVEM 2,E51201 + SUBB 1,E51201 ;*SUBB SHOULD PLACE 0,,41 INTO BOTH AC AND E + CAIE 1,41 ;PASS IF C(AC)=0,,41 + STOP + MOVE 2,E51201 + CAIE 2,41 ;PASS IF C(E)=0,,41 + STOP + + SKIPA ;GO TO NEXT TEST +E51201: 0 ;TEST WORD MEMORY + +;********** +SUBTTL TEST OF MSCL CAIX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E. +;IN THIS CASE, C(AC)=0,,1 AND E=0,,2 +;HENCE, CAIL SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIL SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C51300: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + CAIL 1,2 ;*CAIL SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E. +;IN THIS CASE, C(AC)=0,,2 AND E=0,,2. +;HENCE, CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIL DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51310: MOVEI 1,2 ;PRELOAD AC WITH 0,,2 + CAIL 1,2 ;*CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIL DOES NOT SKIP + STOP + +;********** +;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E +;IN THIS CASE, C(AC)=0,,3 AND E=0,,2 +;HENCE, CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIL DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51320: MOVEI 1,3 ;PRELOAD AC WITH 0,,3 + CAIL 1,2 ;*CAIL SHOULD SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIL DOES NOT SKIP + STOP + +;********** + +;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E +;IN THIS CASE, C(AC)=-1,,-1 AND E=0 +;HENCE, CAILE SHOULD SKIP THE NEXT INSTRUCTION +;IF CAILE SKIPS THE NEXT INSTRUCTION, THE TEST PASSES + +C51400: SETO 1, ;PRELOAD AC WITH -1,,-1 + CAILE 1,0 ;*CAILE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E +;IN THIS CASE, C(AC)=0 AND E=0 +;HENCE, CAILE SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAILE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51410: SETZ 1, ;PRELOAD AC WITH 0 + CAILE 1,0 ;*CAILE SHOULD SKIP THE NEXT INSTRUCTION. + STOP + +;********** + +;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E +;IN THIS CASE, C(AC)=0,,1 AND E=0 +;HENCE, CAILE SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAILE DOES NOT SKIP THE NEXT INSTRUCTION, THE TEST PASSES + +C51420: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + CAILE 1,0 ;*CAILE SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAILE DOES NOT SKIP + STOP + +;********** +;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS +;SKIPS THE NEXT INSTRUCTION +;IN THIS CASE, C(AC)=-1,,-1 AND E=0 +;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION +;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C51500: SETO 1, ;PRELOAD AC WITH -1,,-1 + CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS +;SKIPS THE NEXT INSTRUCTION +;IN THIS CASE, C(AC)=0 AND E=0 +;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C51510: SETZ 1, ;PRELOAD AC WITH 0 + CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS +;SKIPS THE NEXT INSTRUCTION +;IN THIS CASE, C(AC)=0,,1 AND E=0 +;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51520: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + CAIA 1,0 ;*CAIA SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E. +;IN THIS CASE, C(AC)=0,,5 AND E=0,,6 +;HENCE, CAIGE SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIGE DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES + +C51600: MOVEI 2,5 ;PRELOAD AC WITH 0,,5 + CAIGE 2,6 ;*CAIGE SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIGE DOES NOT SKIP + STOP + +;********** +;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E +;IN THIS CASE, C(AC)=0,,6 AND E=0,,6 +;HENCE, CAIGE SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIGE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51610: MOVEI 2,6 ;PRELOAD AC WITH 0,,6 + CAIGE ;*CAIGE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E. +;IN THIS CASE, C(AC)=0,,7 AND E=0,,6 +;HENCE, CAIGE SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIGE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C51620: MOVEI 2,7 ;PRELOAD AC WITH 0,,7 + CAIGE 2,6 ;*CAIGE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIRIES THAT CAIN COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. +;IN THIS CASE, C(AC)=0 AND E=0,,1 +;HENCE, CAIN SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIN SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C51700: SETZ 6, ;PRELOAD AC WITH 0 + CAIN 6,1 ;*CAIN SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIN COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. +;IN THIS CASE, C(AC)=0,,1 AND E=0,,1 +;HENCE, CAIN SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIN DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES + +C51710: MOVE 6,1 ;PRELOAD AC WITH 0,,1 + CAIN 6,1 ;*CAIN SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIN SKIPS + STOP + +;********** +;THIS TEST VERIFIES THAT CAIN COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E. +;IN THIS CASE, C(AC)=0,,2 AND E=0,,1 +;HENCE, CAIN SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIN SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C51720: MOVEI 6,2 ;PRELOAD AC WITH + CAIN 6,1 ;*CAIN SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. +;IN THIS CASE, C(AC)=0,,2 AND E=0,,3. +;HENCE, CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES + +C52000: MOVEI 11,2 ;PRELOAD AC WITH 0,,2 + CAIG 11,3 ;*CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIG DID NOT SKIP + STOP + +;********** +;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. +;IN THIS CASE, C(AC)=0,,3 AND E=0,,3. +;HENCE, CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAIG DOES NOT SKIP THE NEXT INSTRUCTION, THE TEST PASSES. + +C52010: MOVEI 11,3 ;PRELOAD AC WITH 0,,3 + CAIG 11,3 ;*CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAIG DID NOT SKIP + STOP + +;********** + +;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E. +;IN THIS CASE, C(AC)=0,,4 AND E=0,,3. +;HENCE, CAIG SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAIG SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C52020: MOVEI 11,4 ;PRELOAD AC WITH 0,,4 + CAIG 11,3 ;*CAIG SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +SUBTTL TEST OF MSCL CAMX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAT OR EQUAL TO C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0 +;HENCE, CAMLE SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAMLE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C52100: SETO 1, ;PRELOAD AC WITH -1,,-1 + SETZ 2, ;PRELOAD E WITH 0 + CAMLE 1,2 ;*CAMLE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** + +;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=0 +;HENCE, CAMLE SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAMLE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES + +C52110: SETZ 1, ;CLEAR AC + CAMLE 1,[0] ;*CAMLE SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO C(E). +;IN THIS CASE, C(AC)=0,,1 AND C(E)=0 +;HENCE, CAMLE SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAMLE DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + +C52120: MOVEI 1,1 ;PRELOAD AC WITH 0,,1 + SETZ 2, ;PRELOAD E WITH 0 + CAMLE 1,2 ;*CAMLE SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAMLE DOES NOT SKIP + STOP + +;********** + +;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). +;IN THIS CASE, C(AC)=-1,,-2 AND C(E)=-1,,-1. +;HENCE, CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAMG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. + +C52200: HRROI 10,-2 ;PRELOAD AC WITH -1,,-2 + CAMG 10,[-1,,-1] ;*CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. + SKIPA ;PASS IF CAMG DOES NOT SKIP + STOP +;********** + +;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-2. +;HENCE, CAMG SHOULD SKIP THE NEXT INSTRUCTION. + +C52205: HRROI 10,-1 ;PRELOAD AC WITH -1,,-1 + CAMG 10,[-1,,-2] ;*CAMG SHOULD SKIP THE NEXT INSTRUCTION. + STOP +;********** +;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). +;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1. +;HENCE, CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION. +;IF CAMG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES. +C52210: SETO 10, ;PRELOAD AC WITH -1,,-1. + CAMG 10,[-1,,-1] ;*CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION + SKIPA ;PASS IF CAMG DOES NOT SKIP + STOP + +;********** + +;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND +;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E). +;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1. +;HENCE, CAMG SHOULD SKIP THE NEXT INSTRUCTION. +;IF CAMG SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES. + +C52220: SETZ 10, ;PRELOAD AC WITH 0 + CAMG 10,[-1,,-1] ;*CAMG SHOULD SKIP THE NEXT INSTRUCTION + STOP + +;********** +SUBTTL TEST OF MSCL JUMPX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND +;JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR +;EQUAL TO 0. IN THIS CASE, C(AC)=-1,,-1. HENCE, JUMPLE SHOULD JUMP. + +C52300: SETO 17, ;PRELOAD AC WITH -1,,-1 + JUMPLE 17,.+2 ;*JUMPLE SHOULD JUMP + STOP + +;********** + +;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND +;JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR +;EQUAL TO 0. IN THIS CASE, C(AC)=0. HENCE, JUMPLE SHOULD JUMP. + +C52310: SETZ 17, ;PRELOAD AC WITH 0 + JUMPLE 17,.+2 ;*JUMPLE SHOULD JUMP + STOP + +;********** +;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND JUMPS +;TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO +;0. IN THIS CASE, C(AC)=0,,1. HENCE, JUMPLE SHOULD NOT JUMP. + +C52320: MOVEI 17,1 ;PRELOAD AC WITH 0,,1 + JUMP 17,.+2 ;*JUMPLE SHOULD NOT JUMP + SKIPA ;PASS IF JUMPLE DOES NOT JUMP + STOP + +;********** + +;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH 0 AND JUMPS TO +;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC)=-1,,-1. HENCE, JUMPGE SHOULD NOT JUMP. + +C52400: SETO 16, ;PRELOAD AC WITH -1,,-1 + JUMPGE 16,.+2 ;*JUMPGE SHOULD NOT JUMP + SKIPA ;PASS IF JUMPGE DOES NOT JUMP + STOP + +;********** +;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH O AND JUMPS TO +;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC)=0. HENCE, JUMPGE SHOULD JUMP. + +C52410: SETZ 16, ;PRELOAD AC WITH 0 + JUMPGE 16,.+2 ;*JUMPGE SHOULD JUMP + STOP + +;********** + +;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH 0 AND JUMPS TO +;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC)=0,,1. HENCE, JUMPGE SHOULD JUMP. + +C52420: MOVEI 16,1 ;PRELOAD AC WITH 0,,1 + JUMPGE 16,.+2 ;*JUMPGE SHOULD JUMP + STOP + +;********** +SUBTTL TEST OF MSCL AOJX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND PLACES +;THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS COMPARED +;TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) +;IS LESS THAN 0. IN THIS CASE, C(AC)=-1,,-2 BEFORE INCREMENTING. +;HENCE, AOJL SHOULD JUMP. + +C52500: HRROI 15,-2 ;PRELOAD AC WITH -1,,-2 + AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) AND JUMP + STOP + CAME 15,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJ SHOULD NOT JUMP + +C52510: SETO 15, ;PRELOAD AC WITH + AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJL DID NOT JUMP + STOP + CAIE 15,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJL SHOULD NOT JUMP + +C52520: SETZ 15, ;PRELOAD AC WITH 0 + AOJL 15,.+2 ;*AOJL SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJL DID NOT JUMP + STOP + CAIE 15,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0 +;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING +;HENCE, AOJE SHOULD NOT JUMP + +C52600: HRROI 14,-2 ;PRELOAD AC WITH -1,,-2 + AOJE 14,.+2 ;*AOJE SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJE DID NOT JUMP + STOP + CAME 14,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING. +;HENCE, AOJE SHOULD JUMP + +C52610: SETO 14, ;PRELOAD AC WITH -1,,-1 + AOJE 14,.+2 ;*AOJ SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 14,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. +;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJE SHOULD NOT JUMP + +C52620: SETZ 14, ;PRELOAD AC WITH 0 + AOJE 14,.+2 ;*AOJE SHOULD ADD 0,11 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJE DID NOT JUMP + STOP + CAIE 14,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO TLE$EC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJLE SHOULD + +C52700: HRROI 13,-2 ;PRELOAD AC WITH -1,,-2 + AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAME 13,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJLE SHOULD JUMP. + +C52710: SETO 13, ;PRELOAD AC WITH -1,,-1 + AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 13,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC) IS 0 +;HENCE, AOJLE SHOULD NOT JUMP. + +C52720: SETZ 13, ;PRELOAD AC WITH 0 + AOJLE 13,.+2 ;*AOJLE SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJLE DID NOT JUMP + STOP + CAIE 13,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E. +;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING +;HENCE, AOJA SHOULD JUMP + +C53000: HRROI 12,-2 ;PRELOAD AC WITH -1,,-2 + AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAME 12,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJA SHOULD JUMP + +C53010: SETO 12, ;PRELOAD AC WITH -1,,-1 + AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 12,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E. +;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJA SHOULD JUMP + +C53020: SETZ 12, ;PRELOAD AC WITH 0 + AOJA 12,.+2 ;*AOJA SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 12,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING +;HENCE, AOJGE SHOULD NOT JUMP + +C53100: HRROI 11,-2 ;PRELOAD AC WITH -1,,-2 + AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJGE DID NOT JUMP + STOP + CAME 11,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJ SHOULD JUMP + +C53110: SETO 11, ;PRELOAD AC WITH -1,,-1 + AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 11,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJGE SHOULD JUMP + +C53120: SETZ 11, ;PRELOAD AC WITH 0 + AOJGE 11,.+2 ;*AOJGE SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 11,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. +;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING +;HENCE, AOJN SHOULD JUMP + +C53200: HRROI 10,-2 ;PRELOAD AC WITH -1,,-2 + AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAME 10,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJ SHOULD NOT JUMP. + +C53210: SETO 10, ;PRELOAD AC WITH -1,,-1 + AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJN DID NOT JUMP + STOP + CAIE 10,0 ;PASS IF C(AC) INCREMENTED CORRRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0. +;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJN SHOULD JUMP. + +C53220: SETZ 10, ;PRELOAD AC WITH 0 + AOJN 10,.+2 ;*AOJN SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 10,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE REAULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0 +;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INC +;HENCE, AOJG SHOULD NOT JUMP + +C53300: HRROI 7,-2 ;PRELOAD AC WITH -1,,-2 + AOJG 7,.+2 ;*AOJG SHOULD ADD 0,11 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJG DID NOT JUMP + STOP + CAME 7,[-1] ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. +;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING +;HENCE, AOJG SHOULD NOT JUMP. + +C53310: SETO 7, ;PRELOAD AC WITH -1,,-1 + AOJG 7,.+2 ;*AOJG SHOULD ADD 0,,1 TO C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF AOJG DID NOT JUMP + STOP + CAIE 7,0 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. +;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING +;HENCE, AOJG SHOULD JUMP + +C53320: SETZ 7, ;PRELOAD AC WITH 0 + AOJG 7,.+2 ;*AOJG SHOULD ADD 0,,1 TO C(AC) + ;AND JUMP + STOP + CAIE 7,1 ;PASS IF C(AC) INCREMENTED CORRECTLY + STOP + +;********** +SUBTTL TEST OF MSCL AOSX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSL SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C53400: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 7,-2 ;PRELOAD E WITH -1,,-2 + AOSL 6,7 ;*AOSL SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 7,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSL SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C53401: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 7,-2 ;PRELOAD E WITH -1,,-2 + MOVEM 7,E53401 + AOSL 6,E53401 ;*AOSL SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + MOVE 7,E53401 + CAME 7,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + + SKIPA ;GO TO NEXT TEST +E53401: 0 ;TEST WORD MEMORY + +;********** +;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) ISLESS THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSL SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C53410: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 7, ;PRELOAD E WITH -1,,-1 + AOSL 6,7 ;*AOSL SHOULD ADD 00,1 TO C(E) + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSL DID NOT SKIP + STOP + CAME 7,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 6,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSL SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY + +C53420: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 7, ;PRELOAD E WITH 0 + AOSL 6,7 ;*AOSL SHOULD ADD 0,,1 TO C(E). + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSL DID NOT SKIP + STOP + CAME 7,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 6,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSE SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C53500: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 6,-2 ;PRELOAD E WITH -1,,-2 + AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSE DID NOT SKIP + STOP + CAME 6,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 5,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSE SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C53510: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 6, ;PRELOAD E WITH -1,,-1 + AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 6,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 5,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(AC)=0 +;BEFORE INCREMENTING. HENCE, AOSE SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C53520: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 6, ;PRELOAD E WITH 0 + AOSE 5,6 ;*AOSE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSE DID NOT SKIP + STOP + CAME 6,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 5,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSLE SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C53600: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 5,-2 ;PRELOAD E WITH -1,,-2 + AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP ZERO + STOP + CAME 5,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 4,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSLE SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C53610: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETOM 5, ;PRELOAD E WITH -1,,-1 + AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E) + ;UPDATE AC AND SKIP + STOP + CAME 5,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 4,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSLE SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C53620: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 5 ;PRELOAD E WITH 0 + AOSLE 4,5 ;*AOSLE SHOULD ADD 0,,1 TO C(E) + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSLE DID NOT SKIP + STOP + CAME 5,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 4,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSA INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C53700: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 4,-2 ;PRELOAD E WITH -1,,-2 + AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 4,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 3,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSA INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY + +C53710: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 4, ;PRELOAD E WITH -1,,-1 + AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 4,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 3,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOS INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSA SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY + +C53720: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 4, ;PRELOAD E WITH 0 + AOSA 3,4 ;*AOSA SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 4,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 3,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSGE SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY + +C54000: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 3,-2 ;PRELOAD E WITH -1,,-2 + AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSGE DID NOT SKIP + STOP + CAME 3,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 2,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSGE SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY + +C54010: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 3, ;PRELOAD E WITH 0 + AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 3,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 2,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSGE SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY + +C54020: MOVE 2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 3, ;PRELOAD E WITH 0 + AOSGE 2,3 ;*AOSGE SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 3,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 2,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSN SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY + +C54100: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 2,-2 ;PRELOAD E WITH -1,,-2 + AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 2,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 1,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSN SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY + +C54110: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 2, ;PRELOAD E WITH -1,,-1 + AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF AOSN DID NOT SKIP + STOP + CAME 2,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 1,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSN SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY + +C54120: MOVE 1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 2, ;PRELOAD E WITH 0 + AOSN 1,2 ;*AOSN SHOULD ADD 0,,1 TO C(E), + ;UPDATE AC AND SKIP + STOP + CAME 2,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 1,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEST INSTRUCTION IF C(E) IS GREATER THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=-1,,-2 +;BEFORE INCREMENTING. HENCE, AOSG SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND -1,,-1 +;RESPECTIVELY + +C54200: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + HRROI 1,-2 ;PRELOAD E WITH -1,,-2 + AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), + ;AND NOT SKIP + SKIPA ;PASS IF AOSG DID NOT SKIP + STOP + CAME 1,[-1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + +;********** + +;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=-1,,-1 +;BEFORE INCREMENTING. HENCE, AOSG SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 +;RESPECTIVELY + +C54210: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETO 1, ;PRELOAD E WITH -1,,-1 + AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), + ;AND NOT SKIP + SKIPA ;PASS IF AOSG DID NOT SKIP + STOP + CAME 1,[0] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + +;*********** +;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, AOSG SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0,,1 +;RESPECTIVELY + +C54220: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + SETZ 1, ;PRELOAD E WITH 0 + AOSG 0,1 ;*AOSG SHOULD ADD 0,,1 TO C(E), + ;AND SKIP + STOP + CAME 1,[1] ;PASS IF E INCREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + +;********** +SUBTTL TEST OF MSCL SOJX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESTULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN 0. +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJL +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + +C54300: MOVEI 17,0 ;PRELOAD AC WITH 0 + SOJL 17,.+2 ;*SOJL SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 17,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;*********** + +;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN 0. +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJL +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. + +C54310: MOVEI 17,1 ;PRELOAD AC WITH 0,,1 + SOJL 17,.+2 ;*SOJL SHOULD SUBTRACT 0,,1 FROM C(AC) + SKIPA ;PASS IF SOJL DID NOT JUMP + STOP + CAME 17,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN 0 +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJ +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + +C54320: MOVEI 17,2 ;PRELOAD AC WITH 0,,2 + SOJL 17,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJL DID NOT JUMP + STOP + CAME 17,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJE +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + +C54400: MOVEI 16,0 ;PRELOAD AC WITH 0 + SOJE 16,.+2 ;*SOJE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJE DID NOT JUMP + STOP + CAME 16,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0 +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJ +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + +C54410: MOVEI 16,1 ;PRELOAD AC WITH 0,,1 + SOJE 16,.+2 ;*SOJE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 16,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS EQUAL TO 0. +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJE +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + +C54420: MOVEI 16,2 ;PRELOAD AC WITH 0,,2 + SOJE 16,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJE DID NOT JUMP + STOP + CAME 16,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJLE +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + +C54500: MOVEI 15,0 ;PRELOAD AC WITH 0 + SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 15,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUALTO 0. +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJLE +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + +C54510: MOVEI 15,1 ;PRELOAD AC WITH 0,,1 + SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 15,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0. +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJLE +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + +C54520: MOVEI 15,2 ;PRELOAD AC WITH 0,,2 + SOJLE 15,.+2 ;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF SOJLE DID NOT JUMP + STOP + CAME 15,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJA +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + +C54600: MOVEI 14,0 ;PRELOAD AC WITH 0 + SOJA 14,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 14,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJA +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + +C54610: MOVEI 14,1 ;PRELOAD AC WITH 0,,1 + SOJA 14,.+2 ;*SOJA SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 14,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION +;SPECIFIED BY E +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJA +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1 + +C54620: MOVEI 14,2 ;PRELOAD AC WITH 0,,2 + SOJA 14,.+2 ;*SOJA SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 14,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE, SOJGE +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1 + +C54700: MOVEI 13,0 ;PRELOAD A C WITH 0 + SOJGE 13,.+2 ;*SOJGE SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP + SKIPA ;PASS IF SOJGE DID NOT JUMP + STOP + CAME 13,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0 +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJGE +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0 + +C54710: MOVEI 13,1 ;PRELOAD AC WITH 0,,1 + SOJGE 13,.+2 ;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP + STOP + CAME 13,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIRIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND PLACES THE +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS COMPARED +;TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC IS +;GREATER THAN OR EQUAL TO 0. IN THIS CASE, C(AC = 0,,2 BEFORE +;DECREMENTING. HENCE, SOJGE SHOULD JUMP AND THE RESULT IN THE AC SHOULD +;BE 0,,1. + +C54720: MOVEI 13,2 ;PRELOAD AC WITH 0,,2 + SOJGE 13,.+2 ;*SOJGE SHOULD SUBTRACT0,,1 FROM C(AC) + ;AND JUMP. + STOP + CAME 13,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS NON-ZERO. +;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING. HENCE,SOJN +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1. + +C55000: MOVEI 12,0 ;PRELOAD AC WITH 0 + SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP. + STOP + CAME 12,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIRIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED +;BY E IF C(AC) IS NON-ZERO. +;IN THIS CASE, C(AC) = 0,,1 BEFORE DECREMENTING. HENCE, SOJN +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. + +C55010: MOVEI 12,1 ;PRELOAD AC WITH 0,,1 + SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJN DID NOT JUMP + STOP + CAME 12,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIFIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS NON-ZERO. +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJN +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1. + +C55020: MOVEI 12,2 ;PRELOAD AC WITH 0,,2 + SOJN 12,.+2 ;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND JUMP. + STOP + CAME 12,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. +;IN THIS CASE, C(AC) = 0 BEFORE DECREMENTING. HENCE, SOJG +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1. + +C55100: MOVEI 11,0 ;PRELOAD AC WITH 0 + SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJG DID NOT JUMP + STOP + CAME 11,[-1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +;THIS TEST VERIRIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. +;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING. HENCE, SOJG +;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0. + +C55110: MOVEI 11,1 ;PRELOAD AC WITH 0,,1 + SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT 0,,1 FROM C(AC) + ;AND NOT JUMP. + SKIPA ;PASS IF SOJG DID NOT JUMP + STOP + CAME 11,[0] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** + +;THIS TEST VERIFIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND +;PLACES THE RESULT BACK INTO THE AC. THE RESULT IN THE AC IS +;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION +;SPECIFIED BY E IF C(AC) IS GREATER THAN 0. +;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING. HENCE, SOJG +;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1. + +C55120: MOVEI 11,2 ;PRELOAD AC WITH 0,,2 + SOJG 11,.+2 ;*SOJG SHOULD SUBTRACT O,,1 FROM C(AC) + ;AND JUMP. + STOP + CAME 11,[1] ;PASS IF C(AC) DECREMENTED CORRECTLY + STOP + +;********** +SUBTTL TEST OF MSCL SOSX INSTRUCTIONS + +;********** + +;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSL SHOULD SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND -1,,-1 +;RESPECTIVELY. + +C55200: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 1,0 ;PRELOAD E WITH 0 + SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E) + ;AND SKIP + STOP + CAME 1,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 +;RESPECTIVELY. + +C55210: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 1,1 ;PRELOAD E WITH 0,,1 + SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), + ;AND NOT SKIP. + SKIPA ;PASS IF SOSL DID NOT SKIP + STOP + CAME 1,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + +;********** +;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 +;RESPECTIVELY. + +C55211: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 1,1 ;PRELOAD E WITH 0,,1 + MOVEM 1,E55211 + SOSL 0,E55211 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), + ;AND NOT SKIP. + SKIPA ;PASS IF SOSL DID NOT SKIP + STOP + MOVE 1,E55211 + CAME 1,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED + STOP + + SKIPA ;GO TO NEXT TEST +E55211: 0 ;TEST WORD MEMORY + +;********** +;THIS TEST VERIFIES THAT SOS DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E) 0,,2 +;BEFORE INCREMENTING. HENCE, SOSL SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0,,1 +;RESPECTIVELY. + +C55220: MOVE 0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 1,2 ;PRELOAD E WITH 0,,2 + SOSL 0,1 ;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E), + ;AND NOT SKIP + + SKIPA ;PASS IF SOSL DID NOT SKIP + STOP + CAME 1,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 0,[707070,,707070] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSE SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C55300: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 11,0 ;PRELOAD E WITH 0 + SOSE 10,11 ;*SOSE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + + SKIPA ;PASS IF SOSE DID NOT SKIP + STOP + CAME 11,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 10,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSE SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0 +;RESPECTIVELY. + +C55310: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 11,1 ;PRELOAD E WITH 0,,1 + SOSE 10,11 ;*SOS SHOULD SUBTRACT 0,,1 FROM C(E) + ;UPDATE AC AND SKIP + STOP + CAME 11,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 10,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,11 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSE SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C55320: MOVE 10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 11,2 ;PRELOAD E WITH 0,,2 + SOSE 10,11 ;*SOSE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + + SKIPA ;PASS IF SOSE DID NOT SKIP + STOP + CAME 11,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 10,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=7, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSLE SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C55400: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 10,0 ;PRELOAD E WITH 0 + SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 10,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 7,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=7, C(AC)=070707,,070707 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSLE SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C55410: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 10,1 ;PRELOAD E WITH 0,,1 + SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 10,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 7,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=7, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSLE SHOULD NOT SKIP; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C55420: MOVE 7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 10,2 ;PRELOAD E WITH 0,,2 + SOSLE 7,10 ;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF SOSLE DID NOT SKIP + STOP + CAME 10,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 7,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSA SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C55500: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 7,0 ;PRELOAD E WITH 0 + SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 7,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 6,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THEAC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSA SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C55510: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 7,1 ;PRELOAD E WITH 0,,1 + SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 7,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 6,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS +;THE NEXT INSTRUCTION. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSA SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C55520: MOVE 6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 7,2 ;PRELOAD E WITH 0,,2 + SOSA 6,7 ;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 7,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 6,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSGE SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C55600: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 6,0 ;PRELOAD E WITH 0 + SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF SOSGE DID NOT SKIP + STOP + CAME 6,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 5,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSGE SHOULD SKIP ; AND THE +;FINAL RESULTS IN ACAND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C55610: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 6,1 ;PRELOAD E WITH 0,,1 + SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 6,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 5,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSGE SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY. + +C55620: MOVE 5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 6,2 ;PRELOAD E WITH 0,,2 + SOSGE 5,6 ;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 6,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 5,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES SOSN DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSN SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C55700: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 5,0 ;PRELOAD E WITH 0 + SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 5,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 4,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSN DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC +;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSN SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C55710: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 5,1 ;PRELOAD E WITH 0,,1 + SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF SOSN DID NOT SKIP + STOP + CAME 5,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 4,[0] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSN DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;INtTHIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSN SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1 +;RESPECTIVELY + +C55720: MOVE 4,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 5,2 ;PRELOAD E WITH 0,,2 + SOSN 4,5 ;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 5,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 4,[1] ;PASS IF ACWAS UPDATED IF AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIESTHAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0 +;BEFORE INCREMENTING. HENCE, SOSG SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1 +;RESPECTIVELY. + +C56000: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 4,0 ;PRELOAD E WITH 0 + SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF SOSG DID NOT SKIP + STOP + CAME 4,[-1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 3,[-1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + +;THIS TEST VERIFIES THAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0. +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0,,1 +;BEFORE INCREMENTING. HENCE, SOSG SHOULD NOT SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0 +;RESPECTIVELY. + +C56010: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 4,1 ;PRELOAD E WITH 0,,1 + SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND NOT SKIP + SKIPA ;PASS IF SOSG DID NOT SKIP + STOP + CAME 4,[0] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 3,[0] ;PASS IF AC WAS UPDATED IS AC NON-ZERO + STOP + +;********** +;THIS TEST VERIFIES THAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES +;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS +;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0 +;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC. +;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0,,2 +;BEFORE INCREMENTING. HENCE, SOSG SHOULD SKIP ; AND THE +;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 011, +;RESPECTIVELY. + +C56020: MOVE 3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070 + MOVEI 4,2 ;PRELOAD E WITH 0,,2 + SOSG 3,4 ;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E), + ;UPDATE AC AND SKIP + STOP + CAME 4,[1] ;PASS IF E DECREMENTED CORRECTLY + STOP + CAME 3,[1] ;PASS IF AC WAS UPDATED IF AC NON-ZERO + STOP + +;********** + + JRST BEGEND diff --git a/apps/pdp10/diags/klad/dakae/README.md b/apps/pdp10/diags/klad/dakae/README.md new file mode 100644 index 000000000..be22678fe --- /dev/null +++ b/apps/pdp10/diags/klad/dakae/README.md @@ -0,0 +1,286 @@ +--- +layout: page +title: PDP-10 KA10 Basic Instruction Diagnostic #5 +permalink: /apps/pdp10/diags/klad/dakae/ +machines: + - id: testka10 + type: pdp10 + config: /devices/pdp10/machine/ka10/test/debugger/machine.xml + debugger: true + commands: a 30724 DAKAE.MAC +--- + +PDP-10 KA10 Basic Instruction Diagnostic #5 +------------------------------------------- + +The *PDP-10 KA10 Basic Instruction Diagnostic #5* (MAINDEC-10-DAKAE) test code has been extracted from +[DAKAEM.MAC](DAKAEM.MAC.txt) [[original](http://pdp-10.trailing-edge.com/klad_sources/01/klad.sources/dakaem.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](#dakaetxt) +- [History](#dakaehst) +- [Source Code](#dakaemac) +- [MACRO-10 Listing](DAKAE.LST.txt) +- [Additional Information](http://archive.pcjs.org/apps/pdp10/diags/klad/dakae/DAKAE.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 DAKAE.MAC + +will automatically read the [DAKAE.MAC](DAKAE.MAC.txt) source file (a slightly modified copy of [DAKAEM.MAC](DAKAEM.MAC.txt)), +assemble it, and then load the binary output at the specified address. + +--- + +DAKAE.TXT +--------- + +``` + IDENTIFICATION + -------------- + + PRODUCT CODE: AH-6859C-DD + + DIAGNOSTIC CODE: DAKAE + + PRODUCT NAME: DAKAEC0 DECSYSTEM10 PDP-10 KA10 BASIC + INSTRUCTION DIAGNOSTIC (5) + + VERSION: 0.3 + + DATE RELEASED: JANUARY 1979 + + MAINTAINED BY: DIAGNOSTIC ENGINEERING + + AUTHOR: BILL SCORZELLI + + COPYRIGHT (C) 1967, 1979 + + DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. + + 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 EXCEPT 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 DIGITAL EQUIPMENT + CORPORATION. + + THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE WITHOUT + NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL + EQUIPMENT CORPORATION. + + DIGITAL EQUIPMENT CORPORATION ASSUMES NO RESPONSIBILITY FOR THE + USE OR RELIABILITY OF ITS SOFTWARE IN EQUIPMENT WHICH IS NOT + SUPPLIED BY DIGITAL EQUIPMENT CORPORATION. + MAINDEC-10-DAKAE.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-DAKAE.TXT + PAGE 3 + + +1.0 ABSTRACT + + THIS PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC IS THE + FIFTH IN A SERIES OF PDP-10 KA10 PROCESSOR DIAGNOSTICS. + THE DIAGNOSTIC TESTS THE FWT, ADD/SUB, PC CHANGE + 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-DAKAE.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-DAKAE.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 +``` + +DAKAE.HST +--------- + + THIS IS A HISTORY OF THE DEVELOPMENT OF MAINDEC-10-DAKAE + + ************************************************************************ + + ORIGINAL VERSION: 0.1 + + ORIGINAL AUTHOR: RICHARD MALISKA + + ORIGINAL RELEASE: 16-MAR-72 + + ************************************************************************ + + PRODUCT CODE: MAINDEC-10-DAKAE + + PRODUCT NAME: BASIC INSTRUCTION DIAGNOSTIC #5 + + DATE RELEASED: JANUARY 1977 + + VERSION: 0.2 + + UPDATE AUTHOR: JOHN R. KIRCHOFF + + CHANGES MADE: + + 1. UPGRADE TO ALLOW COMPATABILITY WITH THE SUBROUTINE PACKAGE. + ************************************************************************ + + PRODUCT CODE: MAINDEC-10-DAKAE + + PRODUCT NAME: BASIC INSTRUCTION DIAGNOSTIC #5 + + DATE RELEASED: JANUARY 1979 + + VERSION: 0.3 + + UPDATE AUTHOR: BILL SCORZELLI + + CHANGES MADE: + + 1. THE COMPARE INSTRUCTION TESTS DID NOT CHECK THE COMPARE OF 2 + NEGATIVE NUMBERS WITH THE CONTENTS OF THE (AC) BEING LARGER + THAN THE CONTENTS OF (E). ADDED TEST C52205. + + ************************************************************************ + +DAKAE.MAC +--------- + +[[Download](DAKAE.MAC.txt)] + +{% highlight text %} +{% include_relative DAKAE.MAC.txt %} +{% endhighlight %} diff --git a/docs/pcx86/examples/pcx86-dbg.js b/docs/pcx86/examples/pcx86-dbg.js index fd8c1d110..3ccbb7d6b 100644 --- a/docs/pcx86/examples/pcx86-dbg.js +++ b/docs/pcx86/examples/pcx86-dbg.js @@ -720,9 +720,9 @@ function Wx(a,b,c){var d=a;b=b||32;if(c)if(32==b)d=a>>>0;else if(32>b)d=a&(1<a.length)return!1;var e,f=a.pop();e=a.pop();switch(d){case "*":e*=f;break;case "/":if(!f)return!1;e=Math.trunc(e/f);break;case "%":if(!f)return!1;e%=f;break;case "+":e+=f;break;case "-":e-=f;break;case "<<":e<<=f;break;case ">>":e>>=f;break;case ">>>":e>>>=f;break;case "<":e=e":e=e>f?1:0;break;case ">=":e=e>=f?1:0;break;case "==":e=e==f?1:0;break;case "!=":e=e!=f?1:0;break;case "&":e&= f;break;case "!":case "|":e|=f;break;case "^!":e|=f;break;case "&&":e=e&&f?1:0;break;case "||":e=e||f?1:0;break;case "_":case "^_":"^_"==d&&(f=35-(f&255));f&&(e=Wx(e,0,!0),e=0=|>>>|>>|>|<=|<<|<|-|\+|%|\/|\*)/);d=Yx(a,b,0,b.length,a.F,c);void 0!==d&&!1===c&&dy(a,null,d)}return d} +function cy(a,b,c){var d=void 0;a.Ha=null;if(b){"{"!=a.qa[0]&&(b=b.split(a.qa[0]).join("{").split(a.qa[1]).join("}"));b=ay(a,b,'"',7,5,c);if(!b)return d;b=ay(a,b,"'",6,6,c);if(!b)return d;b=b.replace(/(^|[^A-Z0-9$%.])([0-9]+)B/,"$1$2^_").replace(/\s+/g," ");b=b.split(/(\{|}|\|\||&&|\||\^!|\^B|\^O|\^D|\^L|\^-|~|\^_|_|&|!=|!|==|>=|>>>|>>|>|<=|<<|<|-|\+|%|\/|\*| )/);d=Yx(a,b,0,b.length,a.F,c);void 0!==d&&!1===c&&dy(a,null,d)}return d} function ey(a,b){var c,d=a.qa[0],e=a.qa[1];c="("==d||"{"==d||"["==d?"\\":"";for(var f="["==d?"\\":"",f=new RegExp(c+d+"([^"+f+d+f+e+"]+)"+c+e);c=b.match(f);){var g=cy(a,c[1]);if(void 0===g)return;b=b.replace(d+c[1]+e,null!=g?by(a,g):"undefined")}if(a.Aa.length)for(d=a.Aa[0],e=a.Aa[1],c="("==d||"{"==d||"["==d?"\\":"",f="["==d?"\\":"",f=new RegExp(c+d+"([^"+f+d+f+e+"]+)"+c+e);c=b.match(f);)b=a.Pk(b,c[1]);for(;d=b.match(/\$([a-z]+)/i);){e=null;switch(d[1].toLowerCase()){case "ops":e=a.Y-a.ha}if(null== e)break;b=b.replace(d[0],e.toString())}return b}function Zx(a,b,c,d,e){e=void 0===e?0:e;var f;if(null!=b)if(f=a.gh(b),0<=f?f=a.hh(f):(f=a.ga[b],null==f&&(f=oa(b,1>>=2}f=Wx(f)}else d||a.P("invalid "+(c?c:"value")+": "+b);else d||a.P("missing "+(c||"value"));return f} function dy(a,b,c){var d,e=!1;void 0!==c&&(e=!0,d=8==a.F?by(a,c,32,8,1)+" "+c+".":by(a,c,32,16,1)+" "+by(a,c,32,8,1)+" "+by(a,c,32,2,8)+" "+c+".",32<=c&&127>c&&(d+=" '"+String.fromCharCode(c)+"'"));a.P((null!=b?b+": ":"")+d);return e}function fy(a,b){if(b)return dy(a,b,a.ga[b]);var c=0;for(b in a.ga)dy(a,b,a.ga[b]),c++;return 0=|>>>|>>|>|<=|<<|<|-|\+|%|\/|\*)/; - sExp = sExp.replace(/(^|[^A-Z0-9$%.])([0-9]+)B/, "$1$2^_"); + var regExp = /(\{|}|\|\||&&|\||\^!|\^B|\^O|\^D|\^L|\^-|~|\^_|_|&|!=|!|==|>=|>>>|>>|>|<=|<<|<|-|\+|%|\/|\*| )/; + sExp = sExp.replace(/(^|[^A-Z0-9$%.])([0-9]+)B/, "$1$2^_").replace(/\s+/g, ' '); var asValues = sExp.split(regExp); value = this.parseArray(asValues, 0, asValues.length, this.nBase, fQuiet); if (value !== undefined && fQuiet === false) {