![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmpd.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 cmpd.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: * CMPD -COMPARE SGL ACCUMULATOR TO SGL OPERAND ! 8: * ! 9: *****************************************************************************/ ! 10: cmpd() ! 11: { ! 12: asm(".globl _cmpd_t"); ! 13: asm("_cmpd_t:"); /* entry address */ ! 14: if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */ ! 15: { ! 16: writes(" CMPD"); ! 17: } ! 18: cmpd_1(); /* test via registers */ ! 19: cmpd_2(); /* test via cache */ ! 20: cmpd_3(); /* register corruption test */ ! 21: cmpd_4(); /* acc. corruption test */ ! 22: asm("jmp *return"); /* return to the test monitor */ ! 23: } ! 24: ! 25: ! 26: ! 27: /**************************************************************************** ! 28: * ! 29: * SUBTEST 1 - CMPD status test -register data ! 30: * ! 31: ****************************************************************************/ ! 32: cmpd_1() ! 33: { ! 34: force_loop = FALSE; ! 35: subtest = 1; ! 36: index = 0; ! 37: do ! 38: { ! 39: dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */ ! 40: dbl_value_2 = cmpd_1_data[index].two; ! 41: sgl_expected = cmpd_1_data[index].flag; /* get expected results */ ! 42: sgl_value_1 = dbl_value_1.m; ! 43: sgl_value_2 = dbl_value_1.l; ! 44: sgl_value_3 = dbl_value_2.m; ! 45: sgl_value_4 = dbl_value_2.l; ! 46: status_index = 0; /* clear the status index */ ! 47: do ! 48: { ! 49: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */ ! 50: /* ! 51: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 52: * The force loop flag is set after the first error. ! 53: */ ! 54: asm("_cmpd_1_lp1:"); ! 55: asm("movl _sgl_value_1,r4"); /* move operand #1 to r4 */ ! 56: asm("movl _sgl_value_2,r5"); /* move operand #1 to r5 */ ! 57: asm("movl _sgl_value_3,r6"); /* move operand #2 to r6 */ ! 58: asm("movl _sgl_value_4,r7"); /* move operand #2 to r7 */ ! 59: asm("ldd r4"); /* load the operand */ ! 60: asm("tstl _sgl_dummy1"); /* generate initial status */ ! 61: asm("movpsl _init_psl"); /* save the initial status */ ! 62: asm("cmpd r6"); /* compare the operands */ ! 63: asm("movpsl _psl_val"); /* save the final status */ ! 64: if( force_loop ) /* loop? */ ! 65: asm("brb _cmpd_1_lp1");; /* run the loop again */ ! 66: exp_psl = init_psl; /* get the initial PSL */ ! 67: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */ ! 68: if( sgl_expected == ZERO ) ! 69: exp_psl |= PSL_Z; /* expect the ZERO bit set */ ! 70: if( sgl_expected == NEGATIVE ) ! 71: exp_psl |= PSL_N; /* expect the NEG bit set */ ! 72: if( psl_val != exp_psl ) { /* COMPARE the values */ ! 73: errcnt++; /* bump the error count */ ! 74: if ( prt_error ) { ! 75: writes(" \n"); /* start a new print line */ ! 76: writes("cycle: "); ! 77: writed( cycle ); ! 78: writes(" CMPD test "); ! 79: writed( test_no ); ! 80: writes(", subtest 1 (Reg. Data) - BAD FINAL PSL\n"); ! 81: print_cmpd_data(); ! 82: writes(", index = "); ! 83: writed( index ); ! 84: writes("\ninitial PSL = "); ! 85: write32h( init_psl ); ! 86: writes(", final PSL = "); ! 87: write32h( psl_val ); ! 88: writes(", expected PSL = "); ! 89: write32h( exp_psl ); ! 90: writes("\n"); ! 91: } ! 92: if ( halt_flg ) ! 93: cmpd_er_halt( BAD_PSL_HLT );/* halt on the error */ ! 94: if ( loop_on_err ) { ! 95: force_loop = TRUE; /* set the force loop flag */ ! 96: asm("brw _cmpd_1_lp1"); /* and loop on the error */ ! 97: } /* end of loop on error */ ! 98: } /* end of compare error */ ! 99: } while( ++status_index < 3 ); /* end of WHILE loop */ ! 100: } while ( index++ < max_cmpd_1_index ); /* end of WHILE loop */ ! 101: } /* end of subtest 1 */ ! 102: ! 103: ! 104: ! 105: /**************************************************************************** ! 106: * ! 107: * SUBTEST 2 - CMPD status test -cache data ! 108: * ! 109: ****************************************************************************/ ! 110: cmpd_2() ! 111: { ! 112: force_loop = FALSE; ! 113: subtest = 2; ! 114: index = 0; ! 115: do ! 116: { ! 117: dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */ ! 118: dbl_value_2 = cmpd_1_data[index].two; ! 119: sgl_expected = cmpd_1_data[index].flag;/* get expected results */ ! 120: status_index = 0; /* clear the status index */ ! 121: do ! 122: { ! 123: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */ ! 124: /* ! 125: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 126: * The force loop flag is set after the first error. ! 127: */ ! 128: asm("_cmpd_2_lp1:"); ! 129: asm("ldd _dbl_value_1"); /* load the 1st operand */ ! 130: asm("tstl _sgl_dummy1"); /* generate initial status */ ! 131: asm("movpsl _init_psl"); /* save the initial status */ ! 132: asm("cmpd _dbl_value_2"); /* compare the operands */ ! 133: asm("movpsl _psl_val"); /* save the final status */ ! 134: if( force_loop ) /* loop? */ ! 135: asm("brb _cmpd_2_lp1");; /* run the loop again */ ! 136: exp_psl = init_psl; /* get the initial PSL */ ! 137: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */ ! 138: if( sgl_expected == ZERO ) ! 139: exp_psl |= PSL_Z; /* expect the ZERO bit set */ ! 140: if( sgl_expected == NEGATIVE ) ! 141: exp_psl |= PSL_N; /* expect the NEG bit set */ ! 142: if( psl_val != exp_psl ) { /* COMPARE the values */ ! 143: errcnt++; /* bump the error count */ ! 144: if ( prt_error ) { ! 145: writes(" \n"); /* start a new print line */ ! 146: writes("cycle: "); ! 147: writed( cycle ); ! 148: writes(" CMPD test "); ! 149: writed( test_no ); ! 150: writes(", subtest 2 (Cache Data) - BAD FINAL PSL\n"); ! 151: print_cmpd_data(); ! 152: writes(", index = "); ! 153: writed( index ); ! 154: writes("\ninitial PSL = "); ! 155: write32h( init_psl ); ! 156: writes(", final PSL = "); ! 157: write32h( psl_val ); ! 158: writes(", expected PSL = "); ! 159: write32h( exp_psl ); ! 160: writes("\n"); ! 161: } ! 162: if ( halt_flg ) ! 163: cmpd_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 164: if ( loop_on_err ) { ! 165: force_loop = TRUE; /* set the force loop flag */ ! 166: asm("brw _cmpd_2_lp1"); /* and loop on the error */ ! 167: } /* end of loop on error */ ! 168: } /* end of compare error */ ! 169: } while( ++status_index < 3 ); /* end of WHILE loop */ ! 170: } while ( index++ < max_cmpd_1_index ); /* end of WHILE loop */ ! 171: } /* end of subtest 2 */ ! 172: ! 173: ! 174: ! 175: /************************************************************************ ! 176: * ! 177: * SUBTEST 3 - Check for register corruption ! 178: * ! 179: ************************************************************************/ ! 180: cmpd_3() ! 181: { ! 182: force_loop = FALSE; /* clear force_loop flg */ ! 183: subtest = 3; ! 184: fill_reg_buf( load_regs ); /* get pattern for regs */ ! 185: index = 0; ! 186: do ! 187: { ! 188: dbl_value_1 = cmpd_1_data[index].one; /* data to load */ ! 189: dbl_value_2 = cmpd_1_data[index].two; /* data to compare */ ! 190: dbl_expected = cmpd_1_data[index].one; /* expected result */ ! 191: /* ! 192: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 193: * The force loop flag is set after the first error. ! 194: */ ! 195: asm("_cmpd_3_lp1:"); ! 196: asm("ldd _dbl_value_1"); /* LOAD the accumulator */ ! 197: asm("nop"); ! 198: asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */ ! 199: asm("nop"); ! 200: asm("cmpd _dbl_value_2"); /* test the values */ ! 201: asm("nop"); ! 202: asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 203: if( force_loop ) /* loop? */ ! 204: asm("brb _cmpd_3_lp1");; /* run the loop again */ ! 205: /* ! 206: * Now compare the stored register values to those that were loaded ! 207: */ ! 208: index2 = 0; ! 209: while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) ) ! 210: index2++; /* check reg values */ ! 211: if( index2 < 13 ) { /* error if index2 < 13 */ ! 212: errcnt++; /* bump the error count */ ! 213: if ( prt_error ) { ! 214: writes(" \n"); /* start a new print line */ ! 215: writes("cycle: "); ! 216: writed( cycle ); ! 217: writes(", CMPD test "); ! 218: writed( test_no ); ! 219: writes(", subtest 3 - A REGISTER WAS MODIFIED\n"); ! 220: print_cmpd_data(); /* print the operands */ ! 221: writes("\n"); ! 222: writes("register "); /* print the information */ ! 223: writed( index2 ); /* about the corrupted */ ! 224: writes(" = "); /* register */ ! 225: write32h( store_regs[index2] ); ! 226: writes(", should be = "); ! 227: write32h( load_regs[index2] ); ! 228: writes("\n"); ! 229: } ! 230: if ( halt_flg ) /* halt on error? */ ! 231: cmpd_er_halt( BAD_REG_HLT ); /* PC after halt */ ! 232: if ( loop_on_err ) { ! 233: force_loop = TRUE; /* set force loop flag */ ! 234: asm("brw _cmpd_3_lp1"); /* and loop on error */ ! 235: } /* end of loop on error */ ! 236: } /* end of register corruption error */ ! 237: } while ( index++ < max_cmpd_1_index ); /* end of WHILE loop */ ! 238: } /* end of subtest 3 */ ! 239: ! 240: ! 241: ! 242: /************************************************************************ ! 243: * ! 244: * SUBTEST 4 - Check for accumulator corruption ! 245: * ! 246: ************************************************************************/ ! 247: cmpd_4() ! 248: { ! 249: force_loop = FALSE; /* clear force_loop flg */ ! 250: index = 0; ! 251: do ! 252: { ! 253: dbl_value_1 = cmpd_1_data[index].one; /* data to load */ ! 254: dbl_value_2 = cmpd_1_data[index].two; ! 255: dbl_expected = cmpd_1_data[index].one; /* expected result */ ! 256: if( !(dbl_value_1.m & 0x7f800000) ) { /* */ ! 257: dbl_expected.m = 0; /* */ ! 258: dbl_expected.l = 0; /* ignore bad 0's */ ! 259: } /* */ ! 260: sgl_value_1 = dbl_value_1.m; ! 261: sgl_value_2 = dbl_value_1.l; ! 262: sgl_value_3 = dbl_value_2.m; ! 263: sgl_value_4 = dbl_value_2.l; ! 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("_cmpd_4_lp1:"); ! 269: asm("movl _sgl_value_1,r4"); /* r4 = operand #1's MSW */ ! 270: asm("movl _sgl_value_2,r5"); /* r5 = operand #1's LSW */ ! 271: asm("movl _sgl_value_3,r6"); /* r6 = operand #2's MSW */ ! 272: asm("movl _sgl_value_4,r7"); /* r7 = operand #2's LSW */ ! 273: asm("ldd r4"); /* store the accumulator */ ! 274: asm("cmpd r6"); /* test the values */ ! 275: asm("std r8"); /* store the accumulator */ ! 276: if( force_loop ) /* loop? */ ! 277: asm("brb _cmpd_4_lp1");; /* run the loop again */ ! 278: asm("movl r8,_sgl_value_5"); /* move results to cache */ ! 279: asm("movl r9,_sgl_value_6"); ! 280: if ( (sgl_value_5 != dbl_expected.m) || /* COMPARE the values */ ! 281: (sgl_value_6 != dbl_expected.l) ){ ! 282: errcnt++; /* bump the error count */ ! 283: if ( prt_error ) { ! 284: writes(" \n"); /* start a new print line */ ! 285: writes("cycle: "); ! 286: writed( cycle ); ! 287: writes(", CMPD test "); ! 288: writed( test_no ); ! 289: writes(", subtest 4 - THE ACC WAS MODIFIED\n"); ! 290: print_cmpd_data(); ! 291: writes(", index = "); ! 292: writed( index ); ! 293: writec('\n'); ! 294: writes(" final Acc = "); ! 295: write32h( sgl_value_5 ); ! 296: writec(' '); ! 297: write32h( sgl_value_6 ); ! 298: writec('\n'); ! 299: writes(" expected = "); ! 300: write32h( dbl_expected.m ); ! 301: writec(' '); ! 302: write32h( dbl_expected.l ); ! 303: writec('\n'); ! 304: } ! 305: if ( halt_flg ) /* halt on error? */ ! 306: cmpd_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 307: if ( loop_on_err ) { ! 308: force_loop = TRUE; /* set the force loop flag */ ! 309: asm("brw _cmpd_4_lp1"); /* and loop on the error */ ! 310: } /* end of loop on error */ ! 311: } /* end of compare error */ ! 312: } while ( index++ < max_cmpd_1_index ); /* end of WHILE loop */ ! 313: } /* end of subtest 4 */ ! 314: ! 315: ! 316: ! 317: /************************************************************************** ! 318: * ! 319: * PRINT THE DATA AND STORE RESULTS ! 320: * ! 321: * initial Acc = xxxxxxxx xxxxxxxx, operand = xxxxxxxx xxxxxxxx ! 322: **************************************************************************/ ! 323: print_cmpd_data() ! 324: { ! 325: writes("initial Acc = "); ! 326: write32h( dbl_value_1.m ); ! 327: writec(' '); ! 328: write32h( dbl_value_1.l ); ! 329: writes(" operand = "); ! 330: write32h( dbl_value_2.m ); ! 331: writec(' '); ! 332: write32h( dbl_value_2.l ); ! 333: } ! 334: ! 335: ! 336: ! 337: /************************************************************************** ! 338: * ! 339: * HALT ON ERROR ROUTINE ! 340: * ! 341: **************************************************************************/ ! 342: cmpd_er_halt( halt_code ) ! 343: int halt_code; ! 344: { ! 345: sgl_value_1 = dbl_value_1.m; ! 346: sgl_value_2 = dbl_value_1.l; ! 347: sgl_value_3 = dbl_value_2.m; ! 348: sgl_value_4 = dbl_value_2.l; ! 349: sgl_value_5 = dbl_st_acc.m; ! 350: sgl_value_6 = dbl_st_acc.l; ! 351: sgl_dummy1 = halt_code; /* get the error type */ ! 352: asm("movl _test_no,r0"); /* r0 = test number */ ! 353: asm("movl _subtest,r1"); /* r1 = subtest number */ ! 354: asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 355: asm("movl _cycle,r3"); /* r3 = cycle count */ ! 356: asm("movl _sgl_value_1,r4"); /* r4 = MS operand 1 */ ! 357: asm("movl _sgl_value_2,r5"); /* r5 = LS operand 1 */ ! 358: asm("movl _sgl_value_3,r6"); /* r6 = MS operand 2 */ ! 359: asm("movl _sgl_value_4,r7"); /* r7 = MS operand 2 */ ! 360: asm("movl _psl_val,r8"); /* r8 = actual PSL */ ! 361: if( halt_code == BAD_ACC_HLT ) { ! 362: sgl_value_1 = dbl_expected.m; ! 363: sgl_value_2 = dbl_expected.l; ! 364: asm("movl _sgl_value_5,r9"); /* r9 = MS stored */ ! 365: asm("movl _sgl_value_6,r10"); /* r10 = LS stored */ ! 366: asm("movl _sgl_value_1,r11"); /* r11 = MS expected */ ! 367: asm("movl _sgl_value_2,r12"); /* r12 = LS expected */ ! 368: } else ! 369: if( halt_code == BAD_REG_HLT ) { ! 370: sgl_dummy1 = load_regs[index2]; ! 371: sgl_dummy2 = store_regs[index2]; ! 372: asm("movl _index2,r9"); /* r9 = bad register # */ ! 373: asm("movl _sgl_dummy2,r10"); /* r10 = actual value */ ! 374: asm("movl _sgl_dummy1,r11"); /* r11 = expected value */ ! 375: } else ! 376: if( halt_code == BAD_PSL_HLT ) { ! 377: asm("movl _exp_psl,r9"); /* r9 = expected PSL */ ! 378: asm("movl _index,r10"); /* r10 = data index */ ! 379: }; ! 380: asm("halt"); /* HALT ... */ ! 381: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.