![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mulf.c 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 mulf.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 ! root 1: ! 2: #include "fpp_defs.h" ! 3: ! 4: ! 5: /***************************************************************************** ! 6: * ! 7: * MULF - SINGLE PRECISION FLOATING POINT ADD TEST ! 8: * ! 9: *****************************************************************************/ ! 10: mulf() ! 11: { ! 12: asm(".globl _mulf_t"); ! 13: asm("_mulf_t:"); /* entry address */ ! 14: if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */ ! 15: writes(" MULF"); ! 16: mulf_1(); /* multiply through a register*/ ! 17: mulf_2(); /* multiply through the cache */ ! 18: mulf_3(); /* wait 3 NOPs */ ! 19: mulf_4(); /* wait 2 NOPs */ ! 20: mulf_5(); /* wait 1 NOP before storing */ ! 21: mulf_6(); /* register stability test */ ! 22: mulf_7(); /* PSL stability test */ ! 23: mulf_8(); /* pipelined entry test */ ! 24: mulf_9(); /* pipelined exit test */ ! 25: asm("jmp *return"); /* return to the test monitor */ ! 26: } ! 27: ! 28: ! 29: ! 30: /************************************************************************ ! 31: * ! 32: * SUBTEST 1 - multiply through a register ! 33: * ! 34: ************************************************************************/ ! 35: mulf_1() ! 36: { ! 37: force_loop = FALSE; ! 38: subtest = 1; ! 39: for( index = 0; index < max_mulf_1_index; index++ ) { ! 40: sgl_ld_acc = mulf_1_data[index].op_1; /* get operand 1 */ ! 41: sgl_value_1 = mulf_1_data[index].op_2; /* get operand 2 */ ! 42: sgl_expected = mulf_1_data[index].exp; /* get expected result */ ! 43: /* ! 44: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 45: * The force loop flag is set after the first error. ! 46: */ ! 47: asm("_mulf_1_lp1:"); ! 48: asm("movl _sgl_ld_acc,r3"); /* move the 1st data to r3 */ ! 49: asm("movl _sgl_value_1,r4"); /* move the 2nd data to r4 */ ! 50: asm("ldf r3"); /* load the 1st operand */ ! 51: asm("mulf r4"); /* mul the 2nd operand */ ! 52: asm("stf _sgl_st_acc"); /* store the result */ ! 53: if( force_loop ) ! 54: asm("brb _mulf_1_lp1");; /* loop on the error */ ! 55: /* ! 56: * end error loop - test the results ! 57: */ ! 58: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 59: errcnt++; /* bump the error count */ ! 60: if( prt_error ) { ! 61: writes(" \n"); /* start a new print line */ ! 62: writes("cycle: "); ! 63: writed( cycle ); ! 64: writes(" MULF test "); ! 65: writed( test_no ); ! 66: writes(", subtest 1 (Reg. Data) - BAD FINAL ACC\n"); ! 67: print_mulf_data(); ! 68: } ! 69: if( halt_flg ) ! 70: mulf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 71: if( loop_on_err ) { ! 72: force_loop = TRUE; /* set the force loop flag */ ! 73: asm("brw _mulf_1_lp1");; /* and loop on the error */ ! 74: } /* end of loop on error */ ! 75: } /* end of compare error */ ! 76: } /* end of WHILE loop */ ! 77: } /* end of subtest 1 */ ! 78: ! 79: ! 80: ! 81: /************************************************************************ ! 82: * ! 83: * SUBTEST 2 - multiply through memory ! 84: * ! 85: ************************************************************************/ ! 86: mulf_2() ! 87: { ! 88: force_loop = FALSE; ! 89: subtest = 2; ! 90: for( index = 0; index < max_mulf_1_index; index++ ) { ! 91: sgl_ld_acc = mulf_1_data[index].op_1; /* get operand 1 */ ! 92: sgl_value_1 = mulf_1_data[index].op_2; /* get operand 2 */ ! 93: sgl_expected = mulf_1_data[index].exp; /* get expected result */ ! 94: /* ! 95: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 96: * The force loop flag is set after the first error. ! 97: */ ! 98: asm("_mulf_2_lp1:"); ! 99: asm("ldf _sgl_ld_acc"); /* load the 1st operand */ ! 100: asm("mulf _sgl_value_1"); /* mul the 2nd operand */ ! 101: asm("stf _sgl_st_acc"); /* store the result */ ! 102: if( force_loop ) ! 103: asm("brb _mulf_2_lp1");; /* loop on the error */ ! 104: /* ! 105: * end error loop - test the results ! 106: */ ! 107: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 108: errcnt++; /* bump the error count */ ! 109: if( prt_error ) { ! 110: writes(" \n"); /* start a new print line */ ! 111: writes("cycle: "); ! 112: writed( cycle ); ! 113: writes(" MULF test "); ! 114: writed( test_no ); ! 115: writes(", subtest 2 (Cache Data) - BAD FINAL ACC\n"); ! 116: print_mulf_data(); ! 117: } ! 118: if( halt_flg ) ! 119: mulf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 120: if( loop_on_err ) { ! 121: force_loop = TRUE; /* set the force loop flag */ ! 122: asm("brw _mulf_2_lp1");; /* and loop on the error */ ! 123: } /* end of loop on error */ ! 124: } /* end of compare error */ ! 125: } /* end of WHILE loop */ ! 126: } /* end of subtest 2 */ ! 127: ! 128: ! 129: ! 130: /************************************************************************ ! 131: * ! 132: * SUBTEST 3 - Wait 3 NOPs before storing the results ! 133: * ! 134: ************************************************************************/ ! 135: mulf_3() ! 136: { ! 137: force_loop = FALSE; ! 138: subtest = 3; ! 139: for( index = 0; index < max_mulf_1_index; index++ ) { ! 140: sgl_ld_acc = mulf_1_data[index].op_1; /* get operand 1 */ ! 141: sgl_value_1 = mulf_1_data[index].op_2; /* get operand 2 */ ! 142: sgl_expected = mulf_1_data[index].exp; /* get expected result */ ! 143: /* ! 144: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 145: * The force loop flag is set after the first error. ! 146: */ ! 147: asm("_mulf_3_lp1:"); ! 148: asm("ldf _sgl_ld_acc"); /* load the 1st operand */ ! 149: asm("nop"); /* delay */ ! 150: asm("mulf _sgl_value_1"); /* multiply the 2nd operand */ ! 151: asm("nop"); /* delay before ... */ ! 152: asm("nop"); ! 153: asm("nop"); /* ... storing the result */ ! 154: asm("stf _sgl_st_acc"); /* store the result */ ! 155: if( force_loop ) ! 156: asm("brb _mulf_3_lp1");; /* loop on the error */ ! 157: /* ! 158: * end error loop - test the results ! 159: */ ! 160: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 161: errcnt++; /* bump the error count */ ! 162: if( prt_error ) { ! 163: writes(" \n"); /* start a new print line */ ! 164: writes("cycle: "); ! 165: writed( cycle ); ! 166: writes(" MULF test "); ! 167: writed( test_no ); ! 168: writes(", subtest 3 (Cache Data - 3 NOPs) - BAD FINAL ACC\n"); ! 169: print_mulf_data(); ! 170: } ! 171: if( halt_flg ) ! 172: mulf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 173: if( loop_on_err ) { ! 174: force_loop = TRUE; /* set the force loop flag */ ! 175: asm("brw _mulf_3_lp1");; /* and loop on the error */ ! 176: } /* end of loop on error */ ! 177: } /* end of compare error */ ! 178: } /* end of WHILE loop */ ! 179: } /* end of subtest 3 */ ! 180: ! 181: ! 182: ! 183: /************************************************************************ ! 184: * ! 185: * SUBTEST 4 - Wait 2 NOPs before storing the results ! 186: * ! 187: ************************************************************************/ ! 188: mulf_4() ! 189: { ! 190: force_loop = FALSE; ! 191: subtest = 4; ! 192: for( index = 0; index < max_mulf_1_index; index++ ) { ! 193: sgl_ld_acc = mulf_1_data[index].op_1; /* get operand 1 */ ! 194: sgl_value_1 = mulf_1_data[index].op_2; /* get operand 2 */ ! 195: sgl_expected = mulf_1_data[index].exp; /* get expected result */ ! 196: /* ! 197: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 198: * The force loop flag is set after the first error. ! 199: */ ! 200: asm("_mulf_4_lp1:"); ! 201: asm("ldf _sgl_ld_acc"); /* load the 1st operand */ ! 202: asm("nop"); /* delay */ ! 203: asm("mulf _sgl_value_1"); /* multiply the 2nd operand */ ! 204: asm("nop"); /* delay before ... */ ! 205: asm("nop"); /* ... storing the result */ ! 206: asm("stf _sgl_st_acc"); /* store the result */ ! 207: if( force_loop ) ! 208: asm("brb _mulf_4_lp1");; /* loop on the error */ ! 209: /* ! 210: * end error loop - test the results ! 211: */ ! 212: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 213: errcnt++; /* bump the error count */ ! 214: if( prt_error ) { ! 215: writes(" \n"); /* start a new print line */ ! 216: writes("cycle: "); ! 217: writed( cycle ); ! 218: writes(" MULF test "); ! 219: writed( test_no ); ! 220: writes(", subtest 4 (Cache Data - 2 NOPs) - BAD FINAL ACC\n"); ! 221: print_mulf_data(); ! 222: } ! 223: if( halt_flg ) ! 224: mulf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 225: if( loop_on_err ) { ! 226: force_loop = TRUE; /* set the force loop flag */ ! 227: asm("brw _mulf_4_lp1");; /* and loop on the error */ ! 228: } /* end of loop on error */ ! 229: } /* end of compare error */ ! 230: } /* end of WHILE loop */ ! 231: } /* end of subtest 4 */ ! 232: ! 233: ! 234: ! 235: /************************************************************************ ! 236: * ! 237: * SUBTEST 5 - Wait 1 NOP before storing the results ! 238: * ! 239: ************************************************************************/ ! 240: mulf_5() ! 241: { ! 242: force_loop = FALSE; ! 243: subtest = 5; ! 244: for( index = 0; index < max_mulf_1_index; index++ ) { ! 245: sgl_ld_acc = mulf_1_data[index].op_1; /* get operand 1 */ ! 246: sgl_value_1 = mulf_1_data[index].op_2; /* get operand 2 */ ! 247: sgl_expected = mulf_1_data[index].exp; /* get expected result */ ! 248: /* ! 249: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 250: * The force loop flag is set after the first error. ! 251: */ ! 252: asm("_mulf_5_lp1:"); ! 253: asm("ldf _sgl_ld_acc"); /* load the 1st operand */ ! 254: asm("nop"); /* delay */ ! 255: asm("mulf _sgl_value_1"); /* multiply the 2nd operand */ ! 256: asm("nop"); /* delay before storing */ ! 257: asm("stf _sgl_st_acc"); /* store the result */ ! 258: if( force_loop ) ! 259: asm("brb _mulf_5_lp1");; /* loop on the error */ ! 260: /* ! 261: * end error loop - test the results ! 262: */ ! 263: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 264: errcnt++; /* bump the error count */ ! 265: if( prt_error ) { ! 266: writes(" \n"); /* start a new print line */ ! 267: writes("cycle: "); ! 268: writed( cycle ); ! 269: writes(" MULF test "); ! 270: writed( test_no ); ! 271: writes(", subtest 5 (Cache Data - 1 NOPs) - BAD FINAL ACC\n"); ! 272: print_mulf_data(); ! 273: } ! 274: if( halt_flg ) ! 275: mulf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 276: if( loop_on_err ) { ! 277: force_loop = TRUE; /* set the force loop flag */ ! 278: asm("brw _mulf_5_lp1");; /* and loop on the error */ ! 279: } /* end of loop on error */ ! 280: } /* end of compare error */ ! 281: } /* end of WHILE loop */ ! 282: } /* end of subtest 5 */ ! 283: ! 284: ! 285: ! 286: /************************************************************************ ! 287: * ! 288: * SUBTEST 6 - Check for register corruption ! 289: * ! 290: ************************************************************************/ ! 291: mulf_6() ! 292: { ! 293: force_loop = FALSE; /* clear force_loop flg */ ! 294: subtest = 6; ! 295: fill_reg_buf( load_regs ); /* get patterns for regs */ ! 296: index = 0; ! 297: sgl_ld_acc = mulf_1_data[0].op_1; /* get operand 1 */ ! 298: sgl_value_1 = mulf_1_data[0].op_2; /* get operand 2 */ ! 299: sgl_expected = mulf_1_data[0].exp; /* get expected result */ ! 300: /* ! 301: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 302: * The force loop flag is set after the first error. ! 303: */ ! 304: asm("_mulf_6_lp1:"); ! 305: asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */ ! 306: asm("nop"); ! 307: asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */ ! 308: asm("nop"); ! 309: asm("mulf _sgl_value_1"); /* do the multiply */ ! 310: asm("nop"); ! 311: asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 312: asm("stf _sgl_st_acc"); /* save the accumulator */ ! 313: if( force_loop ) ! 314: asm("brb _mulf_6_lp1");; /* loop on the error */ ! 315: /* ! 316: * Now compare the stored register values to those that were loaded ! 317: */ ! 318: index2 = 0; ! 319: while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) ) ! 320: index2++; /* check reg values */ ! 321: if( index2 < 13 ) { /* error if index2 < 13 */ ! 322: errcnt++; /* bump the error count */ ! 323: if( prt_error ) { ! 324: writes(" \n"); /* start a new print line */ ! 325: writes("cycle: "); ! 326: writed( cycle ); ! 327: writes(" MULF test "); ! 328: writed( test_no ); ! 329: writes(", subtest 6 - A REGISTER WAS MODIFIED\n"); ! 330: print_mulf_data(); /* print the operands */ ! 331: writes("register "); /* print the information */ ! 332: writed( index2 ); /* about the corrupted */ ! 333: writes(" = "); /* register */ ! 334: write32h( store_regs[index2] ); ! 335: writes(", should be = "); ! 336: write32h( load_regs[index2] ); ! 337: writes("\n"); ! 338: } ! 339: if( halt_flg ) ! 340: mulf_er_halt( BAD_REG_HLT ); /* halt on the error */ ! 341: if( loop_on_err ) { ! 342: force_loop = TRUE; /* set the force loop flag */ ! 343: asm("brw _mulf_6_lp1");; /* and loop on the error */ ! 344: } /* end of loop on error */ ! 345: } /* end of register corruption error */ ! 346: } /* end of subtest 6 */ ! 347: ! 348: ! 349: ! 350: /************************************************************************ ! 351: * ! 352: * SUBTEST 7 - Check for PSL corruption ! 353: * ! 354: ************************************************************************/ ! 355: mulf_7() ! 356: { ! 357: force_loop = FALSE; /* clear force_loop flg */ ! 358: subtest = 7; ! 359: fill_reg_buf( load_regs ); /* get patterns for regs */ ! 360: for( index = 0; index < 3; index++ ) { ! 361: sgl_ld_acc = mulf_1_data[index].op_1; /* get operand 1 */ ! 362: sgl_value_1 = mulf_1_data[index].op_2; /* get operand 2 */ ! 363: sgl_expected = mulf_1_data[index].exp; /* get expected */ ! 364: sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */ ! 365: /* ! 366: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 367: * The force loop flag is set after the first error. ! 368: */ ! 369: asm("_mulf_7_lp1:"); ! 370: asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */ ! 371: asm("nop"); ! 372: asm("tstl _sgl_dummy1"); /* set the PSL status */ ! 373: asm("movpsl _init_psl"); /* save the initial PSL */ ! 374: asm("mulf _sgl_value_1"); /* do the multiply */ ! 375: asm("nop"); ! 376: asm("movpsl _psl_val"); /* save the final PSL */ ! 377: asm("stf _sgl_st_acc"); /* save the accumulator */ ! 378: if( force_loop ) ! 379: asm("brb _mulf_7_lp1");; /* loop on the error */ ! 380: /* ! 381: * Now compare the final PSL to the initial PSL -they should be the same ! 382: */ ! 383: if( psl_val != init_psl ) { ! 384: errcnt++; /* bump the error count */ ! 385: if( prt_error ) { ! 386: writes(" \n"); /* start a new print line */ ! 387: writes("cycle: "); ! 388: writed( cycle ); ! 389: writes(" MULF test "); ! 390: writed( test_no ); ! 391: writes(", subtest 7 - INCORRECT FINAL PSL\n"); ! 392: print_mulf_data(); /* print the operands */ ! 393: writes("initial PSL = "); ! 394: write32h( init_psl ); ! 395: writes(", final PSL = "); ! 396: write32h( psl_val ); ! 397: writes(", expected PSL = "); ! 398: write32h( exp_psl ); ! 399: writes("\n"); ! 400: } ! 401: if( halt_flg ) ! 402: mulf_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 403: if( loop_on_err ) { ! 404: force_loop = TRUE; /* set the force loop flag */ ! 405: asm("brw _mulf_7_lp1");; /* and loop on the error */ ! 406: } /* end of loop on error */ ! 407: } /* end of PSL corruption error */ ! 408: } /* end of WHILE loop */ ! 409: } /* end of subtest 7 */ ! 410: ! 411: ! 412: ! 413: /************************************************************************ ! 414: * ! 415: * SUBTEST 8 - pipelined entry test ! 416: * ! 417: ************************************************************************/ ! 418: mulf_8() ! 419: { ! 420: force_loop = FALSE; ! 421: subtest = 8; ! 422: for( index = 0; index < max_mulf_1_index; index++ ) { ! 423: sgl_ld_acc = mulf_1_data[index].op_1; /* get operand 1 */ ! 424: sgl_value_1 = mulf_1_data[index].op_2; /* get operand 2 */ ! 425: sgl_expected = mulf_1_data[index].exp; /* get expected result */ ! 426: /* ! 427: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 428: * The force loop flag is set after the first error. ! 429: */ ! 430: asm("_mulf_8_lp1:"); ! 431: asm("movl $0,r0"); /* clear r0 */ ! 432: asm("ldf r0"); /* load the Acc. with 0.0 */ ! 433: asm("addf _sgl_ld_acc"); /* add the 1st operand */ ! 434: asm("mulf _sgl_value_1"); /* multiply the 2nd operand */ ! 435: asm("stf _sgl_st_acc"); /* store the result */ ! 436: if( force_loop ) ! 437: asm("brb _mulf_8_lp1");; /* loop on the error */ ! 438: /* ! 439: * end error loop - test the results ! 440: */ ! 441: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 442: errcnt++; /* bump the error count */ ! 443: if( prt_error ) { ! 444: writes(" \n"); /* start a new print line */ ! 445: writes("cycle: "); ! 446: writed( cycle ); ! 447: writes(" MULF test "); ! 448: writed( test_no ); ! 449: writes(", subtest 8 (Piped Entry) - BAD FINAL ACC\n"); ! 450: print_mulf_data(); ! 451: } ! 452: if( halt_flg ) ! 453: mulf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 454: if( loop_on_err ) { ! 455: force_loop = TRUE; /* set the force loop flag */ ! 456: asm("brw _mulf_8_lp1");; /* and loop on the error */ ! 457: } /* end of loop on error */ ! 458: } /* end of compare error */ ! 459: } /* end of WHILE loop */ ! 460: } /* end of subtest 8 */ ! 461: ! 462: ! 463: ! 464: /************************************************************************ ! 465: * ! 466: * SUBTEST 9 - pipelined exit test ! 467: * ! 468: ************************************************************************/ ! 469: mulf_9() ! 470: { ! 471: force_loop = FALSE; ! 472: subtest = 9; ! 473: for( index = 0; index < max_mulf_1_index; index++ ) { ! 474: sgl_ld_acc = mulf_1_data[index].op_1; /* get operand 1 */ ! 475: sgl_value_1 = mulf_1_data[index].op_2; /* get operand 2 */ ! 476: sgl_expected = mulf_1_data[index].exp; /* get expected result */ ! 477: /* ! 478: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 479: * The force loop flag is set after the first error. ! 480: */ ! 481: asm("_mulf_9_lp1:"); ! 482: asm("movl $0,r0"); /* clear r0 */ ! 483: asm("ldf _sgl_ld_acc"); /* load the 1st operand */ ! 484: asm("mulf _sgl_value_1"); /* multiply the 2nd operand */ ! 485: asm("addf r0"); /* add a 0.0 to the result */ ! 486: asm("stf _sgl_st_acc"); /* store the result */ ! 487: if( force_loop ) ! 488: asm("brb _mulf_9_lp1");; /* loop on the error */ ! 489: /* ! 490: * end error loop - test the results ! 491: */ ! 492: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 493: errcnt++; /* bump the error count */ ! 494: if( prt_error ) { ! 495: writes(" \n"); /* start a new print line */ ! 496: writes("cycle: "); ! 497: writed( cycle ); ! 498: writes(" MULF test "); ! 499: writed( test_no ); ! 500: writes(", subtest 9 (Piped Exit) - BAD FINAL ACC\n"); ! 501: print_mulf_data(); ! 502: } ! 503: if( halt_flg ) ! 504: mulf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 505: if( loop_on_err ) { ! 506: force_loop = TRUE; /* set the force loop flag */ ! 507: asm("brw _mulf_9_lp1");; /* and loop on the error */ ! 508: } /* end of loop on error */ ! 509: } /* end of compare error */ ! 510: } /* end of WHILE loop */ ! 511: } /* end of subtest 9 */ ! 512: ! 513: ! 514: ! 515: /************************************************************************** ! 516: * ! 517: * PRINT THE DATA AND STORE RESULTS ! 518: * ! 519: * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx ! 520: * operand = xxxxxxxx, expected = xxxxxxxx ! 521: **************************************************************************/ ! 522: print_mulf_data() ! 523: { ! 524: writes("initial Acc = "); ! 525: write32h( sgl_ld_acc ); ! 526: writes(", stored = "); ! 527: write32h( sgl_st_acc ); ! 528: writes(", data index = "); ! 529: writed( index ); ! 530: writec('\n'); ! 531: writes(" operand = "); ! 532: write32h( sgl_value_1 ); ! 533: writes(", expected = "); ! 534: write32h( sgl_expected ); ! 535: writec('\n'); ! 536: } ! 537: ! 538: ! 539: ! 540: /************************************************************************** ! 541: * ! 542: * HALT ON ERROR ROUTINE ! 543: * ! 544: **************************************************************************/ ! 545: mulf_er_halt( halt_code ) ! 546: int halt_code; ! 547: { ! 548: sgl_dummy1 = halt_code; /* get the error type */ ! 549: asm("movl _test_no,r0"); /* r0 = test number */ ! 550: asm("movl _subtest,r1"); /* r1 = subtest number */ ! 551: asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 552: asm("movl _cycle,r3"); /* r3 = cycle count */ ! 553: asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */ ! 554: asm("movl _sgl_value_1,r5"); /* r5 = data multiplied */ ! 555: asm("movl _sgl_st_acc,r6"); /* r6 = data stored */ ! 556: if( halt_code == BAD_ACC_HLT ) { ! 557: asm("movl _sgl_expected,r7"); /* r7 = data expected */ ! 558: asm("movl _index,r8"); /* r8 = data index */ ! 559: } else ! 560: if( halt_code == BAD_REG_HLT ) { ! 561: sgl_dummy1 = load_regs[index2]; ! 562: sgl_dummy2 = store_regs[index2]; ! 563: asm("movl _index2,r7"); /* r7 = bad register # */ ! 564: asm("movl _sgl_dummy2,r8"); /* r8 = actual value */ ! 565: asm("movl _sgl_dummy1,r9"); /* r9 = expected value */ ! 566: } else ! 567: if( halt_code == BAD_PSL_HLT ) { ! 568: asm("movl _init_psl,r7"); /* r7 = initial PSL */ ! 569: asm("movl _psl_val,r8"); /* r8 = final PSL */ ! 570: asm("movl _exp_psl,r9"); /* r9 = expected PSL */ ! 571: }; ! 572: asm("halt"); /* HALT ... */ ! 573: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.