![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lnf.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 lnf.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: * LNF - SINGLE PRECISION FLOATING POINT LOAD_NEGATE TEST ! 8: * ! 9: *****************************************************************************/ ! 10: lnf() ! 11: { ! 12: asm(".globl _lnf_t"); ! 13: asm("_lnf_t:"); /* entry address */ ! 14: if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */ ! 15: writes(" LNF"); ! 16: lnf_1(); /* load through a register */ ! 17: lnf_2(); /* load through the cache */ ! 18: lnf_3(); /* register stability */ ! 19: lnf_4(); /* PSL stability test */ ! 20: lnf_5(); /* pipelined entry test */ ! 21: if ( !no_fpp_wcs ) ! 22: lnf_6();; /* pipelined exit test */ ! 23: asm("jmp *return"); /* return to the test monitor */ ! 24: } ! 25: ! 26: ! 27: ! 28: /************************************************************************ ! 29: * ! 30: * SUBTEST 1 - load_negate through a register ! 31: * ! 32: ************************************************************************/ ! 33: lnf_1() ! 34: { ! 35: force_loop = FALSE; ! 36: subtest = 1; ! 37: for( index = 0; index < max_lnf_1_index; index++ ) { ! 38: sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */ ! 39: sgl_expected = lnf_1_data[index].exp; /* get expected result */ ! 40: /* ! 41: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 42: * The force loop flag is set after the first error. ! 43: */ ! 44: asm("_lnf_1_lp1:"); ! 45: asm("movl _sgl_ld_acc,r4"); /* get the value to negate */ ! 46: asm("lnf r4"); /* load and negate value */ ! 47: asm("stf r5"); /* store the result in R5 */ ! 48: if( force_loop ) ! 49: asm("brb _lnf_1_lp1");; /* loop on the error */ ! 50: /* ! 51: * end error loop - test the results ! 52: */ ! 53: asm("movl r5,_sgl_st_acc"); /* move R5 data to cache */ ! 54: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 55: errcnt++; /* bump the error count */ ! 56: if( prt_error ) { ! 57: writes(" \n"); /* start a new print line */ ! 58: writes("cycle: "); ! 59: writed( cycle ); ! 60: writes(" LNF test "); ! 61: writed( test_no ); ! 62: writes(", subtest 1 (Reg. Data) - BAD FINAL ACC\n"); ! 63: print_lnf_data(); ! 64: writes(" Acc expected = "); ! 65: write32h( sgl_expected ); ! 66: writec('\n'); ! 67: } ! 68: if( halt_flg ) ! 69: lnf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 70: if( loop_on_err ) { ! 71: force_loop = TRUE; /* set the force loop flag */ ! 72: asm("brw _lnf_1_lp1");; /* and loop on the error */ ! 73: } /* end of loop on error */ ! 74: } /* end of compare error */ ! 75: } /* end of WHILE loop */ ! 76: } /* end of subtest 1 */ ! 77: ! 78: ! 79: ! 80: /************************************************************************ ! 81: * ! 82: * SUBTEST 2 - load_negate through memory ! 83: * ! 84: ************************************************************************/ ! 85: lnf_2() ! 86: { ! 87: force_loop = FALSE; ! 88: subtest = 2; ! 89: for( index = 0; index < max_lnf_1_index; index++ ) { ! 90: sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */ ! 91: sgl_expected = lnf_1_data[index].exp; /* get expected result */ ! 92: /* ! 93: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 94: * The force loop flag is set after the first error. ! 95: */ ! 96: asm("_lnf_2_lp1:"); ! 97: asm("lnf _sgl_ld_acc"); /* load and negate the value */ ! 98: asm("stf _sgl_st_acc"); /* store the result */ ! 99: if( force_loop ) ! 100: asm("brb _lnf_2_lp1");; /* loop on the error */ ! 101: /* ! 102: * end error loop - test the results ! 103: */ ! 104: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 105: errcnt++; /* bump the error count */ ! 106: if( prt_error ) { ! 107: writes(" \n"); /* start a new print line */ ! 108: writes("cycle: "); ! 109: writed( cycle ); ! 110: writes(" LNF test "); ! 111: writed( test_no ); ! 112: writes(", subtest 2 (Cache Data) - BAD FINAL ACC\n"); ! 113: print_lnf_data(); ! 114: writes(" Acc expected = "); ! 115: write32h( sgl_expected ); ! 116: writec('\n'); ! 117: } ! 118: if( halt_flg ) ! 119: lnf_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 _lnf_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 - Check for register corruption ! 133: * ! 134: ************************************************************************/ ! 135: lnf_3() ! 136: { ! 137: force_loop = FALSE; /* clear force_loop flg */ ! 138: subtest = 3; ! 139: fill_reg_buf( load_regs ); /* get patterns for regs */ ! 140: index = 0; ! 141: sgl_ld_acc = lnf_1_data[0].ld; /* get value to negate */ ! 142: sgl_expected = lnf_1_data[0].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("_lnf_3_lp1:"); ! 148: asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */ ! 149: asm("nop"); ! 150: asm("lnf _sgl_ld_acc"); /* load and negate the value */ ! 151: asm("nop"); ! 152: asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 153: asm("stf _sgl_st_acc"); /* save the accumulator */ ! 154: if( force_loop ) ! 155: asm("brb _lnf_3_lp1");; /* loop on the error */ ! 156: /* ! 157: * Now compare the stored register values to those that were loaded ! 158: */ ! 159: index2 = 0; ! 160: while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) ) ! 161: index2++; /* check reg values */ ! 162: if( index2 < 13 ) { /* error if index2 < 13 */ ! 163: errcnt++; /* bump the error count */ ! 164: if( prt_error ) { ! 165: writes(" \n"); /* start a new print line */ ! 166: writes("cycle: "); ! 167: writed( cycle ); ! 168: writes(" LNF test "); ! 169: writed( test_no ); ! 170: writes(", subtest 3 - A REGISTER WAS MODIFIED\n"); ! 171: print_lnf_data(); /* print the operands */ ! 172: writes("register "); /* print the information */ ! 173: writed( index2 ); /* about the corrupted */ ! 174: writes(" = "); /* register */ ! 175: write32h( store_regs[index2] ); ! 176: writes(", should be = "); ! 177: write32h( load_regs[index2] ); ! 178: writes("\n"); ! 179: } ! 180: if( halt_flg ) ! 181: lnf_er_halt( BAD_REG_HLT ); /* halt on the error */ ! 182: if( loop_on_err ) { ! 183: force_loop = TRUE; /* set the force loop flag */ ! 184: asm("brw _lnf_3_lp1");; /* and loop on the error */ ! 185: } /* end of loop on error */ ! 186: } /* end of register corruption error */ ! 187: } /* end of subtest 3 */ ! 188: ! 189: ! 190: ! 191: /************************************************************************ ! 192: * ! 193: * SUBTEST 4 - Check for PSL corruption ! 194: * ! 195: ************************************************************************/ ! 196: lnf_4() ! 197: { ! 198: force_loop = FALSE; /* clear force_loop flg */ ! 199: subtest = 4; ! 200: fill_reg_buf( load_regs ); /* get patterns for regs */ ! 201: for( index = 0; index < 3; index++ ) { ! 202: sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */ ! 203: sgl_expected = lnf_1_data[index].exp; /* get expected */ ! 204: sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */ ! 205: /* ! 206: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 207: * The force loop flag is set after the first error. ! 208: */ ! 209: asm("_lnf_4_lp1:"); ! 210: asm("tstl _sgl_dummy1"); /* set the PSL status */ ! 211: asm("movpsl _init_psl"); /* save the initial PSL */ ! 212: asm("lnf _sgl_ld_acc"); /* load and negate the value */ ! 213: asm("nop"); ! 214: asm("movpsl _psl_val"); /* save the final PSL */ ! 215: asm("stf _sgl_st_acc"); /* save the accumulator */ ! 216: if( force_loop ) ! 217: asm("brb _lnf_4_lp1");; /* loop on the error */ ! 218: /* ! 219: * Now compare the final PSL to the initial PSL -they should be the same ! 220: */ ! 221: exp_psl = init_psl; ! 222: if( psl_val != init_psl ) { ! 223: errcnt++; /* bump the error count */ ! 224: if( prt_error ) { ! 225: writes(" \n"); /* start a new print line */ ! 226: writes("cycle: "); ! 227: writed( cycle ); ! 228: writes(" LNF test "); ! 229: writed( test_no ); ! 230: writes(", subtest 4 - INCORRECT FINAL PSL\n"); ! 231: print_lnf_data(); /* print the operands */ ! 232: writes("initial PSL = "); ! 233: write32h( init_psl ); ! 234: writes(", final PSL = "); ! 235: write32h( psl_val ); ! 236: writes(", expected PSL = "); ! 237: write32h( exp_psl ); ! 238: writes("\n"); ! 239: } ! 240: if( halt_flg ) ! 241: lnf_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 242: if( loop_on_err ) { ! 243: force_loop = TRUE; /* set the force loop flag */ ! 244: asm("brw _lnf_4_lp1");; /* and loop on the error */ ! 245: } /* end of loop on error */ ! 246: } /* end of PSL corruption error */ ! 247: } /* end of WHILE loop */ ! 248: } /* end of subtest 4 */ ! 249: ! 250: ! 251: ! 252: /************************************************************************ ! 253: * ! 254: * SUBTEST 5 - pipelined entry test ! 255: * ! 256: ************************************************************************/ ! 257: lnf_5() ! 258: { ! 259: force_loop = FALSE; ! 260: subtest = 8; ! 261: for( index = 0; index < max_lnf_1_index; index++ ) { ! 262: sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */ ! 263: sgl_expected = lnf_1_data[index].exp; /* get expected result */ ! 264: /* ! 265: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 266: * The force loop flag is set after the first error. ! 267: */ ! 268: asm("_lnf_5_lp1:"); ! 269: asm("movl $0,r0"); /* clear r0 */ ! 270: asm("ldf r0"); /* load the Acc. with 0.0 */ ! 271: asm("lnf _sgl_ld_acc"); /* load and negate the value */ ! 272: asm("stf _sgl_st_acc"); /* store the result */ ! 273: if( force_loop ) ! 274: asm("brb _lnf_5_lp1");; /* loop on the error */ ! 275: /* ! 276: * end error loop - test the results ! 277: */ ! 278: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 279: errcnt++; /* bump the error count */ ! 280: if( prt_error ) { ! 281: writes(" \n"); /* start a new print line */ ! 282: writes("cycle: "); ! 283: writed( cycle ); ! 284: writes(" LNF test "); ! 285: writed( test_no ); ! 286: writes(", subtest 5 (Piped Entry) - BAD FINAL ACC\n"); ! 287: print_lnf_data(); ! 288: } ! 289: if( halt_flg ) ! 290: lnf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 291: if( loop_on_err ) { ! 292: force_loop = TRUE; /* set the force loop flag */ ! 293: asm("brw _lnf_5_lp1");; /* and loop on the error */ ! 294: } /* end of loop on error */ ! 295: } /* end of compare error */ ! 296: } /* end of WHILE loop */ ! 297: } /* end of subtest 5 */ ! 298: ! 299: ! 300: ! 301: /************************************************************************ ! 302: * ! 303: * SUBTEST 6 - pipelined exit test ! 304: * ! 305: ************************************************************************/ ! 306: lnf_6() ! 307: { ! 308: force_loop = FALSE; ! 309: subtest = 8; ! 310: for( index = 0; index < max_lnf_1_index; index++ ) { ! 311: sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */ ! 312: sgl_expected = lnf_1_data[index].exp; /* get expected result */ ! 313: /* ! 314: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 315: * The force loop flag is set after the first error. ! 316: */ ! 317: asm("_lnf_6_lp1:"); ! 318: asm("movl $0,r0"); /* clear r0 */ ! 319: asm("lnf _sgl_ld_acc"); /* load and negate the value */ ! 320: asm("addf r0"); /* add a zero to the acc. */ ! 321: asm("stf _sgl_st_acc"); /* store the result */ ! 322: if( force_loop ) ! 323: asm("brb _lnf_6_lp1");; /* loop on the error */ ! 324: /* ! 325: * end error loop - test the results ! 326: */ ! 327: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 328: errcnt++; /* bump the error count */ ! 329: if( prt_error ) { ! 330: writes(" \n"); /* start a new print line */ ! 331: writes("cycle: "); ! 332: writed( cycle ); ! 333: writes(" LNF test "); ! 334: writed( test_no ); ! 335: writes(", subtest 6 (Piped Exit) - BAD FINAL ACC\n"); ! 336: print_lnf_data(); ! 337: } ! 338: if( halt_flg ) ! 339: lnf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 340: if( loop_on_err ) { ! 341: force_loop = TRUE; /* set the force loop flag */ ! 342: asm("brw _lnf_6_lp1");; /* and loop on the error */ ! 343: } /* end of loop on error */ ! 344: } /* end of compare error */ ! 345: } /* end of WHILE loop */ ! 346: } /* end of subtest 6 */ ! 347: ! 348: ! 349: ! 350: /************************************************************************** ! 351: * ! 352: * PRINT THE DATA AND STORE RESULTS ! 353: * ! 354: * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx ! 355: **************************************************************************/ ! 356: print_lnf_data() ! 357: { ! 358: writes("initial Acc = "); ! 359: write32h( sgl_ld_acc ); ! 360: writes(", Acc stored = "); ! 361: write32h( sgl_st_acc ); ! 362: writes(", data index = "); ! 363: writed( index ); ! 364: writec('\n'); ! 365: } ! 366: ! 367: ! 368: ! 369: /************************************************************************** ! 370: * ! 371: * HALT ON ERROR ROUTINE ! 372: * ! 373: **************************************************************************/ ! 374: lnf_er_halt( halt_code ) ! 375: int halt_code; ! 376: { ! 377: sgl_dummy1 = halt_code; /* get the error type */ ! 378: asm("movl _test_no,r0"); /* r0 = test number */ ! 379: asm("movl _subtest,r1"); /* r1 = subtest number */ ! 380: asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 381: asm("movl _cycle,r3"); /* r3 = cycle count */ ! 382: asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */ ! 383: asm("movl _sgl_st_acc,r5"); /* r5 = data stored */ ! 384: if( halt_code == BAD_ACC_HLT ) { ! 385: asm("movl _sgl_expected,r6"); /* r6 = data expected */ ! 386: asm("movl _index,r7"); /* r7 = data index */ ! 387: } else ! 388: if( halt_code == BAD_REG_HLT ) { ! 389: sgl_dummy1 = load_regs[index2]; ! 390: sgl_dummy2 = store_regs[index2]; ! 391: asm("movl _index2,r6"); /* r6 = bad register # */ ! 392: asm("movl _sgl_dummy2,r7"); /* r7 = actual value */ ! 393: asm("movl _sgl_dummy1,r8"); /* r8 = expected value */ ! 394: } else ! 395: if( halt_code == BAD_PSL_HLT ) { ! 396: asm("movl _init_psl,r6"); /* r6 = initial PSL */ ! 397: asm("movl _psl_val,r7"); /* r7 = final PSL */ ! 398: asm("movl _exp_psl,r8"); /* r8 = expected PSL */ ! 399: }; ! 400: asm("halt"); /* HALT ... */ ! 401: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.