![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmpf.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 cmpf.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 00000c8c * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _cmpf ! 6: 6 00000000 _cmpf: ! 7: 7 000123B8 0000 .word L215 ! 8: 8 000123BA # #include "fpp_defs.h" ! 9: 9 000123BA # ! 10: 10 000123BA # ! 11: 11 000123BA # ! 12: 12 000123BA # /*************************************************************************** ! 13: 13 000123BA # * ! 14: 14 000123BA # * CMPF -COMPARE SGL ACCUMULATOR TO SGL OPERAND ! 15: 15 000123BA # * ! 16: 16 000123BA # *****************************************************************************/ ! 17: 17 000123BA # cmpf() ! 18: 18 000123BA # { ! 19: 19 000123BA 11 57 jbr L217 ! 20: 20 000123BC L218: ! 21: 21 000123BC # asm(".globl _cmpf_t"); ! 22: 22 000123BC .globl _cmpf_t ! 23: 23 000123BC # asm("_cmpf_t:"); /* entry address */ ! 24: 24 000123BC _cmpf_t: ! 25: 25 000123BC # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */ ! 26: 26 000123BC 1d effffffff6 01 cmpl _cycle,$1 ! 27: 27 000123C3 21 15 jneq L219 ! 28: 28 000123C5 5d efffffffed tstl _prt_hdrs ! 29: 29 000123CB 31 0d jeql L219 ! 30: 30 000123CD # { ! 31: 31 000123CD # writes(" CMPF"); ! 32: 32 000123CD .data 1 ! 33: 33 00000c8c * L221: ! 34: 34 00000c8c * 20434D504600 .ascii " CMPF\0" ! 35: 35 00000c92 * .text ! 36: 36 000123CD dd 8f00000c8c pushl $L221 ! 37: 37 000123D3 fe 08 efffffffde callf $8,_writes ! 38: 38 000123DA # } ! 39: 39 000123DA # cmpf_1(); /* test via registers */ ! 40: 40 000123DA L219: ! 41: 41 000123DA fe 04 ef00000035 callf $4,_cmpf_1 ! 42: 42 000123E1 # cmpf_2(); /* test via cache */ ! 43: 43 000123E1 fe 04 ef00000248 callf $4,_cmpf_2 ! 44: 44 000123E8 # cmpf_3(); /* register corruption test */ ! 45: 45 000123E8 fe 04 ef00000455 callf $4,_cmpf_3 ! 46: 46 000123EF # cmpf_4(); /* acc. corruption test */ ! 47: 47 000123EF fe 04 ef00000628 callf $4,_cmpf_4 ! 48: 48 000123F6 # if( !no_fpp_wcs ) { ! 49: 49 000123F6 5d efffffffbc tstl _no_fpp_wcs ! 50: 50 000123FC 21 0e jneq L226 ! 51: 51 000123FE # cmpf_5(); /* pipelined entry test */ ! 52: 52 000123FE fe 04 ef000007a3 callf $4,_cmpf_5 ! 53: 53 00012405 # cmpf_6(); /* pipelined exit test */ ! 54: 54 00012405 fe 04 ef000009b6 callf $4,_cmpf_6 ! 55: 55 0001240C # }; ! 56: 56 0001240C L226: ! 57: 57 0001240C # asm("jmp *return"); /* return to the test monitor */ ! 58: 58 0001240C 71 ffffffffa6 jmp *return ! 59: 59 00012412 # } ! 60: 60 00012412 40 ret#2 ! 61: 61 00012413 .set L215,0x0 ! 62: 62 00012413 L217: ! 63: 63 00012413 11 a7 jbr L218 ! 64: 64 00012415 .data ! 65: 65 00000c8c * .text ! 66: 66 00012415 00 .align 1 ! 67: 67 00012416 .globl _cmpf_1 ! 68: 68 00012416 _cmpf_1: ! 69: 69 00012416 0000 .word L229 ! 70: 70 00012418 # ! 71: 71 00012418 # ! 72: 72 00012418 # ! 73: 73 00012418 # /**************************************************************************** ! 74: 74 00012418 # * ! 75: 75 00012418 # * SUBTEST 1 - CMPF status test -register data ! 76: 76 00012418 # * ! 77: 77 00012418 # ****************************************************************************/ ! 78: 78 00012418 # cmpf_1() ! 79: 79 00012418 # { ! 80: 80 00012418 13 0212 jbr L231 ! 81: 81 0001241B L232: ! 82: 82 0001241B # force_loop = FALSE; ! 83: 83 0001241B 4d efffffff97 clrl _force_loop ! 84: 84 00012421 # subtest = 1; ! 85: 85 00012421 0d 01 efffffff90 movl $1,_subtest ! 86: 86 00012428 # index = 0; ! 87: 87 00012428 4d efffffff8a clrl _index ! 88: 88 0001242E # do ! 89: 89 0001242E L235: ! 90: 90 0001242E # { ! 91: 91 0001242E # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */ ! 92: 92 0001242E 5c 0c efffffff83 50 mull3 $12,_index,r0 ! 93: 93 00012436 0d e000000000 efffffff77 movl _cmpf_1_data(r0),_sgl_value_1 ! 94: 94 00012441 # sgl_value_2 = cmpf_1_data[index].two; ! 95: 95 00012441 5c 0c efffffff70 50 mull3 $12,_index,r0 ! 96: 96 00012449 0d e000000004 efffffff64 movl _cmpf_1_data+4(r0),_sgl_value_2 ! 97: 97 00012454 # sgl_expected = cmpf_1_data[index].flag; /* get expected results */ ! 98: 98 00012454 5c 0c efffffff5d 50 mull3 $12,_index,r0 ! 99: 99 0001245C 0d e000000008 efffffff51 movl _cmpf_1_data+8(r0),_sgl_expected ! 100: 100 00012467 # status_index = 0; /* clear the status index */ ! 101: 101 00012467 4d efffffff4b clrl _status_index ! 102: 102 0001246D # do ! 103: 103 0001246D L238: ! 104: 104 0001246D # { ! 105: 105 0001246D # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */ ! 106: 106 0001246D 0d efffffff45 50 movl _status_index,r0 ! 107: 107 00012474 0d 40efffffff3d movl _status_array[r0],_sgl_dummy1 ! 108: efffffff38 ! 109: 108 00012480 # /* ! 110: 109 00012480 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 111: 110 00012480 # * The force loop flag is set after the first error. ! 112: 111 00012480 # */ ! 113: 112 00012480 # asm("_cmpf_1_lp1:"); ! 114: 113 00012480 _cmpf_1_lp1: ! 115: 114 00012480 # asm("movl _sgl_value_1,r4"); /* move operand #1 to r4 */ ! 116: 115 00012480 0d efffffff32 54 movl _sgl_value_1,r4 ! 117: 116 00012487 # asm("movl _sgl_value_2,r5"); /* move operand #2 to r5 */ ! 118: 117 00012487 0d efffffff2b 55 movl _sgl_value_2,r5 ! 119: 118 0001248E # asm("ldf r4"); /* load the 1st operand */ ! 120: 119 0001248E 06 54 ldf r4 ! 121: 120 00012490 # asm("tstl _sgl_dummy1"); /* generate initial status */ ! 122: 121 00012490 5d efffffff22 tstl _sgl_dummy1 ! 123: 122 00012496 # asm("movpsl _init_psl"); /* save the initial status */ ! 124: 123 00012496 cd efffffff1c movpsl _init_psl ! 125: 124 0001249C # asm("cmpf r5"); /* compare the operands */ ! 126: 125 0001249C 36 55 cmpf r5 ! 127: 126 0001249E # asm("movpsl _psl_val"); /* save the final status */ ! 128: 127 0001249E cd efffffff14 movpsl _psl_val ! 129: 128 000124A4 # asm("stf _sgl_st_acc"); /* save the final acc */ ! 130: 129 000124A4 26 efffffff0e stf _sgl_st_acc ! 131: 130 000124AA # if( force_loop ) /* loop? */ ! 132: 131 000124AA 5d efffffff08 tstl _force_loop ! 133: 132 000124B0 31 02 jeql L239 ! 134: 133 000124B2 # asm("brb _cmpf_1_lp1");; /* run the loop again */ ! 135: 134 000124B2 11 cc brb _cmpf_1_lp1 ! 136: 135 000124B4 L239: ! 137: 136 000124B4 # exp_psl = init_psl; /* get the initial PSL */ ! 138: 137 000124B4 0d effffffefe effffffef9 movl _init_psl,_exp_psl ! 139: 138 000124BF # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */ ! 140: 139 000124BF ac 88f3 effffffef1 andl2 $-13,_exp_psl ! 141: 140 000124C7 # if( sgl_expected == ZERO ) ! 142: 141 000124C7 1d effffffeeb 04 cmpl _sgl_expected,$4 ! 143: 142 000124CE 21 07 jneq L240 ! 144: 143 000124D0 # exp_psl |= PSL_Z; /* expect the ZERO bit set */ ! 145: 144 000124D0 8c 04 effffffee1 orl2 $4,_exp_psl ! 146: 145 000124D7 # if( sgl_expected == NEGATIVE ) ! 147: 146 000124D7 L240: ! 148: 147 000124D7 1d effffffedb 08 cmpl _sgl_expected,$8 ! 149: 148 000124DE 21 07 jneq L241 ! 150: 149 000124E0 # exp_psl |= PSL_N; /* expect the NEG bit set */ ! 151: 150 000124E0 8c 08 effffffed1 orl2 $8,_exp_psl ! 152: 151 000124E7 # if( psl_val != exp_psl ) { /* COMPARE the values */ ! 153: 152 000124E7 L241: ! 154: 153 000124E7 1d effffffecb effffffec6 cmpl _psl_val,_exp_psl ! 155: 154 000124F2 21 03 13 0107 jeql L242 ! 156: 155 000124F7 # errcnt++; /* bump the error count */ ! 157: 156 000124F7 6d effffffebb incl _errcnt ! 158: 157 000124FD # if ( prt_error ) { ! 159: 158 000124FD 5d effffffeb5 tstl _prt_error ! 160: 159 00012503 21 03 13 00d3 jeql L243 ! 161: 160 00012508 # writes(" \n"); /* start a new print line */ ! 162: 161 00012508 .data 1 ! 163: 162 00000c92 * L244: ! 164: 163 00000c92 * 200A00 .ascii " \12\0" ! 165: 164 00000c95 * .text ! 166: 165 00012508 dd 8f00000c92 pushl $L244 ! 167: 166 0001250E fe 08 effffffea3 callf $8,_writes ! 168: 167 00012515 # writes("cycle: "); ! 169: 168 00012515 .data 1 ! 170: 169 00000c95 * L245: ! 171: 170 00000c95 * 6379636C653A2000 .ascii "cycle: \0" ! 172: 171 00000c9d * .text ! 173: 172 00012515 dd 8f00000c95 pushl $L245 ! 174: 173 0001251B fe 08 effffffe96 callf $8,_writes ! 175: 174 00012522 # writed( cycle ); ! 176: 175 00012522 dd effffffe90 pushl _cycle ! 177: 176 00012528 fe 08 effffffe89 callf $8,_writed ! 178: 177 0001252F # writes(" CMPF test "); ! 179: 178 0001252F .data 1 ! 180: 179 00000c9d * L247: ! 181: 180 00000c9d * 2020434D50462074657374200 .ascii " CMPF test \0" ! 182: 0 ! 183: 181 00000caa * .text ! 184: 182 0001252F dd 8f00000c9d pushl $L247 ! 185: 183 00012535 fe 08 effffffe7c callf $8,_writes ! 186: 184 0001253C # writed( test_no ); ! 187: 185 0001253C dd effffffe76 pushl _test_no ! 188: 186 00012542 fe 08 effffffe6f callf $8,_writed ! 189: 187 00012549 # writes(", subtest 1 (Reg. Data) - BAD FINAL PSL\n"); ! 190: 188 00012549 .data 1 ! 191: 189 00000caa * L248: ! 192: 190 00000caa * 2C20737562746573742031202 .ascii ", subtest 1 (Reg. Data) - BAD FINAL PSL\12\0" ! 193: 85265672E204461746129202D ! 194: 204241442046494E414C20505 ! 195: 34C0A00 ! 196: 191 00000cd3 * .text ! 197: 192 00012549 dd 8f00000caa pushl $L248 ! 198: 193 0001254F fe 08 effffffe62 callf $8,_writes ! 199: 194 00012556 # print_cmpf_data(); ! 200: 195 00012556 fe 04 ef000009fb callf $4,_print_cmpf_data ! 201: 196 0001255D # writes(", data index = "); ! 202: 197 0001255D .data 1 ! 203: 198 00000cd3 * L250: ! 204: 199 00000cd3 * 2C20206461746120696E64657 .ascii ", data index = \0" ! 205: 8203D2000 ! 206: 200 00000ce4 * .text ! 207: 201 0001255D dd 8f00000cd3 pushl $L250 ! 208: 202 00012563 fe 08 effffffe4e callf $8,_writes ! 209: 203 0001256A # writed( index ); ! 210: 204 0001256A dd effffffe48 pushl _index ! 211: 205 00012570 fe 08 effffffe41 callf $8,_writed ! 212: 206 00012577 # writec('\n'); ! 213: 207 00012577 dd 0a pushl $10 ! 214: 208 00012579 fe 08 effffffe38 callf $8,_writec ! 215: 209 00012580 # writes("initial PSL = "); ! 216: 210 00012580 .data 1 ! 217: 211 00000ce4 * L252: ! 218: 212 00000ce4 * 696E697469616C2050534C203 .ascii "initial PSL = \0" ! 219: D2000 ! 220: 213 00000cf3 * .text ! 221: 214 00012580 dd 8f00000ce4 pushl $L252 ! 222: 215 00012586 fe 08 effffffe2b callf $8,_writes ! 223: 216 0001258D # write32h( init_psl ); ! 224: 217 0001258D dd effffffe25 pushl _init_psl ! 225: 218 00012593 fe 08 effffffe1e callf $8,_write32h ! 226: 219 0001259A # writes(", final PSL = "); ! 227: 220 0001259A .data 1 ! 228: 221 00000cf3 * L254: ! 229: 222 00000cf3 * 2C2066696E616C2050534C203 .ascii ", final PSL = \0" ! 230: D2000 ! 231: 223 00000d02 * .text ! 232: 224 0001259A dd 8f00000cf3 pushl $L254 ! 233: 225 000125A0 fe 08 effffffe11 callf $8,_writes ! 234: 226 000125A7 # write32h( psl_val ); ! 235: 227 000125A7 dd effffffe0b pushl _psl_val ! 236: 228 000125AD fe 08 effffffe04 callf $8,_write32h ! 237: 229 000125B4 # writes(", expected PSL = "); ! 238: 230 000125B4 .data 1 ! 239: 231 00000d02 * L255: ! 240: 232 00000d02 * 2C20657870656374656420505 .ascii ", expected PSL = \0" ! 241: 34C203D2000 ! 242: 233 00000d14 * .text ! 243: 234 000125B4 dd 8f00000d02 pushl $L255 ! 244: 235 000125BA fe 08 effffffdf7 callf $8,_writes ! 245: 236 000125C1 # write32h( exp_psl ); ! 246: 237 000125C1 dd effffffdf1 pushl _exp_psl ! 247: 238 000125C7 fe 08 effffffdea callf $8,_write32h ! 248: 239 000125CE # writes("\n"); ! 249: 240 000125CE .data 1 ! 250: 241 00000d14 * L256: ! 251: 242 00000d14 * 0A00 .ascii "\12\0" ! 252: 243 00000d16 * .text ! 253: 244 000125CE dd 8f00000d14 pushl $L256 ! 254: 245 000125D4 fe 08 effffffddd callf $8,_writes ! 255: 246 000125DB # } ! 256: 247 000125DB # if ( halt_flg ) ! 257: 248 000125DB L243: ! 258: 249 000125DB 5d effffffdd7 tstl _halt_flg ! 259: 250 000125E1 31 09 jeql L257 ! 260: 251 000125E3 # cmpf_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 261: 252 000125E3 dd 03 pushl $3 ! 262: 253 000125E5 fe 08 ef000009a8 callf $8,_cmpf_er_halt ! 263: 254 000125EC # if ( loop_on_err ) { ! 264: 255 000125EC L257: ! 265: 256 000125EC 5d effffffdc6 tstl _loop_on_err ! 266: 257 000125F2 31 0a jeql L259 ! 267: 258 000125F4 # force_loop = TRUE; /* set the force loop flag */ ! 268: 259 000125F4 0d 01 effffffdbd movl $1,_force_loop ! 269: 260 000125FB # asm("brw _cmpf_1_lp1"); /* and loop on the error */ ! 270: 261 000125FB 13 fe82 brw _cmpf_1_lp1 ! 271: 262 000125FE # } /* end of loop on error */ ! 272: 263 000125FE # } /* end of compare error */ ! 273: 264 000125FE L259: ! 274: 265 000125FE # } while ( ++status_index < 3 ); /* end of PSL WHILE loop */ ! 275: 266 000125FE L242: ! 276: 267 000125FE L237: ! 277: 268 000125FE 6d effffffdb4 incl _status_index ! 278: 269 00012604 0d effffffdae 50 movl _status_index,r0 ! 279: 270 0001260B 1d 50 03 cmpl r0,$3 ! 280: 271 0001260E 81 03 13 fe5a jlss L238 ! 281: 272 00012613 L236: ! 282: 273 00012613 # } while( index++ < max_cmpf_1_index);/* end of data loop */ ! 283: 274 00012613 L234: ! 284: 275 00012613 0d effffffd9f 50 movl _index,r0 ! 285: 276 0001261A 6d effffffd98 incl _index ! 286: 277 00012620 1d 50 effffffd91 cmpl r0,_max_cmpf_1_index ! 287: 278 00012627 81 03 13 fe02 jlss L235 ! 288: 279 0001262C L233: ! 289: 280 0001262C # } /* end of subtest 1 */ ! 290: 281 0001262C 40 ret#2 ! 291: 282 0001262D .set L229,0x0 ! 292: 283 0001262D L231: ! 293: 284 0001262D 13 fdeb jbr L232 ! 294: 285 00012630 .data ! 295: 286 00000c8c * .text ! 296: 287 00012630 .align 1 ! 297: 288 00012630 .globl _cmpf_2 ! 298: 289 00012630 _cmpf_2: ! 299: 290 00012630 0000 .word L260 ! 300: 291 00012632 # ! 301: 292 00012632 # ! 302: 293 00012632 # ! 303: 294 00012632 # /**************************************************************************** ! 304: 295 00012632 # * ! 305: 296 00012632 # * SUBTEST 2 - CMPF status test -cache data ! 306: 297 00012632 # * ! 307: 298 00012632 # ****************************************************************************/ ! 308: 299 00012632 # cmpf_2() ! 309: 300 00012632 # { ! 310: 301 00012632 13 020c jbr L262 ! 311: 302 00012635 L263: ! 312: 303 00012635 # force_loop = FALSE; ! 313: 304 00012635 4d effffffd7d clrl _force_loop ! 314: 305 0001263B # subtest = 2; ! 315: 306 0001263B 0d 02 effffffd76 movl $2,_subtest ! 316: 307 00012642 # index = 0; ! 317: 308 00012642 4d effffffd70 clrl _index ! 318: 309 00012648 # do ! 319: 310 00012648 L266: ! 320: 311 00012648 # { ! 321: 312 00012648 # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */ ! 322: 313 00012648 5c 0c effffffd69 50 mull3 $12,_index,r0 ! 323: 314 00012650 0d e000000000 effffffd5d movl _cmpf_1_data(r0),_sgl_value_1 ! 324: 315 0001265B # sgl_value_2 = cmpf_1_data[index].two; ! 325: 316 0001265B 5c 0c effffffd56 50 mull3 $12,_index,r0 ! 326: 317 00012663 0d e000000004 effffffd4a movl _cmpf_1_data+4(r0),_sgl_value_2 ! 327: 318 0001266E # sgl_expected = cmpf_1_data[index].flag;/* get expected results */ ! 328: 319 0001266E 5c 0c effffffd43 50 mull3 $12,_index,r0 ! 329: 320 00012676 0d e000000008 effffffd37 movl _cmpf_1_data+8(r0),_sgl_expected ! 330: 321 00012681 # status_index = 0; /* clear the status index */ ! 331: 322 00012681 4d effffffd31 clrl _status_index ! 332: 323 00012687 # do ! 333: 324 00012687 L269: ! 334: 325 00012687 # { ! 335: 326 00012687 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */ ! 336: 327 00012687 0d effffffd2b 50 movl _status_index,r0 ! 337: 328 0001268E 0d 40effffffd23 movl _status_array[r0],_sgl_dummy1 ! 338: effffffd1e ! 339: 329 0001269A # /* ! 340: 330 0001269A # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 341: 331 0001269A # * The force loop flag is set after the first error. ! 342: 332 0001269A # */ ! 343: 333 0001269A # asm("_cmpf_2_lp1:"); ! 344: 334 0001269A _cmpf_2_lp1: ! 345: 335 0001269A # asm("ldf _sgl_value_1"); /* load the 1st operand */ ! 346: 336 0001269A 06 effffffd18 ldf _sgl_value_1 ! 347: 337 000126A0 # asm("tstl _sgl_dummy1"); /* generate initial status */ ! 348: 338 000126A0 5d effffffd12 tstl _sgl_dummy1 ! 349: 339 000126A6 # asm("movpsl _init_psl"); /* save the initial status */ ! 350: 340 000126A6 cd effffffd0c movpsl _init_psl ! 351: 341 000126AC # asm("cmpf _sgl_value_2"); /* compare the operands */ ! 352: 342 000126AC 36 effffffd06 cmpf _sgl_value_2 ! 353: 343 000126B2 # asm("movpsl _psl_val"); /* save the final status */ ! 354: 344 000126B2 cd effffffd00 movpsl _psl_val ! 355: 345 000126B8 # asm("stf _sgl_st_acc"); /* save the final acc */ ! 356: 346 000126B8 26 effffffcfa stf _sgl_st_acc ! 357: 347 000126BE # if( force_loop ) /* loop? */ ! 358: 348 000126BE 5d effffffcf4 tstl _force_loop ! 359: 349 000126C4 31 02 jeql L270 ! 360: 350 000126C6 # asm("brb _cmpf_2_lp1");; /* run the loop again */ ! 361: 351 000126C6 11 d2 brb _cmpf_2_lp1 ! 362: 352 000126C8 L270: ! 363: 353 000126C8 # exp_psl = init_psl; /* get the initial PSL */ ! 364: 354 000126C8 0d effffffcea effffffce5 movl _init_psl,_exp_psl ! 365: 355 000126D3 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */ ! 366: 356 000126D3 ac 88f3 effffffcdd andl2 $-13,_exp_psl ! 367: 357 000126DB # if( sgl_expected == ZERO ) ! 368: 358 000126DB 1d effffffcd7 04 cmpl _sgl_expected,$4 ! 369: 359 000126E2 21 07 jneq L271 ! 370: 360 000126E4 # exp_psl |= PSL_Z; /* expect the ZERO bit set */ ! 371: 361 000126E4 8c 04 effffffccd orl2 $4,_exp_psl ! 372: 362 000126EB # if( sgl_expected == NEGATIVE ) ! 373: 363 000126EB L271: ! 374: 364 000126EB 1d effffffcc7 08 cmpl _sgl_expected,$8 ! 375: 365 000126F2 21 07 jneq L272 ! 376: 366 000126F4 # exp_psl |= PSL_N; /* expect the NEG bit set */ ! 377: 367 000126F4 8c 08 effffffcbd orl2 $8,_exp_psl ! 378: 368 000126FB # if( psl_val != exp_psl ) { /* COMPARE the values */ ! 379: 369 000126FB L272: ! 380: 370 000126FB 1d effffffcb7 effffffcb2 cmpl _psl_val,_exp_psl ! 381: 371 00012706 21 03 13 0107 jeql L273 ! 382: 372 0001270B # errcnt++; /* bump the error count */ ! 383: 373 0001270B 6d effffffca7 incl _errcnt ! 384: 374 00012711 # if ( prt_error ) { ! 385: 375 00012711 5d effffffca1 tstl _prt_error ! 386: 376 00012717 21 03 13 00d3 jeql L274 ! 387: 377 0001271C # writes(" \n"); /* start a new print line */ ! 388: 378 0001271C .data 1 ! 389: 379 00000d16 * L275: ! 390: 380 00000d16 * 200A00 .ascii " \12\0" ! 391: 381 00000d19 * .text ! 392: 382 0001271C dd 8f00000d16 pushl $L275 ! 393: 383 00012722 fe 08 effffffc8f callf $8,_writes ! 394: 384 00012729 # writes("cycle: "); ! 395: 385 00012729 .data 1 ! 396: 386 00000d19 * L276: ! 397: 387 00000d19 * 6379636C653A2000 .ascii "cycle: \0" ! 398: 388 00000d21 * .text ! 399: 389 00012729 dd 8f00000d19 pushl $L276 ! 400: 390 0001272F fe 08 effffffc82 callf $8,_writes ! 401: 391 00012736 # writed( cycle ); ! 402: 392 00012736 dd effffffc7c pushl _cycle ! 403: 393 0001273C fe 08 effffffc75 callf $8,_writed ! 404: 394 00012743 # writes(" CMPF test "); ! 405: 395 00012743 .data 1 ! 406: 396 00000d21 * L277: ! 407: 397 00000d21 * 2020434D50462074657374200 .ascii " CMPF test \0" ! 408: 0 ! 409: 398 00000d2e * .text ! 410: 399 00012743 dd 8f00000d21 pushl $L277 ! 411: 400 00012749 fe 08 effffffc68 callf $8,_writes ! 412: 401 00012750 # writed( test_no ); ! 413: 402 00012750 dd effffffc62 pushl _test_no ! 414: 403 00012756 fe 08 effffffc5b callf $8,_writed ! 415: 404 0001275D # writes(", subtest 2 (Cache Data) - BAD FINAL PSL\n"); ! 416: 405 0001275D .data 1 ! 417: 406 00000d2e * L278: ! 418: 407 00000d2e * 2C20737562746573742032202 .ascii ", subtest 2 (Cache Data) - BAD FINAL PSL\12\0" ! 419: 8436163686520446174612920 ! 420: 2D204241442046494E414C205 ! 421: 0534C0A00 ! 422: 408 00000d58 * .text ! 423: 409 0001275D dd 8f00000d2e pushl $L278 ! 424: 410 00012763 fe 08 effffffc4e callf $8,_writes ! 425: 411 0001276A # print_cmpf_data(); ! 426: 412 0001276A fe 04 ef000007e7 callf $4,_print_cmpf_data ! 427: 413 00012771 # writes(", data index = "); ! 428: 414 00012771 .data 1 ! 429: 415 00000d58 * L279: ! 430: 416 00000d58 * 2C20206461746120696E64657 .ascii ", data index = \0" ! 431: 8203D2000 ! 432: 417 00000d69 * .text ! 433: 418 00012771 dd 8f00000d58 pushl $L279 ! 434: 419 00012777 fe 08 effffffc3a callf $8,_writes ! 435: 420 0001277E # writed( index ); ! 436: 421 0001277E dd effffffc34 pushl _index ! 437: 422 00012784 fe 08 effffffc2d callf $8,_writed ! 438: 423 0001278B # writec('\n'); ! 439: 424 0001278B dd 0a pushl $10 ! 440: 425 0001278D fe 08 effffffc24 callf $8,_writec ! 441: 426 00012794 # writes("initial PSL = "); ! 442: 427 00012794 .data 1 ! 443: 428 00000d69 * L280: ! 444: 429 00000d69 * 696E697469616C2050534C203 .ascii "initial PSL = \0" ! 445: D2000 ! 446: 430 00000d78 * .text ! 447: 431 00012794 dd 8f00000d69 pushl $L280 ! 448: 432 0001279A fe 08 effffffc17 callf $8,_writes ! 449: 433 000127A1 # write32h( init_psl ); ! 450: 434 000127A1 dd effffffc11 pushl _init_psl ! 451: 435 000127A7 fe 08 effffffc0a callf $8,_write32h ! 452: 436 000127AE # writes(", final PSL = "); ! 453: 437 000127AE .data 1 ! 454: 438 00000d78 * L281: ! 455: 439 00000d78 * 2C2066696E616C2050534C203 .ascii ", final PSL = \0" ! 456: D2000 ! 457: 440 00000d87 * .text ! 458: 441 000127AE dd 8f00000d78 pushl $L281 ! 459: 442 000127B4 fe 08 effffffbfd callf $8,_writes ! 460: 443 000127BB # write32h( psl_val ); ! 461: 444 000127BB dd effffffbf7 pushl _psl_val ! 462: 445 000127C1 fe 08 effffffbf0 callf $8,_write32h ! 463: 446 000127C8 # writes(", expected PSL = "); ! 464: 447 000127C8 .data 1 ! 465: 448 00000d87 * L282: ! 466: 449 00000d87 * 2C20657870656374656420505 .ascii ", expected PSL = \0" ! 467: 34C203D2000 ! 468: 450 00000d99 * .text ! 469: 451 000127C8 dd 8f00000d87 pushl $L282 ! 470: 452 000127CE fe 08 effffffbe3 callf $8,_writes ! 471: 453 000127D5 # write32h( exp_psl ); ! 472: 454 000127D5 dd effffffbdd pushl _exp_psl ! 473: 455 000127DB fe 08 effffffbd6 callf $8,_write32h ! 474: 456 000127E2 # writes("\n"); ! 475: 457 000127E2 .data 1 ! 476: 458 00000d99 * L283: ! 477: 459 00000d99 * 0A00 .ascii "\12\0" ! 478: 460 00000d9b * .text ! 479: 461 000127E2 dd 8f00000d99 pushl $L283 ! 480: 462 000127E8 fe 08 effffffbc9 callf $8,_writes ! 481: 463 000127EF # } ! 482: 464 000127EF # if ( halt_flg ) ! 483: 465 000127EF L274: ! 484: 466 000127EF 5d effffffbc3 tstl _halt_flg ! 485: 467 000127F5 31 09 jeql L284 ! 486: 468 000127F7 # cmpf_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 487: 469 000127F7 dd 03 pushl $3 ! 488: 470 000127F9 fe 08 ef00000794 callf $8,_cmpf_er_halt ! 489: 471 00012800 # if ( loop_on_err ) { ! 490: 472 00012800 L284: ! 491: 473 00012800 5d effffffbb2 tstl _loop_on_err ! 492: 474 00012806 31 0a jeql L285 ! 493: 475 00012808 # force_loop = TRUE; /* set the force loop flag */ ! 494: 476 00012808 0d 01 effffffba9 movl $1,_force_loop ! 495: 477 0001280F # asm("brw _cmpf_2_lp1"); /* and loop on the error */ ! 496: 478 0001280F 13 fe88 brw _cmpf_2_lp1 ! 497: 479 00012812 # } /* end of loop on error */ ! 498: 480 00012812 # } /* end of compare error */ ! 499: 481 00012812 L285: ! 500: 482 00012812 # } while ( ++status_index < 3 ); /* end of PSL WHILE loop */ ! 501: 483 00012812 L273: ! 502: 484 00012812 L268: ! 503: 485 00012812 6d effffffba0 incl _status_index ! 504: 486 00012818 0d effffffb9a 50 movl _status_index,r0 ! 505: 487 0001281F 1d 50 03 cmpl r0,$3 ! 506: 488 00012822 81 03 13 fe60 jlss L269 ! 507: 489 00012827 L267: ! 508: 490 00012827 # } while( index++ < max_cmpf_1_index);/* end of data loop */ ! 509: 491 00012827 L265: ! 510: 492 00012827 0d effffffb8b 50 movl _index,r0 ! 511: 493 0001282E 6d effffffb84 incl _index ! 512: 494 00012834 1d 50 effffffb7d cmpl r0,_max_cmpf_1_index ! 513: 495 0001283B 81 03 13 fe08 jlss L266 ! 514: 496 00012840 L264: ! 515: 497 00012840 # } /* end of subtest 2 */ ! 516: 498 00012840 40 ret#2 ! 517: 499 00012841 .set L260,0x0 ! 518: 500 00012841 L262: ! 519: 501 00012841 13 fdf1 jbr L263 ! 520: 502 00012844 .data ! 521: 503 00000c8c * .text ! 522: 504 00012844 .align 1 ! 523: 505 00012844 .globl _cmpf_3 ! 524: 506 00012844 _cmpf_3: ! 525: 507 00012844 0000 .word L286 ! 526: 508 00012846 # ! 527: 509 00012846 # ! 528: 510 00012846 # ! 529: 511 00012846 # /************************************************************************ ! 530: 512 00012846 # * ! 531: 513 00012846 # * SUBTEST 3 - Check for register corruption ! 532: 514 00012846 # * ! 533: 515 00012846 # ************************************************************************/ ! 534: 516 00012846 # cmpf_3() ! 535: 517 00012846 # { ! 536: 518 00012846 13 01d2 jbr L288 ! 537: 519 00012849 L289: ! 538: 520 00012849 # force_loop = FALSE; /* clear force_loop flg */ ! 539: 521 00012849 4d effffffb69 clrl _force_loop ! 540: 522 0001284F # subtest = 3; ! 541: 523 0001284F 0d 03 effffffb62 movl $3,_subtest ! 542: 524 00012856 # fill_reg_buf( load_regs ); /* get pattern for regs */ ! 543: 525 00012856 dd 8f00000000 pushl $_load_regs ! 544: 526 0001285C fe 08 effffffb55 callf $8,_fill_reg_buf ! 545: 527 00012863 # index = 0; ! 546: 528 00012863 4d effffffb4f clrl _index ! 547: 529 00012869 # do ! 548: 530 00012869 L293: ! 549: 531 00012869 # { ! 550: 532 00012869 # sgl_value_1 = cmpf_1_data[index].one; /* data to load */ ! 551: 533 00012869 5c 0c effffffb48 50 mull3 $12,_index,r0 ! 552: 534 00012871 0d e000000000 effffffb3c movl _cmpf_1_data(r0),_sgl_value_1 ! 553: 535 0001287C # sgl_value_2 = cmpf_1_data[index].two; /* data to compare */ ! 554: 536 0001287C 5c 0c effffffb35 50 mull3 $12,_index,r0 ! 555: 537 00012884 0d e000000004 effffffb29 movl _cmpf_1_data+4(r0),_sgl_value_2 ! 556: 538 0001288F # /* ! 557: 539 0001288F # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 558: 540 0001288F # * The force loop flag is set after the first error. ! 559: 541 0001288F # */ ! 560: 542 0001288F # asm("_cmpf_3_lp1:"); ! 561: 543 0001288F _cmpf_3_lp1: ! 562: 544 0001288F # asm("ldf _sgl_value_1"); /* LOAD the accumulator */ ! 563: 545 0001288F 06 effffffb23 ldf _sgl_value_1 ! 564: 546 00012895 # asm("nop"); ! 565: 547 00012895 10 nop ! 566: 548 00012896 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */ ! 567: 549 00012896 ab 891fff effffffb19 loadr $0x1fff,_load_regs ! 568: 550 0001289F # asm("nop"); ! 569: 551 0001289F 10 nop ! 570: 552 000128A0 # asm("cmpf _sgl_value_2"); /* test the values */ ! 571: 553 000128A0 36 effffffb12 cmpf _sgl_value_2 ! 572: 554 000128A6 # asm("nop"); ! 573: 555 000128A6 10 nop ! 574: 556 000128A7 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 575: 557 000128A7 bb 891fff effffffb08 storer $0x1fff,_store_regs ! 576: 558 000128B0 # asm("stf _sgl_st_acc"); /* save the final acc */ ! 577: 559 000128B0 26 effffffb02 stf _sgl_st_acc ! 578: 560 000128B6 # if( force_loop ) /* loop? */ ! 579: 561 000128B6 5d effffffafc tstl _force_loop ! 580: 562 000128BC 31 02 jeql L294 ! 581: 563 000128BE # asm("brb _cmpf_3_lp1");; /* run the loop again */ ! 582: 564 000128BE 11 cf brb _cmpf_3_lp1 ! 583: 565 000128C0 L294: ! 584: 566 000128C0 # /* ! 585: 567 000128C0 # * Now compare the stored register values to those that were loaded ! 586: 568 000128C0 # */ ! 587: 569 000128C0 # index2 = 0; ! 588: 570 000128C0 4d effffffaf2 clrl _index2 ! 589: 571 000128C6 # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) ) ! 590: 572 000128C6 L295: ! 591: 573 000128C6 0d effffffaec 50 movl _index2,r0 ! 592: 574 000128CD 0d effffffae5 51 movl _index2,r1 ! 593: 575 000128D4 1d 40effffffadd cmpl _load_regs[r0],_store_regs[r1] ! 594: 41effffffad7 ! 595: 576 000128E1 21 11 jneq L296 ! 596: 577 000128E3 1d effffffacf 0d cmpl _index2,$13 ! 597: 578 000128EA 81 08 jgeq L296 ! 598: 579 000128EC # index2++; /* check reg values */ ! 599: 580 000128EC 6d effffffac6 incl _index2 ! 600: 581 000128F2 11 d2 jbr L295 ! 601: 582 000128F4 L296: ! 602: 583 000128F4 # if( index2 < 13 ) { /* error if index2 < 13 */ ! 603: 584 000128F4 1d effffffabe 0d cmpl _index2,$13 ! 604: 585 000128FB 91 03 13 0101 jgeq L297 ! 605: 586 00012900 # errcnt++; /* bump the error count */ ! 606: 587 00012900 6d effffffab2 incl _errcnt ! 607: 588 00012906 # if ( prt_error ) { ! 608: 589 00012906 5d effffffaac tstl _prt_error ! 609: 590 0001290C 21 03 13 00cd jeql L298 ! 610: 591 00012911 # writes(" \n"); /* start a new print line */ ! 611: 592 00012911 .data 1 ! 612: 593 00000d9b * L299: ! 613: 594 00000d9b * 200A00 .ascii " \12\0" ! 614: 595 00000d9e * .text ! 615: 596 00012911 dd 8f00000d9b pushl $L299 ! 616: 597 00012917 fe 08 effffffa9a callf $8,_writes ! 617: 598 0001291E # writes("cycle: "); ! 618: 599 0001291E .data 1 ! 619: 600 00000d9e * L300: ! 620: 601 00000d9e * 6379636C653A2000 .ascii "cycle: \0" ! 621: 602 00000da6 * .text ! 622: 603 0001291E dd 8f00000d9e pushl $L300 ! 623: 604 00012924 fe 08 effffffa8d callf $8,_writes ! 624: 605 0001292B # writed( cycle ); ! 625: 606 0001292B dd effffffa87 pushl _cycle ! 626: 607 00012931 fe 08 effffffa80 callf $8,_writed ! 627: 608 00012938 # writes(", CMPF test "); ! 628: 609 00012938 .data 1 ! 629: 610 00000da6 * L301: ! 630: 611 00000da6 * 2C20434D50462074657374200 .ascii ", CMPF test \0" ! 631: 0 ! 632: 612 00000db3 * .text ! 633: 613 00012938 dd 8f00000da6 pushl $L301 ! 634: 614 0001293E fe 08 effffffa73 callf $8,_writes ! 635: 615 00012945 # writed( test_no ); ! 636: 616 00012945 dd effffffa6d pushl _test_no ! 637: 617 0001294B fe 08 effffffa66 callf $8,_writed ! 638: 618 00012952 # writes(", subtest 3 - A REGISTER WAS MODIFIED\n"); ! 639: 619 00012952 .data 1 ! 640: 620 00000db3 * L302: ! 641: 621 00000db3 * 2C20737562746573742033202 .ascii ", subtest 3 - A REGISTER WAS MODIFIED\12\0" ! 642: D204120524547495354455220 ! 643: 574153204D4F4449464945440 ! 644: A00 ! 645: 622 00000dda * .text ! 646: 623 00012952 dd 8f00000db3 pushl $L302 ! 647: 624 00012958 fe 08 effffffa59 callf $8,_writes ! 648: 625 0001295F # print_cmpf_data(); /* print the operands */ ! 649: 626 0001295F fe 04 ef000005f2 callf $4,_print_cmpf_data ! 650: 627 00012966 # writes("\n"); ! 651: 628 00012966 .data 1 ! 652: 629 00000dda * L303: ! 653: 630 00000dda * 0A00 .ascii "\12\0" ! 654: 631 00000ddc * .text ! 655: 632 00012966 dd 8f00000dda pushl $L303 ! 656: 633 0001296C fe 08 effffffa45 callf $8,_writes ! 657: 634 00012973 # writes("register "); /* print the information */ ! 658: 635 00012973 .data 1 ! 659: 636 00000ddc * L304: ! 660: 637 00000ddc * 72656769737465722000 .ascii "register \0" ! 661: 638 00000de6 * .text ! 662: 639 00012973 dd 8f00000ddc pushl $L304 ! 663: 640 00012979 fe 08 effffffa38 callf $8,_writes ! 664: 641 00012980 # writed( index2 ); /* about the corrupted */ ! 665: 642 00012980 dd effffffa32 pushl _index2 ! 666: 643 00012986 fe 08 effffffa2b callf $8,_writed ! 667: 644 0001298D # writes(" = "); /* register */ ! 668: 645 0001298D .data 1 ! 669: 646 00000de6 * L305: ! 670: 647 00000de6 * 203D2000 .ascii " = \0" ! 671: 648 00000dea * .text ! 672: 649 0001298D dd 8f00000de6 pushl $L305 ! 673: 650 00012993 fe 08 effffffa1e callf $8,_writes ! 674: 651 0001299A # write32h( store_regs[index2] ); ! 675: 652 0001299A 0d effffffa18 50 movl _index2,r0 ! 676: 653 000129A1 dd 40effffffa10 pushl _store_regs[r0] ! 677: 654 000129A8 fe 08 effffffa09 callf $8,_write32h ! 678: 655 000129AF # writes(", should be = "); ! 679: 656 000129AF .data 1 ! 680: 657 00000dea * L306: ! 681: 658 00000dea * 2C202073686F756C642062652 .ascii ", should be = \0" ! 682: 03D2000 ! 683: 659 00000dfa * .text ! 684: 660 000129AF dd 8f00000dea pushl $L306 ! 685: 661 000129B5 fe 08 effffff9fc callf $8,_writes ! 686: 662 000129BC # write32h( load_regs[index2] ); ! 687: 663 000129BC 0d effffff9f6 50 movl _index2,r0 ! 688: 664 000129C3 dd 40effffff9ee pushl _load_regs[r0] ! 689: 665 000129CA fe 08 effffff9e7 callf $8,_write32h ! 690: 666 000129D1 # writes("\n"); ! 691: 667 000129D1 .data 1 ! 692: 668 00000dfa * L307: ! 693: 669 00000dfa * 0A00 .ascii "\12\0" ! 694: 670 00000dfc * .text ! 695: 671 000129D1 dd 8f00000dfa pushl $L307 ! 696: 672 000129D7 fe 08 effffff9da callf $8,_writes ! 697: 673 000129DE # } ! 698: 674 000129DE # if ( halt_flg ) /* halt on error? */ ! 699: 675 000129DE L298: ! 700: 676 000129DE 5d effffff9d4 tstl _halt_flg ! 701: 677 000129E4 31 09 jeql L308 ! 702: 678 000129E6 # cmpf_er_halt( BAD_REG_HLT ); /* PC after the halt */ ! 703: 679 000129E6 dd 02 pushl $2 ! 704: 680 000129E8 fe 08 ef000005a5 callf $8,_cmpf_er_halt ! 705: 681 000129EF # if ( loop_on_err ) { ! 706: 682 000129EF L308: ! 707: 683 000129EF 5d effffff9c3 tstl _loop_on_err ! 708: 684 000129F5 31 0a jeql L309 ! 709: 685 000129F7 # force_loop = TRUE; /* set the force loop flag */ ! 710: 686 000129F7 0d 01 effffff9ba movl $1,_force_loop ! 711: 687 000129FE # asm("brw _cmpf_3_lp1"); /* and loop on the error */ ! 712: 688 000129FE 13 fe8e brw _cmpf_3_lp1 ! 713: 689 00012A01 # } /* end of loop on error */ ! 714: 690 00012A01 # } /* end of register corruption error */ ! 715: 691 00012A01 L309: ! 716: 692 00012A01 # } while( index++ < max_cmpf_1_index);/* end of data loop */ ! 717: 693 00012A01 L297: ! 718: 694 00012A01 L292: ! 719: 695 00012A01 0d effffff9b1 50 movl _index,r0 ! 720: 696 00012A08 6d effffff9aa incl _index ! 721: 697 00012A0E 1d 50 effffff9a3 cmpl r0,_max_cmpf_1_index ! 722: 698 00012A15 81 03 13 fe4f jlss L293 ! 723: 699 00012A1A L291: ! 724: 700 00012A1A # } /* end of subtest 3 */ ! 725: 701 00012A1A 40 ret#2 ! 726: 702 00012A1B .set L286,0x0 ! 727: 703 00012A1B L288: ! 728: 704 00012A1B 13 fe2b jbr L289 ! 729: 705 00012A1E .data ! 730: 706 00000c8c * .text ! 731: 707 00012A1E .align 1 ! 732: 708 00012A1E .globl _cmpf_4 ! 733: 709 00012A1E _cmpf_4: ! 734: 710 00012A1E 0000 .word L310 ! 735: 711 00012A20 # ! 736: 712 00012A20 # ! 737: 713 00012A20 # ! 738: 714 00012A20 # /************************************************************************ ! 739: 715 00012A20 # * ! 740: 716 00012A20 # * SUBTEST 4 - Check for accumulator corruption ! 741: 717 00012A20 # * ! 742: 718 00012A20 # ************************************************************************/ ! 743: 719 00012A20 # cmpf_4() ! 744: 720 00012A20 # { ! 745: 721 00012A20 13 0181 jbr L312 ! 746: 722 00012A23 L313: ! 747: 723 00012A23 # force_loop = FALSE; /* clear force_loop flg */ ! 748: 724 00012A23 4d effffff98f clrl _force_loop ! 749: 725 00012A29 # index = 0; ! 750: 726 00012A29 4d effffff989 clrl _index ! 751: 727 00012A2F # do ! 752: 728 00012A2F L316: ! 753: 729 00012A2F # { ! 754: 730 00012A2F # sgl_value_1 = cmpf_1_data[index].one; /* data to load */ ! 755: 731 00012A2F 5c 0c effffff982 50 mull3 $12,_index,r0 ! 756: 732 00012A37 0d e000000000 effffff976 movl _cmpf_1_data(r0),_sgl_value_1 ! 757: 733 00012A42 # sgl_value_2 = cmpf_1_data[index].two; ! 758: 734 00012A42 5c 0c effffff96f 50 mull3 $12,_index,r0 ! 759: 735 00012A4A 0d e000000004 effffff963 movl _cmpf_1_data+4(r0),_sgl_value_2 ! 760: 736 00012A55 # if( sgl_value_1 & 0x7f800000 ) ! 761: 737 00012A55 3d 8f7f800000 effffff958 bitl $2139095040,_sgl_value_1 ! 762: 738 00012A60 31 0d jeql L317 ! 763: 739 00012A62 # sgl_expected = sgl_value_1; /* expected = loaded */ ! 764: 740 00012A62 0d effffff950 effffff94b movl _sgl_value_1,_sgl_expected ! 765: 741 00012A6D # else ! 766: 742 00012A6D 11 06 jbr L318 ! 767: 743 00012A6F L317: ! 768: 744 00012A6F # sgl_expected = 0; /* expect a '0' stored */ ! 769: 745 00012A6F 4d effffff943 clrl _sgl_expected ! 770: 746 00012A75 L318: ! 771: 747 00012A75 # /* ! 772: 748 00012A75 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 773: 749 00012A75 # * The force loop flag is set after the first error. ! 774: 750 00012A75 # */ ! 775: 751 00012A75 # asm("_cmpf_4_lp1:"); ! 776: 752 00012A75 _cmpf_4_lp1: ! 777: 753 00012A75 # asm("ldf _sgl_value_1"); /* LOAD the accumulator */ ! 778: 754 00012A75 06 effffff93d ldf _sgl_value_1 ! 779: 755 00012A7B # asm("cmpf _sgl_value_2"); /* test the values */ ! 780: 756 00012A7B 36 effffff937 cmpf _sgl_value_2 ! 781: 757 00012A81 # asm("stf _sgl_st_acc"); /* store the accumulator */ ! 782: 758 00012A81 26 effffff931 stf _sgl_st_acc ! 783: 759 00012A87 # if( force_loop ) /* loop? */ ! 784: 760 00012A87 5d effffff92b tstl _force_loop ! 785: 761 00012A8D 31 02 jeql L319 ! 786: 762 00012A8F # asm("brb _cmpf_4_lp1");; /* run the loop again */ ! 787: 763 00012A8F 11 e4 brb _cmpf_4_lp1 ! 788: 764 00012A91 L319: ! 789: 765 00012A91 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 790: 766 00012A91 1d effffff921 effffff91c cmpl _sgl_st_acc,_sgl_expected ! 791: 767 00012A9C 21 03 13 00e9 jeql L320 ! 792: 768 00012AA1 # { ! 793: 769 00012AA1 # errcnt++; /* bump the error count */ ! 794: 770 00012AA1 6d effffff911 incl _errcnt ! 795: 771 00012AA7 # if ( prt_error ) { ! 796: 772 00012AA7 5d effffff90b tstl _prt_error ! 797: 773 00012AAD 21 03 13 00b5 jeql L321 ! 798: 774 00012AB2 # writes(" \n"); /* start a new print line */ ! 799: 775 00012AB2 .data 1 ! 800: 776 00000dfc * L322: ! 801: 777 00000dfc * 200A00 .ascii " \12\0" ! 802: 778 00000dff * .text ! 803: 779 00012AB2 dd 8f00000dfc pushl $L322 ! 804: 780 00012AB8 fe 08 effffff8f9 callf $8,_writes ! 805: 781 00012ABF # writes("cycle: "); ! 806: 782 00012ABF .data 1 ! 807: 783 00000dff * L323: ! 808: 784 00000dff * 6379636C653A2000 .ascii "cycle: \0" ! 809: 785 00000e07 * .text ! 810: 786 00012ABF dd 8f00000dff pushl $L323 ! 811: 787 00012AC5 fe 08 effffff8ec callf $8,_writes ! 812: 788 00012ACC # writed( cycle ); ! 813: 789 00012ACC dd effffff8e6 pushl _cycle ! 814: 790 00012AD2 fe 08 effffff8df callf $8,_writed ! 815: 791 00012AD9 # writes(" CMPF test "); ! 816: 792 00012AD9 .data 1 ! 817: 793 00000e07 * L324: ! 818: 794 00000e07 * 2020434D50462074657374200 .ascii " CMPF test \0" ! 819: 0 ! 820: 795 00000e14 * .text ! 821: 796 00012AD9 dd 8f00000e07 pushl $L324 ! 822: 797 00012ADF fe 08 effffff8d2 callf $8,_writes ! 823: 798 00012AE6 # writed( test_no ); ! 824: 799 00012AE6 dd effffff8cc pushl _test_no ! 825: 800 00012AEC fe 08 effffff8c5 callf $8,_writed ! 826: 801 00012AF3 # writes(", subtest 4 (Cache Data) - THE ACC WAS MODIFIED\n"); ! 827: 802 00012AF3 .data 1 ! 828: 803 00000e14 * L325: ! 829: 804 00000e14 * 2C20737562746573742034202 .ascii ", subtest 4 (Cache Data) - THE ACC WAS MODIFIED\12\0" ! 830: 8436163686520446174612920 ! 831: 2D20544845204143432057415 ! 832: 3204D4F4449464945440A00 ! 833: 805 00000e45 * .text ! 834: 806 00012AF3 dd 8f00000e14 pushl $L325 ! 835: 807 00012AF9 fe 08 effffff8b8 callf $8,_writes ! 836: 808 00012B00 # print_cmpf_data(); ! 837: 809 00012B00 fe 04 ef00000451 callf $4,_print_cmpf_data ! 838: 810 00012B07 # writes(", data index = "); ! 839: 811 00012B07 .data 1 ! 840: 812 00000e45 * L326: ! 841: 813 00000e45 * 2C20206461746120696E64657 .ascii ", data index = \0" ! 842: 8203D2000 ! 843: 814 00000e56 * .text ! 844: 815 00012B07 dd 8f00000e45 pushl $L326 ! 845: 816 00012B0D fe 08 effffff8a4 callf $8,_writes ! 846: 817 00012B14 # writed( index ); ! 847: 818 00012B14 dd effffff89e pushl _index ! 848: 819 00012B1A fe 08 effffff897 callf $8,_writed ! 849: 820 00012B21 # writec('\n'); ! 850: 821 00012B21 dd 0a pushl $10 ! 851: 822 00012B23 fe 08 effffff88e callf $8,_writec ! 852: 823 00012B2A # writes(" final Acc = "); ! 853: 824 00012B2A .data 1 ! 854: 825 00000e56 * L327: ! 855: 826 00000e56 * 202066696E616C20416363203 .ascii " final Acc = \0" ! 856: D2000 ! 857: 827 00000e65 * .text ! 858: 828 00012B2A dd 8f00000e56 pushl $L327 ! 859: 829 00012B30 fe 08 effffff881 callf $8,_writes ! 860: 830 00012B37 # write32h( sgl_st_acc ); ! 861: 831 00012B37 dd effffff87b pushl _sgl_st_acc ! 862: 832 00012B3D fe 08 effffff874 callf $8,_write32h ! 863: 833 00012B44 # writes(", Acc expected = "); ! 864: 834 00012B44 .data 1 ! 865: 835 00000e65 * L328: ! 866: 836 00000e65 * 2C20204163632065787065637 .ascii ", Acc expected = \0" ! 867: 46564203D2000 ! 868: 837 00000e78 * .text ! 869: 838 00012B44 dd 8f00000e65 pushl $L328 ! 870: 839 00012B4A fe 08 effffff867 callf $8,_writes ! 871: 840 00012B51 # write32h( sgl_expected ); ! 872: 841 00012B51 dd effffff861 pushl _sgl_expected ! 873: 842 00012B57 fe 08 effffff85a callf $8,_write32h ! 874: 843 00012B5E # writec('\n'); ! 875: 844 00012B5E dd 0a pushl $10 ! 876: 845 00012B60 fe 08 effffff851 callf $8,_writec ! 877: 846 00012B67 # } ! 878: 847 00012B67 # if ( halt_flg ) /* halt on error? */ ! 879: 848 00012B67 L321: ! 880: 849 00012B67 5d effffff84b tstl _halt_flg ! 881: 850 00012B6D 31 09 jeql L329 ! 882: 851 00012B6F # cmpf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 883: 852 00012B6F dd 01 pushl $1 ! 884: 853 00012B71 fe 08 ef0000041c callf $8,_cmpf_er_halt ! 885: 854 00012B78 # if ( loop_on_err ) { ! 886: 855 00012B78 L329: ! 887: 856 00012B78 5d effffff83a tstl _loop_on_err ! 888: 857 00012B7E 31 0a jeql L330 ! 889: 858 00012B80 # force_loop = TRUE; /* set the force loop flag */ ! 890: 859 00012B80 0d 01 effffff831 movl $1,_force_loop ! 891: 860 00012B87 # asm("brw _cmpf_4_lp1"); /* and loop on the error */ ! 892: 861 00012B87 13 feeb brw _cmpf_4_lp1 ! 893: 862 00012B8A # } /* end of loop on error */ ! 894: 863 00012B8A # } /* end of compare error */ ! 895: 864 00012B8A L330: ! 896: 865 00012B8A # } while( index++ < max_cmpf_1_index);/* end of data loop */ ! 897: 866 00012B8A L320: ! 898: 867 00012B8A L315: ! 899: 868 00012B8A 0d effffff828 50 movl _index,r0 ! 900: 869 00012B91 6d effffff821 incl _index ! 901: 870 00012B97 1d 50 effffff81a cmpl r0,_max_cmpf_1_index ! 902: 871 00012B9E 81 03 13 fe8c jlss L316 ! 903: 872 00012BA3 L314: ! 904: 873 00012BA3 # } /* end of subtest 4 */ ! 905: 874 00012BA3 40 ret#2 ! 906: 875 00012BA4 .set L310,0x0 ! 907: 876 00012BA4 L312: ! 908: 877 00012BA4 13 fe7c jbr L313 ! 909: 878 00012BA7 .data ! 910: 879 00000c8c * .text ! 911: 880 00012BA7 00 .align 1 ! 912: 881 00012BA8 .globl _cmpf_5 ! 913: 882 00012BA8 _cmpf_5: ! 914: 883 00012BA8 0000 .word L331 ! 915: 884 00012BAA # ! 916: 885 00012BAA # ! 917: 886 00012BAA # ! 918: 887 00012BAA # /**************************************************************************** ! 919: 888 00012BAA # * ! 920: 889 00012BAA # * SUBTEST 5 - CMPF status test - piped entry ! 921: 890 00012BAA # * ! 922: 891 00012BAA # ****************************************************************************/ ! 923: 892 00012BAA # cmpf_5() ! 924: 893 00012BAA # { ! 925: 894 00012BAA 13 0211 jbr L333 ! 926: 895 00012BAD L334: ! 927: 896 00012BAD # force_loop = FALSE; ! 928: 897 00012BAD 4d effffff805 clrl _force_loop ! 929: 898 00012BB3 # subtest = 5; ! 930: 899 00012BB3 0d 05 effffff7fe movl $5,_subtest ! 931: 900 00012BBA # index = 0; ! 932: 901 00012BBA 4d effffff7f8 clrl _index ! 933: 902 00012BC0 # do ! 934: 903 00012BC0 L337: ! 935: 904 00012BC0 # { ! 936: 905 00012BC0 # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */ ! 937: 906 00012BC0 5c 0c effffff7f1 50 mull3 $12,_index,r0 ! 938: 907 00012BC8 0d e000000000 effffff7e5 movl _cmpf_1_data(r0),_sgl_value_1 ! 939: 908 00012BD3 # sgl_value_2 = cmpf_1_data[index].two; ! 940: 909 00012BD3 5c 0c effffff7de 50 mull3 $12,_index,r0 ! 941: 910 00012BDB 0d e000000004 effffff7d2 movl _cmpf_1_data+4(r0),_sgl_value_2 ! 942: 911 00012BE6 # sgl_expected = cmpf_1_data[index].flag;/* get expected results */ ! 943: 912 00012BE6 5c 0c effffff7cb 50 mull3 $12,_index,r0 ! 944: 913 00012BEE 0d e000000008 effffff7bf movl _cmpf_1_data+8(r0),_sgl_expected ! 945: 914 00012BF9 # status_index = 0; /* clear the status index */ ! 946: 915 00012BF9 4d effffff7b9 clrl _status_index ! 947: 916 00012BFF # do ! 948: 917 00012BFF L340: ! 949: 918 00012BFF # { ! 950: 919 00012BFF # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */ ! 951: 920 00012BFF 0d effffff7b3 50 movl _status_index,r0 ! 952: 921 00012C06 0d 40effffff7ab movl _status_array[r0],_sgl_dummy1 ! 953: effffff7a6 ! 954: 922 00012C12 # /* ! 955: 923 00012C12 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 956: 924 00012C12 # * The force loop flag is set after the first error. ! 957: 925 00012C12 # */ ! 958: 926 00012C12 # asm("_cmpf_5_lp1:"); ! 959: 927 00012C12 _cmpf_5_lp1: ! 960: 928 00012C12 # asm("movl $0,r0"); /* clear r0 */ ! 961: 929 00012C12 0d 00 50 movl $0,r0 ! 962: 930 00012C15 # asm("ldf r0"); /* load the accumulator */ ! 963: 931 00012C15 06 50 ldf r0 ! 964: 932 00012C17 # asm("addf _sgl_value_1"); /* add the 1st operand */ ! 965: 933 00012C17 c6 effffff79b addf _sgl_value_1 ! 966: 934 00012C1D # asm("tstl _sgl_dummy1"); /* generate initial status */ ! 967: 935 00012C1D 5d effffff795 tstl _sgl_dummy1 ! 968: 936 00012C23 # asm("movpsl _init_psl"); /* save the initial status */ ! 969: 937 00012C23 cd effffff78f movpsl _init_psl ! 970: 938 00012C29 # asm("cmpf _sgl_value_2"); /* compare the operands */ ! 971: 939 00012C29 36 effffff789 cmpf _sgl_value_2 ! 972: 940 00012C2F # asm("movpsl _psl_val"); /* save the final status */ ! 973: 941 00012C2F cd effffff783 movpsl _psl_val ! 974: 942 00012C35 # asm("stf _sgl_st_acc"); /* save the final acc */ ! 975: 943 00012C35 26 effffff77d stf _sgl_st_acc ! 976: 944 00012C3B # if( force_loop ) /* loop? */ ! 977: 945 00012C3B 5d effffff777 tstl _force_loop ! 978: 946 00012C41 31 02 jeql L341 ! 979: 947 00012C43 # asm("brb _cmpf_5_lp1");; /* run the loop again */ ! 980: 948 00012C43 11 cd brb _cmpf_5_lp1 ! 981: 949 00012C45 L341: ! 982: 950 00012C45 # exp_psl = init_psl; /* get the initial PSL */ ! 983: 951 00012C45 0d effffff76d effffff768 movl _init_psl,_exp_psl ! 984: 952 00012C50 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */ ! 985: 953 00012C50 ac 88f3 effffff760 andl2 $-13,_exp_psl ! 986: 954 00012C58 # if( sgl_expected == ZERO ) ! 987: 955 00012C58 1d effffff75a 04 cmpl _sgl_expected,$4 ! 988: 956 00012C5F 21 07 jneq L342 ! 989: 957 00012C61 # exp_psl |= PSL_Z; /* expect the ZERO bit set */ ! 990: 958 00012C61 8c 04 effffff750 orl2 $4,_exp_psl ! 991: 959 00012C68 # if( sgl_expected == NEGATIVE ) ! 992: 960 00012C68 L342: ! 993: 961 00012C68 1d effffff74a 08 cmpl _sgl_expected,$8 ! 994: 962 00012C6F 21 07 jneq L343 ! 995: 963 00012C71 # exp_psl |= PSL_N; /* expect the NEG bit set */ ! 996: 964 00012C71 8c 08 effffff740 orl2 $8,_exp_psl ! 997: 965 00012C78 # if( psl_val != exp_psl ) { /* COMPARE the values */ ! 998: 966 00012C78 L343: ! 999: 967 00012C78 1d effffff73a effffff735 cmpl _psl_val,_exp_psl ! 1000: 968 00012C83 21 03 13 0107 jeql L344 ! 1001: 969 00012C88 # errcnt++; /* bump the error count */ ! 1002: 970 00012C88 6d effffff72a incl _errcnt ! 1003: 971 00012C8E # if ( prt_error ) { ! 1004: 972 00012C8E 5d effffff724 tstl _prt_error ! 1005: 973 00012C94 21 03 13 00d3 jeql L345 ! 1006: 974 00012C99 # writes(" \n"); /* start a new print line */ ! 1007: 975 00012C99 .data 1 ! 1008: 976 00000e78 * L346: ! 1009: 977 00000e78 * 200A00 .ascii " \12\0" ! 1010: 978 00000e7b * .text ! 1011: 979 00012C99 dd 8f00000e78 pushl $L346 ! 1012: 980 00012C9F fe 08 effffff712 callf $8,_writes ! 1013: 981 00012CA6 # writes("cycle: "); ! 1014: 982 00012CA6 .data 1 ! 1015: 983 00000e7b * L347: ! 1016: 984 00000e7b * 6379636C653A2000 .ascii "cycle: \0" ! 1017: 985 00000e83 * .text ! 1018: 986 00012CA6 dd 8f00000e7b pushl $L347 ! 1019: 987 00012CAC fe 08 effffff705 callf $8,_writes ! 1020: 988 00012CB3 # writed( cycle ); ! 1021: 989 00012CB3 dd effffff6ff pushl _cycle ! 1022: 990 00012CB9 fe 08 effffff6f8 callf $8,_writed ! 1023: 991 00012CC0 # writes(" CMPF test "); ! 1024: 992 00012CC0 .data 1 ! 1025: 993 00000e83 * L348: ! 1026: 994 00000e83 * 2020434D50462074657374200 .ascii " CMPF test \0" ! 1027: 0 ! 1028: 995 00000e90 * .text ! 1029: 996 00012CC0 dd 8f00000e83 pushl $L348 ! 1030: 997 00012CC6 fe 08 effffff6eb callf $8,_writes ! 1031: 998 00012CCD # writed( test_no ); ! 1032: 999 00012CCD dd effffff6e5 pushl _test_no ! 1033: 1000 00012CD3 fe 08 effffff6de callf $8,_writed ! 1034: 1001 00012CDA # writes(", subtest 5 (Piped Entry) - BAD FINAL PSL\n"); ! 1035: 1002 00012CDA .data 1 ! 1036: 1003 00000e90 * L349: ! 1037: 1004 00000e90 * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Entry) - BAD FINAL PSL\12\0" ! 1038: 8506970656420456E74727929 ! 1039: 202D204241442046494E414C2 ! 1040: 050534C0A00 ! 1041: 1005 00000ebb * .text ! 1042: 1006 00012CDA dd 8f00000e90 pushl $L349 ! 1043: 1007 00012CE0 fe 08 effffff6d1 callf $8,_writes ! 1044: 1008 00012CE7 # print_cmpf_data(); ! 1045: 1009 00012CE7 fe 04 ef0000026a callf $4,_print_cmpf_data ! 1046: 1010 00012CEE # writes(", data index = "); ! 1047: 1011 00012CEE .data 1 ! 1048: 1012 00000ebb * L350: ! 1049: 1013 00000ebb * 2C20206461746120696E64657 .ascii ", data index = \0" ! 1050: 8203D2000 ! 1051: 1014 00000ecc * .text ! 1052: 1015 00012CEE dd 8f00000ebb pushl $L350 ! 1053: 1016 00012CF4 fe 08 effffff6bd callf $8,_writes ! 1054: 1017 00012CFB # writed( index ); ! 1055: 1018 00012CFB dd effffff6b7 pushl _index ! 1056: 1019 00012D01 fe 08 effffff6b0 callf $8,_writed ! 1057: 1020 00012D08 # writec('\n'); ! 1058: 1021 00012D08 dd 0a pushl $10 ! 1059: 1022 00012D0A fe 08 effffff6a7 callf $8,_writec ! 1060: 1023 00012D11 # writes("initial PSL = "); ! 1061: 1024 00012D11 .data 1 ! 1062: 1025 00000ecc * L351: ! 1063: 1026 00000ecc * 696E697469616C2050534C203 .ascii "initial PSL = \0" ! 1064: D2000 ! 1065: 1027 00000edb * .text ! 1066: 1028 00012D11 dd 8f00000ecc pushl $L351 ! 1067: 1029 00012D17 fe 08 effffff69a callf $8,_writes ! 1068: 1030 00012D1E # write32h( init_psl ); ! 1069: 1031 00012D1E dd effffff694 pushl _init_psl ! 1070: 1032 00012D24 fe 08 effffff68d callf $8,_write32h ! 1071: 1033 00012D2B # writes(", final PSL = "); ! 1072: 1034 00012D2B .data 1 ! 1073: 1035 00000edb * L352: ! 1074: 1036 00000edb * 2C202066696E616C2050534C2 .ascii ", final PSL = \0" ! 1075: 03D2000 ! 1076: 1037 00000eeb * .text ! 1077: 1038 00012D2B dd 8f00000edb pushl $L352 ! 1078: 1039 00012D31 fe 08 effffff680 callf $8,_writes ! 1079: 1040 00012D38 # write32h( psl_val ); ! 1080: 1041 00012D38 dd effffff67a pushl _psl_val ! 1081: 1042 00012D3E fe 08 effffff673 callf $8,_write32h ! 1082: 1043 00012D45 # writes(", expected PSL = "); ! 1083: 1044 00012D45 .data 1 ! 1084: 1045 00000eeb * L353: ! 1085: 1046 00000eeb * 2C20206578706563746564205 .ascii ", expected PSL = \0" ! 1086: 0534C203D2000 ! 1087: 1047 00000efe * .text ! 1088: 1048 00012D45 dd 8f00000eeb pushl $L353 ! 1089: 1049 00012D4B fe 08 effffff666 callf $8,_writes ! 1090: 1050 00012D52 # write32h( exp_psl ); ! 1091: 1051 00012D52 dd effffff660 pushl _exp_psl ! 1092: 1052 00012D58 fe 08 effffff659 callf $8,_write32h ! 1093: 1053 00012D5F # writes("\n"); ! 1094: 1054 00012D5F .data 1 ! 1095: 1055 00000efe * L354: ! 1096: 1056 00000efe * 0A00 .ascii "\12\0" ! 1097: 1057 00000f00 * .text ! 1098: 1058 00012D5F dd 8f00000efe pushl $L354 ! 1099: 1059 00012D65 fe 08 effffff64c callf $8,_writes ! 1100: 1060 00012D6C # } ! 1101: 1061 00012D6C # if ( halt_flg ) ! 1102: 1062 00012D6C L345: ! 1103: 1063 00012D6C 5d effffff646 tstl _halt_flg ! 1104: 1064 00012D72 31 09 jeql L355 ! 1105: 1065 00012D74 # cmpf_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 1106: 1066 00012D74 dd 03 pushl $3 ! 1107: 1067 00012D76 fe 08 ef00000217 callf $8,_cmpf_er_halt ! 1108: 1068 00012D7D # if ( loop_on_err ) { ! 1109: 1069 00012D7D L355: ! 1110: 1070 00012D7D 5d effffff635 tstl _loop_on_err ! 1111: 1071 00012D83 31 0a jeql L356 ! 1112: 1072 00012D85 # force_loop = TRUE; /* set the force loop flag */ ! 1113: 1073 00012D85 0d 01 effffff62c movl $1,_force_loop ! 1114: 1074 00012D8C # asm("brw _cmpf_5_lp1"); /* and loop on the error */ ! 1115: 1075 00012D8C 13 fe83 brw _cmpf_5_lp1 ! 1116: 1076 00012D8F # } /* end of loop on error */ ! 1117: 1077 00012D8F # } /* end of compare error */ ! 1118: 1078 00012D8F L356: ! 1119: 1079 00012D8F # } while ( ++status_index < 3 ); /* end of PSL WHILE loop */ ! 1120: 1080 00012D8F L344: ! 1121: 1081 00012D8F L339: ! 1122: 1082 00012D8F 6d effffff623 incl _status_index ! 1123: 1083 00012D95 0d effffff61d 50 movl _status_index,r0 ! 1124: 1084 00012D9C 1d 50 03 cmpl r0,$3 ! 1125: 1085 00012D9F 81 03 13 fe5b jlss L340 ! 1126: 1086 00012DA4 L338: ! 1127: 1087 00012DA4 # } while( index++ < max_cmpf_1_index);/* end of data loop */ ! 1128: 1088 00012DA4 L336: ! 1129: 1089 00012DA4 0d effffff60e 50 movl _index,r0 ! 1130: 1090 00012DAB 6d effffff607 incl _index ! 1131: 1091 00012DB1 1d 50 effffff600 cmpl r0,_max_cmpf_1_index ! 1132: 1092 00012DB8 81 03 13 fe03 jlss L337 ! 1133: 1093 00012DBD L335: ! 1134: 1094 00012DBD # } /* end of subtest 5 */ ! 1135: 1095 00012DBD 40 ret#2 ! 1136: 1096 00012DBE .set L331,0x0 ! 1137: 1097 00012DBE L333: ! 1138: 1098 00012DBE 13 fdec jbr L334 ! 1139: 1099 00012DC1 .data ! 1140: 1100 00000c8c * .text ! 1141: 1101 00012DC1 00 .align 1 ! 1142: 1102 00012DC2 .globl _cmpf_6 ! 1143: 1103 00012DC2 _cmpf_6: ! 1144: 1104 00012DC2 0000 .word L357 ! 1145: 1105 00012DC4 # ! 1146: 1106 00012DC4 # ! 1147: 1107 00012DC4 # ! 1148: 1108 00012DC4 # /**************************************************************************** ! 1149: 1109 00012DC4 # * ! 1150: 1110 00012DC4 # * SUBTEST 6 - CMPF status test -piped exit ! 1151: 1111 00012DC4 # * ! 1152: 1112 00012DC4 # ****************************************************************************/ ! 1153: 1113 00012DC4 # cmpf_6() ! 1154: 1114 00012DC4 # { ! 1155: 1115 00012DC4 13 018d jbr L359 ! 1156: 1116 00012DC7 L360: ! 1157: 1117 00012DC7 # force_loop = FALSE; ! 1158: 1118 00012DC7 4d effffff5eb clrl _force_loop ! 1159: 1119 00012DCD # subtest = 2; ! 1160: 1120 00012DCD 0d 02 effffff5e4 movl $2,_subtest ! 1161: 1121 00012DD4 # index = 0; ! 1162: 1122 00012DD4 4d effffff5de clrl _index ! 1163: 1123 00012DDA # do ! 1164: 1124 00012DDA L363: ! 1165: 1125 00012DDA # { ! 1166: 1126 00012DDA # sgl_value_1 = cmpf_1_data[index].one; /* data to load */ ! 1167: 1127 00012DDA 5c 0c effffff5d7 50 mull3 $12,_index,r0 ! 1168: 1128 00012DE2 0d e000000000 effffff5cb movl _cmpf_1_data(r0),_sgl_value_1 ! 1169: 1129 00012DED # sgl_value_2 = cmpf_1_data[index].two; ! 1170: 1130 00012DED 5c 0c effffff5c4 50 mull3 $12,_index,r0 ! 1171: 1131 00012DF5 0d e000000004 effffff5b8 movl _cmpf_1_data+4(r0),_sgl_value_2 ! 1172: 1132 00012E00 # if( sgl_value_1 & 0x7f800000 ) ! 1173: 1133 00012E00 3d 8f7f800000 effffff5ad bitl $2139095040,_sgl_value_1 ! 1174: 1134 00012E0B 31 0d jeql L364 ! 1175: 1135 00012E0D # sgl_expected = sgl_value_1; /* expected = loaded */ ! 1176: 1136 00012E0D 0d effffff5a5 effffff5a0 movl _sgl_value_1,_sgl_expected ! 1177: 1137 00012E18 # else ! 1178: 1138 00012E18 11 06 jbr L365 ! 1179: 1139 00012E1A L364: ! 1180: 1140 00012E1A # sgl_expected = 0; /* expect a '0' stored */ ! 1181: 1141 00012E1A 4d effffff598 clrl _sgl_expected ! 1182: 1142 00012E20 L365: ! 1183: 1143 00012E20 # /* ! 1184: 1144 00012E20 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1185: 1145 00012E20 # * The force loop flag is set after the first error. ! 1186: 1146 00012E20 # */ ! 1187: 1147 00012E20 # asm("_cmpf_6_lp1:"); ! 1188: 1148 00012E20 _cmpf_6_lp1: ! 1189: 1149 00012E20 # asm("movl $0,r0"); /* clear r0 */ ! 1190: 1150 00012E20 0d 00 50 movl $0,r0 ! 1191: 1151 00012E23 # asm("ldf _sgl_value_1"); /* load the 1st operand */ ! 1192: 1152 00012E23 06 effffff58f ldf _sgl_value_1 ! 1193: 1153 00012E29 # asm("cmpf _sgl_value_2"); /* compare the value */ ! 1194: 1154 00012E29 36 effffff589 cmpf _sgl_value_2 ! 1195: 1155 00012E2F # asm("addf r0"); /* add a zero to the acc */ ! 1196: 1156 00012E2F c6 50 addf r0 ! 1197: 1157 00012E31 # asm("stf _sgl_st_acc"); /* save the accumulator */ ! 1198: 1158 00012E31 26 effffff581 stf _sgl_st_acc ! 1199: 1159 00012E37 # if( force_loop ) /* loop? */ ! 1200: 1160 00012E37 5d effffff57b tstl _force_loop ! 1201: 1161 00012E3D 31 02 jeql L366 ! 1202: 1162 00012E3F # asm("brb _cmpf_6_lp1");; /* run the loop again */ ! 1203: 1163 00012E3F 11 df brb _cmpf_6_lp1 ! 1204: 1164 00012E41 L366: ! 1205: 1165 00012E41 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 1206: 1166 00012E41 1d effffff571 effffff56c cmpl _sgl_st_acc,_sgl_expected ! 1207: 1167 00012E4C 21 03 13 00e9 jeql L367 ! 1208: 1168 00012E51 # errcnt++; /* bump the error count */ ! 1209: 1169 00012E51 6d effffff561 incl _errcnt ! 1210: 1170 00012E57 # if ( prt_error ) { ! 1211: 1171 00012E57 5d effffff55b tstl _prt_error ! 1212: 1172 00012E5D 21 03 13 00b5 jeql L368 ! 1213: 1173 00012E62 # writes(" \n"); /* start a new print line */ ! 1214: 1174 00012E62 .data 1 ! 1215: 1175 00000f00 * L369: ! 1216: 1176 00000f00 * 200A00 .ascii " \12\0" ! 1217: 1177 00000f03 * .text ! 1218: 1178 00012E62 dd 8f00000f00 pushl $L369 ! 1219: 1179 00012E68 fe 08 effffff549 callf $8,_writes ! 1220: 1180 00012E6F # writes("cycle: "); ! 1221: 1181 00012E6F .data 1 ! 1222: 1182 00000f03 * L370: ! 1223: 1183 00000f03 * 6379636C653A2000 .ascii "cycle: \0" ! 1224: 1184 00000f0b * .text ! 1225: 1185 00012E6F dd 8f00000f03 pushl $L370 ! 1226: 1186 00012E75 fe 08 effffff53c callf $8,_writes ! 1227: 1187 00012E7C # writed( cycle ); ! 1228: 1188 00012E7C dd effffff536 pushl _cycle ! 1229: 1189 00012E82 fe 08 effffff52f callf $8,_writed ! 1230: 1190 00012E89 # writes(" CMPF test "); ! 1231: 1191 00012E89 .data 1 ! 1232: 1192 00000f0b * L371: ! 1233: 1193 00000f0b * 2020434D50462074657374200 .ascii " CMPF test \0" ! 1234: 0 ! 1235: 1194 00000f18 * .text ! 1236: 1195 00012E89 dd 8f00000f0b pushl $L371 ! 1237: 1196 00012E8F fe 08 effffff522 callf $8,_writes ! 1238: 1197 00012E96 # writed( test_no ); ! 1239: 1198 00012E96 dd effffff51c pushl _test_no ! 1240: 1199 00012E9C fe 08 effffff515 callf $8,_writed ! 1241: 1200 00012EA3 # writes(", subtest 6 (Piped Exit) - THE ACC WAS MODIFIED\n"); ! 1242: 1201 00012EA3 .data 1 ! 1243: 1202 00000f18 * L372: ! 1244: 1203 00000f18 * 2C20737562746573742036202 .ascii ", subtest 6 (Piped Exit) - THE ACC WAS MODIFIED\12\0" ! 1245: 8506970656420457869742920 ! 1246: 2D20544845204143432057415 ! 1247: 3204D4F4449464945440A00 ! 1248: 1204 00000f49 * .text ! 1249: 1205 00012EA3 dd 8f00000f18 pushl $L372 ! 1250: 1206 00012EA9 fe 08 effffff508 callf $8,_writes ! 1251: 1207 00012EB0 # print_cmpf_data(); ! 1252: 1208 00012EB0 fe 04 ef000000a1 callf $4,_print_cmpf_data ! 1253: 1209 00012EB7 # writes(", data index = "); ! 1254: 1210 00012EB7 .data 1 ! 1255: 1211 00000f49 * L373: ! 1256: 1212 00000f49 * 2C20206461746120696E64657 .ascii ", data index = \0" ! 1257: 8203D2000 ! 1258: 1213 00000f5a * .text ! 1259: 1214 00012EB7 dd 8f00000f49 pushl $L373 ! 1260: 1215 00012EBD fe 08 effffff4f4 callf $8,_writes ! 1261: 1216 00012EC4 # writed( index ); ! 1262: 1217 00012EC4 dd effffff4ee pushl _index ! 1263: 1218 00012ECA fe 08 effffff4e7 callf $8,_writed ! 1264: 1219 00012ED1 # writec('\n'); ! 1265: 1220 00012ED1 dd 0a pushl $10 ! 1266: 1221 00012ED3 fe 08 effffff4de callf $8,_writec ! 1267: 1222 00012EDA # writes(" final Acc = "); ! 1268: 1223 00012EDA .data 1 ! 1269: 1224 00000f5a * L374: ! 1270: 1225 00000f5a * 202066696E616C20416363203 .ascii " final Acc = \0" ! 1271: D2000 ! 1272: 1226 00000f69 * .text ! 1273: 1227 00012EDA dd 8f00000f5a pushl $L374 ! 1274: 1228 00012EE0 fe 08 effffff4d1 callf $8,_writes ! 1275: 1229 00012EE7 # write32h( sgl_st_acc ); ! 1276: 1230 00012EE7 dd effffff4cb pushl _sgl_st_acc ! 1277: 1231 00012EED fe 08 effffff4c4 callf $8,_write32h ! 1278: 1232 00012EF4 # writes(", Acc expected = "); ! 1279: 1233 00012EF4 .data 1 ! 1280: 1234 00000f69 * L375: ! 1281: 1235 00000f69 * 2C20204163632065787065637 .ascii ", Acc expected = \0" ! 1282: 46564203D2000 ! 1283: 1236 00000f7c * .text ! 1284: 1237 00012EF4 dd 8f00000f69 pushl $L375 ! 1285: 1238 00012EFA fe 08 effffff4b7 callf $8,_writes ! 1286: 1239 00012F01 # write32h( sgl_expected ); ! 1287: 1240 00012F01 dd effffff4b1 pushl _sgl_expected ! 1288: 1241 00012F07 fe 08 effffff4aa callf $8,_write32h ! 1289: 1242 00012F0E # writec('\n'); ! 1290: 1243 00012F0E dd 0a pushl $10 ! 1291: 1244 00012F10 fe 08 effffff4a1 callf $8,_writec ! 1292: 1245 00012F17 # } ! 1293: 1246 00012F17 # if ( halt_flg ) ! 1294: 1247 00012F17 L368: ! 1295: 1248 00012F17 5d effffff49b tstl _halt_flg ! 1296: 1249 00012F1D 31 09 jeql L376 ! 1297: 1250 00012F1F # cmpf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 1298: 1251 00012F1F dd 01 pushl $1 ! 1299: 1252 00012F21 fe 08 ef0000006c callf $8,_cmpf_er_halt ! 1300: 1253 00012F28 # if ( loop_on_err ) { ! 1301: 1254 00012F28 L376: ! 1302: 1255 00012F28 5d effffff48a tstl _loop_on_err ! 1303: 1256 00012F2E 31 0a jeql L377 ! 1304: 1257 00012F30 # force_loop = TRUE; /* set the force loop flag */ ! 1305: 1258 00012F30 0d 01 effffff481 movl $1,_force_loop ! 1306: 1259 00012F37 # asm("brw _cmpf_6_lp1"); /* and loop on the error */ ! 1307: 1260 00012F37 13 fee6 brw _cmpf_6_lp1 ! 1308: 1261 00012F3A # } /* end of loop on error */ ! 1309: 1262 00012F3A # } /* end of compare error */ ! 1310: 1263 00012F3A L377: ! 1311: 1264 00012F3A # } while( index++ < max_cmpf_1_index); /* end of data loop */ ! 1312: 1265 00012F3A L367: ! 1313: 1266 00012F3A L362: ! 1314: 1267 00012F3A 0d effffff478 50 movl _index,r0 ! 1315: 1268 00012F41 6d effffff471 incl _index ! 1316: 1269 00012F47 1d 50 effffff46a cmpl r0,_max_cmpf_1_index ! 1317: 1270 00012F4E 81 03 13 fe87 jlss L363 ! 1318: 1271 00012F53 L361: ! 1319: 1272 00012F53 # } /* end of subtest 6 */ ! 1320: 1273 00012F53 40 ret#2 ! 1321: 1274 00012F54 .set L357,0x0 ! 1322: 1275 00012F54 L359: ! 1323: 1276 00012F54 13 fe70 jbr L360 ! 1324: 1277 00012F57 .data ! 1325: 1278 00000c8c * .text ! 1326: 1279 00012F57 00 .align 1 ! 1327: 1280 00012F58 .globl _print_cmpf_data ! 1328: 1281 00012F58 _print_cmpf_data: ! 1329: 1282 00012F58 0000 .word L378 ! 1330: 1283 00012F5A # ! 1331: 1284 00012F5A # ! 1332: 1285 00012F5A # ! 1333: 1286 00012F5A # /************************************************************************** ! 1334: 1287 00012F5A # * ! 1335: 1288 00012F5A # * PRINT THE DATA AND STORE RESULTS ! 1336: 1289 00012F5A # * ! 1337: 1290 00012F5A # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx ! 1338: 1291 00012F5A # * operand = xxxxxxxx, expected = xxxxxxxx ! 1339: 1292 00012F5A # **************************************************************************/ ! 1340: 1293 00012F5A # print_cmpf_data() ! 1341: 1294 00012F5A # { ! 1342: 1295 00012F5A 11 35 jbr L380 ! 1343: 1296 00012F5C L381: ! 1344: 1297 00012F5C # writes("initial Acc = "); ! 1345: 1298 00012F5C .data 1 ! 1346: 1299 00000f7c * L382: ! 1347: 1300 00000f7c * 696E697469616C20416363203 .ascii "initial Acc = \0" ! 1348: D2000 ! 1349: 1301 00000f8b * .text ! 1350: 1302 00012F5C dd 8f00000f7c pushl $L382 ! 1351: 1303 00012F62 fe 08 effffff44f callf $8,_writes ! 1352: 1304 00012F69 # write32h( sgl_value_1 ); ! 1353: 1305 00012F69 dd effffff449 pushl _sgl_value_1 ! 1354: 1306 00012F6F fe 08 effffff442 callf $8,_write32h ! 1355: 1307 00012F76 # writes(", operand = "); ! 1356: 1308 00012F76 .data 1 ! 1357: 1309 00000f8b * L383: ! 1358: 1310 00000f8b * 2C2020206F706572616E64203 .ascii ", operand = \0" ! 1359: D2000 ! 1360: 1311 00000f9a * .text ! 1361: 1312 00012F76 dd 8f00000f8b pushl $L383 ! 1362: 1313 00012F7C fe 08 effffff435 callf $8,_writes ! 1363: 1314 00012F83 # write32h( sgl_value_2 ); ! 1364: 1315 00012F83 dd effffff42f pushl _sgl_value_2 ! 1365: 1316 00012F89 fe 08 effffff428 callf $8,_write32h ! 1366: 1317 00012F90 # } ! 1367: 1318 00012F90 40 ret#2 ! 1368: 1319 00012F91 .set L378,0x0 ! 1369: 1320 00012F91 L380: ! 1370: 1321 00012F91 11 c9 jbr L381 ! 1371: 1322 00012F93 .data ! 1372: 1323 00000c8c * .text ! 1373: 1324 00012F93 00 .align 1 ! 1374: 1325 00012F94 .globl _cmpf_er_halt ! 1375: 1326 00012F94 _cmpf_er_halt: ! 1376: 1327 00012F94 0000 .word L384 ! 1377: 1328 00012F96 # ! 1378: 1329 00012F96 # ! 1379: 1330 00012F96 # ! 1380: 1331 00012F96 # /************************************************************************** ! 1381: 1332 00012F96 # * ! 1382: 1333 00012F96 # * HALT ON ERROR ROUTINE ! 1383: 1334 00012F96 # * ! 1384: 1335 00012F96 # **************************************************************************/ ! 1385: 1336 00012F96 # cmpf_er_halt( halt_code ) ! 1386: 1337 00012F96 # int halt_code; ! 1387: 1338 00012F96 # { ! 1388: 1339 00012F96 13 00a8 jbr L386 ! 1389: 1340 00012F99 L387: ! 1390: 1341 00012F99 # sgl_dummy1 = halt_code; /* get the error type */ ! 1391: 1342 00012F99 0d ad04 effffff417 movl 4(fp),_sgl_dummy1 ! 1392: 1343 00012FA1 # asm("movl _test_no,r0"); /* r0 = test number */ ! 1393: 1344 00012FA1 0d effffff411 50 movl _test_no,r0 ! 1394: 1345 00012FA8 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1395: 1346 00012FA8 0d effffff40a 51 movl _subtest,r1 ! 1396: 1347 00012FAF # asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 1397: 1348 00012FAF 0d effffff403 52 movl _sgl_dummy1,r2 ! 1398: 1349 00012FB6 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1399: 1350 00012FB6 0d effffff3fc 53 movl _cycle,r3 ! 1400: 1351 00012FBD # asm("movl _sgl_value_1,r4"); /* r4 = initial acc */ ! 1401: 1352 00012FBD 0d effffff3f5 54 movl _sgl_value_1,r4 ! 1402: 1353 00012FC4 # asm("movl _sgl_value_2,r5"); /* r5 = data compared */ ! 1403: 1354 00012FC4 0d effffff3ee 55 movl _sgl_value_2,r5 ! 1404: 1355 00012FCB # asm("movl _psl_val,r6"); /* r6 = final PSL */ ! 1405: 1356 00012FCB 0d effffff3e7 56 movl _psl_val,r6 ! 1406: 1357 00012FD2 # if( halt_code == BAD_ACC_HLT ) { ! 1407: 1358 00012FD2 1d ad04 01 cmpl 4(fp),$1 ! 1408: 1359 00012FD6 21 10 jneq L388 ! 1409: 1360 00012FD8 # asm("movl _sgl_st_acc,r7"); /* r7 = actual value */ ! 1410: 1361 00012FD8 0d effffff3da 57 movl _sgl_st_acc,r7 ! 1411: 1362 00012FDF # asm("movl _sgl_expected,r8"); /* r8 = expected value */ ! 1412: 1363 00012FDF 0d effffff3d3 58 movl _sgl_expected,r8 ! 1413: 1364 00012FE6 # } else ! 1414: 1365 00012FE6 11 57 jbr L389 ! 1415: 1366 00012FE8 L388: ! 1416: 1367 00012FE8 # if( halt_code == BAD_REG_HLT ) { ! 1417: 1368 00012FE8 1d ad04 02 cmpl 4(fp),$2 ! 1418: 1369 00012FEC 21 3d jneq L390 ! 1419: 1370 00012FEE # sgl_dummy1 = load_regs[index2]; ! 1420: 1371 00012FEE 0d effffff3c4 50 movl _index2,r0 ! 1421: 1372 00012FF5 0d 40effffff3bc movl _load_regs[r0],_sgl_dummy1 ! 1422: effffff3b7 ! 1423: 1373 00013001 # sgl_dummy2 = store_regs[index2]; ! 1424: 1374 00013001 0d effffff3b1 50 movl _index2,r0 ! 1425: 1375 00013008 0d 40effffff3a9 movl _store_regs[r0],_sgl_dummy2 ! 1426: effffff3a4 ! 1427: 1376 00013014 # asm("movl _index2,r7"); /* r7 = bad register # */ ! 1428: 1377 00013014 0d effffff39e 57 movl _index2,r7 ! 1429: 1378 0001301B # asm("movl _sgl_dummy2,r8"); /* r8 = actual value */ ! 1430: 1379 0001301B 0d effffff397 58 movl _sgl_dummy2,r8 ! 1431: 1380 00013022 # asm("movl _sgl_dummy1,r9"); /* r9 = expected value */ ! 1432: 1381 00013022 0d effffff390 59 movl _sgl_dummy1,r9 ! 1433: 1382 00013029 # } else ! 1434: 1383 00013029 11 14 jbr L391 ! 1435: 1384 0001302B L390: ! 1436: 1385 0001302B # if( halt_code == BAD_PSL_HLT ) { ! 1437: 1386 0001302B 1d ad04 03 cmpl 4(fp),$3 ! 1438: 1387 0001302F 21 0e jneq L392 ! 1439: 1388 00013031 # asm("movl _exp_psl,r7"); /* r7 = expected PSL */ ! 1440: 1389 00013031 0d effffff381 57 movl _exp_psl,r7 ! 1441: 1390 00013038 # asm("movl _index,r7"); /* r8 = data index */ ! 1442: 1391 00013038 0d effffff37a 57 movl _index,r7 ! 1443: 1392 0001303F # }; ! 1444: 1393 0001303F L392: ! 1445: 1394 0001303F L391: ! 1446: 1395 0001303F L389: ! 1447: 1396 0001303F # asm("halt"); /* HALT ... */ ! 1448: 1397 0001303F 00 halt ! 1449: 1398 00013040 # } ! 1450: 1399 00013040 40 ret#2 ! 1451: 1400 00013041 .set L384,0x0 ! 1452: 1401 00013041 L386: ! 1453: 1402 00013041 13 ff55 jbr L387 ! 1454: 1403 00000c8c * .data ! 1455: 1403 00000c8c * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.