![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmpd2.lst CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4|
Return to cmpd2.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 ! root 1: 1 00000000 LL0: ! 2: 2 00000000 .data ! 3: 3 00001398 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _cmpd2 ! 6: 6 00000000 _cmpd2: ! 7: 7 0001BDF0 0000 .word L215 ! 8: 8 0001BDF2 # #include "fpp_defs.h" ! 9: 9 0001BDF2 # ! 10: 10 0001BDF2 # ! 11: 11 0001BDF2 # ! 12: 12 0001BDF2 # /*************************************************************************** ! 13: 13 0001BDF2 # * ! 14: 14 0001BDF2 # * CMPD2 -COMPARE 2 DBL OPERANDS TO EACH OTHER -IGNORE THE ACCUMULATOR ! 15: 15 0001BDF2 # * ! 16: 16 0001BDF2 # *****************************************************************************/ ! 17: 17 0001BDF2 # cmpd2() ! 18: 18 0001BDF2 # { ! 19: 19 0001BDF2 11 4f jbr L217 ! 20: 20 0001BDF4 L218: ! 21: 21 0001BDF4 # asm(".globl _cmpd2_t"); ! 22: 22 0001BDF4 .globl _cmpd2_t ! 23: 23 0001BDF4 # asm("_cmpd2_t:"); /* entry address */ ! 24: 24 0001BDF4 _cmpd2_t: ! 25: 25 0001BDF4 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */ ! 26: 26 0001BDF4 1d effffffff6 01 cmpl _cycle,$1 ! 27: 27 0001BDFB 21 15 jneq L219 ! 28: 28 0001BDFD 5d efffffffed tstl _prt_hdrs ! 29: 29 0001BE03 31 0d jeql L219 ! 30: 30 0001BE05 # writes(" CMPD2"); ! 31: 31 0001BE05 .data 1 ! 32: 32 00001398 * L221: ! 33: 33 00001398 * 20434D50443200 .ascii " CMPD2\0" ! 34: 34 0000139f * .text ! 35: 35 0001BE05 dd 8f00001398 pushl $L221 ! 36: 36 0001BE0B fe 08 efffffffde callf $8,_writes ! 37: 37 0001BE12 # cmpd2_1(); /* register / register data */ ! 38: 38 0001BE12 L219: ! 39: 39 0001BE12 fe 04 ef0000002d callf $4,_cmpd2_1 ! 40: 40 0001BE19 # cmpd2_2(); /* cache / cache data */ ! 41: 41 0001BE19 fe 04 ef00000342 callf $4,_cmpd2_2 ! 42: 42 0001BE20 # cmpd2_3(); /* cache / register data */ ! 43: 43 0001BE20 fe 04 ef00000645 callf $4,_cmpd2_3 ! 44: 44 0001BE27 # cmpd2_4(); /* register / cache data */ ! 45: 45 0001BE27 fe 04 ef00000952 callf $4,_cmpd2_4 ! 46: 46 0001BE2E # cmpd2_5(); /* acc. corruption test */ ! 47: 47 0001BE2E fe 04 ef00000c61 callf $4,_cmpd2_5 ! 48: 48 0001BE35 # cmpd2_6(); /* register corruption test */ ! 49: 49 0001BE35 fe 04 ef00000ef8 callf $4,_cmpd2_6 ! 50: 50 0001BE3C # asm("jmp *return"); /* return to the test monitor */ ! 51: 51 0001BE3C 71 ffffffffae jmp *return ! 52: 52 0001BE42 # } ! 53: 53 0001BE42 40 ret#2 ! 54: 54 0001BE43 .set L215,0x0 ! 55: 55 0001BE43 L217: ! 56: 56 0001BE43 11 af jbr L218 ! 57: 57 0001BE45 .data ! 58: 58 00001398 * .text ! 59: 59 0001BE45 00 .align 1 ! 60: 60 0001BE46 .globl _cmpd2_1 ! 61: 61 0001BE46 _cmpd2_1: ! 62: 62 0001BE46 0000 .word L228 ! 63: 63 0001BE48 # ! 64: 64 0001BE48 # ! 65: 65 0001BE48 # ! 66: 66 0001BE48 # /**************************************************************************** ! 67: 67 0001BE48 # * ! 68: 68 0001BE48 # * SUBTEST 1 - CMPD2 test -register / register data ! 69: 69 0001BE48 # * ! 70: 70 0001BE48 # ****************************************************************************/ ! 71: 71 0001BE48 # cmpd2_1() ! 72: 72 0001BE48 # { ! 73: 73 0001BE48 13 0314 jbr L230 ! 74: 74 0001BE4B L231: ! 75: 75 0001BE4B # force_loop = FALSE; ! 76: 76 0001BE4B 4d efffffff9f clrl _force_loop ! 77: 77 0001BE51 # subtest = 1; ! 78: 78 0001BE51 0d 01 efffffff98 movl $1,_subtest ! 79: 79 0001BE58 # index = 0; ! 80: 80 0001BE58 4d efffffff92 clrl _index ! 81: 81 0001BE5E # do ! 82: 82 0001BE5E L234: ! 83: 83 0001BE5E # { ! 84: 84 0001BE5E # dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */ ! 85: 85 0001BE5E 5c 14 efffffff8b 50 mull3 $20,_index,r0 ! 86: 86 0001BE66 0c 8f00000000 50 addl2 $_cmpd_1_data,r0 ! 87: 87 0001BE6D 0d a004 efffffff7f movl 4(r0),_dbl_value_1+4 ! 88: 88 0001BE75 0d 60 efffffff74 movl (r0),_dbl_value_1 ! 89: 89 0001BE7C # dbl_value_2 = cmpd_1_data[index].two; ! 90: 90 0001BE7C 5c 14 efffffff6d 50 mull3 $20,_index,r0 ! 91: 91 0001BE84 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0 ! 92: 92 0001BE8B 0d a004 efffffff61 movl 4(r0),_dbl_value_2+4 ! 93: 93 0001BE93 0d 60 efffffff56 movl (r0),_dbl_value_2 ! 94: 94 0001BE9A # sgl_expected = cmpd_1_data[index].flag; /* get expected results */ ! 95: 95 0001BE9A 5c 14 efffffff4f 50 mull3 $20,_index,r0 ! 96: 96 0001BEA2 0d e000000010 efffffff43 movl _cmpd_1_data+16(r0),_sgl_expected ! 97: 97 0001BEAD # sgl_value_1 = dbl_value_1.m; ! 98: 98 0001BEAD 0d efffffff3d efffffff38 movl _dbl_value_1,_sgl_value_1 ! 99: 99 0001BEB8 # sgl_value_2 = dbl_value_1.l; ! 100: 100 0001BEB8 0d efffffff36 efffffff2d movl _dbl_value_1+4,_sgl_value_2 ! 101: 101 0001BEC3 # sgl_value_3 = dbl_value_2.m; ! 102: 102 0001BEC3 0d efffffff27 efffffff22 movl _dbl_value_2,_sgl_value_3 ! 103: 103 0001BECE # sgl_value_4 = dbl_value_2.l; ! 104: 104 0001BECE 0d efffffff20 efffffff17 movl _dbl_value_2+4,_sgl_value_4 ! 105: 105 0001BED9 # index2 = 0; /* clear Acc. data index */ ! 106: 106 0001BED9 4d efffffff11 clrl _index2 ! 107: 107 0001BEDF # do ! 108: 108 0001BEDF L237: ! 109: 109 0001BEDF # { ! 110: 110 0001BEDF # dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */ ! 111: 111 0001BEDF 48 04 efffffff0a 50 shll $4,_index2,r0 ! 112: 112 0001BEE7 0c 8f00000000 50 addl2 $_ldd_1_data,r0 ! 113: 113 0001BEEE 0d a004 effffffefe movl 4(r0),_dbl_ld_acc+4 ! 114: 114 0001BEF6 0d 60 effffffef3 movl (r0),_dbl_ld_acc ! 115: 115 0001BEFD # asm("ldd _dbl_ld_acc"); /* load the accumulator */ ! 116: 116 0001BEFD 07 effffffeed ldd _dbl_ld_acc ! 117: 117 0001BF03 # status_index = 0; /* clear the status index */ ! 118: 118 0001BF03 4d effffffee7 clrl _status_index ! 119: 119 0001BF09 # do ! 120: 120 0001BF09 L240: ! 121: 121 0001BF09 # { ! 122: 122 0001BF09 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */ ! 123: 123 0001BF09 0d effffffee1 50 movl _status_index,r0 ! 124: 124 0001BF10 0d 40effffffed9 movl _status_array[r0],_sgl_dummy1 ! 125: effffffed4 ! 126: 125 0001BF1C # /* ! 127: 126 0001BF1C # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 128: 127 0001BF1C # * The force loop flag is set after the first error. ! 129: 128 0001BF1C # */ ! 130: 129 0001BF1C # asm("_cmpd2_1_lp1:"); ! 131: 130 0001BF1C _cmpd2_1_lp1: ! 132: 131 0001BF1C # asm("movl _sgl_value_1,r4"); /* r4 = operand #1's MSW */ ! 133: 132 0001BF1C 0d effffffece 54 movl _sgl_value_1,r4 ! 134: 133 0001BF23 # asm("movl _sgl_value_2,r5"); /* r5 = operand #1's LSW */ ! 135: 134 0001BF23 0d effffffec7 55 movl _sgl_value_2,r5 ! 136: 135 0001BF2A # asm("movl _sgl_value_3,r6"); /* r6 = operand #2's MSW */ ! 137: 136 0001BF2A 0d effffffec0 56 movl _sgl_value_3,r6 ! 138: 137 0001BF31 # asm("movl _sgl_value_4,r7"); /* r7 = operand #2's LSW */ ! 139: 138 0001BF31 0d effffffeb9 57 movl _sgl_value_4,r7 ! 140: 139 0001BF38 # asm("nop"); ! 141: 140 0001BF38 10 nop ! 142: 141 0001BF39 # asm("tstl _sgl_dummy1"); /* generate initial status */ ! 143: 142 0001BF39 5d effffffeb1 tstl _sgl_dummy1 ! 144: 143 0001BF3F # asm("movpsl _init_psl"); /* save the initial status */ ! 145: 144 0001BF3F cd effffffeab movpsl _init_psl ! 146: 145 0001BF45 # asm("cmpd2 r4,r6"); /* compare the operands */ ! 147: 146 0001BF45 47 54 56 cmpd2 r4,r6 ! 148: 147 0001BF48 # asm("movpsl _psl_val"); /* save the final status */ ! 149: 148 0001BF48 cd effffffea2 movpsl _psl_val ! 150: 149 0001BF4E # asm("std _dbl_st_acc"); /* save the acc */ ! 151: 150 0001BF4E 27 effffffe9c std _dbl_st_acc ! 152: 151 0001BF54 # if( force_loop ) /* loop? */ ! 153: 152 0001BF54 5d effffffe96 tstl _force_loop ! 154: 153 0001BF5A 31 02 jeql L241 ! 155: 154 0001BF5C # asm("brb _cmpd2_1_lp1");; /* run the loop again */ ! 156: 155 0001BF5C 11 be brb _cmpd2_1_lp1 ! 157: 156 0001BF5E L241: ! 158: 157 0001BF5E # exp_psl = init_psl; /* get the initial PSL */ ! 159: 158 0001BF5E 0d effffffe8c effffffe87 movl _init_psl,_exp_psl ! 160: 159 0001BF69 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */ ! 161: 160 0001BF69 ac 88f3 effffffe7f andl2 $-13,_exp_psl ! 162: 161 0001BF71 # if( sgl_expected == ZERO ) ! 163: 162 0001BF71 1d effffffe79 04 cmpl _sgl_expected,$4 ! 164: 163 0001BF78 21 07 jneq L242 ! 165: 164 0001BF7A # exp_psl |= PSL_Z; /* expect the ZERO bit set */ ! 166: 165 0001BF7A 8c 04 effffffe6f orl2 $4,_exp_psl ! 167: 166 0001BF81 # if( sgl_expected == NEGATIVE ) ! 168: 167 0001BF81 L242: ! 169: 168 0001BF81 1d effffffe69 08 cmpl _sgl_expected,$8 ! 170: 169 0001BF88 21 07 jneq L243 ! 171: 170 0001BF8A # exp_psl |= PSL_N; /* expect the NEG bit set */ ! 172: 171 0001BF8A 8c 08 effffffe5f orl2 $8,_exp_psl ! 173: 172 0001BF91 # if( psl_val != exp_psl ) { /* COMPARE the values */ ! 174: 173 0001BF91 L243: ! 175: 174 0001BF91 1d effffffe59 effffffe54 cmpl _psl_val,_exp_psl ! 176: 175 0001BF9C 21 03 13 0170 jeql L244 ! 177: 176 0001BFA1 # errcnt++; /* bump the error count */ ! 178: 177 0001BFA1 6d effffffe49 incl _errcnt ! 179: 178 0001BFA7 # if ( prt_error ) { ! 180: 179 0001BFA7 5d effffffe43 tstl _prt_error ! 181: 180 0001BFAD 21 03 13 013c jeql L245 ! 182: 181 0001BFB2 # writes(" \n"); /* start a new print line */ ! 183: 182 0001BFB2 .data 1 ! 184: 183 0000139f * L246: ! 185: 184 0000139f * 200A00 .ascii " \12\0" ! 186: 185 000013a2 * .text ! 187: 186 0001BFB2 dd 8f0000139f pushl $L246 ! 188: 187 0001BFB8 fe 08 effffffe31 callf $8,_writes ! 189: 188 0001BFBF # writes("cycle: "); ! 190: 189 0001BFBF .data 1 ! 191: 190 000013a2 * L247: ! 192: 191 000013a2 * 6379636C653A2000 .ascii "cycle: \0" ! 193: 192 000013aa * .text ! 194: 193 0001BFBF dd 8f000013a2 pushl $L247 ! 195: 194 0001BFC5 fe 08 effffffe24 callf $8,_writes ! 196: 195 0001BFCC # writed( cycle ); ! 197: 196 0001BFCC dd effffffe1e pushl _cycle ! 198: 197 0001BFD2 fe 08 effffffe17 callf $8,_writed ! 199: 198 0001BFD9 # writes(" CMPD2 test "); ! 200: 199 0001BFD9 .data 1 ! 201: 200 000013aa * L249: ! 202: 201 000013aa * 2020434D50443220746573742 .ascii " CMPD2 test \0" ! 203: 000 ! 204: 202 000013b8 * .text ! 205: 203 0001BFD9 dd 8f000013aa pushl $L249 ! 206: 204 0001BFDF fe 08 effffffe0a callf $8,_writes ! 207: 205 0001BFE6 # writed( test_no ); ! 208: 206 0001BFE6 dd effffffe04 pushl _test_no ! 209: 207 0001BFEC fe 08 effffffdfd callf $8,_writed ! 210: 208 0001BFF3 # writes(", subtest 1 (Reg./Reg. Data) - BAD FINAL PSL\n"); ! 211: 209 0001BFF3 .data 1 ! 212: 210 000013b8 * L250: ! 213: 211 000013b8 * 2C20737562746573742031202 .ascii ", subtest 1 (Reg./Reg. Data) - BAD FINAL PSL\12\0" ! 214: 85265672E2F5265672E204461 ! 215: 746129202D204241442046494 ! 216: E414C2050534C0A00 ! 217: 212 000013e6 * .text ! 218: 213 0001BFF3 dd 8f000013b8 pushl $L250 ! 219: 214 0001BFF9 fe 08 effffffdf0 callf $8,_writes ! 220: 215 0001C000 # print_cmpd2_data(); ! 221: 216 0001C000 fe 04 ef00000fcf callf $4,_print_cmpd2_data ! 222: 217 0001C007 # writes(", index = "); ! 223: 218 0001C007 .data 1 ! 224: 219 000013e6 * L252: ! 225: 220 000013e6 * 2C202020696E646578203D200 .ascii ", index = \0" ! 226: 0 ! 227: 221 000013f3 * .text ! 228: 222 0001C007 dd 8f000013e6 pushl $L252 ! 229: 223 0001C00D fe 08 effffffddc callf $8,_writes ! 230: 224 0001C014 # writed( index ); ! 231: 225 0001C014 dd effffffdd6 pushl _index ! 232: 226 0001C01A fe 08 effffffdcf callf $8,_writed ! 233: 227 0001C021 # writec('\n'); ! 234: 228 0001C021 dd 0a pushl $10 ! 235: 229 0001C023 fe 08 effffffdc6 callf $8,_writec ! 236: 230 0001C02A # writes(" final Acc = "); ! 237: 231 0001C02A .data 1 ! 238: 232 000013f3 * L254: ! 239: 233 000013f3 * 20202066696E616C204163632 .ascii " final Acc = \0" ! 240: 03D2000 ! 241: 234 00001403 * .text ! 242: 235 0001C02A dd 8f000013f3 pushl $L254 ! 243: 236 0001C030 fe 08 effffffdb9 callf $8,_writes ! 244: 237 0001C037 # write32h( dbl_st_acc.m ); ! 245: 238 0001C037 dd effffffdb3 pushl _dbl_st_acc ! 246: 239 0001C03D fe 08 effffffdac callf $8,_write32h ! 247: 240 0001C044 # writec(' '); ! 248: 241 0001C044 dd 20 pushl $32 ! 249: 242 0001C046 fe 08 effffffda3 callf $8,_writec ! 250: 243 0001C04D # write32h( dbl_st_acc.l ); ! 251: 244 0001C04D dd effffffda1 pushl _dbl_st_acc+4 ! 252: 245 0001C053 fe 08 effffffd96 callf $8,_write32h ! 253: 246 0001C05A # writes(", operand 2 = "); ! 254: 247 0001C05A .data 1 ! 255: 248 00001403 * L256: ! 256: 249 00001403 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0" ! 257: 03D2000 ! 258: 250 00001413 * .text ! 259: 251 0001C05A dd 8f00001403 pushl $L256 ! 260: 252 0001C060 fe 08 effffffd89 callf $8,_writes ! 261: 253 0001C067 # write32h( sgl_value_3); ! 262: 254 0001C067 dd effffffd83 pushl _sgl_value_3 ! 263: 255 0001C06D fe 08 effffffd7c callf $8,_write32h ! 264: 256 0001C074 # writec(' '); ! 265: 257 0001C074 dd 20 pushl $32 ! 266: 258 0001C076 fe 08 effffffd73 callf $8,_writec ! 267: 259 0001C07D # write32h( sgl_value_4); ! 268: 260 0001C07D dd effffffd6d pushl _sgl_value_4 ! 269: 261 0001C083 fe 08 effffffd66 callf $8,_write32h ! 270: 262 0001C08A # writec('\n'); ! 271: 263 0001C08A dd 0a pushl $10 ! 272: 264 0001C08C fe 08 effffffd5d callf $8,_writec ! 273: 265 0001C093 # writes(" initial PSL = "); ! 274: 266 0001C093 .data 1 ! 275: 267 00001413 * L257: ! 276: 268 00001413 * 2020696E697469616C2050534 .ascii " initial PSL = \0" ! 277: C203D2000 ! 278: 269 00001424 * .text ! 279: 270 0001C093 dd 8f00001413 pushl $L257 ! 280: 271 0001C099 fe 08 effffffd50 callf $8,_writes ! 281: 272 0001C0A0 # write32h( init_psl ); ! 282: 273 0001C0A0 dd effffffd4a pushl _init_psl ! 283: 274 0001C0A6 fe 08 effffffd43 callf $8,_write32h ! 284: 275 0001C0AD # writes(", final PSL = "); ! 285: 276 0001C0AD .data 1 ! 286: 277 00001424 * L258: ! 287: 278 00001424 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0" ! 288: 03D2000 ! 289: 279 00001434 * .text ! 290: 280 0001C0AD dd 8f00001424 pushl $L258 ! 291: 281 0001C0B3 fe 08 effffffd36 callf $8,_writes ! 292: 282 0001C0BA # write32h( psl_val ); ! 293: 283 0001C0BA dd effffffd30 pushl _psl_val ! 294: 284 0001C0C0 fe 08 effffffd29 callf $8,_write32h ! 295: 285 0001C0C7 # writes(", expected PSL = "); ! 296: 286 0001C0C7 .data 1 ! 297: 287 00001434 * L259: ! 298: 288 00001434 * 2C20206578706563746564205 .ascii ", expected PSL = \0" ! 299: 0534C203D2000 ! 300: 289 00001447 * .text ! 301: 290 0001C0C7 dd 8f00001434 pushl $L259 ! 302: 291 0001C0CD fe 08 effffffd1c callf $8,_writes ! 303: 292 0001C0D4 # write32h( exp_psl ); ! 304: 293 0001C0D4 dd effffffd16 pushl _exp_psl ! 305: 294 0001C0DA fe 08 effffffd0f callf $8,_write32h ! 306: 295 0001C0E1 # writes(" \n"); ! 307: 296 0001C0E1 .data 1 ! 308: 297 00001447 * L260: ! 309: 298 00001447 * 200A00 .ascii " \12\0" ! 310: 299 0000144a * .text ! 311: 300 0001C0E1 dd 8f00001447 pushl $L260 ! 312: 301 0001C0E7 fe 08 effffffd02 callf $8,_writes ! 313: 302 0001C0EE # } ! 314: 303 0001C0EE # if ( halt_flg ) ! 315: 304 0001C0EE L245: ! 316: 305 0001C0EE 5d effffffcfc tstl _halt_flg ! 317: 306 0001C0F4 31 09 jeql L261 ! 318: 307 0001C0F6 # cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 319: 308 0001C0F6 dd 03 pushl $3 ! 320: 309 0001C0F8 fe 08 ef00000f3f callf $8,_cmpd2_er_halt ! 321: 310 0001C0FF # if ( loop_on_err ) { ! 322: 311 0001C0FF L261: ! 323: 312 0001C0FF 5d effffffceb tstl _loop_on_err ! 324: 313 0001C105 31 0a jeql L263 ! 325: 314 0001C107 # force_loop = TRUE; /* set the force loop flag */ ! 326: 315 0001C107 0d 01 effffffce2 movl $1,_force_loop ! 327: 316 0001C10E # asm("brw _cmpd2_1_lp1"); /* and loop */ ! 328: 317 0001C10E 13 fe0b brw _cmpd2_1_lp1 ! 329: 318 0001C111 # }; /* end of loop-on-error */ ! 330: 319 0001C111 L263: ! 331: 320 0001C111 # } /* end of compare error */ ! 332: 321 0001C111 # } while( ++status_index < 3 ); ! 333: 322 0001C111 L244: ! 334: 323 0001C111 L239: ! 335: 324 0001C111 6d effffffcd9 incl _status_index ! 336: 325 0001C117 0d effffffcd3 50 movl _status_index,r0 ! 337: 326 0001C11E 1d 50 03 cmpl r0,$3 ! 338: 327 0001C121 81 03 13 fde3 jlss L240 ! 339: 328 0001C126 L238: ! 340: 329 0001C126 # index2++; ! 341: 330 0001C126 6d effffffcc4 incl _index2 ! 342: 331 0001C12C # } while( (index2 < 10) && (index2 < max_ldf_1_index) ); ! 343: 332 0001C12C L236: ! 344: 333 0001C12C 1d effffffcbe 0a cmpl _index2,$10 ! 345: 334 0001C133 81 10 jgeq L9999 ! 346: 335 0001C135 1d effffffcb5 effffffcb0 cmpl _index2,_max_ldf_1_index ! 347: 336 0001C140 81 03 13 fd9a jlss L237 ! 348: 337 0001C145 L9999: ! 349: 338 0001C145 L235: ! 350: 339 0001C145 # } while( index++ < max_cmpd_1_index ); ! 351: 340 0001C145 L233: ! 352: 341 0001C145 0d effffffca5 50 movl _index,r0 ! 353: 342 0001C14C 6d effffffc9e incl _index ! 354: 343 0001C152 1d 50 effffffc97 cmpl r0,_max_cmpd_1_index ! 355: 344 0001C159 81 03 13 fd00 jlss L234 ! 356: 345 0001C15E L232: ! 357: 346 0001C15E # } /* end of subtest 1 */ ! 358: 347 0001C15E 40 ret#2 ! 359: 348 0001C15F .set L228,0x0 ! 360: 349 0001C15F L230: ! 361: 350 0001C15F 13 fce9 jbr L231 ! 362: 351 0001C162 .data ! 363: 352 00001398 * .text ! 364: 353 0001C162 .align 1 ! 365: 354 0001C162 .globl _cmpd2_2 ! 366: 355 0001C162 _cmpd2_2: ! 367: 356 0001C162 0000 .word L264 ! 368: 357 0001C164 # ! 369: 358 0001C164 # ! 370: 359 0001C164 # ! 371: 360 0001C164 # /**************************************************************************** ! 372: 361 0001C164 # * ! 373: 362 0001C164 # * SUBTEST 2 - CMPD2 test - cache / cache data ! 374: 363 0001C164 # * ! 375: 364 0001C164 # ****************************************************************************/ ! 376: 365 0001C164 # cmpd2_2() ! 377: 366 0001C164 # { ! 378: 367 0001C164 13 0301 jbr L266 ! 379: 368 0001C167 L267: ! 380: 369 0001C167 # force_loop = FALSE; ! 381: 370 0001C167 4d effffffc83 clrl _force_loop ! 382: 371 0001C16D # subtest = 2; ! 383: 372 0001C16D 0d 02 effffffc7c movl $2,_subtest ! 384: 373 0001C174 # index = 0; ! 385: 374 0001C174 4d effffffc76 clrl _index ! 386: 375 0001C17A # do ! 387: 376 0001C17A L270: ! 388: 377 0001C17A # { ! 389: 378 0001C17A # dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */ ! 390: 379 0001C17A 5c 14 effffffc6f 50 mull3 $20,_index,r0 ! 391: 380 0001C182 0c 8f00000000 50 addl2 $_cmpd_1_data,r0 ! 392: 381 0001C189 0d a004 effffffc63 movl 4(r0),_dbl_value_1+4 ! 393: 382 0001C191 0d 60 effffffc58 movl (r0),_dbl_value_1 ! 394: 383 0001C198 # dbl_value_2 = cmpd_1_data[index].two; ! 395: 384 0001C198 5c 14 effffffc51 50 mull3 $20,_index,r0 ! 396: 385 0001C1A0 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0 ! 397: 386 0001C1A7 0d a004 effffffc45 movl 4(r0),_dbl_value_2+4 ! 398: 387 0001C1AF 0d 60 effffffc3a movl (r0),_dbl_value_2 ! 399: 388 0001C1B6 # sgl_value_1 = dbl_value_1.m; ! 400: 389 0001C1B6 0d effffffc34 effffffc2f movl _dbl_value_1,_sgl_value_1 ! 401: 390 0001C1C1 # sgl_value_2 = dbl_value_1.l; ! 402: 391 0001C1C1 0d effffffc2d effffffc24 movl _dbl_value_1+4,_sgl_value_2 ! 403: 392 0001C1CC # sgl_value_3 = dbl_value_2.m; ! 404: 393 0001C1CC 0d effffffc1e effffffc19 movl _dbl_value_2,_sgl_value_3 ! 405: 394 0001C1D7 # sgl_value_4 = dbl_value_2.l; ! 406: 395 0001C1D7 0d effffffc17 effffffc0e movl _dbl_value_2+4,_sgl_value_4 ! 407: 396 0001C1E2 # sgl_expected = cmpd_1_data[index].flag; /* get expected results */ ! 408: 397 0001C1E2 5c 14 effffffc07 50 mull3 $20,_index,r0 ! 409: 398 0001C1EA 0d e000000010 effffffbfb movl _cmpd_1_data+16(r0),_sgl_expected ! 410: 399 0001C1F5 # index2 = 0; /* clear Acc. data index */ ! 411: 400 0001C1F5 4d effffffbf5 clrl _index2 ! 412: 401 0001C1FB # do ! 413: 402 0001C1FB L273: ! 414: 403 0001C1FB # { ! 415: 404 0001C1FB # dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */ ! 416: 405 0001C1FB 48 04 effffffbee 50 shll $4,_index2,r0 ! 417: 406 0001C203 0c 8f00000000 50 addl2 $_ldd_1_data,r0 ! 418: 407 0001C20A 0d a004 effffffbe2 movl 4(r0),_dbl_ld_acc+4 ! 419: 408 0001C212 0d 60 effffffbd7 movl (r0),_dbl_ld_acc ! 420: 409 0001C219 # asm("ldd _dbl_ld_acc"); /* load the accumulator */ ! 421: 410 0001C219 07 effffffbd1 ldd _dbl_ld_acc ! 422: 411 0001C21F # status_index = 0; /* clear the status index */ ! 423: 412 0001C21F 4d effffffbcb clrl _status_index ! 424: 413 0001C225 # do ! 425: 414 0001C225 L276: ! 426: 415 0001C225 # { ! 427: 416 0001C225 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */ ! 428: 417 0001C225 0d effffffbc5 50 movl _status_index,r0 ! 429: 418 0001C22C 0d 40effffffbbd movl _status_array[r0],_sgl_dummy1 ! 430: effffffbb8 ! 431: 419 0001C238 # /* ! 432: 420 0001C238 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 433: 421 0001C238 # * The force loop flag is set after the first error. ! 434: 422 0001C238 # */ ! 435: 423 0001C238 # asm("_cmpd2_2_lp1:"); ! 436: 424 0001C238 _cmpd2_2_lp1: ! 437: 425 0001C238 # asm("tstl _sgl_dummy1"); /* generate initial status */ ! 438: 426 0001C238 5d effffffbb2 tstl _sgl_dummy1 ! 439: 427 0001C23E # asm("movpsl _init_psl"); /* save the initial status */ ! 440: 428 0001C23E cd effffffbac movpsl _init_psl ! 441: 429 0001C244 # asm("nop"); ! 442: 430 0001C244 10 nop ! 443: 431 0001C245 # asm("cmpd2 _dbl_value_1,_dbl_value_2"); /* compare the data */ ! 444: 432 0001C245 47 effffffba5 effffffba0 cmpd2 _dbl_value_1,_dbl_value_2 ! 445: 433 0001C250 # asm("nop"); ! 446: 434 0001C250 10 nop ! 447: 435 0001C251 # asm("movpsl _psl_val"); /* save the final status */ ! 448: 436 0001C251 cd effffffb99 movpsl _psl_val ! 449: 437 0001C257 # asm("std _dbl_st_acc"); /* save the acc */ ! 450: 438 0001C257 27 effffffb93 std _dbl_st_acc ! 451: 439 0001C25D # if( force_loop ) /* loop? */ ! 452: 440 0001C25D 5d effffffb8d tstl _force_loop ! 453: 441 0001C263 31 02 jeql L277 ! 454: 442 0001C265 # asm("brb _cmpd2_2_lp1");; /* run the loop again */ ! 455: 443 0001C265 11 d1 brb _cmpd2_2_lp1 ! 456: 444 0001C267 L277: ! 457: 445 0001C267 # exp_psl = init_psl; /* get the initial PSL */ ! 458: 446 0001C267 0d effffffb83 effffffb7e movl _init_psl,_exp_psl ! 459: 447 0001C272 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */ ! 460: 448 0001C272 ac 88f3 effffffb76 andl2 $-13,_exp_psl ! 461: 449 0001C27A # if( sgl_expected == ZERO ) ! 462: 450 0001C27A 1d effffffb70 04 cmpl _sgl_expected,$4 ! 463: 451 0001C281 21 07 jneq L278 ! 464: 452 0001C283 # exp_psl |= PSL_Z; /* expect the ZERO bit set */ ! 465: 453 0001C283 8c 04 effffffb66 orl2 $4,_exp_psl ! 466: 454 0001C28A # if( sgl_expected == NEGATIVE ) ! 467: 455 0001C28A L278: ! 468: 456 0001C28A 1d effffffb60 08 cmpl _sgl_expected,$8 ! 469: 457 0001C291 21 07 jneq L279 ! 470: 458 0001C293 # exp_psl |= PSL_N; /* expect the NEG bit set */ ! 471: 459 0001C293 8c 08 effffffb56 orl2 $8,_exp_psl ! 472: 460 0001C29A # if( psl_val != exp_psl ) { /* COMPARE the values */ ! 473: 461 0001C29A L279: ! 474: 462 0001C29A 1d effffffb50 effffffb4b cmpl _psl_val,_exp_psl ! 475: 463 0001C2A5 21 03 13 0170 jeql L280 ! 476: 464 0001C2AA # errcnt++; /* bump the error count */ ! 477: 465 0001C2AA 6d effffffb40 incl _errcnt ! 478: 466 0001C2B0 # if ( prt_error ) { ! 479: 467 0001C2B0 5d effffffb3a tstl _prt_error ! 480: 468 0001C2B6 21 03 13 013c jeql L281 ! 481: 469 0001C2BB # writes(" \n"); /* start a new print line */ ! 482: 470 0001C2BB .data 1 ! 483: 471 0000144a * L282: ! 484: 472 0000144a * 200A00 .ascii " \12\0" ! 485: 473 0000144d * .text ! 486: 474 0001C2BB dd 8f0000144a pushl $L282 ! 487: 475 0001C2C1 fe 08 effffffb28 callf $8,_writes ! 488: 476 0001C2C8 # writes("cycle: "); ! 489: 477 0001C2C8 .data 1 ! 490: 478 0000144d * L283: ! 491: 479 0000144d * 6379636C653A2000 .ascii "cycle: \0" ! 492: 480 00001455 * .text ! 493: 481 0001C2C8 dd 8f0000144d pushl $L283 ! 494: 482 0001C2CE fe 08 effffffb1b callf $8,_writes ! 495: 483 0001C2D5 # writed( cycle ); ! 496: 484 0001C2D5 dd effffffb15 pushl _cycle ! 497: 485 0001C2DB fe 08 effffffb0e callf $8,_writed ! 498: 486 0001C2E2 # writes(" CMPD2 test "); ! 499: 487 0001C2E2 .data 1 ! 500: 488 00001455 * L284: ! 501: 489 00001455 * 2020434D50443220746573742 .ascii " CMPD2 test \0" ! 502: 000 ! 503: 490 00001463 * .text ! 504: 491 0001C2E2 dd 8f00001455 pushl $L284 ! 505: 492 0001C2E8 fe 08 effffffb01 callf $8,_writes ! 506: 493 0001C2EF # writed( test_no ); ! 507: 494 0001C2EF dd effffffafb pushl _test_no ! 508: 495 0001C2F5 fe 08 effffffaf4 callf $8,_writed ! 509: 496 0001C2FC # writes(", subtest 2 (Cache/Cache Data) - BAD FINAL PSL\n"); ! 510: 497 0001C2FC .data 1 ! 511: 498 00001463 * L285: ! 512: 499 00001463 * 2C20737562746573742032202 .ascii ", subtest 2 (Cache/Cache Data) - BAD FINAL PSL\12\0" ! 513: 843616368652F436163686520 ! 514: 4461746129202D20424144204 ! 515: 6494E414C2050534C0A00 ! 516: 500 00001493 * .text ! 517: 501 0001C2FC dd 8f00001463 pushl $L285 ! 518: 502 0001C302 fe 08 effffffae7 callf $8,_writes ! 519: 503 0001C309 # print_cmpd2_data(); ! 520: 504 0001C309 fe 04 ef00000cc6 callf $4,_print_cmpd2_data ! 521: 505 0001C310 # writes(", index = "); ! 522: 506 0001C310 .data 1 ! 523: 507 00001493 * L286: ! 524: 508 00001493 * 2C202020696E646578203D200 .ascii ", index = \0" ! 525: 0 ! 526: 509 000014a0 * .text ! 527: 510 0001C310 dd 8f00001493 pushl $L286 ! 528: 511 0001C316 fe 08 effffffad3 callf $8,_writes ! 529: 512 0001C31D # writed( index ); ! 530: 513 0001C31D dd effffffacd pushl _index ! 531: 514 0001C323 fe 08 effffffac6 callf $8,_writed ! 532: 515 0001C32A # writec('\n'); ! 533: 516 0001C32A dd 0a pushl $10 ! 534: 517 0001C32C fe 08 effffffabd callf $8,_writec ! 535: 518 0001C333 # writes(" final Acc = "); ! 536: 519 0001C333 .data 1 ! 537: 520 000014a0 * L287: ! 538: 521 000014a0 * 20202066696E616C204163632 .ascii " final Acc = \0" ! 539: 03D2000 ! 540: 522 000014b0 * .text ! 541: 523 0001C333 dd 8f000014a0 pushl $L287 ! 542: 524 0001C339 fe 08 effffffab0 callf $8,_writes ! 543: 525 0001C340 # write32h( dbl_st_acc.m ); ! 544: 526 0001C340 dd effffffaaa pushl _dbl_st_acc ! 545: 527 0001C346 fe 08 effffffaa3 callf $8,_write32h ! 546: 528 0001C34D # writec(' '); ! 547: 529 0001C34D dd 20 pushl $32 ! 548: 530 0001C34F fe 08 effffffa9a callf $8,_writec ! 549: 531 0001C356 # write32h( dbl_st_acc.l ); ! 550: 532 0001C356 dd effffffa98 pushl _dbl_st_acc+4 ! 551: 533 0001C35C fe 08 effffffa8d callf $8,_write32h ! 552: 534 0001C363 # writes(", operand 2 = "); ! 553: 535 0001C363 .data 1 ! 554: 536 000014b0 * L288: ! 555: 537 000014b0 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0" ! 556: 03D2000 ! 557: 538 000014c0 * .text ! 558: 539 0001C363 dd 8f000014b0 pushl $L288 ! 559: 540 0001C369 fe 08 effffffa80 callf $8,_writes ! 560: 541 0001C370 # write32h( sgl_value_3); ! 561: 542 0001C370 dd effffffa7a pushl _sgl_value_3 ! 562: 543 0001C376 fe 08 effffffa73 callf $8,_write32h ! 563: 544 0001C37D # writec(' '); ! 564: 545 0001C37D dd 20 pushl $32 ! 565: 546 0001C37F fe 08 effffffa6a callf $8,_writec ! 566: 547 0001C386 # write32h( sgl_value_4); ! 567: 548 0001C386 dd effffffa64 pushl _sgl_value_4 ! 568: 549 0001C38C fe 08 effffffa5d callf $8,_write32h ! 569: 550 0001C393 # writec('\n'); ! 570: 551 0001C393 dd 0a pushl $10 ! 571: 552 0001C395 fe 08 effffffa54 callf $8,_writec ! 572: 553 0001C39C # writes(" initial PSL = "); ! 573: 554 0001C39C .data 1 ! 574: 555 000014c0 * L289: ! 575: 556 000014c0 * 2020696E697469616C2050534 .ascii " initial PSL = \0" ! 576: C203D2000 ! 577: 557 000014d1 * .text ! 578: 558 0001C39C dd 8f000014c0 pushl $L289 ! 579: 559 0001C3A2 fe 08 effffffa47 callf $8,_writes ! 580: 560 0001C3A9 # write32h( init_psl ); ! 581: 561 0001C3A9 dd effffffa41 pushl _init_psl ! 582: 562 0001C3AF fe 08 effffffa3a callf $8,_write32h ! 583: 563 0001C3B6 # writes(", final PSL = "); ! 584: 564 0001C3B6 .data 1 ! 585: 565 000014d1 * L290: ! 586: 566 000014d1 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0" ! 587: 03D2000 ! 588: 567 000014e1 * .text ! 589: 568 0001C3B6 dd 8f000014d1 pushl $L290 ! 590: 569 0001C3BC fe 08 effffffa2d callf $8,_writes ! 591: 570 0001C3C3 # write32h( psl_val ); ! 592: 571 0001C3C3 dd effffffa27 pushl _psl_val ! 593: 572 0001C3C9 fe 08 effffffa20 callf $8,_write32h ! 594: 573 0001C3D0 # writes(", expected PSL = "); ! 595: 574 0001C3D0 .data 1 ! 596: 575 000014e1 * L291: ! 597: 576 000014e1 * 2C20206578706563746564205 .ascii ", expected PSL = \0" ! 598: 0534C203D2000 ! 599: 577 000014f4 * .text ! 600: 578 0001C3D0 dd 8f000014e1 pushl $L291 ! 601: 579 0001C3D6 fe 08 effffffa13 callf $8,_writes ! 602: 580 0001C3DD # write32h( exp_psl ); ! 603: 581 0001C3DD dd effffffa0d pushl _exp_psl ! 604: 582 0001C3E3 fe 08 effffffa06 callf $8,_write32h ! 605: 583 0001C3EA # writes(" \n"); ! 606: 584 0001C3EA .data 1 ! 607: 585 000014f4 * L292: ! 608: 586 000014f4 * 200A00 .ascii " \12\0" ! 609: 587 000014f7 * .text ! 610: 588 0001C3EA dd 8f000014f4 pushl $L292 ! 611: 589 0001C3F0 fe 08 effffff9f9 callf $8,_writes ! 612: 590 0001C3F7 # } ! 613: 591 0001C3F7 # if ( halt_flg ) ! 614: 592 0001C3F7 L281: ! 615: 593 0001C3F7 5d effffff9f3 tstl _halt_flg ! 616: 594 0001C3FD 31 09 jeql L293 ! 617: 595 0001C3FF # cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 618: 596 0001C3FF dd 03 pushl $3 ! 619: 597 0001C401 fe 08 ef00000c36 callf $8,_cmpd2_er_halt ! 620: 598 0001C408 # if ( loop_on_err ) ! 621: 599 0001C408 L293: ! 622: 600 0001C408 5d effffff9e2 tstl _loop_on_err ! 623: 601 0001C40E 31 0a jeql L294 ! 624: 602 0001C410 # { ! 625: 603 0001C410 # force_loop = TRUE; /* set the force loop flag */ ! 626: 604 0001C410 0d 01 effffff9d9 movl $1,_force_loop ! 627: 605 0001C417 # asm("brw _cmpd2_2_lp1"); /* and loop */ ! 628: 606 0001C417 13 fe1e brw _cmpd2_2_lp1 ! 629: 607 0001C41A # }; /* end of loop-on-error */ ! 630: 608 0001C41A L294: ! 631: 609 0001C41A # } /* end of compare error */ ! 632: 610 0001C41A # } while( ++status_index < 3 ); ! 633: 611 0001C41A L280: ! 634: 612 0001C41A L275: ! 635: 613 0001C41A 6d effffff9d0 incl _status_index ! 636: 614 0001C420 0d effffff9ca 50 movl _status_index,r0 ! 637: 615 0001C427 1d 50 03 cmpl r0,$3 ! 638: 616 0001C42A 81 03 13 fdf6 jlss L276 ! 639: 617 0001C42F L274: ! 640: 618 0001C42F # index2++; ! 641: 619 0001C42F 6d effffff9bb incl _index2 ! 642: 620 0001C435 # } while( (index2 < 10) && (index2 < max_ldf_1_index) ); ! 643: 621 0001C435 L272: ! 644: 622 0001C435 1d effffff9b5 0a cmpl _index2,$10 ! 645: 623 0001C43C 81 10 jgeq L9998 ! 646: 624 0001C43E 1d effffff9ac effffff9a7 cmpl _index2,_max_ldf_1_index ! 647: 625 0001C449 81 03 13 fdad jlss L273 ! 648: 626 0001C44E L9998: ! 649: 627 0001C44E L271: ! 650: 628 0001C44E # } while( index++ < max_cmpd_1_index ); ! 651: 629 0001C44E L269: ! 652: 630 0001C44E 0d effffff99c 50 movl _index,r0 ! 653: 631 0001C455 6d effffff995 incl _index ! 654: 632 0001C45B 1d 50 effffff98e cmpl r0,_max_cmpd_1_index ! 655: 633 0001C462 81 03 13 fd13 jlss L270 ! 656: 634 0001C467 L268: ! 657: 635 0001C467 # } /* end of subtest 2 */ ! 658: 636 0001C467 40 ret#2 ! 659: 637 0001C468 .set L264,0x0 ! 660: 638 0001C468 L266: ! 661: 639 0001C468 13 fcfc jbr L267 ! 662: 640 0001C46B .data ! 663: 641 00001398 * .text ! 664: 642 0001C46B 00 .align 1 ! 665: 643 0001C46C .globl _cmpd2_3 ! 666: 644 0001C46C _cmpd2_3: ! 667: 645 0001C46C 0000 .word L295 ! 668: 646 0001C46E # ! 669: 647 0001C46E # ! 670: 648 0001C46E # ! 671: 649 0001C46E # /**************************************************************************** ! 672: 650 0001C46E # * ! 673: 651 0001C46E # * SUBTEST 3 - CMPD2 test - cache / register data ! 674: 652 0001C46E # * ! 675: 653 0001C46E # ****************************************************************************/ ! 676: 654 0001C46E # cmpd2_3() ! 677: 655 0001C46E # { ! 678: 656 0001C46E 13 030b jbr L297 ! 679: 657 0001C471 L298: ! 680: 658 0001C471 # force_loop = FALSE; ! 681: 659 0001C471 4d effffff979 clrl _force_loop ! 682: 660 0001C477 # subtest = 3; ! 683: 661 0001C477 0d 03 effffff972 movl $3,_subtest ! 684: 662 0001C47E # index = 0; ! 685: 663 0001C47E 4d effffff96c clrl _index ! 686: 664 0001C484 # do ! 687: 665 0001C484 L301: ! 688: 666 0001C484 # { ! 689: 667 0001C484 # dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */ ! 690: 668 0001C484 5c 14 effffff965 50 mull3 $20,_index,r0 ! 691: 669 0001C48C 0c 8f00000000 50 addl2 $_cmpd_1_data,r0 ! 692: 670 0001C493 0d a004 effffff959 movl 4(r0),_dbl_value_1+4 ! 693: 671 0001C49B 0d 60 effffff94e movl (r0),_dbl_value_1 ! 694: 672 0001C4A2 # dbl_value_2 = cmpd_1_data[index].two; ! 695: 673 0001C4A2 5c 14 effffff947 50 mull3 $20,_index,r0 ! 696: 674 0001C4AA 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0 ! 697: 675 0001C4B1 0d a004 effffff93b movl 4(r0),_dbl_value_2+4 ! 698: 676 0001C4B9 0d 60 effffff930 movl (r0),_dbl_value_2 ! 699: 677 0001C4C0 # sgl_value_1 = dbl_value_1.m; ! 700: 678 0001C4C0 0d effffff92a effffff925 movl _dbl_value_1,_sgl_value_1 ! 701: 679 0001C4CB # sgl_value_2 = dbl_value_1.l; ! 702: 680 0001C4CB 0d effffff923 effffff91a movl _dbl_value_1+4,_sgl_value_2 ! 703: 681 0001C4D6 # sgl_value_3 = dbl_value_2.m; ! 704: 682 0001C4D6 0d effffff914 effffff90f movl _dbl_value_2,_sgl_value_3 ! 705: 683 0001C4E1 # sgl_value_4 = dbl_value_2.l; ! 706: 684 0001C4E1 0d effffff90d effffff904 movl _dbl_value_2+4,_sgl_value_4 ! 707: 685 0001C4EC # sgl_expected = cmpd_1_data[index].flag; /* get expected results */ ! 708: 686 0001C4EC 5c 14 effffff8fd 50 mull3 $20,_index,r0 ! 709: 687 0001C4F4 0d e000000010 effffff8f1 movl _cmpd_1_data+16(r0),_sgl_expected ! 710: 688 0001C4FF # index2 = 0; /* clear Acc. data index */ ! 711: 689 0001C4FF 4d effffff8eb clrl _index2 ! 712: 690 0001C505 # do ! 713: 691 0001C505 L304: ! 714: 692 0001C505 # { ! 715: 693 0001C505 # dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */ ! 716: 694 0001C505 48 04 effffff8e4 50 shll $4,_index2,r0 ! 717: 695 0001C50D 0c 8f00000000 50 addl2 $_ldd_1_data,r0 ! 718: 696 0001C514 0d a004 effffff8d8 movl 4(r0),_dbl_ld_acc+4 ! 719: 697 0001C51C 0d 60 effffff8cd movl (r0),_dbl_ld_acc ! 720: 698 0001C523 # asm("ldd _dbl_ld_acc"); /* load the accumulator */ ! 721: 699 0001C523 07 effffff8c7 ldd _dbl_ld_acc ! 722: 700 0001C529 # status_index = 0; /* clear the status index */ ! 723: 701 0001C529 4d effffff8c1 clrl _status_index ! 724: 702 0001C52F # do ! 725: 703 0001C52F L307: ! 726: 704 0001C52F # { ! 727: 705 0001C52F # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */ ! 728: 706 0001C52F 0d effffff8bb 50 movl _status_index,r0 ! 729: 707 0001C536 0d 40effffff8b3 movl _status_array[r0],_sgl_dummy1 ! 730: effffff8ae ! 731: 708 0001C542 # /* ! 732: 709 0001C542 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 733: 710 0001C542 # * The force loop flag is set after the first error. ! 734: 711 0001C542 # */ ! 735: 712 0001C542 # asm("_cmpd2_3_lp1:"); ! 736: 713 0001C542 _cmpd2_3_lp1: ! 737: 714 0001C542 # asm("movl _sgl_value_3,r4"); /* move operand #2's MSW,r4 */ ! 738: 715 0001C542 0d effffff8a8 54 movl _sgl_value_3,r4 ! 739: 716 0001C549 # asm("movl _sgl_value_4,r5"); /* move operand #2's LSW,r5 */ ! 740: 717 0001C549 0d effffff8a1 55 movl _sgl_value_4,r5 ! 741: 718 0001C550 # asm("tstl _sgl_dummy1"); /* generate initial status */ ! 742: 719 0001C550 5d effffff89a tstl _sgl_dummy1 ! 743: 720 0001C556 # asm("movpsl _init_psl"); /* save the initial status */ ! 744: 721 0001C556 cd effffff894 movpsl _init_psl ! 745: 722 0001C55C # asm("nop"); ! 746: 723 0001C55C 10 nop ! 747: 724 0001C55D # asm("cmpd2 _dbl_value_1,r4"); /* compare the data */ ! 748: 725 0001C55D 47 effffff88d 54 cmpd2 _dbl_value_1,r4 ! 749: 726 0001C564 # asm("nop"); ! 750: 727 0001C564 10 nop ! 751: 728 0001C565 # asm("movpsl _psl_val"); /* save the final status */ ! 752: 729 0001C565 cd effffff885 movpsl _psl_val ! 753: 730 0001C56B # asm("std _sgl_st_acc"); /* save the acc */ ! 754: 731 0001C56B 27 effffff87f std _sgl_st_acc ! 755: 732 0001C571 # if( force_loop ) /* loop? */ ! 756: 733 0001C571 5d effffff879 tstl _force_loop ! 757: 734 0001C577 31 02 jeql L308 ! 758: 735 0001C579 # asm("brb _cmpd2_3_lp1");; /* run the loop again */ ! 759: 736 0001C579 11 c7 brb _cmpd2_3_lp1 ! 760: 737 0001C57B L308: ! 761: 738 0001C57B # exp_psl = init_psl; /* get the initial PSL */ ! 762: 739 0001C57B 0d effffff86f effffff86a movl _init_psl,_exp_psl ! 763: 740 0001C586 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */ ! 764: 741 0001C586 ac 88f3 effffff862 andl2 $-13,_exp_psl ! 765: 742 0001C58E # if( sgl_expected == ZERO ) ! 766: 743 0001C58E 1d effffff85c 04 cmpl _sgl_expected,$4 ! 767: 744 0001C595 21 07 jneq L309 ! 768: 745 0001C597 # exp_psl |= PSL_Z; /* expect the ZERO bit set */ ! 769: 746 0001C597 8c 04 effffff852 orl2 $4,_exp_psl ! 770: 747 0001C59E # if( sgl_expected == NEGATIVE ) ! 771: 748 0001C59E L309: ! 772: 749 0001C59E 1d effffff84c 08 cmpl _sgl_expected,$8 ! 773: 750 0001C5A5 21 07 jneq L310 ! 774: 751 0001C5A7 # exp_psl |= PSL_N; /* expect the NEG bit set */ ! 775: 752 0001C5A7 8c 08 effffff842 orl2 $8,_exp_psl ! 776: 753 0001C5AE # if( psl_val != exp_psl ) { /* COMPARE the values */ ! 777: 754 0001C5AE L310: ! 778: 755 0001C5AE 1d effffff83c effffff837 cmpl _psl_val,_exp_psl ! 779: 756 0001C5B9 21 03 13 0170 jeql L311 ! 780: 757 0001C5BE # errcnt++; /* bump the error count */ ! 781: 758 0001C5BE 6d effffff82c incl _errcnt ! 782: 759 0001C5C4 # if ( prt_error ) { ! 783: 760 0001C5C4 5d effffff826 tstl _prt_error ! 784: 761 0001C5CA 21 03 13 013c jeql L312 ! 785: 762 0001C5CF # writes(" \n"); /* start a new print line */ ! 786: 763 0001C5CF .data 1 ! 787: 764 000014f7 * L313: ! 788: 765 000014f7 * 200A00 .ascii " \12\0" ! 789: 766 000014fa * .text ! 790: 767 0001C5CF dd 8f000014f7 pushl $L313 ! 791: 768 0001C5D5 fe 08 effffff814 callf $8,_writes ! 792: 769 0001C5DC # writes("cycle: "); ! 793: 770 0001C5DC .data 1 ! 794: 771 000014fa * L314: ! 795: 772 000014fa * 6379636C653A2000 .ascii "cycle: \0" ! 796: 773 00001502 * .text ! 797: 774 0001C5DC dd 8f000014fa pushl $L314 ! 798: 775 0001C5E2 fe 08 effffff807 callf $8,_writes ! 799: 776 0001C5E9 # writed( cycle ); ! 800: 777 0001C5E9 dd effffff801 pushl _cycle ! 801: 778 0001C5EF fe 08 effffff7fa callf $8,_writed ! 802: 779 0001C5F6 # writes(" CMPD2 test "); ! 803: 780 0001C5F6 .data 1 ! 804: 781 00001502 * L315: ! 805: 782 00001502 * 2020434D50443220746573742 .ascii " CMPD2 test \0" ! 806: 000 ! 807: 783 00001510 * .text ! 808: 784 0001C5F6 dd 8f00001502 pushl $L315 ! 809: 785 0001C5FC fe 08 effffff7ed callf $8,_writes ! 810: 786 0001C603 # writed( test_no ); ! 811: 787 0001C603 dd effffff7e7 pushl _test_no ! 812: 788 0001C609 fe 08 effffff7e0 callf $8,_writed ! 813: 789 0001C610 # writes(", subtest 3 (Cache/Reg. Data) - BAD FINAL PSL\n"); ! 814: 790 0001C610 .data 1 ! 815: 791 00001510 * L316: ! 816: 792 00001510 * 2C20737562746573742033202 .ascii ", subtest 3 (Cache/Reg. Data) - BAD FINAL PSL\12\0" ! 817: 843616368652F5265672E2044 ! 818: 61746129202D2042414420464 ! 819: 94E414C2050534C0A00 ! 820: 793 0000153f * .text ! 821: 794 0001C610 dd 8f00001510 pushl $L316 ! 822: 795 0001C616 fe 08 effffff7d3 callf $8,_writes ! 823: 796 0001C61D # print_cmpd2_data(); ! 824: 797 0001C61D fe 04 ef000009b2 callf $4,_print_cmpd2_data ! 825: 798 0001C624 # writes(", index = "); ! 826: 799 0001C624 .data 1 ! 827: 800 0000153f * L317: ! 828: 801 0000153f * 2C202020696E646578203D200 .ascii ", index = \0" ! 829: 0 ! 830: 802 0000154c * .text ! 831: 803 0001C624 dd 8f0000153f pushl $L317 ! 832: 804 0001C62A fe 08 effffff7bf callf $8,_writes ! 833: 805 0001C631 # writed( index ); ! 834: 806 0001C631 dd effffff7b9 pushl _index ! 835: 807 0001C637 fe 08 effffff7b2 callf $8,_writed ! 836: 808 0001C63E # writec('\n'); ! 837: 809 0001C63E dd 0a pushl $10 ! 838: 810 0001C640 fe 08 effffff7a9 callf $8,_writec ! 839: 811 0001C647 # writes(" final Acc = "); ! 840: 812 0001C647 .data 1 ! 841: 813 0000154c * L318: ! 842: 814 0000154c * 20202066696E616C204163632 .ascii " final Acc = \0" ! 843: 03D2000 ! 844: 815 0000155c * .text ! 845: 816 0001C647 dd 8f0000154c pushl $L318 ! 846: 817 0001C64D fe 08 effffff79c callf $8,_writes ! 847: 818 0001C654 # write32h( dbl_st_acc.m ); ! 848: 819 0001C654 dd effffff796 pushl _dbl_st_acc ! 849: 820 0001C65A fe 08 effffff78f callf $8,_write32h ! 850: 821 0001C661 # writec(' '); ! 851: 822 0001C661 dd 20 pushl $32 ! 852: 823 0001C663 fe 08 effffff786 callf $8,_writec ! 853: 824 0001C66A # write32h( dbl_st_acc.l ); ! 854: 825 0001C66A dd effffff784 pushl _dbl_st_acc+4 ! 855: 826 0001C670 fe 08 effffff779 callf $8,_write32h ! 856: 827 0001C677 # writes(", operand 2 = "); ! 857: 828 0001C677 .data 1 ! 858: 829 0000155c * L319: ! 859: 830 0000155c * 2C20206F706572616E6420322 .ascii ", operand 2 = \0" ! 860: 03D2000 ! 861: 831 0000156c * .text ! 862: 832 0001C677 dd 8f0000155c pushl $L319 ! 863: 833 0001C67D fe 08 effffff76c callf $8,_writes ! 864: 834 0001C684 # write32h( sgl_value_3); ! 865: 835 0001C684 dd effffff766 pushl _sgl_value_3 ! 866: 836 0001C68A fe 08 effffff75f callf $8,_write32h ! 867: 837 0001C691 # writec(' '); ! 868: 838 0001C691 dd 20 pushl $32 ! 869: 839 0001C693 fe 08 effffff756 callf $8,_writec ! 870: 840 0001C69A # write32h( sgl_value_4); ! 871: 841 0001C69A dd effffff750 pushl _sgl_value_4 ! 872: 842 0001C6A0 fe 08 effffff749 callf $8,_write32h ! 873: 843 0001C6A7 # writec('\n'); ! 874: 844 0001C6A7 dd 0a pushl $10 ! 875: 845 0001C6A9 fe 08 effffff740 callf $8,_writec ! 876: 846 0001C6B0 # writes(" initial PSL = "); ! 877: 847 0001C6B0 .data 1 ! 878: 848 0000156c * L320: ! 879: 849 0000156c * 2020696E697469616C2050534 .ascii " initial PSL = \0" ! 880: C203D2000 ! 881: 850 0000157d * .text ! 882: 851 0001C6B0 dd 8f0000156c pushl $L320 ! 883: 852 0001C6B6 fe 08 effffff733 callf $8,_writes ! 884: 853 0001C6BD # write32h( init_psl ); ! 885: 854 0001C6BD dd effffff72d pushl _init_psl ! 886: 855 0001C6C3 fe 08 effffff726 callf $8,_write32h ! 887: 856 0001C6CA # writes(", final PSL = "); ! 888: 857 0001C6CA .data 1 ! 889: 858 0000157d * L321: ! 890: 859 0000157d * 2C202066696E616C2050534C2 .ascii ", final PSL = \0" ! 891: 03D2000 ! 892: 860 0000158d * .text ! 893: 861 0001C6CA dd 8f0000157d pushl $L321 ! 894: 862 0001C6D0 fe 08 effffff719 callf $8,_writes ! 895: 863 0001C6D7 # write32h( psl_val ); ! 896: 864 0001C6D7 dd effffff713 pushl _psl_val ! 897: 865 0001C6DD fe 08 effffff70c callf $8,_write32h ! 898: 866 0001C6E4 # writes(", expected PSL = "); ! 899: 867 0001C6E4 .data 1 ! 900: 868 0000158d * L322: ! 901: 869 0000158d * 2C20206578706563746564205 .ascii ", expected PSL = \0" ! 902: 0534C203D2000 ! 903: 870 000015a0 * .text ! 904: 871 0001C6E4 dd 8f0000158d pushl $L322 ! 905: 872 0001C6EA fe 08 effffff6ff callf $8,_writes ! 906: 873 0001C6F1 # write32h( exp_psl ); ! 907: 874 0001C6F1 dd effffff6f9 pushl _exp_psl ! 908: 875 0001C6F7 fe 08 effffff6f2 callf $8,_write32h ! 909: 876 0001C6FE # writes(" \n"); ! 910: 877 0001C6FE .data 1 ! 911: 878 000015a0 * L323: ! 912: 879 000015a0 * 200A00 .ascii " \12\0" ! 913: 880 000015a3 * .text ! 914: 881 0001C6FE dd 8f000015a0 pushl $L323 ! 915: 882 0001C704 fe 08 effffff6e5 callf $8,_writes ! 916: 883 0001C70B # } ! 917: 884 0001C70B # if ( halt_flg ) ! 918: 885 0001C70B L312: ! 919: 886 0001C70B 5d effffff6df tstl _halt_flg ! 920: 887 0001C711 31 09 jeql L324 ! 921: 888 0001C713 # cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 922: 889 0001C713 dd 03 pushl $3 ! 923: 890 0001C715 fe 08 ef00000922 callf $8,_cmpd2_er_halt ! 924: 891 0001C71C # if ( loop_on_err ) ! 925: 892 0001C71C L324: ! 926: 893 0001C71C 5d effffff6ce tstl _loop_on_err ! 927: 894 0001C722 31 0a jeql L325 ! 928: 895 0001C724 # { ! 929: 896 0001C724 # force_loop = TRUE; /* set the force loop flag */ ! 930: 897 0001C724 0d 01 effffff6c5 movl $1,_force_loop ! 931: 898 0001C72B # asm("brw _cmpd2_3_lp1"); /* and loop */ ! 932: 899 0001C72B 13 fe14 brw _cmpd2_3_lp1 ! 933: 900 0001C72E # }; /* end of loop-on-error */ ! 934: 901 0001C72E L325: ! 935: 902 0001C72E # } /* end of compare error */ ! 936: 903 0001C72E # } while( ++status_index < 3 ); ! 937: 904 0001C72E L311: ! 938: 905 0001C72E L306: ! 939: 906 0001C72E 6d effffff6bc incl _status_index ! 940: 907 0001C734 0d effffff6b6 50 movl _status_index,r0 ! 941: 908 0001C73B 1d 50 03 cmpl r0,$3 ! 942: 909 0001C73E 81 03 13 fdec jlss L307 ! 943: 910 0001C743 L305: ! 944: 911 0001C743 # index2++; ! 945: 912 0001C743 6d effffff6a7 incl _index2 ! 946: 913 0001C749 # } while( (index2 < 10) && (index2 < max_ldf_1_index) ); ! 947: 914 0001C749 L303: ! 948: 915 0001C749 1d effffff6a1 0a cmpl _index2,$10 ! 949: 916 0001C750 81 10 jgeq L9997 ! 950: 917 0001C752 1d effffff698 effffff693 cmpl _index2,_max_ldf_1_index ! 951: 918 0001C75D 81 03 13 fda3 jlss L304 ! 952: 919 0001C762 L9997: ! 953: 920 0001C762 L302: ! 954: 921 0001C762 # } while( index++ < max_cmpd_1_index ); ! 955: 922 0001C762 L300: ! 956: 923 0001C762 0d effffff688 50 movl _index,r0 ! 957: 924 0001C769 6d effffff681 incl _index ! 958: 925 0001C76F 1d 50 effffff67a cmpl r0,_max_cmpd_1_index ! 959: 926 0001C776 81 03 13 fd09 jlss L301 ! 960: 927 0001C77B L299: ! 961: 928 0001C77B # } /* end of subtest 3 */ ! 962: 929 0001C77B 40 ret#2 ! 963: 930 0001C77C .set L295,0x0 ! 964: 931 0001C77C L297: ! 965: 932 0001C77C 13 fcf2 jbr L298 ! 966: 933 0001C77F .data ! 967: 934 00001398 * .text ! 968: 935 0001C77F 00 .align 1 ! 969: 936 0001C780 .globl _cmpd2_4 ! 970: 937 0001C780 _cmpd2_4: ! 971: 938 0001C780 0000 .word L326 ! 972: 939 0001C782 # ! 973: 940 0001C782 # ! 974: 941 0001C782 # ! 975: 942 0001C782 # /**************************************************************************** ! 976: 943 0001C782 # * ! 977: 944 0001C782 # * SUBTEST 4 - CMPD2 test - register / cache data ! 978: 945 0001C782 # * ! 979: 946 0001C782 # ****************************************************************************/ ! 980: 947 0001C782 # cmpd2_4() ! 981: 948 0001C782 # { ! 982: 949 0001C782 13 030e jbr L328 ! 983: 950 0001C785 L329: ! 984: 951 0001C785 # force_loop = FALSE; ! 985: 952 0001C785 4d effffff665 clrl _force_loop ! 986: 953 0001C78B # subtest = 4; ! 987: 954 0001C78B 0d 04 effffff65e movl $4,_subtest ! 988: 955 0001C792 # index = 0; ! 989: 956 0001C792 4d effffff658 clrl _index ! 990: 957 0001C798 # do ! 991: 958 0001C798 L332: ! 992: 959 0001C798 # { ! 993: 960 0001C798 # dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */ ! 994: 961 0001C798 5c 14 effffff651 50 mull3 $20,_index,r0 ! 995: 962 0001C7A0 0c 8f00000000 50 addl2 $_cmpd_1_data,r0 ! 996: 963 0001C7A7 0d a004 effffff645 movl 4(r0),_dbl_value_1+4 ! 997: 964 0001C7AF 0d 60 effffff63a movl (r0),_dbl_value_1 ! 998: 965 0001C7B6 # dbl_value_2 = cmpd_1_data[index].two; ! 999: 966 0001C7B6 5c 14 effffff633 50 mull3 $20,_index,r0 ! 1000: 967 0001C7BE 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0 ! 1001: 968 0001C7C5 0d a004 effffff627 movl 4(r0),_dbl_value_2+4 ! 1002: 969 0001C7CD 0d 60 effffff61c movl (r0),_dbl_value_2 ! 1003: 970 0001C7D4 # sgl_value_1 = dbl_value_1.m; ! 1004: 971 0001C7D4 0d effffff616 effffff611 movl _dbl_value_1,_sgl_value_1 ! 1005: 972 0001C7DF # sgl_value_2 = dbl_value_1.l; ! 1006: 973 0001C7DF 0d effffff60f effffff606 movl _dbl_value_1+4,_sgl_value_2 ! 1007: 974 0001C7EA # sgl_value_3 = dbl_value_2.m; ! 1008: 975 0001C7EA 0d effffff600 effffff5fb movl _dbl_value_2,_sgl_value_3 ! 1009: 976 0001C7F5 # sgl_value_4 = dbl_value_2.l; ! 1010: 977 0001C7F5 0d effffff5f9 effffff5f0 movl _dbl_value_2+4,_sgl_value_4 ! 1011: 978 0001C800 # sgl_expected = cmpd_1_data[index].flag; /* get expected results */ ! 1012: 979 0001C800 5c 14 effffff5e9 50 mull3 $20,_index,r0 ! 1013: 980 0001C808 0d e000000010 effffff5dd movl _cmpd_1_data+16(r0),_sgl_expected ! 1014: 981 0001C813 # index2 = 0; /* clear Acc. data index */ ! 1015: 982 0001C813 4d effffff5d7 clrl _index2 ! 1016: 983 0001C819 # do ! 1017: 984 0001C819 L335: ! 1018: 985 0001C819 # { ! 1019: 986 0001C819 # dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */ ! 1020: 987 0001C819 48 04 effffff5d0 50 shll $4,_index2,r0 ! 1021: 988 0001C821 0c 8f00000000 50 addl2 $_ldd_1_data,r0 ! 1022: 989 0001C828 0d a004 effffff5c4 movl 4(r0),_dbl_ld_acc+4 ! 1023: 990 0001C830 0d 60 effffff5b9 movl (r0),_dbl_ld_acc ! 1024: 991 0001C837 # asm("ldd _dbl_ld_acc"); /* load the accumulator */ ! 1025: 992 0001C837 07 effffff5b3 ldd _dbl_ld_acc ! 1026: 993 0001C83D # status_index = 0; /* clear the status index */ ! 1027: 994 0001C83D 4d effffff5ad clrl _status_index ! 1028: 995 0001C843 # do ! 1029: 996 0001C843 L338: ! 1030: 997 0001C843 # { ! 1031: 998 0001C843 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */ ! 1032: 999 0001C843 0d effffff5a7 50 movl _status_index,r0 ! 1033: 1000 0001C84A 0d 40effffff59f movl _status_array[r0],_sgl_dummy1 ! 1034: effffff59a ! 1035: 1001 0001C856 # /* ! 1036: 1002 0001C856 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1037: 1003 0001C856 # * The force loop flag is set after the first error. ! 1038: 1004 0001C856 # */ ! 1039: 1005 0001C856 # asm("_cmpd2_4_lp1:"); ! 1040: 1006 0001C856 _cmpd2_4_lp1: ! 1041: 1007 0001C856 # asm("movl _sgl_value_1,r2"); /* move operand #1,s MSW,r2 */ ! 1042: 1008 0001C856 0d effffff594 52 movl _sgl_value_1,r2 ! 1043: 1009 0001C85D # asm("movl _sgl_value_2,r3"); /* move operand #1's LSW,r3 */ ! 1044: 1010 0001C85D 0d effffff58d 53 movl _sgl_value_2,r3 ! 1045: 1011 0001C864 # asm("tstl _sgl_dummy1"); /* generate initial status */ ! 1046: 1012 0001C864 5d effffff586 tstl _sgl_dummy1 ! 1047: 1013 0001C86A # asm("movpsl _init_psl"); /* save the initial status */ ! 1048: 1014 0001C86A cd effffff580 movpsl _init_psl ! 1049: 1015 0001C870 # asm("nop"); ! 1050: 1016 0001C870 10 nop ! 1051: 1017 0001C871 # asm("cmpd2 r2,_dbl_value_2"); /* compare the data */ ! 1052: 1018 0001C871 47 52 effffff578 cmpd2 r2,_dbl_value_2 ! 1053: 1019 0001C878 # asm("nop"); ! 1054: 1020 0001C878 10 nop ! 1055: 1021 0001C879 # asm("movpsl _psl_val"); /* save the final status */ ! 1056: 1022 0001C879 cd effffff571 movpsl _psl_val ! 1057: 1023 0001C87F # asm("std _dbl_st_acc"); /* save the acc */ ! 1058: 1024 0001C87F 27 effffff56b std _dbl_st_acc ! 1059: 1025 0001C885 # if( force_loop ) /* loop? */ ! 1060: 1026 0001C885 5d effffff565 tstl _force_loop ! 1061: 1027 0001C88B 31 02 jeql L339 ! 1062: 1028 0001C88D # asm("brb _cmpd2_4_lp1");; /* run the loop again */ ! 1063: 1029 0001C88D 11 c7 brb _cmpd2_4_lp1 ! 1064: 1030 0001C88F L339: ! 1065: 1031 0001C88F # exp_psl = init_psl; /* get the initial PSL */ ! 1066: 1032 0001C88F 0d effffff55b effffff556 movl _init_psl,_exp_psl ! 1067: 1033 0001C89A # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */ ! 1068: 1034 0001C89A ac 88f3 effffff54e andl2 $-13,_exp_psl ! 1069: 1035 0001C8A2 # if( sgl_expected == ZERO ) ! 1070: 1036 0001C8A2 1d effffff548 04 cmpl _sgl_expected,$4 ! 1071: 1037 0001C8A9 21 07 jneq L340 ! 1072: 1038 0001C8AB # exp_psl |= PSL_Z; /* expect the ZERO bit set */ ! 1073: 1039 0001C8AB 8c 04 effffff53e orl2 $4,_exp_psl ! 1074: 1040 0001C8B2 # if( sgl_expected == NEGATIVE ) ! 1075: 1041 0001C8B2 L340: ! 1076: 1042 0001C8B2 1d effffff538 08 cmpl _sgl_expected,$8 ! 1077: 1043 0001C8B9 21 07 jneq L341 ! 1078: 1044 0001C8BB # exp_psl |= PSL_N; /* expect the NEG bit set */ ! 1079: 1045 0001C8BB 8c 08 effffff52e orl2 $8,_exp_psl ! 1080: 1046 0001C8C2 # if( psl_val != exp_psl ) { /* COMPARE the values */ ! 1081: 1047 0001C8C2 L341: ! 1082: 1048 0001C8C2 1d effffff528 effffff523 cmpl _psl_val,_exp_psl ! 1083: 1049 0001C8CD 21 03 13 0173 jeql L342 ! 1084: 1050 0001C8D2 # errcnt++; /* bump the error count */ ! 1085: 1051 0001C8D2 6d effffff518 incl _errcnt ! 1086: 1052 0001C8D8 # if ( prt_error ) { ! 1087: 1053 0001C8D8 5d effffff512 tstl _prt_error ! 1088: 1054 0001C8DE 21 03 13 013c jeql L343 ! 1089: 1055 0001C8E3 # writes(" \n"); /* start a new print line */ ! 1090: 1056 0001C8E3 .data 1 ! 1091: 1057 000015a3 * L344: ! 1092: 1058 000015a3 * 200A00 .ascii " \12\0" ! 1093: 1059 000015a6 * .text ! 1094: 1060 0001C8E3 dd 8f000015a3 pushl $L344 ! 1095: 1061 0001C8E9 fe 08 effffff500 callf $8,_writes ! 1096: 1062 0001C8F0 # writes("cycle: "); ! 1097: 1063 0001C8F0 .data 1 ! 1098: 1064 000015a6 * L345: ! 1099: 1065 000015a6 * 6379636C653A2000 .ascii "cycle: \0" ! 1100: 1066 000015ae * .text ! 1101: 1067 0001C8F0 dd 8f000015a6 pushl $L345 ! 1102: 1068 0001C8F6 fe 08 effffff4f3 callf $8,_writes ! 1103: 1069 0001C8FD # writed( cycle ); ! 1104: 1070 0001C8FD dd effffff4ed pushl _cycle ! 1105: 1071 0001C903 fe 08 effffff4e6 callf $8,_writed ! 1106: 1072 0001C90A # writes(" CMPD2 test "); ! 1107: 1073 0001C90A .data 1 ! 1108: 1074 000015ae * L346: ! 1109: 1075 000015ae * 2020434D50443220746573742 .ascii " CMPD2 test \0" ! 1110: 000 ! 1111: 1076 000015bc * .text ! 1112: 1077 0001C90A dd 8f000015ae pushl $L346 ! 1113: 1078 0001C910 fe 08 effffff4d9 callf $8,_writes ! 1114: 1079 0001C917 # writed( test_no ); ! 1115: 1080 0001C917 dd effffff4d3 pushl _test_no ! 1116: 1081 0001C91D fe 08 effffff4cc callf $8,_writed ! 1117: 1082 0001C924 # writes(", subtest 4 (Reg./Cache Data) - BAD FINAL PSL\n"); ! 1118: 1083 0001C924 .data 1 ! 1119: 1084 000015bc * L347: ! 1120: 1085 000015bc * 2C20737562746573742034202 .ascii ", subtest 4 (Reg./Cache Data) - BAD FINAL PSL\12\0" ! 1121: 85265672E2F43616368652044 ! 1122: 61746129202D2042414420464 ! 1123: 94E414C2050534C0A00 ! 1124: 1086 000015eb * .text ! 1125: 1087 0001C924 dd 8f000015bc pushl $L347 ! 1126: 1088 0001C92A fe 08 effffff4bf callf $8,_writes ! 1127: 1089 0001C931 # print_cmpd2_data(); ! 1128: 1090 0001C931 fe 04 ef0000069e callf $4,_print_cmpd2_data ! 1129: 1091 0001C938 # writes(", index = "); ! 1130: 1092 0001C938 .data 1 ! 1131: 1093 000015eb * L348: ! 1132: 1094 000015eb * 2C202020696E646578203D200 .ascii ", index = \0" ! 1133: 0 ! 1134: 1095 000015f8 * .text ! 1135: 1096 0001C938 dd 8f000015eb pushl $L348 ! 1136: 1097 0001C93E fe 08 effffff4ab callf $8,_writes ! 1137: 1098 0001C945 # writed( index ); ! 1138: 1099 0001C945 dd effffff4a5 pushl _index ! 1139: 1100 0001C94B fe 08 effffff49e callf $8,_writed ! 1140: 1101 0001C952 # writec('\n'); ! 1141: 1102 0001C952 dd 0a pushl $10 ! 1142: 1103 0001C954 fe 08 effffff495 callf $8,_writec ! 1143: 1104 0001C95B # writes(" final Acc = "); ! 1144: 1105 0001C95B .data 1 ! 1145: 1106 000015f8 * L349: ! 1146: 1107 000015f8 * 20202066696E616C204163632 .ascii " final Acc = \0" ! 1147: 03D2000 ! 1148: 1108 00001608 * .text ! 1149: 1109 0001C95B dd 8f000015f8 pushl $L349 ! 1150: 1110 0001C961 fe 08 effffff488 callf $8,_writes ! 1151: 1111 0001C968 # write32h( dbl_st_acc.m ); ! 1152: 1112 0001C968 dd effffff482 pushl _dbl_st_acc ! 1153: 1113 0001C96E fe 08 effffff47b callf $8,_write32h ! 1154: 1114 0001C975 # writec(' '); ! 1155: 1115 0001C975 dd 20 pushl $32 ! 1156: 1116 0001C977 fe 08 effffff472 callf $8,_writec ! 1157: 1117 0001C97E # write32h( dbl_st_acc.l ); ! 1158: 1118 0001C97E dd effffff470 pushl _dbl_st_acc+4 ! 1159: 1119 0001C984 fe 08 effffff465 callf $8,_write32h ! 1160: 1120 0001C98B # writes(", operand 2 = "); ! 1161: 1121 0001C98B .data 1 ! 1162: 1122 00001608 * L350: ! 1163: 1123 00001608 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0" ! 1164: 03D2000 ! 1165: 1124 00001618 * .text ! 1166: 1125 0001C98B dd 8f00001608 pushl $L350 ! 1167: 1126 0001C991 fe 08 effffff458 callf $8,_writes ! 1168: 1127 0001C998 # write32h( sgl_value_3); ! 1169: 1128 0001C998 dd effffff452 pushl _sgl_value_3 ! 1170: 1129 0001C99E fe 08 effffff44b callf $8,_write32h ! 1171: 1130 0001C9A5 # writec(' '); ! 1172: 1131 0001C9A5 dd 20 pushl $32 ! 1173: 1132 0001C9A7 fe 08 effffff442 callf $8,_writec ! 1174: 1133 0001C9AE # write32h( sgl_value_4); ! 1175: 1134 0001C9AE dd effffff43c pushl _sgl_value_4 ! 1176: 1135 0001C9B4 fe 08 effffff435 callf $8,_write32h ! 1177: 1136 0001C9BB # writec('\n'); ! 1178: 1137 0001C9BB dd 0a pushl $10 ! 1179: 1138 0001C9BD fe 08 effffff42c callf $8,_writec ! 1180: 1139 0001C9C4 # writes(" initial PSL = "); ! 1181: 1140 0001C9C4 .data 1 ! 1182: 1141 00001618 * L351: ! 1183: 1142 00001618 * 2020696E697469616C2050534 .ascii " initial PSL = \0" ! 1184: C203D2000 ! 1185: 1143 00001629 * .text ! 1186: 1144 0001C9C4 dd 8f00001618 pushl $L351 ! 1187: 1145 0001C9CA fe 08 effffff41f callf $8,_writes ! 1188: 1146 0001C9D1 # write32h( init_psl ); ! 1189: 1147 0001C9D1 dd effffff419 pushl _init_psl ! 1190: 1148 0001C9D7 fe 08 effffff412 callf $8,_write32h ! 1191: 1149 0001C9DE # writes(", final PSL = "); ! 1192: 1150 0001C9DE .data 1 ! 1193: 1151 00001629 * L352: ! 1194: 1152 00001629 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0" ! 1195: 03D2000 ! 1196: 1153 00001639 * .text ! 1197: 1154 0001C9DE dd 8f00001629 pushl $L352 ! 1198: 1155 0001C9E4 fe 08 effffff405 callf $8,_writes ! 1199: 1156 0001C9EB # write32h( psl_val ); ! 1200: 1157 0001C9EB dd effffff3ff pushl _psl_val ! 1201: 1158 0001C9F1 fe 08 effffff3f8 callf $8,_write32h ! 1202: 1159 0001C9F8 # writes(", expected PSL = "); ! 1203: 1160 0001C9F8 .data 1 ! 1204: 1161 00001639 * L353: ! 1205: 1162 00001639 * 2C20206578706563746564205 .ascii ", expected PSL = \0" ! 1206: 0534C203D2000 ! 1207: 1163 0000164c * .text ! 1208: 1164 0001C9F8 dd 8f00001639 pushl $L353 ! 1209: 1165 0001C9FE fe 08 effffff3eb callf $8,_writes ! 1210: 1166 0001CA05 # write32h( exp_psl ); ! 1211: 1167 0001CA05 dd effffff3e5 pushl _exp_psl ! 1212: 1168 0001CA0B fe 08 effffff3de callf $8,_write32h ! 1213: 1169 0001CA12 # writes(" \n"); ! 1214: 1170 0001CA12 .data 1 ! 1215: 1171 0000164c * L354: ! 1216: 1172 0000164c * 200A00 .ascii " \12\0" ! 1217: 1173 0000164f * .text ! 1218: 1174 0001CA12 dd 8f0000164c pushl $L354 ! 1219: 1175 0001CA18 fe 08 effffff3d1 callf $8,_writes ! 1220: 1176 0001CA1F # } ! 1221: 1177 0001CA1F # if ( halt_flg ) ! 1222: 1178 0001CA1F L343: ! 1223: 1179 0001CA1F 5d effffff3cb tstl _halt_flg ! 1224: 1180 0001CA25 31 09 jeql L355 ! 1225: 1181 0001CA27 # cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 1226: 1182 0001CA27 dd 03 pushl $3 ! 1227: 1183 0001CA29 fe 08 ef0000060e callf $8,_cmpd2_er_halt ! 1228: 1184 0001CA30 # if ( loop_on_err ) ! 1229: 1185 0001CA30 L355: ! 1230: 1186 0001CA30 5d effffff3ba tstl _loop_on_err ! 1231: 1187 0001CA36 31 0d jeql L356 ! 1232: 1188 0001CA38 # { ! 1233: 1189 0001CA38 # force_loop = TRUE; /* set the force loop flag */ ! 1234: 1190 0001CA38 0d 01 effffff3b1 movl $1,_force_loop ! 1235: 1191 0001CA3F # asm("jmp _cmpd2_4_lp1"); /* and loop */ ! 1236: 1192 0001CA3F 71 effffffe11 jmp _cmpd2_4_lp1 ! 1237: 1193 0001CA45 # } /* end of loop-on-error */ ! 1238: 1194 0001CA45 # } /* end of compare error */ ! 1239: 1195 0001CA45 L356: ! 1240: 1196 0001CA45 # } while( ++status_index < 3 ); /* end of status loop */ ! 1241: 1197 0001CA45 L342: ! 1242: 1198 0001CA45 L337: ! 1243: 1199 0001CA45 6d effffff3a5 incl _status_index ! 1244: 1200 0001CA4B 0d effffff39f 50 movl _status_index,r0 ! 1245: 1201 0001CA52 1d 50 03 cmpl r0,$3 ! 1246: 1202 0001CA55 81 03 13 fde9 jlss L338 ! 1247: 1203 0001CA5A L336: ! 1248: 1204 0001CA5A # index2++; ! 1249: 1205 0001CA5A 6d effffff390 incl _index2 ! 1250: 1206 0001CA60 # } while( (index2 < 10) && (index2 < max_ldf_1_index) ); ! 1251: 1207 0001CA60 L334: ! 1252: 1208 0001CA60 1d effffff38a 0a cmpl _index2,$10 ! 1253: 1209 0001CA67 81 10 jgeq L9996 ! 1254: 1210 0001CA69 1d effffff381 effffff37c cmpl _index2,_max_ldf_1_index ! 1255: 1211 0001CA74 81 03 13 fda0 jlss L335 ! 1256: 1212 0001CA79 L9996: ! 1257: 1213 0001CA79 L333: ! 1258: 1214 0001CA79 # } while( index++ < max_cmpd_1_index ); ! 1259: 1215 0001CA79 L331: ! 1260: 1216 0001CA79 0d effffff371 50 movl _index,r0 ! 1261: 1217 0001CA80 6d effffff36a incl _index ! 1262: 1218 0001CA86 1d 50 effffff363 cmpl r0,_max_cmpd_1_index ! 1263: 1219 0001CA8D 81 03 13 fd06 jlss L332 ! 1264: 1220 0001CA92 L330: ! 1265: 1221 0001CA92 # } /* end of subtest 4 */ ! 1266: 1222 0001CA92 40 ret#2 ! 1267: 1223 0001CA93 .set L326,0x0 ! 1268: 1224 0001CA93 L328: ! 1269: 1225 0001CA93 13 fcef jbr L329 ! 1270: 1226 0001CA96 .data ! 1271: 1227 00001398 * .text ! 1272: 1228 0001CA96 .align 1 ! 1273: 1229 0001CA96 .globl _cmpd2_5 ! 1274: 1230 0001CA96 _cmpd2_5: ! 1275: 1231 0001CA96 0000 .word L357 ! 1276: 1232 0001CA98 # ! 1277: 1233 0001CA98 # ! 1278: 1234 0001CA98 # ! 1279: 1235 0001CA98 # /************************************************************************ ! 1280: 1236 0001CA98 # * ! 1281: 1237 0001CA98 # * SUBTEST 5 - Check for register corruption ! 1282: 1238 0001CA98 # * ! 1283: 1239 0001CA98 # ************************************************************************/ ! 1284: 1240 0001CA98 # cmpd2_5() ! 1285: 1241 0001CA98 # { ! 1286: 1242 0001CA98 13 0296 jbr L359 ! 1287: 1243 0001CA9B L360: ! 1288: 1244 0001CA9B # force_loop = FALSE; /* clear force_loop flg */ ! 1289: 1245 0001CA9B 4d effffff34f clrl _force_loop ! 1290: 1246 0001CAA1 # subtest = 5; ! 1291: 1247 0001CAA1 0d 05 effffff348 movl $5,_subtest ! 1292: 1248 0001CAA8 # fill_reg_buf( load_regs ); /* get pattern for regs */ ! 1293: 1249 0001CAA8 dd 8f00000000 pushl $_load_regs ! 1294: 1250 0001CAAE fe 08 effffff33b callf $8,_fill_reg_buf ! 1295: 1251 0001CAB5 # index = 0; ! 1296: 1252 0001CAB5 4d effffff335 clrl _index ! 1297: 1253 0001CABB # do ! 1298: 1254 0001CABB L364: ! 1299: 1255 0001CABB # { ! 1300: 1256 0001CABB # dbl_value_1 = cmpd_1_data[index].one; /* data to load */ ! 1301: 1257 0001CABB 5c 14 effffff32e 50 mull3 $20,_index,r0 ! 1302: 1258 0001CAC3 0c 8f00000000 50 addl2 $_cmpd_1_data,r0 ! 1303: 1259 0001CACA 0d a004 effffff322 movl 4(r0),_dbl_value_1+4 ! 1304: 1260 0001CAD2 0d 60 effffff317 movl (r0),_dbl_value_1 ! 1305: 1261 0001CAD9 # dbl_value_2 = cmpd_1_data[index].two; /* data to compare */ ! 1306: 1262 0001CAD9 5c 14 effffff310 50 mull3 $20,_index,r0 ! 1307: 1263 0001CAE1 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0 ! 1308: 1264 0001CAE8 0d a004 effffff304 movl 4(r0),_dbl_value_2+4 ! 1309: 1265 0001CAF0 0d 60 effffff2f9 movl (r0),_dbl_value_2 ! 1310: 1266 0001CAF7 # dbl_ld_acc.m = 0x40800000; /* get acc data */ ! 1311: 1267 0001CAF7 0d 8f40800000 effffff2ee movl $1082130432,_dbl_ld_acc ! 1312: 1268 0001CB02 # dbl_ld_acc.l = 0x10101010; /* get acc data */ ! 1313: 1269 0001CB02 0d 8f10101010 effffff2e7 movl $269488144,_dbl_ld_acc+4 ! 1314: 1270 0001CB0D # sgl_value_1 = dbl_value_1.m; ! 1315: 1271 0001CB0D 0d effffff2dd effffff2d8 movl _dbl_value_1,_sgl_value_1 ! 1316: 1272 0001CB18 # sgl_value_2 = dbl_value_1.l; ! 1317: 1273 0001CB18 0d effffff2d6 effffff2cd movl _dbl_value_1+4,_sgl_value_2 ! 1318: 1274 0001CB23 # sgl_value_3 = dbl_value_2.m; ! 1319: 1275 0001CB23 0d effffff2c7 effffff2c2 movl _dbl_value_2,_sgl_value_3 ! 1320: 1276 0001CB2E # sgl_value_4 = dbl_value_2.l; ! 1321: 1277 0001CB2E 0d effffff2c0 effffff2b7 movl _dbl_value_2+4,_sgl_value_4 ! 1322: 1278 0001CB39 # asm("ldd _dbl_ld_acc"); /* load the acc */ ! 1323: 1279 0001CB39 07 effffff2b1 ldd _dbl_ld_acc ! 1324: 1280 0001CB3F # /* ! 1325: 1281 0001CB3F # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1326: 1282 0001CB3F # * The force loop flag is set after the first error. ! 1327: 1283 0001CB3F # */ ! 1328: 1284 0001CB3F # asm("_cmpd2_5_lp1:"); ! 1329: 1285 0001CB3F _cmpd2_5_lp1: ! 1330: 1286 0001CB3F # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */ ! 1331: 1287 0001CB3F ab 891fff effffff2a8 loadr $0x1fff,_load_regs ! 1332: 1288 0001CB48 # asm("nop"); ! 1333: 1289 0001CB48 10 nop ! 1334: 1290 0001CB49 # asm("cmpd2 _dbl_value_1,_dbl_value_2"); /* compare the data */ ! 1335: 1291 0001CB49 47 effffff2a1 effffff29c cmpd2 _dbl_value_1,_dbl_value_2 ! 1336: 1292 0001CB54 # asm("nop"); ! 1337: 1293 0001CB54 10 nop ! 1338: 1294 0001CB55 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 1339: 1295 0001CB55 bb 891fff effffff292 storer $0x1fff,_store_regs ! 1340: 1296 0001CB5E # asm("std _dbl_st_acc"); /* save the acc */ ! 1341: 1297 0001CB5E 27 effffff28c std _dbl_st_acc ! 1342: 1298 0001CB64 # if( force_loop ) /* loop? */ ! 1343: 1299 0001CB64 5d effffff286 tstl _force_loop ! 1344: 1300 0001CB6A 31 02 jeql L365 ! 1345: 1301 0001CB6C # asm("brb _cmpd2_5_lp1");; /* run the loop again */ ! 1346: 1302 0001CB6C 11 d1 brb _cmpd2_5_lp1 ! 1347: 1303 0001CB6E L365: ! 1348: 1304 0001CB6E # /* ! 1349: 1305 0001CB6E # * Now compare the stored register values to those that were loaded ! 1350: 1306 0001CB6E # */ ! 1351: 1307 0001CB6E # index2 = 0; ! 1352: 1308 0001CB6E 4d effffff27c clrl _index2 ! 1353: 1309 0001CB74 # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) ) ! 1354: 1310 0001CB74 L366: ! 1355: 1311 0001CB74 0d effffff276 50 movl _index2,r0 ! 1356: 1312 0001CB7B 0d effffff26f 51 movl _index2,r1 ! 1357: 1313 0001CB82 1d 40effffff267 cmpl _load_regs[r0],_store_regs[r1] ! 1358: 41effffff261 ! 1359: 1314 0001CB8F 21 11 jneq L367 ! 1360: 1315 0001CB91 1d effffff259 0d cmpl _index2,$13 ! 1361: 1316 0001CB98 81 08 jgeq L367 ! 1362: 1317 0001CB9A # index2++; /* check reg values */ ! 1363: 1318 0001CB9A 6d effffff250 incl _index2 ! 1364: 1319 0001CBA0 11 d2 jbr L366 ! 1365: 1320 0001CBA2 L367: ! 1366: 1321 0001CBA2 # if( index2 < 13 ) { /* error if index2 < 13 */ ! 1367: 1322 0001CBA2 1d effffff248 0d cmpl _index2,$13 ! 1368: 1323 0001CBA9 91 03 13 0169 jgeq L368 ! 1369: 1324 0001CBAE # errcnt++; /* bump the error count */ ! 1370: 1325 0001CBAE 6d effffff23c incl _errcnt ! 1371: 1326 0001CBB4 # if ( prt_error ) { ! 1372: 1327 0001CBB4 5d effffff236 tstl _prt_error ! 1373: 1328 0001CBBA 21 03 13 0132 jeql L369 ! 1374: 1329 0001CBBF # writes(" \n"); /* start a new print line */ ! 1375: 1330 0001CBBF .data 1 ! 1376: 1331 0000164f * L370: ! 1377: 1332 0000164f * 200A00 .ascii " \12\0" ! 1378: 1333 00001652 * .text ! 1379: 1334 0001CBBF dd 8f0000164f pushl $L370 ! 1380: 1335 0001CBC5 fe 08 effffff224 callf $8,_writes ! 1381: 1336 0001CBCC # writes("cycle: "); ! 1382: 1337 0001CBCC .data 1 ! 1383: 1338 00001652 * L371: ! 1384: 1339 00001652 * 6379636C653A2000 .ascii "cycle: \0" ! 1385: 1340 0000165a * .text ! 1386: 1341 0001CBCC dd 8f00001652 pushl $L371 ! 1387: 1342 0001CBD2 fe 08 effffff217 callf $8,_writes ! 1388: 1343 0001CBD9 # writed( cycle ); ! 1389: 1344 0001CBD9 dd effffff211 pushl _cycle ! 1390: 1345 0001CBDF fe 08 effffff20a callf $8,_writed ! 1391: 1346 0001CBE6 # writes(", CMPD2 test "); ! 1392: 1347 0001CBE6 .data 1 ! 1393: 1348 0000165a * L372: ! 1394: 1349 0000165a * 2C20434D50443220746573742 .ascii ", CMPD2 test \0" ! 1395: 000 ! 1396: 1350 00001668 * .text ! 1397: 1351 0001CBE6 dd 8f0000165a pushl $L372 ! 1398: 1352 0001CBEC fe 08 effffff1fd callf $8,_writes ! 1399: 1353 0001CBF3 # writed( test_no ); ! 1400: 1354 0001CBF3 dd effffff1f7 pushl _test_no ! 1401: 1355 0001CBF9 fe 08 effffff1f0 callf $8,_writed ! 1402: 1356 0001CC00 # writes(", subtest 5 - A REGISTER WAS MODIFIED\n"); ! 1403: 1357 0001CC00 .data 1 ! 1404: 1358 00001668 * L373: ! 1405: 1359 00001668 * 2C20737562746573742035202 .ascii ", subtest 5 - A REGISTER WAS MODIFIED\12\0" ! 1406: D204120524547495354455220 ! 1407: 574153204D4F4449464945440 ! 1408: A00 ! 1409: 1360 0000168f * .text ! 1410: 1361 0001CC00 dd 8f00001668 pushl $L373 ! 1411: 1362 0001CC06 fe 08 effffff1e3 callf $8,_writes ! 1412: 1363 0001CC0D # print_cmpd2_data(); ! 1413: 1364 0001CC0D fe 04 ef000003c2 callf $4,_print_cmpd2_data ! 1414: 1365 0001CC14 # writec('\n'); ! 1415: 1366 0001CC14 dd 0a pushl $10 ! 1416: 1367 0001CC16 fe 08 effffff1d3 callf $8,_writec ! 1417: 1368 0001CC1D # writes(" final Acc = "); ! 1418: 1369 0001CC1D .data 1 ! 1419: 1370 0000168f * L374: ! 1420: 1371 0000168f * 20202066696E616C204163632 .ascii " final Acc = \0" ! 1421: 03D2000 ! 1422: 1372 0000169f * .text ! 1423: 1373 0001CC1D dd 8f0000168f pushl $L374 ! 1424: 1374 0001CC23 fe 08 effffff1c6 callf $8,_writes ! 1425: 1375 0001CC2A # write32h( dbl_st_acc.m ); ! 1426: 1376 0001CC2A dd effffff1c0 pushl _dbl_st_acc ! 1427: 1377 0001CC30 fe 08 effffff1b9 callf $8,_write32h ! 1428: 1378 0001CC37 # writec(' '); ! 1429: 1379 0001CC37 dd 20 pushl $32 ! 1430: 1380 0001CC39 fe 08 effffff1b0 callf $8,_writec ! 1431: 1381 0001CC40 # write32h( dbl_st_acc.l ); ! 1432: 1382 0001CC40 dd effffff1ae pushl _dbl_st_acc+4 ! 1433: 1383 0001CC46 fe 08 effffff1a3 callf $8,_write32h ! 1434: 1384 0001CC4D # writes(", operand 2 = "); ! 1435: 1385 0001CC4D .data 1 ! 1436: 1386 0000169f * L375: ! 1437: 1387 0000169f * 2C20206F706572616E6420322 .ascii ", operand 2 = \0" ! 1438: 03D2000 ! 1439: 1388 000016af * .text ! 1440: 1389 0001CC4D dd 8f0000169f pushl $L375 ! 1441: 1390 0001CC53 fe 08 effffff196 callf $8,_writes ! 1442: 1391 0001CC5A # write32h( sgl_value_3); ! 1443: 1392 0001CC5A dd effffff190 pushl _sgl_value_3 ! 1444: 1393 0001CC60 fe 08 effffff189 callf $8,_write32h ! 1445: 1394 0001CC67 # writec(' '); ! 1446: 1395 0001CC67 dd 20 pushl $32 ! 1447: 1396 0001CC69 fe 08 effffff180 callf $8,_writec ! 1448: 1397 0001CC70 # write32h( sgl_value_4); ! 1449: 1398 0001CC70 dd effffff17a pushl _sgl_value_4 ! 1450: 1399 0001CC76 fe 08 effffff173 callf $8,_write32h ! 1451: 1400 0001CC7D # writec('\n'); ! 1452: 1401 0001CC7D dd 0a pushl $10 ! 1453: 1402 0001CC7F fe 08 effffff16a callf $8,_writec ! 1454: 1403 0001CC86 # writes("register "); ! 1455: 1404 0001CC86 .data 1 ! 1456: 1405 000016af * L376: ! 1457: 1406 000016af * 72656769737465722000 .ascii "register \0" ! 1458: 1407 000016b9 * .text ! 1459: 1408 0001CC86 dd 8f000016af pushl $L376 ! 1460: 1409 0001CC8C fe 08 effffff15d callf $8,_writes ! 1461: 1410 0001CC93 # writed( index2 ); ! 1462: 1411 0001CC93 dd effffff157 pushl _index2 ! 1463: 1412 0001CC99 fe 08 effffff150 callf $8,_writed ! 1464: 1413 0001CCA0 # writes(" = "); ! 1465: 1414 0001CCA0 .data 1 ! 1466: 1415 000016b9 * L377: ! 1467: 1416 000016b9 * 203D2000 .ascii " = \0" ! 1468: 1417 000016bd * .text ! 1469: 1418 0001CCA0 dd 8f000016b9 pushl $L377 ! 1470: 1419 0001CCA6 fe 08 effffff143 callf $8,_writes ! 1471: 1420 0001CCAD # write32h( store_regs[ index2 ] ); ! 1472: 1421 0001CCAD 0d effffff13d 50 movl _index2,r0 ! 1473: 1422 0001CCB4 dd 40effffff135 pushl _store_regs[r0] ! 1474: 1423 0001CCBB fe 08 effffff12e callf $8,_write32h ! 1475: 1424 0001CCC2 # writes(", should be = "); ! 1476: 1425 0001CCC2 .data 1 ! 1477: 1426 000016bd * L378: ! 1478: 1427 000016bd * 2C202073686F756C642062652 .ascii ", should be = \0" ! 1479: 03D2000 ! 1480: 1428 000016cd * .text ! 1481: 1429 0001CCC2 dd 8f000016bd pushl $L378 ! 1482: 1430 0001CCC8 fe 08 effffff121 callf $8,_writes ! 1483: 1431 0001CCCF # write32h( load_regs[ index2 ] ); ! 1484: 1432 0001CCCF 0d effffff11b 50 movl _index2,r0 ! 1485: 1433 0001CCD6 dd 40effffff113 pushl _load_regs[r0] ! 1486: 1434 0001CCDD fe 08 effffff10c callf $8,_write32h ! 1487: 1435 0001CCE4 # writes("\n"); ! 1488: 1436 0001CCE4 .data 1 ! 1489: 1437 000016cd * L379: ! 1490: 1438 000016cd * 0A00 .ascii "\12\0" ! 1491: 1439 000016cf * .text ! 1492: 1440 0001CCE4 dd 8f000016cd pushl $L379 ! 1493: 1441 0001CCEA fe 08 effffff0ff callf $8,_writes ! 1494: 1442 0001CCF1 # } ! 1495: 1443 0001CCF1 # if ( halt_flg ) ! 1496: 1444 0001CCF1 L369: ! 1497: 1445 0001CCF1 5d effffff0f9 tstl _halt_flg ! 1498: 1446 0001CCF7 31 09 jeql L380 ! 1499: 1447 0001CCF9 # cmpd2_er_halt( BAD_REG_HLT ); /* halt on the error */ ! 1500: 1448 0001CCF9 dd 02 pushl $2 ! 1501: 1449 0001CCFB fe 08 ef0000033c callf $8,_cmpd2_er_halt ! 1502: 1450 0001CD02 # if ( loop_on_err ) ! 1503: 1451 0001CD02 L380: ! 1504: 1452 0001CD02 5d effffff0e8 tstl _loop_on_err ! 1505: 1453 0001CD08 31 0d jeql L381 ! 1506: 1454 0001CD0A # { ! 1507: 1455 0001CD0A # force_loop = TRUE; /* set the force loop flag */ ! 1508: 1456 0001CD0A 0d 01 effffff0df movl $1,_force_loop ! 1509: 1457 0001CD11 # asm("jmp _cmpd2_5_lp1"); /* and loop */ ! 1510: 1458 0001CD11 71 effffffe28 jmp _cmpd2_5_lp1 ! 1511: 1459 0001CD17 # }; /* end of loop-on-error */ ! 1512: 1460 0001CD17 L381: ! 1513: 1461 0001CD17 # } /* end of compare error */ ! 1514: 1462 0001CD17 # } while( index++ < max_cmpd_1_index ); ! 1515: 1463 0001CD17 L368: ! 1516: 1464 0001CD17 L363: ! 1517: 1465 0001CD17 0d effffff0d3 50 movl _index,r0 ! 1518: 1466 0001CD1E 6d effffff0cc incl _index ! 1519: 1467 0001CD24 1d 50 effffff0c5 cmpl r0,_max_cmpd_1_index ! 1520: 1468 0001CD2B 81 03 13 fd8b jlss L364 ! 1521: 1469 0001CD30 L362: ! 1522: 1470 0001CD30 # } /* end of subtest 5 */ ! 1523: 1471 0001CD30 40 ret#2 ! 1524: 1472 0001CD31 .set L357,0x0 ! 1525: 1473 0001CD31 L359: ! 1526: 1474 0001CD31 13 fd67 jbr L360 ! 1527: 1475 0001CD34 .data ! 1528: 1476 00001398 * .text ! 1529: 1477 0001CD34 .align 1 ! 1530: 1478 0001CD34 .globl _cmpd2_6 ! 1531: 1479 0001CD34 _cmpd2_6: ! 1532: 1480 0001CD34 0000 .word L382 ! 1533: 1481 0001CD36 # ! 1534: 1482 0001CD36 # ! 1535: 1483 0001CD36 # ! 1536: 1484 0001CD36 # /**************************************************************************** ! 1537: 1485 0001CD36 # * ! 1538: 1486 0001CD36 # * SUBTEST 6 - CMPD2 test Accumulator stability test ! 1539: 1487 0001CD36 # * ! 1540: 1488 0001CD36 # ****************************************************************************/ ! 1541: 1489 0001CD36 # cmpd2_6() ! 1542: 1490 0001CD36 # { ! 1543: 1491 0001CD36 13 029a jbr L384 ! 1544: 1492 0001CD39 L385: ! 1545: 1493 0001CD39 # force_loop = FALSE; ! 1546: 1494 0001CD39 4d effffff0b1 clrl _force_loop ! 1547: 1495 0001CD3F # subtest = 6; ! 1548: 1496 0001CD3F 0d 06 effffff0aa movl $6,_subtest ! 1549: 1497 0001CD46 # index = 0; ! 1550: 1498 0001CD46 4d effffff0a4 clrl _index ! 1551: 1499 0001CD4C # do ! 1552: 1500 0001CD4C L388: ! 1553: 1501 0001CD4C # { ! 1554: 1502 0001CD4C # dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */ ! 1555: 1503 0001CD4C 5c 14 effffff09d 50 mull3 $20,_index,r0 ! 1556: 1504 0001CD54 0c 8f00000000 50 addl2 $_cmpd_1_data,r0 ! 1557: 1505 0001CD5B 0d a004 effffff091 movl 4(r0),_dbl_value_1+4 ! 1558: 1506 0001CD63 0d 60 effffff086 movl (r0),_dbl_value_1 ! 1559: 1507 0001CD6A # dbl_value_2 = cmpd_1_data[index].two; ! 1560: 1508 0001CD6A 5c 14 effffff07f 50 mull3 $20,_index,r0 ! 1561: 1509 0001CD72 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0 ! 1562: 1510 0001CD79 0d a004 effffff073 movl 4(r0),_dbl_value_2+4 ! 1563: 1511 0001CD81 0d 60 effffff068 movl (r0),_dbl_value_2 ! 1564: 1512 0001CD88 # sgl_value_1 = dbl_value_1.m; ! 1565: 1513 0001CD88 0d effffff062 effffff05d movl _dbl_value_1,_sgl_value_1 ! 1566: 1514 0001CD93 # sgl_value_2 = dbl_value_1.l; ! 1567: 1515 0001CD93 0d effffff05b effffff052 movl _dbl_value_1+4,_sgl_value_2 ! 1568: 1516 0001CD9E # sgl_value_3 = dbl_value_2.m; ! 1569: 1517 0001CD9E 0d effffff04c effffff047 movl _dbl_value_2,_sgl_value_3 ! 1570: 1518 0001CDA9 # sgl_value_4 = dbl_value_2.l; ! 1571: 1519 0001CDA9 0d effffff045 effffff03c movl _dbl_value_2+4,_sgl_value_4 ! 1572: 1520 0001CDB4 # index2 = 0; /* clear Acc. data index */ ! 1573: 1521 0001CDB4 4d effffff036 clrl _index2 ! 1574: 1522 0001CDBA # do ! 1575: 1523 0001CDBA L391: ! 1576: 1524 0001CDBA # { ! 1577: 1525 0001CDBA # dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */ ! 1578: 1526 0001CDBA 48 04 effffff02f 50 shll $4,_index2,r0 ! 1579: 1527 0001CDC2 0c 8f00000000 50 addl2 $_ldd_1_data,r0 ! 1580: 1528 0001CDC9 0d a004 effffff023 movl 4(r0),_dbl_ld_acc+4 ! 1581: 1529 0001CDD1 0d 60 effffff018 movl (r0),_dbl_ld_acc ! 1582: 1530 0001CDD8 # if( !(dbl_ld_acc.m & 0x7f800000 ) ) { ! 1583: 1531 0001CDD8 3d 8f7f800000 effffff00d bitl $2139095040,_dbl_ld_acc ! 1584: 1532 0001CDE3 21 0e jneq L392 ! 1585: 1533 0001CDE5 # dbl_expected.m = 0; /* expect a '0' stored */ ! 1586: 1534 0001CDE5 4d effffff005 clrl _dbl_expected ! 1587: 1535 0001CDEB # dbl_expected.l = 0; ! 1588: 1536 0001CDEB 4d effffff003 clrl _dbl_expected+4 ! 1589: 1537 0001CDF1 # } else ! 1590: 1538 0001CDF1 11 16 jbr L393 ! 1591: 1539 0001CDF3 L392: ! 1592: 1540 0001CDF3 # dbl_expected = dbl_ld_acc; ! 1593: 1541 0001CDF3 0d efffffeffb efffffeff6 movl _dbl_ld_acc+4,_dbl_expected+4 ! 1594: 1542 0001CDFE 0d efffffefec efffffefe7 movl _dbl_ld_acc,_dbl_expected ! 1595: 1543 0001CE09 L393: ! 1596: 1544 0001CE09 # asm("ldd _dbl_ld_acc"); /* load the acc */ ! 1597: 1545 0001CE09 07 efffffefe1 ldd _dbl_ld_acc ! 1598: 1546 0001CE0F # /* ! 1599: 1547 0001CE0F # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1600: 1548 0001CE0F # * The force loop flag is set after the first error. ! 1601: 1549 0001CE0F # */ ! 1602: 1550 0001CE0F # asm("_cmpd2_6_lp1:"); ! 1603: 1551 0001CE0F _cmpd2_6_lp1: ! 1604: 1552 0001CE0F # asm("nop"); ! 1605: 1553 0001CE0F 10 nop ! 1606: 1554 0001CE10 # asm("cmpd2 _dbl_value_1,_dbl_value_2");/* compare the operands */ ! 1607: 1555 0001CE10 47 efffffefda efffffefd5 cmpd2 _dbl_value_1,_dbl_value_2 ! 1608: 1556 0001CE1B # asm("nop"); ! 1609: 1557 0001CE1B 10 nop ! 1610: 1558 0001CE1C # asm("std _dbl_st_acc"); /* store the accumulator */ ! 1611: 1559 0001CE1C 27 efffffefce std _dbl_st_acc ! 1612: 1560 0001CE22 # if( force_loop ) /* loop? */ ! 1613: 1561 0001CE22 5d efffffefc8 tstl _force_loop ! 1614: 1562 0001CE28 31 02 jeql L394 ! 1615: 1563 0001CE2A # asm("brb _cmpd2_6_lp1");; /* run the loop again */ ! 1616: 1564 0001CE2A 11 e3 brb _cmpd2_6_lp1 ! 1617: 1565 0001CE2C L394: ! 1618: 1566 0001CE2C # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the final */ ! 1619: 1567 0001CE2C # (dbl_st_acc.l != dbl_expected.l) ) { /* results */ ! 1620: 1568 0001CE2C 1d efffffefbe efffffefb9 cmpl _dbl_st_acc,_dbl_expected ! 1621: 1569 0001CE37 21 10 jneq L9995 ! 1622: 1570 0001CE39 1d efffffefb5 efffffefb0 cmpl _dbl_st_acc+4,_dbl_expected+4 ! 1623: 1571 0001CE44 21 03 13 0151 jeql L395 ! 1624: 1572 0001CE49 L9995: ! 1625: 1573 0001CE49 # errcnt++; /* bump the error count */ ! 1626: 1574 0001CE49 6d efffffefa1 incl _errcnt ! 1627: 1575 0001CE4F # if ( prt_error ) { ! 1628: 1576 0001CE4F 5d efffffef9b tstl _prt_error ! 1629: 1577 0001CE55 21 03 13 011a jeql L396 ! 1630: 1578 0001CE5A # writes(" \n"); /* start a new print line */ ! 1631: 1579 0001CE5A .data 1 ! 1632: 1580 000016cf * L397: ! 1633: 1581 000016cf * 200A00 .ascii " \12\0" ! 1634: 1582 000016d2 * .text ! 1635: 1583 0001CE5A dd 8f000016cf pushl $L397 ! 1636: 1584 0001CE60 fe 08 efffffef89 callf $8,_writes ! 1637: 1585 0001CE67 # writes("cycle: "); ! 1638: 1586 0001CE67 .data 1 ! 1639: 1587 000016d2 * L398: ! 1640: 1588 000016d2 * 6379636C653A2000 .ascii "cycle: \0" ! 1641: 1589 000016da * .text ! 1642: 1590 0001CE67 dd 8f000016d2 pushl $L398 ! 1643: 1591 0001CE6D fe 08 efffffef7c callf $8,_writes ! 1644: 1592 0001CE74 # writed( cycle ); ! 1645: 1593 0001CE74 dd efffffef76 pushl _cycle ! 1646: 1594 0001CE7A fe 08 efffffef6f callf $8,_writed ! 1647: 1595 0001CE81 # writes(" CMPD2 test "); ! 1648: 1596 0001CE81 .data 1 ! 1649: 1597 000016da * L399: ! 1650: 1598 000016da * 2020434D50443220746573742 .ascii " CMPD2 test \0" ! 1651: 000 ! 1652: 1599 000016e8 * .text ! 1653: 1600 0001CE81 dd 8f000016da pushl $L399 ! 1654: 1601 0001CE87 fe 08 efffffef62 callf $8,_writes ! 1655: 1602 0001CE8E # writed( test_no ); ! 1656: 1603 0001CE8E dd efffffef5c pushl _test_no ! 1657: 1604 0001CE94 fe 08 efffffef55 callf $8,_writed ! 1658: 1605 0001CE9B # writes(", subtest 6 - BAD FINAL ACC\n"); ! 1659: 1606 0001CE9B .data 1 ! 1660: 1607 000016e8 * L400: ! 1661: 1608 000016e8 * 2C20737562746573742036202 .ascii ", subtest 6 - BAD FINAL ACC\12\0" ! 1662: D204241442046494E414C2041 ! 1663: 43430A00 ! 1664: 1609 00001705 * .text ! 1665: 1610 0001CE9B dd 8f000016e8 pushl $L400 ! 1666: 1611 0001CEA1 fe 08 efffffef48 callf $8,_writes ! 1667: 1612 0001CEA8 # print_cmpd2_data(); ! 1668: 1613 0001CEA8 fe 04 ef00000127 callf $4,_print_cmpd2_data ! 1669: 1614 0001CEAF # writes(", index = "); ! 1670: 1615 0001CEAF .data 1 ! 1671: 1616 00001705 * L401: ! 1672: 1617 00001705 * 2C202020696E646578203D200 .ascii ", index = \0" ! 1673: 0 ! 1674: 1618 00001712 * .text ! 1675: 1619 0001CEAF dd 8f00001705 pushl $L401 ! 1676: 1620 0001CEB5 fe 08 efffffef34 callf $8,_writes ! 1677: 1621 0001CEBC # writed( index ); ! 1678: 1622 0001CEBC dd efffffef2e pushl _index ! 1679: 1623 0001CEC2 fe 08 efffffef27 callf $8,_writed ! 1680: 1624 0001CEC9 # writec('\n'); ! 1681: 1625 0001CEC9 dd 0a pushl $10 ! 1682: 1626 0001CECB fe 08 efffffef1e callf $8,_writec ! 1683: 1627 0001CED2 # writes(" final Acc = "); ! 1684: 1628 0001CED2 .data 1 ! 1685: 1629 00001712 * L402: ! 1686: 1630 00001712 * 20202066696E616C204163632 .ascii " final Acc = \0" ! 1687: 03D2000 ! 1688: 1631 00001722 * .text ! 1689: 1632 0001CED2 dd 8f00001712 pushl $L402 ! 1690: 1633 0001CED8 fe 08 efffffef11 callf $8,_writes ! 1691: 1634 0001CEDF # write32h( dbl_st_acc.m ); ! 1692: 1635 0001CEDF dd efffffef0b pushl _dbl_st_acc ! 1693: 1636 0001CEE5 fe 08 efffffef04 callf $8,_write32h ! 1694: 1637 0001CEEC # writec(' '); ! 1695: 1638 0001CEEC dd 20 pushl $32 ! 1696: 1639 0001CEEE fe 08 efffffeefb callf $8,_writec ! 1697: 1640 0001CEF5 # write32h( dbl_st_acc.l ); ! 1698: 1641 0001CEF5 dd efffffeef9 pushl _dbl_st_acc+4 ! 1699: 1642 0001CEFB fe 08 efffffeeee callf $8,_write32h ! 1700: 1643 0001CF02 # writes(", operand 2 = "); ! 1701: 1644 0001CF02 .data 1 ! 1702: 1645 00001722 * L403: ! 1703: 1646 00001722 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0" ! 1704: 03D2000 ! 1705: 1647 00001732 * .text ! 1706: 1648 0001CF02 dd 8f00001722 pushl $L403 ! 1707: 1649 0001CF08 fe 08 efffffeee1 callf $8,_writes ! 1708: 1650 0001CF0F # write32h( sgl_value_3); ! 1709: 1651 0001CF0F dd efffffeedb pushl _sgl_value_3 ! 1710: 1652 0001CF15 fe 08 efffffeed4 callf $8,_write32h ! 1711: 1653 0001CF1C # writec(' '); ! 1712: 1654 0001CF1C dd 20 pushl $32 ! 1713: 1655 0001CF1E fe 08 efffffeecb callf $8,_writec ! 1714: 1656 0001CF25 # write32h( sgl_value_4); ! 1715: 1657 0001CF25 dd efffffeec5 pushl _sgl_value_4 ! 1716: 1658 0001CF2B fe 08 efffffeebe callf $8,_write32h ! 1717: 1659 0001CF32 # writec('\n'); ! 1718: 1660 0001CF32 dd 0a pushl $10 ! 1719: 1661 0001CF34 fe 08 efffffeeb5 callf $8,_writec ! 1720: 1662 0001CF3B # writes("expected Acc = "); ! 1721: 1663 0001CF3B .data 1 ! 1722: 1664 00001732 * L404: ! 1723: 1665 00001732 * 6578706563746564204163632 .ascii "expected Acc = \0" ! 1724: 03D2000 ! 1725: 1666 00001742 * .text ! 1726: 1667 0001CF3B dd 8f00001732 pushl $L404 ! 1727: 1668 0001CF41 fe 08 efffffeea8 callf $8,_writes ! 1728: 1669 0001CF48 # write32h( dbl_expected.m ); ! 1729: 1670 0001CF48 dd efffffeea2 pushl _dbl_expected ! 1730: 1671 0001CF4E fe 08 efffffee9b callf $8,_write32h ! 1731: 1672 0001CF55 # writec(' '); ! 1732: 1673 0001CF55 dd 20 pushl $32 ! 1733: 1674 0001CF57 fe 08 efffffee92 callf $8,_writec ! 1734: 1675 0001CF5E # write32h( dbl_expected.l ); ! 1735: 1676 0001CF5E dd efffffee90 pushl _dbl_expected+4 ! 1736: 1677 0001CF64 fe 08 efffffee85 callf $8,_write32h ! 1737: 1678 0001CF6B # writec('\n'); ! 1738: 1679 0001CF6B dd 0a pushl $10 ! 1739: 1680 0001CF6D fe 08 efffffee7c callf $8,_writec ! 1740: 1681 0001CF74 # } ! 1741: 1682 0001CF74 # if ( halt_flg ) /* halt on error? */ ! 1742: 1683 0001CF74 L396: ! 1743: 1684 0001CF74 5d efffffee76 tstl _halt_flg ! 1744: 1685 0001CF7A 31 09 jeql L405 ! 1745: 1686 0001CF7C # cmpd2_er_halt( BAD_ACC_HLT ); ! 1746: 1687 0001CF7C dd 01 pushl $1 ! 1747: 1688 0001CF7E fe 08 ef000000b9 callf $8,_cmpd2_er_halt ! 1748: 1689 0001CF85 # if ( loop_on_err ) ! 1749: 1690 0001CF85 L405: ! 1750: 1691 0001CF85 5d efffffee65 tstl _loop_on_err ! 1751: 1692 0001CF8B 31 0d jeql L406 ! 1752: 1693 0001CF8D # { ! 1753: 1694 0001CF8D # force_loop = TRUE; /* set the force loop flag */ ! 1754: 1695 0001CF8D 0d 01 efffffee5c movl $1,_force_loop ! 1755: 1696 0001CF94 # asm("jmp _cmpd2_6_lp1"); /* and loop */ ! 1756: 1697 0001CF94 71 effffffe75 jmp _cmpd2_6_lp1 ! 1757: 1698 0001CF9A # }; /* end of loop-on-error */ ! 1758: 1699 0001CF9A L406: ! 1759: 1700 0001CF9A # } /* end of compare error */ ! 1760: 1701 0001CF9A # index2++; ! 1761: 1702 0001CF9A L395: ! 1762: 1703 0001CF9A 6d efffffee50 incl _index2 ! 1763: 1704 0001CFA0 # } while( (index2 < 10) && (index2 < max_ldf_1_index) ); ! 1764: 1705 0001CFA0 L390: ! 1765: 1706 0001CFA0 1d efffffee4a 0a cmpl _index2,$10 ! 1766: 1707 0001CFA7 81 10 jgeq L9994 ! 1767: 1708 0001CFA9 1d efffffee41 efffffee3c cmpl _index2,_max_ldf_1_index ! 1768: 1709 0001CFB4 81 03 13 fe01 jlss L391 ! 1769: 1710 0001CFB9 L9994: ! 1770: 1711 0001CFB9 L389: ! 1771: 1712 0001CFB9 # } while( index++ < max_cmpd_1_index ); ! 1772: 1713 0001CFB9 L387: ! 1773: 1714 0001CFB9 0d efffffee31 50 movl _index,r0 ! 1774: 1715 0001CFC0 6d efffffee2a incl _index ! 1775: 1716 0001CFC6 1d 50 efffffee23 cmpl r0,_max_cmpd_1_index ! 1776: 1717 0001CFCD 81 03 13 fd7a jlss L388 ! 1777: 1718 0001CFD2 L386: ! 1778: 1719 0001CFD2 # } /* end of subtest 6 */ ! 1779: 1720 0001CFD2 40 ret#2 ! 1780: 1721 0001CFD3 .set L382,0x0 ! 1781: 1722 0001CFD3 L384: ! 1782: 1723 0001CFD3 13 fd63 jbr L385 ! 1783: 1724 0001CFD6 .data ! 1784: 1725 00001398 * .text ! 1785: 1726 0001CFD6 .align 1 ! 1786: 1727 0001CFD6 .globl _print_cmpd2_data ! 1787: 1728 0001CFD6 _print_cmpd2_data: ! 1788: 1729 0001CFD6 0000 .word L407 ! 1789: 1730 0001CFD8 # ! 1790: 1731 0001CFD8 # ! 1791: 1732 0001CFD8 # ! 1792: 1733 0001CFD8 # /************************************************************************** ! 1793: 1734 0001CFD8 # * ! 1794: 1735 0001CFD8 # * PRINT THE DATA AND STORE RESULTS ! 1795: 1736 0001CFD8 # * ! 1796: 1737 0001CFD8 # * initial Acc = xxxxxxxx xxxxxxxx, operand 1 = xxxxxxxx xxxxxxxx ! 1797: 1738 0001CFD8 # **************************************************************************/ ! 1798: 1739 0001CFD8 # print_cmpd2_data() ! 1799: 1740 0001CFD8 # { ! 1800: 1741 0001CFD8 11 61 jbr L409 ! 1801: 1742 0001CFDA L410: ! 1802: 1743 0001CFDA # writes(" initial Acc = "); ! 1803: 1744 0001CFDA .data 1 ! 1804: 1745 00001742 * L411: ! 1805: 1746 00001742 * 20696E697469616C204163632 .ascii " initial Acc = \0" ! 1806: 03D2000 ! 1807: 1747 00001752 * .text ! 1808: 1748 0001CFDA dd 8f00001742 pushl $L411 ! 1809: 1749 0001CFE0 fe 08 efffffee09 callf $8,_writes ! 1810: 1750 0001CFE7 # write32h( dbl_ld_acc.m ); ! 1811: 1751 0001CFE7 dd efffffee03 pushl _dbl_ld_acc ! 1812: 1752 0001CFED fe 08 efffffedfc callf $8,_write32h ! 1813: 1753 0001CFF4 # writec(' '); ! 1814: 1754 0001CFF4 dd 20 pushl $32 ! 1815: 1755 0001CFF6 fe 08 efffffedf3 callf $8,_writec ! 1816: 1756 0001CFFD # write32h( dbl_ld_acc.l ); ! 1817: 1757 0001CFFD dd efffffedf1 pushl _dbl_ld_acc+4 ! 1818: 1758 0001D003 fe 08 efffffede6 callf $8,_write32h ! 1819: 1759 0001D00A # writes(", operand 1 = "); ! 1820: 1760 0001D00A .data 1 ! 1821: 1761 00001752 * L412: ! 1822: 1762 00001752 * 2C20206F706572616E6420312 .ascii ", operand 1 = \0" ! 1823: 03D2000 ! 1824: 1763 00001762 * .text ! 1825: 1764 0001D00A dd 8f00001752 pushl $L412 ! 1826: 1765 0001D010 fe 08 efffffedd9 callf $8,_writes ! 1827: 1766 0001D017 # write32h( sgl_value_1 ); ! 1828: 1767 0001D017 dd efffffedd3 pushl _sgl_value_1 ! 1829: 1768 0001D01D fe 08 efffffedcc callf $8,_write32h ! 1830: 1769 0001D024 # writec(' '); ! 1831: 1770 0001D024 dd 20 pushl $32 ! 1832: 1771 0001D026 fe 08 efffffedc3 callf $8,_writec ! 1833: 1772 0001D02D # write32h( sgl_value_2 ); ! 1834: 1773 0001D02D dd efffffedbd pushl _sgl_value_2 ! 1835: 1774 0001D033 fe 08 efffffedb6 callf $8,_write32h ! 1836: 1775 0001D03A # } ! 1837: 1776 0001D03A 40 ret#2 ! 1838: 1777 0001D03B .set L407,0x0 ! 1839: 1778 0001D03B L409: ! 1840: 1779 0001D03B 11 9d jbr L410 ! 1841: 1780 0001D03D .data ! 1842: 1781 00001398 * .text ! 1843: 1782 0001D03D 00 .align 1 ! 1844: 1783 0001D03E .globl _cmpd2_er_halt ! 1845: 1784 0001D03E _cmpd2_er_halt: ! 1846: 1785 0001D03E 0000 .word L413 ! 1847: 1786 0001D040 # ! 1848: 1787 0001D040 # ! 1849: 1788 0001D040 # ! 1850: 1789 0001D040 # /************************************************************************** ! 1851: 1790 0001D040 # * ! 1852: 1791 0001D040 # * HALT ON ERROR ROUTINE ! 1853: 1792 0001D040 # * ! 1854: 1793 0001D040 # **************************************************************************/ ! 1855: 1794 0001D040 # cmpd2_er_halt( halt_code ) ! 1856: 1795 0001D040 # int halt_code; ! 1857: 1796 0001D040 # { ! 1858: 1797 0001D040 13 0140 jbr L415 ! 1859: 1798 0001D043 L416: ! 1860: 1799 0001D043 # sgl_value_1 = dbl_value_1.m; ! 1861: 1800 0001D043 0d efffffeda7 efffffeda2 movl _dbl_value_1,_sgl_value_1 ! 1862: 1801 0001D04E # sgl_value_2 = dbl_value_1.l; ! 1863: 1802 0001D04E 0d efffffeda0 efffffed97 movl _dbl_value_1+4,_sgl_value_2 ! 1864: 1803 0001D059 # sgl_value_3 = dbl_value_2.m; ! 1865: 1804 0001D059 0d efffffed91 efffffed8c movl _dbl_value_2,_sgl_value_3 ! 1866: 1805 0001D064 # sgl_value_4 = dbl_value_2.l; ! 1867: 1806 0001D064 0d efffffed8a efffffed81 movl _dbl_value_2+4,_sgl_value_4 ! 1868: 1807 0001D06F # sgl_value_5 = dbl_ld_acc.m; ! 1869: 1808 0001D06F 0d efffffed7b efffffed76 movl _dbl_ld_acc,_sgl_value_5 ! 1870: 1809 0001D07A # sgl_value_6 = dbl_ld_acc.l; ! 1871: 1810 0001D07A 0d efffffed74 efffffed6b movl _dbl_ld_acc+4,_sgl_value_6 ! 1872: 1811 0001D085 # sgl_value_7 = dbl_st_acc.m; ! 1873: 1812 0001D085 0d efffffed65 efffffed60 movl _dbl_st_acc,_sgl_value_7 ! 1874: 1813 0001D090 # sgl_value_8 = dbl_st_acc.l; ! 1875: 1814 0001D090 0d efffffed5e efffffed55 movl _dbl_st_acc+4,_sgl_value_8 ! 1876: 1815 0001D09B # sgl_dummy1 = halt_code; /* get the error type */ ! 1877: 1816 0001D09B 0d ad04 efffffed4d movl 4(fp),_sgl_dummy1 ! 1878: 1817 0001D0A3 # asm("movl _test_no,r0"); /* r0 = test number */ ! 1879: 1818 0001D0A3 0d efffffed47 50 movl _test_no,r0 ! 1880: 1819 0001D0AA # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1881: 1820 0001D0AA 0d efffffed40 51 movl _subtest,r1 ! 1882: 1821 0001D0B1 # asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 1883: 1822 0001D0B1 0d efffffed39 52 movl _sgl_dummy1,r2 ! 1884: 1823 0001D0B8 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1885: 1824 0001D0B8 0d efffffed32 53 movl _cycle,r3 ! 1886: 1825 0001D0BF # asm("movl _sgl_value_5,r4"); /* r4 = MS acc loaded */ ! 1887: 1826 0001D0BF 0d efffffed2b 54 movl _sgl_value_5,r4 ! 1888: 1827 0001D0C6 # asm("movl _sgl_value_6,r5"); /* r5 = LS acc loaded */ ! 1889: 1828 0001D0C6 0d efffffed24 55 movl _sgl_value_6,r5 ! 1890: 1829 0001D0CD # asm("movl _sgl_value_1,r6"); /* r6 = MS operand 1 */ ! 1891: 1830 0001D0CD 0d efffffed1d 56 movl _sgl_value_1,r6 ! 1892: 1831 0001D0D4 # asm("movl _sgl_value_2,r7"); /* r7 = MS operand 1 */ ! 1893: 1832 0001D0D4 0d efffffed16 57 movl _sgl_value_2,r7 ! 1894: 1833 0001D0DB # asm("movl _sgl_value_3,r8"); /* r8 = MS operand 2 */ ! 1895: 1834 0001D0DB 0d efffffed0f 58 movl _sgl_value_3,r8 ! 1896: 1835 0001D0E2 # asm("movl _sgl_value_4,r9"); /* r9 = MS operand 2 */ ! 1897: 1836 0001D0E2 0d efffffed08 59 movl _sgl_value_4,r9 ! 1898: 1837 0001D0E9 # asm("movl _psl_val,r10"); /* r10 = actual PSL */ ! 1899: 1838 0001D0E9 0d efffffed01 5a movl _psl_val,r10 ! 1900: 1839 0001D0F0 # if( halt_code == BAD_ACC_HLT ) { ! 1901: 1840 0001D0F0 1d ad04 01 cmpl 4(fp),$1 ! 1902: 1841 0001D0F4 21 34 jneq L417 ! 1903: 1842 0001D0F6 # sgl_value_1 = dbl_expected.m; ! 1904: 1843 0001D0F6 0d efffffecf4 efffffecef movl _dbl_expected,_sgl_value_1 ! 1905: 1844 0001D101 # sgl_value_2 = dbl_expected.l; ! 1906: 1845 0001D101 0d efffffeced efffffece4 movl _dbl_expected+4,_sgl_value_2 ! 1907: 1846 0001D10C # asm("movl _sgl_value_7,r11"); /* r11 = MS stored */ ! 1908: 1847 0001D10C 0d efffffecde 5b movl _sgl_value_7,r11 ! 1909: 1848 0001D113 # asm("movl _sgl_value_8,r12"); /* r12 = LS stored */ ! 1910: 1849 0001D113 0d efffffecd7 5c movl _sgl_value_8,r12 ! 1911: 1850 0001D11A # asm("movl _sgl_value_1,r13"); /* r13 = MS expected */ ! 1912: 1851 0001D11A 0d efffffecd0 5d movl _sgl_value_1,r13 ! 1913: 1852 0001D121 # asm("movl _sgl_value_2,r14"); /* r14 = LS expected */ ! 1914: 1853 0001D121 0d efffffecc9 5e movl _sgl_value_2,r14 ! 1915: 1854 0001D128 # } else ! 1916: 1855 0001D128 11 57 jbr L418 ! 1917: 1856 0001D12A L417: ! 1918: 1857 0001D12A # if( halt_code == BAD_REG_HLT ) { ! 1919: 1858 0001D12A 1d ad04 02 cmpl 4(fp),$2 ! 1920: 1859 0001D12E 21 3d jneq L419 ! 1921: 1860 0001D130 # sgl_dummy1 = load_regs[index2]; ! 1922: 1861 0001D130 0d efffffecba 50 movl _index2,r0 ! 1923: 1862 0001D137 0d 40efffffecb2 movl _load_regs[r0],_sgl_dummy1 ! 1924: efffffecad ! 1925: 1863 0001D143 # sgl_dummy2 = store_regs[index2]; ! 1926: 1864 0001D143 0d efffffeca7 50 movl _index2,r0 ! 1927: 1865 0001D14A 0d 40efffffec9f movl _store_regs[r0],_sgl_dummy2 ! 1928: efffffec9a ! 1929: 1866 0001D156 # asm("movl _index2,r11"); /* r11 = bad register # */ ! 1930: 1867 0001D156 0d efffffec94 5b movl _index2,r11 ! 1931: 1868 0001D15D # asm("movl _sgl_dummy2,r12"); /* r12 = actual value */ ! 1932: 1869 0001D15D 0d efffffec8d 5c movl _sgl_dummy2,r12 ! 1933: 1870 0001D164 # asm("movl _sgl_dummy1,r13"); /* r13 = expected value */ ! 1934: 1871 0001D164 0d efffffec86 5d movl _sgl_dummy1,r13 ! 1935: 1872 0001D16B # } else ! 1936: 1873 0001D16B 11 14 jbr L420 ! 1937: 1874 0001D16D L419: ! 1938: 1875 0001D16D # if( halt_code == BAD_PSL_HLT ) { ! 1939: 1876 0001D16D 1d ad04 03 cmpl 4(fp),$3 ! 1940: 1877 0001D171 21 0e jneq L421 ! 1941: 1878 0001D173 # asm("movl _exp_psl,r11"); /* r11 = expected PSL */ ! 1942: 1879 0001D173 0d efffffec77 5b movl _exp_psl,r11 ! 1943: 1880 0001D17A # asm("movl _index,r12"); /* r12 = data index */ ! 1944: 1881 0001D17A 0d efffffec70 5c movl _index,r12 ! 1945: 1882 0001D181 # }; ! 1946: 1883 0001D181 L421: ! 1947: 1884 0001D181 L420: ! 1948: 1885 0001D181 L418: ! 1949: 1886 0001D181 # asm("halt"); /* HALT ... */ ! 1950: 1887 0001D181 00 halt ! 1951: 1888 0001D182 # } ! 1952: 1889 0001D182 40 ret#2 ! 1953: 1890 0001D183 .set L413,0x0 ! 1954: 1891 0001D183 L415: ! 1955: 1892 0001D183 13 febd jbr L416 ! 1956: 1893 0001D186 .data ! 1957: 1893 00038F76 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.