![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe11.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 pipe11.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 #11 MONITOR
7: *
8: * This test will do a series of 2, 3, 4, 5, and 6 NEGFs.
9: *
10: *****************************************************************************/
11: pipe_11()
12: {
13: asm(".globl _pipeline_11_t");
14: asm("_pipeline_11_t:"); /* entry address */
15: if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
16: {
17: writes(" PIPE_11");
18: }
19: pipe11_1(); /* do 2 NEGFs */
20: pipe11_2(); /* do 3 NEGFs */
21: pipe11_3(); /* do 4 NEGFs */
22: pipe11_4(); /* do 5 NEGFs */
23: pipe11_5(); /* do 6 NEGFs */
24: asm("jmp *return"); /* return to the test monitor */
25: }
26:
27:
28:
29:
30:
31:
32: /************************************************************************
33: *
34: * SUBTEST 1 : 2 NEGFs
35: *
36: ************************************************************************/
37: pipe11_1()
38: {
39: subtest = 1;
40: force_loop = FALSE;
41: for( index = 0; index < max_ldf_1_index; index++ )
42: {
43: sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
44: sgl_expected = ldf_1_data[index].exp; /* get expected results */
45: /*
46: * If LOOP ON ERROR is set, this is the loop for this subtest.
47: * The force loop flag is set after the first error.
48: */
49: asm("_pipe11_1_lp1:");
50: asm("ldf _sgl_value_1"); /* load the operand */
51: asm("negf"); /* negate it ( twice ) */
52: asm("negf");
53: asm("stf _sgl_st_acc"); /* store the result */
54: if( force_loop )
55: asm("brb _pipe11_1_lp1"); /* loop on an error */
56: /*
57: * verify the results
58: */
59: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
60: errcnt++; /* bump the error count */
61: if( prt_error )
62: pipe11_print( 2 ); /* print error msg -2 NEGFS*/
63: if( halt_flg ) /* halt on error? */
64: pipe11_halt( 2 ); /* error halt -2 NEGFS */
65: if( loop_on_err ) {
66: force_loop = TRUE; /* set the force loop flag */
67: asm("jmp _pipe11_1_lp1"); /* and loop */
68: }
69: }
70: } /* end of FOR loop */
71: } /* end of subtest 1 */
72:
73:
74:
75:
76:
77: /************************************************************************
78: *
79: * SUBTEST 2 : 3 NEGFs
80: *
81: ************************************************************************/
82: pipe11_2()
83: {
84: subtest = 2;
85: force_loop = FALSE;
86: for( index = 0; index < max_ldf_1_index; index++ )
87: {
88: sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
89: sgl_expected = ldf_1_data[index].exp; /* get expected results */
90: if( sgl_expected )
91: sgl_expected ^= 0x80000000; /* negate exptd results */
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("_pipe11_2_lp1:");
97: asm("ldf _sgl_value_1"); /* load the operand */
98: asm("negf"); /* negate it ( 3 times ) */
99: asm("negf");
100: asm("negf");
101: asm("stf _sgl_st_acc"); /* store the result */
102: if( force_loop )
103: asm("brb _pipe11_2_lp1"); /* loop on an error */
104: /*
105: * verify the results
106: */
107: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
108: errcnt++; /* bump the error count */
109: if( prt_error )
110: pipe11_print( 3 ); /* print error msg -3 NEGFS*/
111: if( halt_flg ) /* halt on error? */
112: pipe11_halt( 3 ); /* error halt -3 NEGFS */
113: if( loop_on_err ) {
114: force_loop = TRUE; /* set the force loop flag */
115: asm("jmp _pipe11_2_lp1"); /* and loop */
116: }
117: }
118: } /* end of FOR loop */
119: } /* end of subtest 2 */
120:
121:
122:
123:
124:
125: /************************************************************************
126: *
127: * SUBTEST 3 : 4 NEGFs
128: *
129: ************************************************************************/
130: pipe11_3()
131: {
132: subtest = 3;
133: force_loop = FALSE;
134: for( index = 0; index < max_ldf_1_index; index++ )
135: {
136: sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
137: sgl_expected = ldf_1_data[index].exp; /* get expected results */
138: /*
139: * If LOOP ON ERROR is set, this is the loop for this subtest.
140: * The force loop flag is set after the first error.
141: */
142: asm("_pipe11_3_lp1:");
143: asm("ldf _sgl_value_1"); /* load the operand */
144: asm("negf"); /* negate it ( 4 times ) */
145: asm("negf");
146: asm("negf");
147: asm("negf");
148: asm("stf _sgl_st_acc"); /* store the result */
149: if( force_loop )
150: asm("brb _pipe11_3_lp1"); /* loop on an error */
151: /*
152: * verify the results
153: */
154: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
155: errcnt++; /* bump the error count */
156: if( prt_error )
157: pipe11_print( 4 ); /* print error msg -4 NEGFS*/
158: if( halt_flg ) /* halt on error? */
159: pipe11_halt( 4 ); /* error halt -4 NEGFS */
160: if( loop_on_err ) {
161: force_loop = TRUE; /* set the force loop flag */
162: asm("jmp _pipe11_3_lp1"); /* and loop */
163: }
164: }
165: } /* end of FOR loop */
166: } /* end of subtest 3 */
167:
168:
169:
170:
171:
172:
173: /************************************************************************
174: *
175: * SUBTEST 4 : 5 NEGFs
176: *
177: ************************************************************************/
178: pipe11_4()
179: {
180: subtest = 4;
181: force_loop = FALSE;
182: for( index = 0; index < max_ldf_1_index; index++ )
183: {
184: sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
185: sgl_expected = ldf_1_data[index].exp; /* get expected results */
186: if( sgl_expected )
187: sgl_expected ^= 0x80000000; /* negate exptd results */
188: /*
189: * If LOOP ON ERROR is set, this is the loop for this subtest.
190: * The force loop flag is set after the first error.
191: */
192: asm("_pipe11_4_lp1:");
193: asm("ldf _sgl_value_1"); /* load the operand */
194: asm("negf"); /* negate it ( 5 times ) */
195: asm("negf");
196: asm("negf");
197: asm("negf");
198: asm("negf");
199: asm("stf _sgl_st_acc"); /* store the result */
200: if( force_loop )
201: asm("brb _pipe11_4_lp1"); /* loop on an error */
202: /*
203: * verify the results
204: */
205: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
206: errcnt++; /* bump the error count */
207: if( prt_error )
208: pipe11_print( 5 ); /* print error msg -5 NEGFS*/
209: if( halt_flg ) /* halt on error? */
210: pipe11_halt( 5 ); /* error halt -5 NEGFS */
211: if( loop_on_err ) {
212: force_loop = TRUE; /* set the force loop flag */
213: asm("jmp _pipe11_4_lp1"); /* and loop */
214: }
215: }
216: } /* end of FOR loop */
217: } /* end of subtest 4 */
218:
219:
220:
221:
222:
223: /************************************************************************
224: *
225: * SUBTEST 5 : 6 NEGFs
226: *
227: ************************************************************************/
228: pipe11_5()
229: {
230: subtest = 5;
231: force_loop = FALSE;
232: for( index = 0; index < max_ldf_1_index; index++ )
233: {
234: sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
235: sgl_expected = ldf_1_data[index].exp; /* get expected results */
236: /*
237: * If LOOP ON ERROR is set, this is the loop for this subtest.
238: * The force loop flag is set after the first error.
239: */
240: asm("_pipe11_5_lp1:");
241: asm("ldf _sgl_value_1"); /* load the operand */
242: asm("negf"); /* negate it ( 6 times ) */
243: asm("negf");
244: asm("negf");
245: asm("negf");
246: asm("negf");
247: asm("negf");
248: asm("stf _sgl_st_acc"); /* store the result */
249: if( force_loop )
250: asm("brb _pipe11_5_lp1"); /* loop on an error */
251: /*
252: * verify the results
253: */
254: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
255: errcnt++; /* bump the error count */
256: if( prt_error )
257: pipe11_print( 6 ); /* print error msg -6 NEGFS*/
258: if( halt_flg ) /* halt on error? */
259: pipe11_halt( 6 ); /* error halt -6 NEGFS */
260: if( loop_on_err ) {
261: force_loop = TRUE; /* set the force loop flag */
262: asm("jmp _pipe11_5_lp1"); /* and loop */
263: }
264: }
265: } /* end of FOR loop */
266: } /* end of subtest 5 */
267:
268:
269:
270:
271: /****************************************************************************
272: *
273: * PRINT AN ERROR MESSAGE
274: *
275: * cycle dd PIPELINE 11, subtest dd error
276: * LDF op, {NEGF}, STF
277: * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = xxxxxxxx
278: * expected Acc = xxxxxxxx
279: ****************************************************************************/
280: pipe11_print( nop_count )
281: int nop_count; /* # of NEGF instructions */
282: {
283: writes(" \n"); /* start a new print line */
284: writes("cycle: ");
285: writed( cycle );
286: writes(" (Pipe 11), subtest ");
287: writed( subtest );
288: writes(" error\n");
289: writes(" LDF(op), NEGF");
290: while( --nop_count )
291: writes(", NEGF");
292: writes(", STF\n");
293: writec('\n');
294: writes("operand = ");
295: write32h( sgl_value_1 );
296: writes(", final Acc = ");
297: write32h( sgl_st_acc );
298: writes(", data index = ");
299: writed( index );
300: writec('\n');
301: writes(" expected Acc = ");
302: write32h( sgl_expected );
303: writec('\n');
304: }
305:
306:
307:
308: /****************************************************************************
309: *
310: * SET UP THE REGISTERS AND HALT
311: *
312: ****************************************************************************/
313: pipe11_halt( nop_count )
314: int nop_count; /* # of NEGF instructions */
315: {
316: sgl_dummy1 = nop_count;
317: asm("movl _test_no,r0"); /* r0 = test number */
318: asm("movl _subtest,r1"); /* r1 = subtest number */
319: asm("movl $1,r2"); /* r2 = error code */
320: asm("movl _cycle,r3"); /* r3 = cycle count */
321: asm("movl _sgl_dummy1,r4"); /* r4 = # of NEGFS */
322: asm("movl _sgl_value_1,r5"); /* r5 = sgl operand */
323: asm("movl _sgl_st_acc,r6"); /* r6 = sgl stored */
324: asm("movl _sgl_expected,r7"); /* r7 = sgl expected */
325: asm("movl _index,r8"); /* r8 = data index */
326: asm("halt"); /* HALT ... */
327: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.