![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe9.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 pipe9.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: * PIPELINE TEST #9
6: *
7: * LDF(op1), MULF(op2), CVFL r0, SUBF operand[r0], STF
8: *
9: * -where the operands are the fmacro1 MULF data patterns. The SUBF operand's
10: * address is based on the result of the CVFL.
11: * -The load, multiply, and convert will be done twice. The first time will
12: * be to get the index and the data to subtract. The data to subtract will
13: * be the same as the accumulator so we'll expect a reasult of zero. The
14: * data will be stored based on the 1st CVFL result.
15: * -If the 2nd CVFL doesn't get done before the SUBF operand is fetched then
16: * we won't get a final accumulator of zero.
17: * -For size reasons, only the MULF data with a result between -100 and +100
18: * will be used for this test.
19: *****************************************************************************/
20: pipe_9()
21: {
22: asm(".globl _pipeline_9_t");
23: asm("_pipeline_9_t:");
24: if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
25: writes(" PIPE_9 ");
26: force_loop = FALSE; /* clear force_loop flag */
27: for( index = 0; index <= max_mulf_1_index; index++ ) {
28: sgl_value_1 = mulf_1_data[index].op_1; /* get the data */
29: sgl_value_2 = mulf_1_data[index].op_2; /* operands */
30: sgl_expected = mulf_1_data[index].exp;
31: asm("ldf _sgl_value_1");
32: asm("mulf _sgl_value_2");
33: asm("cvfl _index2");
34: asm("nop");
35: if( (index2 >= -99) && (index2 <= 99) ) {
36: if( index2 ) {
37: sgl_value_5 = 0; /* set a dummy index */
38: adr_pipe_ops[sgl_value_5] = 0;
39: } else {
40: sgl_value_5 = 6; /* set a dummy index */
41: adr_pipe_ops[sgl_value_5] = 0xabadbabe;
42: }
43: asm("movl _index2,r0"); /* save the index */
44: asm("stf _pipe_ops[r0]"); /* save the Acc's value */
45: asm("stf _sgl_value_4"); /* save this value */
46: /*
47: * This is the start of the LOOP ON ERROR section
48: */
49: asm("_pipe9_1_lp:");
50: asm("movl _sgl_value_5,r0"); /* save the bum index */
51: asm("ldf _sgl_value_1");
52: asm("mulf _sgl_value_2");
53: asm("cvfl r0"); /* set up the index to use */
54: asm("subf _pipe_ops[r0]"); /* subtract saved value */
55: asm("stf _sgl_st_acc");
56: asm("movl r0,_sgl_value_6"); /* save the index used */
57: if( force_loop )
58: asm("brb _pipe9_1_lp");; /* loop on the error */
59: /*
60: * Verify the results
61: */
62: if( sgl_st_acc ) { /* the Acc s/b cleared */
63: errcnt++; /* bump the error count */
64: if ( prt_error )
65: pipe9_print(); /* print the error mesage */
66: if ( halt_flg )
67: pipe9_halt( 1 ); /* halt on the error */
68: if ( loop_on_err ) {
69: force_loop = 1;
70: asm("jmp _pipe9_1_lp");;
71: }
72: }
73: }
74: };
75: asm("jmp *return"); /* return to the test monitor */
76: }
77:
78:
79:
80:
81: /***************************************************************************
82: *
83: * print an error message of the form
84: *
85: * cycle: xx Test xx, (Pipe 9), error
86: * test sequence = LDF(op1), MULF(op2), CVFL r0, SUBF operand[r0], STF
87: * op #1 = xxxxxxxx, final Acc = xxxxxxxx, data index = xxxxxxxx
88: * op #2 = xxxxxxxx, expected Acc = xxxxxxxx
89: * op #3 = xxxxxxxx, CVFL result = xxxxxxxx
90: * int expected = xxxxxxxx
91: ***************************************************************************/
92: pipe9_print()
93: {
94: writes("\n"); /* start a new print line */
95: writes("cycle: ");
96: writed( cycle );
97: writes(" Test ");
98: writed( test_no );
99: writes(" (Pipe 9), error\n");
100: writes(" LDF(op1), MULF(op2), CVFL(r0), SUBF(op3), STF\n");
101: writes("operand 1 = ");
102: write32h( sgl_value_1 );
103: writes(", final Acc = ");
104: write32h( sgl_st_acc );
105: writes(", data index = ");
106: writed( index );
107: writec('\n');
108: writes("operand 2 = ");
109: write32h( sgl_value_2 );
110: writes(", expected Acc = ");
111: write32h( sgl_expected );
112: writec('\n');
113: writes("operand 3 = ");
114: write32h( sgl_value_4 );
115: writes(", CVFL result = ");
116: write32h( sgl_value_6 );
117: writec('\n');
118: writes(" int expected = ");
119: write32h( index2 );
120: writec('\n');
121:
122:
123: }
124:
125:
126:
127: /*
128: **************************************************************************
129: *
130: * HALT ON AN ERROR
131: *
132: **************************************************************************
133: */
134: pipe9_halt()
135: {
136: asm("movl _test_no,r0"); /* r0 = test number */
137: asm("movl $1,r1"); /* r1 = subtest number */
138: asm("movl $1,r2"); /* r2 = error code */
139: asm("movl _cycle,r3"); /* r3 = cycle count */
140: asm("movl _sgl_value_1,r4"); /* r4 = sgl operand #1 */
141: asm("movl _sgl_value_2,r5"); /* r5 = sgl operand #2 */
142: asm("movl _sgl_st_acc,r6"); /* r6 = sgl stored */
143: asm("movl _sgl_expected,r7"); /* r7 = sgl expected */
144: asm("movl _sgl_value_6,r8"); /* r8 = CVFL int actual */
145: asm("movl _index2,r9"); /* r9 = CVFL int expected */
146: asm("movl _index,r10"); /* r10 = data index */
147: asm("halt"); /* HALT ... */
148: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.