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