![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe18.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 pipe18.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: * PIPELINE TEST #18 ! 7: * ! 8: * LDD(op1), MULD(op2), CVDL r0, SUBD operand[r0], STD ! 9: * ! 10: * -where the operands are the fmacro1 MULD data patterns. The SUBD operand's ! 11: * address is based on the result of the CVDL. ! 12: * -The load, multiply, and convert will be done twice. The first time will ! 13: * be to get the index and the data to subtract. The data to subtract will ! 14: * be the same as the accumulator so we'll expect a reasult of zero. The ! 15: * data will be stored based on the 1st CVDL result. ! 16: * -If the 2nd CVDL doesn't get done before the SUBD operand is fetched then ! 17: * we won't get a final accumulator of zero. ! 18: * -For size reasons, only the MULD data with a result between -100 and +100 ! 19: * will be used for this test. ! 20: *****************************************************************************/ ! 21: pipe_18() ! 22: { ! 23: asm(".globl _pipeline_18_t"); ! 24: asm("_pipeline_18_t:"); ! 25: if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 26: writes(" PIPE_18"); ! 27: force_loop = FALSE; /* clear force_loop flag */ ! 28: for( index = 0; index <= max_muld_1_index; index++ ) { ! 29: dbl_value_1 = muld_1_data[index].op_1; /* get the data */ ! 30: dbl_value_2 = muld_1_data[index].op_2; /* operands */ ! 31: dbl_expected.m = dbl_expected.l = 0; /* result s/b 0 */ ! 32: asm("ldd _dbl_value_1"); ! 33: asm("muld _dbl_value_2"); ! 34: asm("cvdl _index2"); ! 35: asm("nop"); ! 36: if( (index2 >= -99) && (index2 <= 99) ) { ! 37: if( index2 ) { ! 38: sgl_value_5 = 0; /* set a dummy index */ ! 39: adr_dpipe_ops[sgl_value_5].m = 0; ! 40: adr_dpipe_ops[sgl_value_5].l = 0xabadface; ! 41: } else { ! 42: sgl_value_5 = 6; /* set a dummy index */ ! 43: adr_dpipe_ops[sgl_value_5].m = 0xabadbabe; ! 44: adr_dpipe_ops[sgl_value_5].l = 0xabadface; ! 45: } ! 46: asm("movl _index2,r0"); /* save the index */ ! 47: asm("std _dpipe_ops[r0]"); /* save the Acc's value */ ! 48: asm("std _dbl_value_3"); /* save this value */ ! 49: /* ! 50: * This is the start of the LOOP ON ERROR section ! 51: */ ! 52: asm("_pipe18_1_lp:"); ! 53: asm("movl _sgl_value_5,r0"); /* save the bum index */ ! 54: asm("ldd _dbl_value_1"); ! 55: asm("muld _dbl_value_2"); ! 56: asm("cvdl r0"); /* set up the index to use */ ! 57: asm("subd _dpipe_ops[r0]"); /* subtract saved value */ ! 58: asm("std _dbl_st_acc"); ! 59: asm("movl r0,_sgl_value_6"); /* save the index used */ ! 60: if( force_loop ) ! 61: asm("brb _pipe18_1_lp");; /* loop on the error */ ! 62: /* ! 63: * Verify the results (the accumulator should be = 0) ! 64: */ ! 65: if( (dbl_st_acc.m) || (dbl_st_acc.l) ) { ! 66: errcnt++; /* bump the error count */ ! 67: if ( prt_error ) ! 68: pipe18_print(); /* print the error mesage */ ! 69: if ( halt_flg ) ! 70: pipe18_halt( 1 ); /* halt on the error */ ! 71: if ( loop_on_err ) { ! 72: force_loop = TRUE; ! 73: asm("jmp _pipe18_1_lp");; ! 74: } ! 75: } ! 76: } ! 77: } ! 78: asm("jmp *return"); /* return to the test monitor */ ! 79: } ! 80: ! 81: ! 82: ! 83: ! 84: /* ! 85: ************************************************************************** ! 86: * ! 87: * print an error message of the form ! 88: * ! 89: * cycle: xx Test xx, Error with subtract data based on CVDL value, index = xx ! 90: * test sequence = LDD(op1), MULD(op2), CVDL r0, SUBD operand[r0], STD ! 91: *operand 1 = xxxxxxx xxxxxxx, final Acc = xxxxxxx xxxxxxx, index = xxxxxxx ! 92: *operand 2 = xxxxxxx xxxxxxx, expected Acc = xxxxxxx xxxxxxx ! 93: *operand 3 = xxxxxxx xxxxxxx, CVDL result = xxxxxxx ! 94: * int expected = xxxxxxx ! 95: ************************************************************************** ! 96: */ ! 97: pipe18_print() ! 98: { ! 99: writes(" \n"); /* start a new print line */ ! 100: writes("cycle: "); ! 101: writed( cycle ); ! 102: writes(" Test "); ! 103: writed( test_no ); ! 104: writes(" (Pipe 18), error\n"); ! 105: writes(" LDD(op1), MULD(op2), CVDL(r0), SUBD(op3), STD\n"); ! 106: writes("operand 1 = "); ! 107: write32h( dbl_value_1.m ); ! 108: writec(' '); ! 109: write32h( dbl_value_1.l ); ! 110: writes(", final Acc = "); ! 111: write32h( dbl_st_acc.m ); ! 112: writec(' '); ! 113: write32h( dbl_st_acc.l ); ! 114: writes(", index = "); ! 115: writed( index ); ! 116: writes("\noperand 2 = "); ! 117: write32h( dbl_value_2.m ); ! 118: writec(' '); ! 119: write32h( dbl_value_2.l ); ! 120: writes(", expected Acc = "); ! 121: write32h( dbl_expected.m ); ! 122: writec(' '); ! 123: write32h( dbl_expected.l ); ! 124: writes("\noperand 3 = "); ! 125: write32h( dbl_value_3.m ); ! 126: writec(' '); ! 127: write32h( dbl_value_3.l ); ! 128: writes(", CVDL result = "); ! 129: write32h( sgl_value_6 ); ! 130: writec('\n'); ! 131: writes(" int expected = "); ! 132: write32h( index2 ); ! 133: writec('\n'); ! 134: } ! 135: ! 136: ! 137: ! 138: /* ! 139: ************************************************************************** ! 140: * ! 141: * HALT ON AN ERROR ! 142: * ! 143: ************************************************************************** ! 144: */ ! 145: pipe18_halt() ! 146: { ! 147: sgl_value_1 = dbl_value_1.m; ! 148: sgl_value_2 = dbl_value_1.l; ! 149: sgl_value_3 = dbl_value_2.m; ! 150: sgl_value_4 = dbl_value_2.l; ! 151: asm("movl _test_no,r0"); /* r0 = test number */ ! 152: asm("movl $1,r1"); /* r1 = subtest number */ ! 153: asm("movl $1,r2"); /* r2 = error code */ ! 154: asm("movl _cycle,r3"); /* r3 = cycle count */ ! 155: asm("movl _sgl_value_1,r4"); /* r4 = MS of dbl operand #1 */ ! 156: asm("movl _sgl_value_2,r5"); /* r5 = LS of dbl operand #1 */ ! 157: asm("movl _sgl_value_3,r6"); /* r6 = MS of dbl operand #2 */ ! 158: asm("movl _sgl_value_4,r7"); /* r7 = LS of dbl operand #2 */ ! 159: sgl_value_1 = dbl_st_acc.m; ! 160: sgl_value_2 = dbl_st_acc.l; ! 161: sgl_value_3 = dbl_expected.m; ! 162: sgl_value_4 = dbl_expected.l; ! 163: sgl_value_5 = dbl_value_3.m; ! 164: sgl_value_6 = dbl_value_3.l; ! 165: asm("movl _sgl_value_5,r8"); /* r8 = MS of dbl operand #3 */ ! 166: asm("movl _sgl_value_6,r9"); /* r9 = LS of dbl operand #3 */ ! 167: asm("movl _sgl_value_1,r10"); /* r10 = MS of final result */ ! 168: asm("movl _sgl_value_2,r11"); /* r11 = LS of final result */ ! 169: asm("movl _sgl_value_3,r12"); /* r12 = MS of expected result */ ! 170: asm("movl _sgl_value_4,r13"); /* r13 = LS of expected result */ ! 171: asm("movl _index,r14"); /* r14 = data index */ ! 172: asm("halt"); /* HALT ... */ ! 173: } ! 174:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.