![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expf.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 expf.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: * ! 7: * EXPF - SINGLE PRECISION FLOATING POINT EXPF FUNCTION TEST ! 8: * ! 9: * EXPF TEST MONITOR ! 10: * ! 11: *****************************************************************************/ ! 12: expf() ! 13: { ! 14: asm(".globl _expf_t"); ! 15: asm("_expf_t:"); /* entry address */ ! 16: if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */ ! 17: { ! 18: writes(" EXPF"); ! 19: } ! 20: expf_1(); /* test expf with delay */ ! 21: expf_2(); /* test expf */ ! 22: expf_3(); /* register corruption */ ! 23: expf_4(); /* test the PSL */ ! 24: expf_5(); /* pipelined entry */ ! 25: expf_6(); /* pipelined exit */ ! 26: asm("jmp *return"); /* return to the test monitor */ ! 27: } ! 28: ! 29: ! 30: ! 31: /*************************************************************************** ! 32: * ! 33: * SUBTEST 1 - EXPF ! 34: * ! 35: ***************************************************************************/ ! 36: expf_1() ! 37: { ! 38: #define DELAY 10 /* wait 20 ticks between EXPF & STF */ ! 39: force_loop = FALSE; /* clear the LOOP flag */ ! 40: subtest = 1; ! 41: index = 0; ! 42: do ! 43: { ! 44: sgl_ld_acc = expf_1_data[index].ld; /* get the operand */ ! 45: sgl_expected = expf_1_data[index].exp; /* get expected results */ ! 46: sgl_dummy1 = DELAY; ! 47: /* ! 48: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 49: * The force loop flag is set after the first error. ! 50: */ ! 51: asm("_expf_1_lp1:"); ! 52: asm("movl _sgl_ld_acc,r4"); /* set the data to load */ ! 53: asm("ldf r4"); /* load the accumulator */ ! 54: asm("movl _sgl_dummy1,r0"); /* get the delay factor */ ! 55: asm("expf"); /* get ACC.s' exponent */ ! 56: asm("1:"); ! 57: asm("decl r0"); /* delay to let the EXPF */ ! 58: asm("bgtr 1b"); /* instruction finish */ ! 59: asm("stf r5"); /* store the result */ ! 60: if( force_loop ) ! 61: asm("brb _expf_1_lp1");; /* loop on the error */ ! 62: /* ! 63: * end error loop ! 64: */ ! 65: asm("movl r5,_sgl_st_acc"); /* save the result */ ! 66: if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 67: { ! 68: errcnt++; /* bump the error count */ ! 69: if ( prt_error ) ! 70: { ! 71: writes(" \n"); /* start a new print line */ ! 72: writes("cycle: "); ! 73: writed( cycle ); ! 74: writes(" EXPF test "); ! 75: writed( test_no ); ! 76: writes(", subtest 1 (delayed store) - BAD FINAL ACC\n"); ! 77: print_expf_data(); ! 78: writes(", data index = "); ! 79: writed( index ); ! 80: writec('\n'); ! 81: writes(" Acc expected = "); ! 82: write32h( sgl_expected ); ! 83: writec('\n'); ! 84: } ! 85: if ( halt_flg ) /* halt on error? */ ! 86: expf_er_halt( BAD_ACC_HLT ); ! 87: if ( loop_on_err ) ! 88: { ! 89: force_loop = TRUE; /* set the force loop flag */ ! 90: asm("jmp _expf_1_lp1"); /* and loop */ ! 91: } ! 92: } /* end of compare error */ ! 93: } while( index++ < max_expf_1_index ); ! 94: } /* end of subtest 1 */ ! 95: ! 96: ! 97: ! 98: /*************************************************************************** ! 99: * ! 100: * SUBTEST 2 - EXPF FUNCTION ! 101: * ! 102: ***************************************************************************/ ! 103: expf_2() ! 104: { ! 105: force_loop = FALSE; /* clear the LOOP flag */ ! 106: subtest = 2; ! 107: index = 0; ! 108: do ! 109: { ! 110: sgl_ld_acc = expf_1_data[index].ld; /* get the operand */ ! 111: sgl_expected = expf_1_data[index].exp; /* get expected results */ ! 112: /* ! 113: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 114: * The force loop flag is set after the first error. ! 115: */ ! 116: asm("_expf_2_lp1:"); ! 117: asm("movl _sgl_ld_acc,r4"); /* set the data to load */ ! 118: asm("ldf r4"); /* load the accumulator */ ! 119: asm("expf"); /* get ACC.'s exponent */ ! 120: asm("stf r5"); /* store the result */ ! 121: if( force_loop ) ! 122: asm("brb _expf_2_lp1");; /* loop on the error */ ! 123: /* ! 124: * end error loop ! 125: */ ! 126: asm("movl r5,_sgl_st_acc"); /* save the result */ ! 127: if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 128: { ! 129: errcnt++; /* bump the error count */ ! 130: if ( prt_error ) ! 131: { ! 132: writes(" \n"); /* start a new print line */ ! 133: writes("cycle: "); ! 134: writed( cycle ); ! 135: writes(" EXPF test "); ! 136: writed( test_no ); ! 137: writes(", subtest 2 (immediate store) - BAD FINAL ACC\n"); ! 138: print_expf_data(); ! 139: writes(", data index = "); ! 140: writed( index ); ! 141: writec('\n'); ! 142: writes(" Acc expected = "); ! 143: write32h( sgl_expected ); ! 144: writec('\n'); ! 145: } ! 146: if ( halt_flg ) /* halt on error? */ ! 147: expf_er_halt( BAD_ACC_HLT ); ! 148: if ( loop_on_err ) ! 149: { ! 150: force_loop = TRUE; /* set the force loop flag */ ! 151: asm("jmp _expf_2_lp1"); /* and loop */ ! 152: } ! 153: } /* end of compare error */ ! 154: } while( index++ < max_expf_1_index ); ! 155: } /* end of subtest 2 */ ! 156: ! 157: ! 158: ! 159: /*************************************************************************** ! 160: * ! 161: * SUBTEST 3 - REGISTER INTEGRITY WITH THE EXPF FUNCTION ! 162: * ! 163: ***************************************************************************/ ! 164: expf_3() ! 165: { ! 166: fill_reg_buf( load_regs ); /* set reg values to load */ ! 167: force_loop = FALSE; /* clear the LOOP flag */ ! 168: subtest = 3; ! 169: index = 0; ! 170: do ! 171: { ! 172: sgl_ld_acc = expf_1_data[index].ld; /* get the operand */ ! 173: sgl_expected = expf_1_data[index].exp; /* get expected results */ ! 174: /* ! 175: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 176: * The force loop flag is set after the first error. ! 177: */ ! 178: asm("_expf_3_lp1:"); ! 179: asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 (FP) */ ! 180: asm("ldf _sgl_ld_acc"); /* load the accumulator */ ! 181: asm("expf"); /* get ACC.'s exponent */ ! 182: asm("stf _sgl_st_acc"); /* store the result */ ! 183: asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 184: if( force_loop ) ! 185: asm("brb _expf_3_lp1");; /* loop on the error */ ! 186: /* ! 187: * end error loop ! 188: */ ! 189: reg_no = 0; ! 190: regs_ok = TRUE; ! 191: while( (reg_no < 13) && (regs_ok) ) /* check 1st 12 regs */ ! 192: if( store_regs[ reg_no ] == load_regs[ reg_no ] ) ! 193: reg_no++; ! 194: else ! 195: regs_ok = FALSE; ! 196: if( !regs_ok ) ! 197: { ! 198: errcnt++; /* bump the error count */ ! 199: if ( prt_error ) ! 200: { ! 201: writes(" \n"); /* start a new print line */ ! 202: writes("cycle: "); ! 203: writed( cycle ); ! 204: writes(" EXPF test "); ! 205: writed( test_no ); ! 206: writes(", subtest 3 - A REGISTER WAS MODIFIED\n"); { ! 207: print_expf_data(); ! 208: writec('\n'); ! 209: writes("register "); ! 210: writed( reg_no ); ! 211: writes(" = "); ! 212: write32h( load_regs[reg_no] ); ! 213: writes(", should be = "); ! 214: write32h( store_regs[reg_no] ); ! 215: writec('\n'); ! 216: } ! 217: if ( halt_flg ) /* halt on error? */ ! 218: expf_er_halt( BAD_REG_HLT ); ! 219: if ( loop_on_err ) ! 220: { ! 221: force_loop = TRUE; /* get the force loop flag */ ! 222: asm("jmp _expf_3_lp1"); /* and loop */ ! 223: } ! 224: } /* end of compare error */ ! 225: } /* end of while loop */ ! 226: } while( index++ < max_expf_1_index ); ! 227: } /* end of subtest 3 */ ! 228: ! 229: ! 230: ! 231: /************************************************************************ ! 232: * ! 233: * SUBTEST 4 - Check for PSL corruption ! 234: * ! 235: ************************************************************************/ ! 236: expf_4() ! 237: { ! 238: force_loop = FALSE; /* clear force_loop flg */ ! 239: subtest = 4; ! 240: fill_reg_buf( load_regs ); /* get patterns for regs */ ! 241: for( index = 0; index < 3; index++ ) { ! 242: sgl_ld_acc = expf_1_data[index].ld; /* get operand 1 */ ! 243: sgl_expected = expf_1_data[index].exp; /* get expected */ ! 244: sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */ ! 245: /* ! 246: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 247: * The force loop flag is set after the first error. ! 248: */ ! 249: asm("_expf_4_lp1:"); ! 250: asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */ ! 251: asm("nop"); ! 252: asm("tstl _sgl_dummy1"); /* set the PSL status */ ! 253: asm("movpsl _init_psl"); /* save the initial PSL */ ! 254: asm("expf"); /* do the expf */ ! 255: asm("nop"); ! 256: asm("movpsl _psl_val"); /* save the final PSL */ ! 257: asm("stf _sgl_st_acc"); /* save the accumulator */ ! 258: if( force_loop ) ! 259: asm("brb _expf_4_lp1");; /* loop on the error */ ! 260: /* ! 261: * Now compare the final PSL to the initial PSL -they should be the same ! 262: */ ! 263: exp_psl = init_psl; ! 264: if( psl_val != exp_psl ) { ! 265: errcnt++; /* bump the error count */ ! 266: if( prt_error ) { ! 267: writes(" \n"); /* start a new print line */ ! 268: writes("cycle: "); ! 269: writed( cycle ); ! 270: writes(" EXPF test "); ! 271: writed( test_no ); ! 272: writes(", subtest 4 - INCORRECT FINAL PSL\n"); ! 273: print_expf_data(); /* print the operands */ ! 274: writec('\n'); ! 275: writes("initial PSL = "); ! 276: write32h( init_psl ); ! 277: writes(", final PSL = "); ! 278: write32h( psl_val ); ! 279: writes(", expected PSL = "); ! 280: write32h( exp_psl ); ! 281: writes("\n"); ! 282: } ! 283: if( halt_flg ) ! 284: expf_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 285: if( loop_on_err ) { ! 286: force_loop = TRUE; /* set the force loop flag */ ! 287: asm("brw _expf_4_lp1");; /* and loop on the error */ ! 288: } /* end of loop on error */ ! 289: } /* end of PSL corruption error */ ! 290: } /* end of WHILE loop */ ! 291: } /* end of subtest 4 */ ! 292: ! 293: ! 294: ! 295: /************************************************************************ ! 296: * ! 297: * SUBTEST 5 - pipelined entry test ! 298: * ! 299: ************************************************************************/ ! 300: expf_5() ! 301: { ! 302: force_loop = FALSE; ! 303: subtest = 8; ! 304: for( index = 0; index < max_expf_1_index; index++ ) { ! 305: sgl_ld_acc = expf_1_data[index].ld; /* get operand 1 */ ! 306: sgl_expected = expf_1_data[index].exp; /* get expected result */ ! 307: /* ! 308: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 309: * The force loop flag is set after the first error. ! 310: */ ! 311: asm("_expf_5_lp1:"); ! 312: asm("movl $0,r0"); /* clear r0 */ ! 313: asm("ldf r0"); /* load the Acc. with 0.0 */ ! 314: asm("addf _sgl_ld_acc"); /* add the 1st operand */ ! 315: asm("expf"); /* get the expf */ ! 316: asm("stf _sgl_st_acc"); /* store the result */ ! 317: if( force_loop ) ! 318: asm("brb _expf_5_lp1");; /* loop on the error */ ! 319: /* ! 320: * end error loop - test the results ! 321: */ ! 322: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 323: errcnt++; /* bump the error count */ ! 324: if( prt_error ) { ! 325: writes(" \n"); /* start a new print line */ ! 326: writes("cycle: "); ! 327: writed( cycle ); ! 328: writes(" EXPF test "); ! 329: writed( test_no ); ! 330: writes(", subtest 5 (Piped Entry) - BAD FINAL ACC\n"); ! 331: print_expf_data(); ! 332: writes(", data index = "); ! 333: writed( index ); ! 334: writec('\n'); ! 335: writes(" Acc expected = "); ! 336: write32h( sgl_expected ); ! 337: writec('\n'); ! 338: } ! 339: if( halt_flg ) ! 340: expf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 341: if( loop_on_err ) { ! 342: force_loop = TRUE; /* set the force loop flag */ ! 343: asm("brw _expf_5_lp1");; /* and loop on the error */ ! 344: } /* end of loop on error */ ! 345: } /* end of compare error */ ! 346: } /* end of WHILE loop */ ! 347: } /* end of subtest 5 */ ! 348: ! 349: ! 350: ! 351: /************************************************************************ ! 352: * ! 353: * SUBTEST 6 - pipelined exit test ! 354: * ! 355: ************************************************************************/ ! 356: expf_6() ! 357: { ! 358: force_loop = FALSE; ! 359: subtest = 8; ! 360: for( index = 0; index < max_expf_1_index; index++ ) { ! 361: sgl_ld_acc = expf_1_data[index].ld; /* get operand 1 */ ! 362: sgl_expected = expf_1_data[index].exp; /* get expected result */ ! 363: /* ! 364: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 365: * The force loop flag is set after the first error. ! 366: */ ! 367: asm("_expf_6_lp1:"); ! 368: asm("movl $0,r0"); /* clear r0 */ ! 369: asm("ldf _sgl_ld_acc"); /* load the Acc. */ ! 370: asm("expf"); /* get the expf */ ! 371: asm("addf r0"); /* add a zero to the acc */ ! 372: asm("stf _sgl_st_acc"); /* store the result */ ! 373: if( force_loop ) ! 374: asm("brb _expf_6_lp1");; /* loop on the error */ ! 375: /* ! 376: * end error loop - test the results ! 377: */ ! 378: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 379: errcnt++; /* bump the error count */ ! 380: if( prt_error ) { ! 381: writes(" \n"); /* start a new print line */ ! 382: writes("cycle: "); ! 383: writed( cycle ); ! 384: writes(" EXPF test "); ! 385: writed( test_no ); ! 386: writes(", subtest 6 (Piped Exit) - BAD FINAL ACC\n"); ! 387: print_expf_data(); ! 388: writes(", data index = "); ! 389: writed( index ); ! 390: writec('\n'); ! 391: writes(" Acc expected = "); ! 392: write32h( sgl_expected ); ! 393: writec('\n'); ! 394: } ! 395: if( halt_flg ) ! 396: expf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 397: if( loop_on_err ) { ! 398: force_loop = TRUE; /* set the force loop flag */ ! 399: asm("brw _expf_6_lp1");; /* and loop on the error */ ! 400: } /* end of loop on error */ ! 401: } /* end of compare error */ ! 402: } /* end of WHILE loop */ ! 403: } /* end of subtest 6 */ ! 404: ! 405: ! 406: ! 407: /************************************************************************** ! 408: * ! 409: * PRINT THE DATA AND STORE RESULTS ! 410: * ! 411: * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx ! 412: * Acc expected = xxxxxxxx ! 413: **************************************************************************/ ! 414: print_expf_data() ! 415: { ! 416: writes("initial Acc = "); ! 417: write32h( sgl_ld_acc ); ! 418: writes(", final Acc = "); ! 419: write32h( sgl_st_acc ); ! 420: } ! 421: ! 422: ! 423: ! 424: /************************************************************************** ! 425: * ! 426: * HALT ON ERROR ROUTINE ! 427: * ! 428: **************************************************************************/ ! 429: expf_er_halt( halt_code ) ! 430: int halt_code; ! 431: { ! 432: sgl_dummy1 = halt_code; /* get the error type */ ! 433: asm("movl _test_no,r0"); /* r0 = test number */ ! 434: asm("movl _subtest,r1"); /* r1 = subtest number */ ! 435: asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 436: asm("movl _cycle,r3"); /* r3 = cycle count */ ! 437: asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */ ! 438: asm("movl _sgl_st_acc,r5"); /* r5 = data stored */ ! 439: asm("movl _sgl_expected,r6"); /* r6 = data expected */ ! 440: asm("movl _index,r7"); /* r7 = data index */ ! 441: if( halt_code == BAD_REG_HLT ) { ! 442: sgl_dummy1 = load_regs[index2]; ! 443: sgl_dummy2 = store_regs[index2]; ! 444: asm("movl _index2,r6"); /* r6 = bad register # */ ! 445: asm("movl _sgl_dummy2,r7"); /* r7 = actual value */ ! 446: asm("movl _sgl_dummy1,r8"); /* r8 = expected value */ ! 447: } else ! 448: if( halt_code == BAD_PSL_HLT ) { ! 449: asm("movl _init_psl,r6"); /* r6 = initial PSL */ ! 450: asm("movl _psl_val,r7"); /* r7 = final PSL */ ! 451: asm("movl _exp_psl,r8"); /* r8 = expected PSL */ ! 452: }; ! 453: asm("halt"); /* HALT ... */ ! 454: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.