![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmpf.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 cmpf.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: * CMPF -COMPARE SGL ACCUMULATOR TO SGL OPERAND
8: *
9: *****************************************************************************/
10: cmpf()
11: {
12: asm(".globl _cmpf_t");
13: asm("_cmpf_t:"); /* entry address */
14: if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
15: {
16: writes(" CMPF");
17: }
18: cmpf_1(); /* test via registers */
19: cmpf_2(); /* test via cache */
20: cmpf_3(); /* register corruption test */
21: cmpf_4(); /* acc. corruption test */
22: if( !no_fpp_wcs ) {
23: cmpf_5(); /* pipelined entry test */
24: cmpf_6(); /* pipelined exit test */
25: };
26: asm("jmp *return"); /* return to the test monitor */
27: }
28:
29:
30:
31: /****************************************************************************
32: *
33: * SUBTEST 1 - CMPF status test -register data
34: *
35: ****************************************************************************/
36: cmpf_1()
37: {
38: force_loop = FALSE;
39: subtest = 1;
40: index = 0;
41: do
42: {
43: sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
44: sgl_value_2 = cmpf_1_data[index].two;
45: sgl_expected = cmpf_1_data[index].flag; /* get expected results */
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("_cmpf_1_lp1:");
55: asm("movl _sgl_value_1,r4"); /* move operand #1 to r4 */
56: asm("movl _sgl_value_2,r5"); /* move operand #2 to r5 */
57: asm("ldf r4"); /* load the 1st operand */
58: asm("tstl _sgl_dummy1"); /* generate initial status */
59: asm("movpsl _init_psl"); /* save the initial status */
60: asm("cmpf r5"); /* compare the operands */
61: asm("movpsl _psl_val"); /* save the final status */
62: asm("stf _sgl_st_acc"); /* save the final acc */
63: if( force_loop ) /* loop? */
64: asm("brb _cmpf_1_lp1");; /* run the loop again */
65: exp_psl = init_psl; /* get the initial PSL */
66: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
67: if( sgl_expected == ZERO )
68: exp_psl |= PSL_Z; /* expect the ZERO bit set */
69: if( sgl_expected == NEGATIVE )
70: exp_psl |= PSL_N; /* expect the NEG bit set */
71: if( psl_val != exp_psl ) { /* COMPARE the values */
72: errcnt++; /* bump the error count */
73: if ( prt_error ) {
74: writes(" \n"); /* start a new print line */
75: writes("cycle: ");
76: writed( cycle );
77: writes(" CMPF test ");
78: writed( test_no );
79: writes(", subtest 1 (Reg. Data) - BAD FINAL PSL\n");
80: print_cmpf_data();
81: writes(", data index = ");
82: writed( index );
83: writec('\n');
84: writes("initial 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: cmpf_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 _cmpf_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 PSL WHILE loop */
100: } while( index++ < max_cmpf_1_index);/* end of data loop */
101: } /* end of subtest 1 */
102:
103:
104:
105: /****************************************************************************
106: *
107: * SUBTEST 2 - CMPF status test -cache data
108: *
109: ****************************************************************************/
110: cmpf_2()
111: {
112: force_loop = FALSE;
113: subtest = 2;
114: index = 0;
115: do
116: {
117: sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
118: sgl_value_2 = cmpf_1_data[index].two;
119: sgl_expected = cmpf_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("_cmpf_2_lp1:");
129: asm("ldf _sgl_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("cmpf _sgl_value_2"); /* compare the operands */
133: asm("movpsl _psl_val"); /* save the final status */
134: asm("stf _sgl_st_acc"); /* save the final acc */
135: if( force_loop ) /* loop? */
136: asm("brb _cmpf_2_lp1");; /* run the loop again */
137: exp_psl = init_psl; /* get the initial PSL */
138: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
139: if( sgl_expected == ZERO )
140: exp_psl |= PSL_Z; /* expect the ZERO bit set */
141: if( sgl_expected == NEGATIVE )
142: exp_psl |= PSL_N; /* expect the NEG bit set */
143: if( psl_val != exp_psl ) { /* COMPARE the values */
144: errcnt++; /* bump the error count */
145: if ( prt_error ) {
146: writes(" \n"); /* start a new print line */
147: writes("cycle: ");
148: writed( cycle );
149: writes(" CMPF test ");
150: writed( test_no );
151: writes(", subtest 2 (Cache Data) - BAD FINAL PSL\n");
152: print_cmpf_data();
153: writes(", data index = ");
154: writed( index );
155: writec('\n');
156: writes("initial PSL = ");
157: write32h( init_psl );
158: writes(", final PSL = ");
159: write32h( psl_val );
160: writes(", expected PSL = ");
161: write32h( exp_psl );
162: writes("\n");
163: }
164: if ( halt_flg )
165: cmpf_er_halt( BAD_PSL_HLT ); /* halt on the error */
166: if ( loop_on_err ) {
167: force_loop = TRUE; /* set the force loop flag */
168: asm("brw _cmpf_2_lp1"); /* and loop on the error */
169: } /* end of loop on error */
170: } /* end of compare error */
171: } while ( ++status_index < 3 ); /* end of PSL WHILE loop */
172: } while( index++ < max_cmpf_1_index);/* end of data loop */
173: } /* end of subtest 2 */
174:
175:
176:
177: /************************************************************************
178: *
179: * SUBTEST 3 - Check for register corruption
180: *
181: ************************************************************************/
182: cmpf_3()
183: {
184: force_loop = FALSE; /* clear force_loop flg */
185: subtest = 3;
186: fill_reg_buf( load_regs ); /* get pattern for regs */
187: index = 0;
188: do
189: {
190: sgl_value_1 = cmpf_1_data[index].one; /* data to load */
191: sgl_value_2 = cmpf_1_data[index].two; /* data to compare */
192: /*
193: * If LOOP ON ERROR is set, this is the loop for this subtest.
194: * The force loop flag is set after the first error.
195: */
196: asm("_cmpf_3_lp1:");
197: asm("ldf _sgl_value_1"); /* LOAD the accumulator */
198: asm("nop");
199: asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
200: asm("nop");
201: asm("cmpf _sgl_value_2"); /* test the values */
202: asm("nop");
203: asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
204: asm("stf _sgl_st_acc"); /* save the final acc */
205: if( force_loop ) /* loop? */
206: asm("brb _cmpf_3_lp1");; /* run the loop again */
207: /*
208: * Now compare the stored register values to those that were loaded
209: */
210: index2 = 0;
211: while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
212: index2++; /* check reg values */
213: if( index2 < 13 ) { /* error if index2 < 13 */
214: errcnt++; /* bump the error count */
215: if ( prt_error ) {
216: writes(" \n"); /* start a new print line */
217: writes("cycle: ");
218: writed( cycle );
219: writes(", CMPF test ");
220: writed( test_no );
221: writes(", subtest 3 - A REGISTER WAS MODIFIED\n");
222: print_cmpf_data(); /* print the operands */
223: writes("\n");
224: writes("register "); /* print the information */
225: writed( index2 ); /* about the corrupted */
226: writes(" = "); /* register */
227: write32h( store_regs[index2] );
228: writes(", should be = ");
229: write32h( load_regs[index2] );
230: writes("\n");
231: }
232: if ( halt_flg ) /* halt on error? */
233: cmpf_er_halt( BAD_REG_HLT ); /* PC after the halt */
234: if ( loop_on_err ) {
235: force_loop = TRUE; /* set the force loop flag */
236: asm("brw _cmpf_3_lp1"); /* and loop on the error */
237: } /* end of loop on error */
238: } /* end of register corruption error */
239: } while( index++ < max_cmpf_1_index);/* end of data loop */
240: } /* end of subtest 3 */
241:
242:
243:
244: /************************************************************************
245: *
246: * SUBTEST 4 - Check for accumulator corruption
247: *
248: ************************************************************************/
249: cmpf_4()
250: {
251: force_loop = FALSE; /* clear force_loop flg */
252: index = 0;
253: do
254: {
255: sgl_value_1 = cmpf_1_data[index].one; /* data to load */
256: sgl_value_2 = cmpf_1_data[index].two;
257: if( sgl_value_1 & 0x7f800000 )
258: sgl_expected = sgl_value_1; /* expected = loaded */
259: else
260: sgl_expected = 0; /* expect a '0' stored */
261: /*
262: * If LOOP ON ERROR is set, this is the loop for this subtest.
263: * The force loop flag is set after the first error.
264: */
265: asm("_cmpf_4_lp1:");
266: asm("ldf _sgl_value_1"); /* LOAD the accumulator */
267: asm("cmpf _sgl_value_2"); /* test the values */
268: asm("stf _sgl_st_acc"); /* store the accumulator */
269: if( force_loop ) /* loop? */
270: asm("brb _cmpf_4_lp1");; /* run the loop again */
271: if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
272: {
273: errcnt++; /* bump the error count */
274: if ( prt_error ) {
275: writes(" \n"); /* start a new print line */
276: writes("cycle: ");
277: writed( cycle );
278: writes(" CMPF test ");
279: writed( test_no );
280: writes(", subtest 4 (Cache Data) - THE ACC WAS MODIFIED\n");
281: print_cmpf_data();
282: writes(", data index = ");
283: writed( index );
284: writec('\n');
285: writes(" final Acc = ");
286: write32h( sgl_st_acc );
287: writes(", Acc expected = ");
288: write32h( sgl_expected );
289: writec('\n');
290: }
291: if ( halt_flg ) /* halt on error? */
292: cmpf_er_halt( BAD_ACC_HLT ); /* halt on the error */
293: if ( loop_on_err ) {
294: force_loop = TRUE; /* set the force loop flag */
295: asm("brw _cmpf_4_lp1"); /* and loop on the error */
296: } /* end of loop on error */
297: } /* end of compare error */
298: } while( index++ < max_cmpf_1_index);/* end of data loop */
299: } /* end of subtest 4 */
300:
301:
302:
303: /****************************************************************************
304: *
305: * SUBTEST 5 - CMPF status test - piped entry
306: *
307: ****************************************************************************/
308: cmpf_5()
309: {
310: force_loop = FALSE;
311: subtest = 5;
312: index = 0;
313: do
314: {
315: sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
316: sgl_value_2 = cmpf_1_data[index].two;
317: sgl_expected = cmpf_1_data[index].flag;/* get expected results */
318: status_index = 0; /* clear the status index */
319: do
320: {
321: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
322: /*
323: * If LOOP ON ERROR is set, this is the loop for this subtest.
324: * The force loop flag is set after the first error.
325: */
326: asm("_cmpf_5_lp1:");
327: asm("movl $0,r0"); /* clear r0 */
328: asm("ldf r0"); /* load the accumulator */
329: asm("addf _sgl_value_1"); /* add the 1st operand */
330: asm("tstl _sgl_dummy1"); /* generate initial status */
331: asm("movpsl _init_psl"); /* save the initial status */
332: asm("cmpf _sgl_value_2"); /* compare the operands */
333: asm("movpsl _psl_val"); /* save the final status */
334: asm("stf _sgl_st_acc"); /* save the final acc */
335: if( force_loop ) /* loop? */
336: asm("brb _cmpf_5_lp1");; /* run the loop again */
337: exp_psl = init_psl; /* get the initial PSL */
338: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
339: if( sgl_expected == ZERO )
340: exp_psl |= PSL_Z; /* expect the ZERO bit set */
341: if( sgl_expected == NEGATIVE )
342: exp_psl |= PSL_N; /* expect the NEG bit set */
343: if( psl_val != exp_psl ) { /* COMPARE the values */
344: errcnt++; /* bump the error count */
345: if ( prt_error ) {
346: writes(" \n"); /* start a new print line */
347: writes("cycle: ");
348: writed( cycle );
349: writes(" CMPF test ");
350: writed( test_no );
351: writes(", subtest 5 (Piped Entry) - BAD FINAL PSL\n");
352: print_cmpf_data();
353: writes(", data index = ");
354: writed( index );
355: writec('\n');
356: writes("initial PSL = ");
357: write32h( init_psl );
358: writes(", final PSL = ");
359: write32h( psl_val );
360: writes(", expected PSL = ");
361: write32h( exp_psl );
362: writes("\n");
363: }
364: if ( halt_flg )
365: cmpf_er_halt( BAD_PSL_HLT ); /* halt on the error */
366: if ( loop_on_err ) {
367: force_loop = TRUE; /* set the force loop flag */
368: asm("brw _cmpf_5_lp1"); /* and loop on the error */
369: } /* end of loop on error */
370: } /* end of compare error */
371: } while ( ++status_index < 3 ); /* end of PSL WHILE loop */
372: } while( index++ < max_cmpf_1_index);/* end of data loop */
373: } /* end of subtest 5 */
374:
375:
376:
377: /****************************************************************************
378: *
379: * SUBTEST 6 - CMPF status test -piped exit
380: *
381: ****************************************************************************/
382: cmpf_6()
383: {
384: force_loop = FALSE;
385: subtest = 2;
386: index = 0;
387: do
388: {
389: sgl_value_1 = cmpf_1_data[index].one; /* data to load */
390: sgl_value_2 = cmpf_1_data[index].two;
391: if( sgl_value_1 & 0x7f800000 )
392: sgl_expected = sgl_value_1; /* expected = loaded */
393: else
394: sgl_expected = 0; /* expect a '0' stored */
395: /*
396: * If LOOP ON ERROR is set, this is the loop for this subtest.
397: * The force loop flag is set after the first error.
398: */
399: asm("_cmpf_6_lp1:");
400: asm("movl $0,r0"); /* clear r0 */
401: asm("ldf _sgl_value_1"); /* load the 1st operand */
402: asm("cmpf _sgl_value_2"); /* compare the value */
403: asm("addf r0"); /* add a zero to the acc */
404: asm("stf _sgl_st_acc"); /* save the accumulator */
405: if( force_loop ) /* loop? */
406: asm("brb _cmpf_6_lp1");; /* run the loop again */
407: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
408: errcnt++; /* bump the error count */
409: if ( prt_error ) {
410: writes(" \n"); /* start a new print line */
411: writes("cycle: ");
412: writed( cycle );
413: writes(" CMPF test ");
414: writed( test_no );
415: writes(", subtest 6 (Piped Exit) - THE ACC WAS MODIFIED\n");
416: print_cmpf_data();
417: writes(", data index = ");
418: writed( index );
419: writec('\n');
420: writes(" final Acc = ");
421: write32h( sgl_st_acc );
422: writes(", Acc expected = ");
423: write32h( sgl_expected );
424: writec('\n');
425: }
426: if ( halt_flg )
427: cmpf_er_halt( BAD_ACC_HLT ); /* halt on the error */
428: if ( loop_on_err ) {
429: force_loop = TRUE; /* set the force loop flag */
430: asm("brw _cmpf_6_lp1"); /* and loop on the error */
431: } /* end of loop on error */
432: } /* end of compare error */
433: } while( index++ < max_cmpf_1_index); /* end of data loop */
434: } /* end of subtest 6 */
435:
436:
437:
438: /**************************************************************************
439: *
440: * PRINT THE DATA AND STORE RESULTS
441: *
442: * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
443: * operand = xxxxxxxx, expected = xxxxxxxx
444: **************************************************************************/
445: print_cmpf_data()
446: {
447: writes("initial Acc = ");
448: write32h( sgl_value_1 );
449: writes(", operand = ");
450: write32h( sgl_value_2 );
451: }
452:
453:
454:
455: /**************************************************************************
456: *
457: * HALT ON ERROR ROUTINE
458: *
459: **************************************************************************/
460: cmpf_er_halt( halt_code )
461: int halt_code;
462: {
463: sgl_dummy1 = halt_code; /* get the error type */
464: asm("movl _test_no,r0"); /* r0 = test number */
465: asm("movl _subtest,r1"); /* r1 = subtest number */
466: asm("movl _sgl_dummy1,r2"); /* r2 = error code */
467: asm("movl _cycle,r3"); /* r3 = cycle count */
468: asm("movl _sgl_value_1,r4"); /* r4 = initial acc */
469: asm("movl _sgl_value_2,r5"); /* r5 = data compared */
470: asm("movl _psl_val,r6"); /* r6 = final PSL */
471: if( halt_code == BAD_ACC_HLT ) {
472: asm("movl _sgl_st_acc,r7"); /* r7 = actual value */
473: asm("movl _sgl_expected,r8"); /* r8 = expected value */
474: } else
475: if( halt_code == BAD_REG_HLT ) {
476: sgl_dummy1 = load_regs[index2];
477: sgl_dummy2 = store_regs[index2];
478: asm("movl _index2,r7"); /* r7 = bad register # */
479: asm("movl _sgl_dummy2,r8"); /* r8 = actual value */
480: asm("movl _sgl_dummy1,r9"); /* r9 = expected value */
481: } else
482: if( halt_code == BAD_PSL_HLT ) {
483: asm("movl _exp_psl,r7"); /* r7 = expected PSL */
484: asm("movl _index,r7"); /* r8 = data index */
485: };
486: asm("halt"); /* HALT ... */
487: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.