![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe20.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 pipe20.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: * DBL PIPELINE TEST #20 MONITOR
7: *
8: * This test will do a series of 2, 3, 4, 5, and 6 NEGDs.
9: * The data used will be the LDD data patterns.
10: *
11: *****************************************************************************/
12: pipe_20()
13: {
14: asm(".globl _pipeline_20_t");
15: asm("_pipeline_20_t:"); /* entry address */
16: if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
17: writes(" PIPE_20");
18: pipe20_1(); /* 2 NOPs */
19: pipe20_2(); /* 3 NOPs */
20: pipe20_3(); /* 4 NOPs */
21: pipe20_4(); /* 5 NOPs */
22: pipe20_5(); /* 6 NOPs */
23: asm("jmp *return"); /* return to the test monitor */
24: }
25:
26:
27:
28:
29:
30: /************************************************************************
31: *
32: * SUBTEST 1 : 2 NEGDs
33: *
34: ************************************************************************/
35: pipe20_1()
36: {
37: subtest = 1;
38: force_loop = FALSE;
39: for( index = 0; index < max_ldd_1_index; index++ )
40: {
41: dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
42: dbl_expected = ldd_1_data[index].exp; /* get expected results */
43: /*
44: * If LOOP ON ERROR is set, this is the loop for this subtest.
45: * The force loop flag is set after the first error.
46: */
47: asm("_pipe20_1_lp1:");
48: asm("ldd _dbl_value_1"); /* load the operand */
49: asm("negd"); /* negate it ( twice ) */
50: asm("negd");
51: asm("std _dbl_st_acc"); /* store the result */
52: if( force_loop )
53: asm("brb _pipe20_1_lp1"); /* loop on an error */
54: /*
55: * verify the results
56: */
57: if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
58: (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
59: errcnt++; /* bump the error count */
60: if( prt_error )
61: pipe20_print( 2 ); /* print error msg -2 NOPs */
62: if( halt_flg ) /* halt on error? */
63: pipe20_halt( 2 ); /* error halt -2 NOPs */
64: if( loop_on_err ) {
65: force_loop = TRUE; /* set the force loop flag */
66: asm("jmp _pipe20_1_lp1"); /* and loop */
67: }
68: }
69: } /* end of FOR loop */
70: } /* end of subtest 1 */
71:
72:
73:
74:
75:
76: /************************************************************************
77: *
78: * SUBTEST 2 : 3 NEGDs
79: *
80: ************************************************************************/
81: pipe20_2()
82: {
83: subtest = 2;
84: force_loop = FALSE;
85: for( index = 0; index < max_ldd_1_index; index++ )
86: {
87: dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
88: dbl_expected = ldd_1_data[index].exp; /* get expected results */
89: if( dbl_expected.m )
90: dbl_expected.m ^= 0x80000000; /* negate exptd results */
91: /*
92: * If LOOP ON ERROR is set, this is the loop for this subtest.
93: * The force loop flag is set after the first error.
94: */
95: asm("_pipe20_2_lp1:");
96: asm("ldd _dbl_value_1"); /* load the operand */
97: asm("negd"); /* negate it ( 3 times ) */
98: asm("negd");
99: asm("negd");
100: asm("std _dbl_st_acc"); /* store the result */
101: if( force_loop )
102: asm("brb _pipe20_2_lp1"); /* loop on an error */
103: /*
104: * verify the results
105: */
106: if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
107: (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
108: errcnt++; /* bump the error count */
109: if( prt_error )
110: pipe20_print( 3 ); /* print error msg -3 NOPs */
111: if( halt_flg ) /* halt on error? */
112: pipe20_halt( 3 ); /* error halt -3 NOPs */
113: if( loop_on_err ) {
114: force_loop = TRUE; /* set the force loop flag */
115: asm("jmp _pipe20_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 NEGDs
128: *
129: ************************************************************************/
130: pipe20_3()
131: {
132: subtest = 3;
133: force_loop = FALSE;
134: for( index = 0; index < max_ldd_1_index; index++ )
135: {
136: dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
137: dbl_expected = ldd_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("_pipe20_3_lp1:");
143: asm("ldd _dbl_value_1"); /* load the operand */
144: asm("negd"); /* negate it ( 4 times ) */
145: asm("negd");
146: asm("negd");
147: asm("negd");
148: asm("std _dbl_st_acc"); /* store the result */
149: if( force_loop )
150: asm("brb _pipe20_3_lp1"); /* loop on an error */
151: /*
152: * verify the results
153: */
154: if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
155: (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
156: errcnt++; /* bump the error count */
157: if( prt_error )
158: pipe20_print( 4 ); /* print error msg -4 NOPs */
159: if( halt_flg ) /* halt on error? */
160: pipe20_halt( 4 ); /* error halt -4 NOPs */
161: if( loop_on_err ) {
162: force_loop = TRUE; /* set the force loop flag */
163: asm("jmp _pipe20_3_lp1"); /* and loop */
164: }
165: }
166: } /* end of FOR loop */
167: } /* end of subtest 3 */
168:
169:
170:
171:
172:
173:
174: /************************************************************************
175: *
176: * SUBTEST 4 : 5 NEGDs
177: *
178: ************************************************************************/
179: pipe20_4()
180: {
181: subtest = 4;
182: force_loop = FALSE;
183: for( index = 0; index < max_ldd_1_index; index++ )
184: {
185: dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
186: dbl_expected = ldd_1_data[index].exp; /* get expected results */
187: if( dbl_expected.m )
188: dbl_expected.m ^= 0x80000000; /* negate exptd results */
189: /*
190: * If LOOP ON ERROR is set, this is the loop for this subtest.
191: * The force loop flag is set after the first error.
192: */
193: asm("_pipe20_4_lp1:");
194: asm("ldd _dbl_value_1"); /* load the operand */
195: asm("negd"); /* negate it ( 5 times ) */
196: asm("negd");
197: asm("negd");
198: asm("negd");
199: asm("negd");
200: asm("std _dbl_st_acc"); /* store the result */
201: if( force_loop )
202: asm("brb _pipe20_4_lp1"); /* loop on an error */
203: /*
204: * verify the results
205: */
206: if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
207: (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
208: errcnt++; /* bump the error count */
209: if( prt_error )
210: pipe20_print( 5 ); /* print error msg -5 NOPs */
211: if( halt_flg ) /* halt on error? */
212: pipe20_halt( 5 ); /* error halt -5 NOPs */
213: if( loop_on_err ) {
214: force_loop = TRUE; /* set the force loop flag */
215: asm("jmp _pipe20_4_lp1"); /* and loop */
216: }
217: }
218: } /* end of FOR loop */
219: } /* end of subtest 4 */
220:
221:
222:
223:
224:
225: /************************************************************************
226: *
227: * SUBTEST 5 : 6 NEGDs
228: *
229: ************************************************************************/
230: pipe20_5()
231: {
232: subtest = 5;
233: force_loop = FALSE;
234: for( index = 0; index < max_ldd_1_index; index++ )
235: {
236: dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
237: dbl_expected = ldd_1_data[index].exp; /* get expected results */
238: /*
239: * If LOOP ON ERROR is set, this is the loop for this subtest.
240: * The force loop flag is set after the first error.
241: */
242: asm("_pipe20_5_lp1:");
243: asm("ldd _dbl_value_1"); /* load the operand */
244: asm("negd"); /* negate it ( 6 times ) */
245: asm("negd");
246: asm("negd");
247: asm("negd");
248: asm("negd");
249: asm("negd");
250: asm("std _dbl_st_acc"); /* store the result */
251: if( force_loop )
252: asm("brb _pipe20_5_lp1"); /* loop on an error */
253: /*
254: * verify the results
255: */
256: if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
257: (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
258: errcnt++; /* bump the error count */
259: if( prt_error )
260: pipe20_print( 6 ); /* print error msg -6 NOPs */
261: if( halt_flg ) /* halt on error? */
262: pipe20_halt( 6 ); /* error halt -6 NOPs */
263: if( loop_on_err ) {
264: force_loop = TRUE; /* set the force loop flag */
265: asm("jmp _pipe20_5_lp1"); /* and loop */
266: }
267: }
268: } /* end of FOR loop */
269: } /* end of subtest 5 */
270:
271:
272:
273:
274: /****************************************************************************
275: *
276: * PRINT AN ERROR MESSAGE
277: *
278: * cycle dd PIPELINE 20, subtest dd error
279: * LDD op, {NEGD}, STD
280: * operand = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = dd
281: * expected Acc = xxxxxxxx xxxxxxxx
282: *
283: ****************************************************************************/
284: pipe20_print( nop_count )
285: int nop_count; /* # of NOP instructions */
286: {
287: writes(" \n"); /* start a new print line */
288: writes("cycle: ");
289: writed( cycle );
290: writes(" PIPELINE 20, subtest ");
291: writed( subtest );
292: writes(" error\n");
293: writes(" LDD(op), NEGD");
294: while( --nop_count )
295: writes(", NEGD");
296: writes(", STD\n");
297: writes("operand = ");
298: write32h( dbl_value_1.m );
299: writec(' ');
300: write32h( dbl_value_1.l );
301: writes(", final Acc = ");
302: write32h( dbl_st_acc.m );
303: writec(' ');
304: write32h( dbl_st_acc.l );
305: writes(", index = ");
306: writed( index );
307: writes("\n expected Acc = ");
308: write32h( dbl_expected.m );
309: writec(' ');
310: write32h( dbl_expected.l );
311: writec('\n');
312: }
313:
314:
315:
316: /****************************************************************************
317: *
318: * SET UP THE REGISTERS AND HALT
319: *
320: ****************************************************************************/
321: pipe20_halt( nop_count )
322: int nop_count; /* # of NOP instructions */
323: {
324: sgl_dummy1 = nop_count;
325: sgl_value_1 = dbl_value_1.m;
326: sgl_value_2 = dbl_value_1.l;
327: sgl_value_3 = dbl_st_acc.m;
328: sgl_value_4 = dbl_st_acc.l;
329: sgl_value_5 = dbl_expected.m;
330: sgl_value_6 = dbl_expected.l;
331: asm("movl _test_no,r0"); /* r0 = test number */
332: asm("movl _subtest,r1"); /* r1 = subtest number */
333: asm("movl $1,r2"); /* r2 = error code */
334: asm("movl _cycle,r3"); /* r3 = cycle count */
335: asm("movl _sgl_dummy1,r4"); /* r4 = # of NEGDS */
336: asm("movl _sgl_value_1,r5"); /* r5 = MS operand */
337: asm("movl _sgl_value_2,r6"); /* r6 = LS operand */
338: asm("movl _sgl_value_3,r7"); /* r7 = MS stored */
339: asm("movl _sgl_value_4,r8"); /* r8 = LS stored */
340: asm("movl _sgl_value_5,r9"); /* r9 = MS expected */
341: asm("movl _sgl_value_6,r10"); /* r10 = LS expected */
342: asm("movl _index,r11"); /* r11 = data index */
343: asm("halt"); /* HALT ... */
344: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.