![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to subf.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 subf.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 root 1:
2: #include "fpp_defs.h"
3:
4:
5: /*****************************************************************************
6: *
7: * SUBF - SINGLE PRECISION FLOATING POINT ADD TEST
8: *
9: *****************************************************************************/
10: subf()
11: {
12: asm(".globl _subf_t");
13: asm("_subf_t:"); /* entry address */
14: if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
15: writes(" SUBF");
16: subf_1(); /* subract through a register */
17: subf_2(); /* subract through the cache */
18: subf_3(); /* wait 3 NOPs */
19: subf_4(); /* wait 2 NOPs */
20: subf_5(); /* wait 1 NOP before storing */
21: subf_6(); /* register stability test */
22: subf_7(); /* PSL stability test */
23: subf_8(); /* pipelined entry test */
24: subf_9(); /* pipelined exit test */
25: asm("jmp *return"); /* return to the test monitor */
26: }
27:
28:
29:
30: /************************************************************************
31: *
32: * SUBTEST 1 - subract through a register
33: *
34: ************************************************************************/
35: subf_1()
36: {
37: force_loop = FALSE;
38: subtest = 1;
39: for( index = 0; index < max_subf_1_index; index++ ) {
40: sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
41: sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
42: sgl_expected = subf_1_data[index].exp; /* get expected result */
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("_subf_1_lp1:");
48: asm("movl _sgl_ld_acc,r3"); /* move the 1st data to r3 */
49: asm("movl _sgl_value_1,r4"); /* move the 2nd data to r4 */
50: asm("ldf r3"); /* load the 1st operand */
51: asm("subf r4"); /* subract the 2nd operand */
52: asm("stf _sgl_st_acc"); /* store the result */
53: if( force_loop )
54: asm("brb _subf_1_lp1");; /* loop on the error */
55: /*
56: * end error loop - test the results
57: */
58: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
59: errcnt++; /* bump the error count */
60: if( prt_error ) {
61: writes(" \n"); /* start a new print line */
62: writes("cycle: ");
63: writed( cycle );
64: writes(" SUBF test ");
65: writed( test_no );
66: writes(", subtest 1 (Reg. Data) - BAD FINAL ACC\n");
67: print_subf_data();
68: }
69: if( halt_flg )
70: subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
71: if( loop_on_err ) {
72: force_loop = TRUE; /* set the force loop flag */
73: asm("brw _subf_1_lp1");; /* and loop on the error */
74: } /* end of loop on error */
75: } /* end of compare error */
76: } /* end of WHILE loop */
77: } /* end of subtest 1 */
78:
79:
80:
81: /************************************************************************
82: *
83: * SUBTEST 2 - subract through memory
84: *
85: ************************************************************************/
86: subf_2()
87: {
88: force_loop = FALSE;
89: subtest = 2;
90: for( index = 0; index < max_subf_1_index; index++ ) {
91: sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
92: sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
93: sgl_expected = subf_1_data[index].exp; /* get expected result */
94: /*
95: * If LOOP ON ERROR is set, this is the loop for this subtest.
96: * The force loop flag is set after the first error.
97: */
98: asm("_subf_2_lp1:");
99: asm("ldf _sgl_ld_acc"); /* load the 1st operand */
100: asm("subf _sgl_value_1"); /* sub the 2nd operand */
101: asm("stf _sgl_st_acc"); /* store the result */
102: if( force_loop )
103: asm("brb _subf_2_lp1");; /* loop on the error */
104: /*
105: * end error loop - test the results
106: */
107: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
108: errcnt++; /* bump the error count */
109: if( prt_error ) {
110: writes(" \n"); /* start a new print line */
111: writes("cycle: ");
112: writed( cycle );
113: writes(" SUBF test ");
114: writed( test_no );
115: writes(", subtest 2 (Cache Data) - BAD FINAL ACC\n");
116: print_subf_data();
117: }
118: if( halt_flg )
119: subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
120: if( loop_on_err ) {
121: force_loop = TRUE; /* set the force loop flag */
122: asm("brw _subf_2_lp1");; /* and loop on the error */
123: } /* end of loop on error */
124: } /* end of compare error */
125: } /* end of WHILE loop */
126: } /* end of subtest 2 */
127:
128:
129:
130: /************************************************************************
131: *
132: * SUBTEST 3 - Wait 3 NOPs before storing the results
133: *
134: ************************************************************************/
135: subf_3()
136: {
137: force_loop = FALSE;
138: subtest = 3;
139: for( index = 0; index < max_subf_1_index; index++ ) {
140: sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
141: sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
142: sgl_expected = subf_1_data[index].exp; /* get expected result */
143: /*
144: * If LOOP ON ERROR is set, this is the loop for this subtest.
145: * The force loop flag is set after the first error.
146: */
147: asm("_subf_3_lp1:");
148: asm("ldf _sgl_ld_acc"); /* load the 1st operand */
149: asm("nop"); /* delay */
150: asm("subf _sgl_value_1"); /* sub the 2nd operand */
151: asm("nop"); /* delay before ... */
152: asm("nop");
153: asm("nop"); /* ... storing the result */
154: asm("stf _sgl_st_acc"); /* store the result */
155: if( force_loop )
156: asm("brb _subf_3_lp1");; /* loop on the error */
157: /*
158: * end error loop - test the results
159: */
160: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
161: errcnt++; /* bump the error count */
162: if( prt_error ) {
163: writes(" \n"); /* start a new print line */
164: writes("cycle: ");
165: writed( cycle );
166: writes(" SUBF test ");
167: writed( test_no );
168: writes(", subtest 3 (Cache Data - 3 NOPS) - BAD FINAL ACC\n");
169: print_subf_data();
170: }
171: if( halt_flg )
172: subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
173: if( loop_on_err ) {
174: force_loop = TRUE; /* set the force loop flag */
175: asm("brw _subf_3_lp1");; /* and loop on the error */
176: } /* end of loop on error */
177: } /* end of compare error */
178: } /* end of WHILE loop */
179: } /* end of subtest 3 */
180:
181:
182:
183: /************************************************************************
184: *
185: * SUBTEST 4 - Wait 2 NOPs before storing the results
186: *
187: ************************************************************************/
188: subf_4()
189: {
190: force_loop = FALSE;
191: subtest = 4;
192: for( index = 0; index < max_subf_1_index; index++ ) {
193: sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
194: sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
195: sgl_expected = subf_1_data[index].exp; /* get expected result */
196: /*
197: * If LOOP ON ERROR is set, this is the loop for this subtest.
198: * The force loop flag is set after the first error.
199: */
200: asm("_subf_4_lp1:");
201: asm("ldf _sgl_ld_acc"); /* load the 1st operand */
202: asm("nop"); /* delay */
203: asm("subf _sgl_value_1"); /* subract the 2nd operand */
204: asm("nop"); /* delay before ... */
205: asm("nop"); /* ... storing the result */
206: asm("stf _sgl_st_acc"); /* store the result */
207: if( force_loop )
208: asm("brb _subf_4_lp1");; /* loop on the error */
209: /*
210: * end error loop - test the results
211: */
212: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
213: errcnt++; /* bump the error count */
214: if( prt_error ) {
215: writes(" \n"); /* start a new print line */
216: writes("cycle: ");
217: writed( cycle );
218: writes(" SUBF test ");
219: writed( test_no );
220: writes(", subtest 4 (Cache Data - 2 NOPS) - BAD FINAL ACC\n");
221: print_subf_data();
222: }
223: if( halt_flg )
224: subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
225: if( loop_on_err ) {
226: force_loop = TRUE; /* set the force loop flag */
227: asm("brw _subf_4_lp1");; /* and loop on the error */
228: } /* end of loop on error */
229: } /* end of compare error */
230: } /* end of WHILE loop */
231: } /* end of subtest 4 */
232:
233:
234:
235: /************************************************************************
236: *
237: * SUBTEST 5 - Wait 1 NOP before storing the results
238: *
239: ************************************************************************/
240: subf_5()
241: {
242: force_loop = FALSE;
243: subtest = 5;
244: for( index = 0; index < max_subf_1_index; index++ ) {
245: sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
246: sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
247: sgl_expected = subf_1_data[index].exp; /* get expected result */
248: /*
249: * If LOOP ON ERROR is set, this is the loop for this subtest.
250: * The force loop flag is set after the first error.
251: */
252: asm("_subf_5_lp1:");
253: asm("ldf _sgl_ld_acc"); /* load the 1st operand */
254: asm("nop"); /* delay */
255: asm("subf _sgl_value_1"); /* subract the 2nd operand */
256: asm("nop"); /* delay before storing */
257: asm("stf _sgl_st_acc"); /* store the result */
258: if( force_loop )
259: asm("brb _subf_5_lp1");; /* loop on the error */
260: /*
261: * end error loop - test the results
262: */
263: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
264: errcnt++; /* bump the error count */
265: if( prt_error ) {
266: writes(" \n"); /* start a new print line */
267: writes("cycle: ");
268: writed( cycle );
269: writes(" SUBF test ");
270: writed( test_no );
271: writes(", subtest 5 (Cache Data - 1 NOPS) - BAD FINAL ACC\n");
272: print_subf_data();
273: }
274: if( halt_flg )
275: subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
276: if( loop_on_err ) {
277: force_loop = TRUE; /* set the force loop flag */
278: asm("brw _subf_5_lp1");; /* and loop on the error */
279: } /* end of loop on error */
280: } /* end of compare error */
281: } /* end of WHILE loop */
282: } /* end of subtest 5 */
283:
284:
285:
286: /************************************************************************
287: *
288: * SUBTEST 6 - Check for register corruption
289: *
290: ************************************************************************/
291: subf_6()
292: {
293: force_loop = FALSE; /* clear force_loop flg */
294: subtest = 6;
295: fill_reg_buf( load_regs ); /* get patterns for regs */
296: index = 0;
297: sgl_ld_acc = subf_1_data[0].op_1; /* get operand 1 */
298: sgl_value_1 = subf_1_data[0].op_2; /* get operand 2 */
299: sgl_expected = subf_1_data[0].exp; /* get expected result */
300: /*
301: * If LOOP ON ERROR is set, this is the loop for this subtest.
302: * The force loop flag is set after the first error.
303: */
304: asm("_subf_6_lp1:");
305: asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */
306: asm("nop");
307: asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
308: asm("nop");
309: asm("subf _sgl_value_1"); /* do the subraction */
310: asm("nop");
311: asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
312: asm("stf _sgl_st_acc"); /* save the accumulator */
313: if( force_loop )
314: asm("brb _subf_6_lp1");; /* loop on the error */
315: /*
316: * Now compare the stored register values to those that were loaded
317: */
318: index2 = 0;
319: while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
320: index2++; /* check reg values */
321: if( index2 < 13 ) { /* error if index2 < 13 */
322: errcnt++; /* bump the error count */
323: if( prt_error ) {
324: writes(" \n"); /* start a new print line */
325: writes("cycle: ");
326: writed( cycle );
327: writes(" SUBF test ");
328: writed( test_no );
329: writes(", subtest 6 - A REGISTER WAS MODIFIED\n");
330: print_subf_data(); /* print the operands */
331: writes("register "); /* print the information */
332: writed( index2 ); /* about the corrupted */
333: writes(" = "); /* register */
334: write32h( store_regs[index2] );
335: writes(", should be = ");
336: write32h( load_regs[index2] );
337: writes("\n");
338: }
339: if( halt_flg )
340: subf_er_halt( BAD_REG_HLT ); /* halt on the error */
341: if( loop_on_err ) {
342: force_loop = TRUE; /* set the force loop flag */
343: asm("brw _subf_6_lp1");; /* and loop on the error */
344: } /* end of loop on error */
345: } /* end of register corruption error */
346: } /* end of subtest 6 */
347:
348:
349:
350: /************************************************************************
351: *
352: * SUBTEST 7 - Check for PSL corruption
353: *
354: ************************************************************************/
355: subf_7()
356: {
357: force_loop = FALSE; /* clear force_loop flg */
358: subtest = 7;
359: fill_reg_buf( load_regs ); /* get patterns for regs */
360: for( index = 0; index < 3; index++ ) {
361: sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
362: sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
363: sgl_expected = subf_1_data[index].exp; /* get expected */
364: sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */
365: /*
366: * If LOOP ON ERROR is set, this is the loop for this subtest.
367: * The force loop flag is set after the first error.
368: */
369: asm("_subf_7_lp1:");
370: asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */
371: asm("nop");
372: asm("tstl _sgl_dummy1"); /* set the PSL status */
373: asm("movpsl _init_psl"); /* save the initial PSL */
374: asm("subf _sgl_value_1"); /* do the subract */
375: asm("nop");
376: asm("movpsl _psl_val"); /* save the final PSL */
377: asm("stf _sgl_st_acc"); /* save the accumulator */
378: if( force_loop )
379: asm("brb _subf_7_lp1");; /* loop on the error */
380: /*
381: * Now compare the final PSL to the initial PSL -they should be the same
382: */
383: exp_psl = init_psl;
384: if( psl_val != init_psl ) {
385: errcnt++; /* bump the error count */
386: if( prt_error ) {
387: writes(" \n"); /* start a new print line */
388: writes("cycle: ");
389: writed( cycle );
390: writes(" SUBF test ");
391: writed( test_no );
392: writes(", subtest 7 - INCORRECT FINAL PSL\n");
393: print_subf_data(); /* print the operands */
394: writes("initial PSL = ");
395: write32h( init_psl );
396: writes(", final PSL = ");
397: write32h( psl_val );
398: writes(", expected PSL = ");
399: write32h( exp_psl );
400: writes("\n");
401: }
402: if( halt_flg )
403: subf_er_halt( BAD_PSL_HLT ); /* halt on the error */
404: if( loop_on_err ) {
405: force_loop = TRUE; /* set the force loop flag */
406: asm("brw _subf_7_lp1");; /* and loop on the error */
407: } /* end of loop on error */
408: } /* end of PSL corruption error */
409: } /* end of WHILE loop */
410: } /* end of subtest 7 */
411:
412:
413:
414: /************************************************************************
415: *
416: * SUBTEST 8 - pipelined entry test
417: *
418: ************************************************************************/
419: subf_8()
420: {
421: force_loop = FALSE;
422: subtest = 8;
423: for( index = 0; index < max_subf_1_index; index++ ) {
424: sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
425: sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
426: sgl_expected = subf_1_data[index].exp; /* get expected result */
427: /*
428: * If LOOP ON ERROR is set, this is the loop for this subtest.
429: * The force loop flag is set after the first error.
430: */
431: asm("_subf_8_lp1:");
432: asm("movl $0,r0"); /* clear r0 */
433: asm("ldf r0"); /* load the Acc. with 0.0 */
434: asm("addf _sgl_ld_acc"); /* add the 1st operand */
435: asm("subf _sgl_value_1"); /* subract the 2nd operand */
436: asm("stf _sgl_st_acc"); /* store the result */
437: if( force_loop )
438: asm("brb _subf_8_lp1");; /* loop on the error */
439: /*
440: * end error loop - test the results
441: */
442: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
443: errcnt++; /* bump the error count */
444: if( prt_error ) {
445: writes(" \n"); /* start a new print line */
446: writes("cycle: ");
447: writed( cycle );
448: writes(" SUBF test ");
449: writed( test_no );
450: writes(", subtest 8 (Piped Entry) - BAD FINAL ACC\n");
451: print_subf_data();
452: }
453: if( halt_flg )
454: subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
455: if( loop_on_err ) {
456: force_loop = TRUE; /* set the force loop flag */
457: asm("brw _subf_8_lp1");; /* and loop on the error */
458: } /* end of loop on error */
459: } /* end of compare error */
460: } /* end of WHILE loop */
461: } /* end of subtest 8 */
462:
463:
464:
465: /************************************************************************
466: *
467: * SUBTEST 9 - pipelined exit test
468: *
469: ************************************************************************/
470: subf_9()
471: {
472: force_loop = FALSE;
473: subtest = 9;
474: for( index = 0; index < max_subf_1_index; index++ ) {
475: sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
476: sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
477: sgl_expected = subf_1_data[index].exp; /* get expected result */
478: /*
479: * If LOOP ON ERROR is set, this is the loop for this subtest.
480: * The force loop flag is set after the first error.
481: */
482: asm("_subf_9_lp1:");
483: asm("movl $0,r0"); /* clear r0 */
484: asm("ldf _sgl_ld_acc"); /* load the 1st operand */
485: asm("subf _sgl_value_1"); /* subract the 2nd operand */
486: asm("addf r0"); /* add a 0.0 to the result */
487: asm("stf _sgl_st_acc"); /* store the result */
488: if( force_loop )
489: asm("brb _subf_9_lp1");; /* loop on the error */
490: /*
491: * end error loop - test the results
492: */
493: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
494: errcnt++; /* bump the error count */
495: if( prt_error ) {
496: writes(" \n"); /* start a new print line */
497: writes("cycle: ");
498: writed( cycle );
499: writes(" SUBF test ");
500: writed( test_no );
501: writes(", subtest 9 (Piped Exit) - BAD FINAL ACC\n");
502: print_subf_data();
503: }
504: if( halt_flg )
505: subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
506: if( loop_on_err ) {
507: force_loop = TRUE; /* set the force loop flag */
508: asm("brw _subf_9_lp1");; /* and loop on the error */
509: } /* end of loop on error */
510: } /* end of compare error */
511: } /* end of WHILE loop */
512: } /* end of subtest 9 */
513:
514:
515:
516: /**************************************************************************
517: *
518: * PRINT THE DATA AND STORE RESULTS
519: *
520: * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
521: * operand = xxxxxxxx, expected = xxxxxxxx
522: **************************************************************************/
523: print_subf_data()
524: {
525: writes("initial Acc = ");
526: write32h( sgl_ld_acc );
527: writes(", stored = ");
528: write32h( sgl_st_acc );
529: writes(", data index = ");
530: writed( index );
531: writec('\n');
532: writes(" operand = ");
533: write32h( sgl_value_1 );
534: writes(", expected = ");
535: write32h( sgl_expected );
536: writec('\n');
537: }
538:
539:
540:
541: /**************************************************************************
542: *
543: * HALT ON ERROR ROUTINE
544: *
545: **************************************************************************/
546: subf_er_halt( halt_code )
547: int halt_code;
548: {
549: sgl_dummy1 = halt_code; /* get the error type */
550: asm("movl _test_no,r0"); /* r0 = test number */
551: asm("movl _subtest,r1"); /* r1 = subtest number */
552: asm("movl _sgl_dummy1,r2"); /* r2 = error code */
553: asm("movl _cycle,r3"); /* r3 = cycle count */
554: asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
555: asm("movl _sgl_value_1,r5"); /* r5 = data subtracted */
556: asm("movl _sgl_st_acc,r6"); /* r6 = data stored */
557: if(halt_code == BAD_ACC_HLT ) {
558: asm("movl _sgl_expected,r7"); /* r7 = data expected */
559: asm("movl _index,r8"); /* r8 = data index */
560: } else
561: if( halt_code == BAD_REG_HLT ) {
562: sgl_dummy1 = load_regs[index2];
563: sgl_dummy2 = store_regs[index2];
564: asm("movl _index2,r7"); /* r7 = bad register # */
565: asm("movl _sgl_dummy2,r8"); /* r8 = actual value */
566: asm("movl _sgl_dummy1,r9"); /* r9 = expected value */
567: } else
568: if( halt_code == BAD_PSL_HLT ) {
569: asm("movl _init_psl,r7"); /* r7 = initial PSL */
570: asm("movl _psl_val,r8"); /* r8 = final PSL */
571: asm("movl _exp_psl,r9"); /* r9 = expected PSL */
572: };
573: asm("halt"); /* HALT ... */
574: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.