![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmpf2.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 cmpf2.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: * CMPF2 -COMPARE 2 SGL OPERANDS TO EACH OTHER -IGNORE THE ACCUMULATOR
8: *
9: *****************************************************************************/
10: cmpf2()
11: {
12: asm(".globl _cmpf2_t");
13: asm("_cmpf2_t:"); /* entry address */
14: if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
15: writes(" CMPF2");
16: cmpf2_1(); /* register / register data */
17: cmpf2_2(); /* cache / cache data */
18: cmpf2_3(); /* cache / register data */
19: cmpf2_4(); /* register / cache data */
20: cmpf2_5(); /* acc. corruption test */
21: cmpf2_6(); /* register corruption test */
22: if( !no_fpp_wcs ) {
23: cmpf2_7(); /* pipelined entry test */
24: cmpf2_8(); /* pipelined exit test */
25: };
26: asm("jmp *return"); /* return to the test monitor */
27: }
28:
29:
30:
31: /****************************************************************************
32: *
33: * SUBTEST 1 - CMPF2 test -register / register data
34: *
35: ****************************************************************************/
36: cmpf2_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: index2 = 0; /* clear Acc. data index */
47: do
48: {
49: sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
50: status_index = 0; /* clear the status index */
51: do
52: {
53: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
54: /*
55: * If LOOP ON ERROR is set, this is the loop for this subtest.
56: * The force loop flag is set after the first error.
57: */
58: asm("_cmpf2_1_lp1:");
59: asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
60: asm("movl _sgl_value_1,r4"); /* move operand #1 to r4 */
61: asm("movl _sgl_value_2,r5"); /* move operand #2 to r5 */
62: asm("ldf r3"); /* load the accumulator */
63: asm("tstl _sgl_dummy1"); /* generate initial status */
64: asm("movpsl _init_psl"); /* save the initial status */
65: asm("cmpf2 r4,r5"); /* compare the operands */
66: asm("movpsl _psl_val"); /* save the final status */
67: asm("stf r6"); /* save the accumulator */
68: if( force_loop ) /* loop? */
69: asm("brb _cmpf2_1_lp1");; /* run the loop again */
70: asm("movl r6,_sgl_st_acc"); /* put the acc into cache */
71: exp_psl = init_psl; /* get the initial PSL */
72: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
73: if( sgl_expected == ZERO )
74: exp_psl |= PSL_Z; /* expect the ZERO bit set */
75: if( sgl_expected == NEGATIVE )
76: exp_psl |= PSL_N; /* expect the NEG bit set */
77: if( psl_val != exp_psl ) /* COMPARE the values */
78: {
79: errcnt++; /* bump the error count */
80: if ( prt_error ) {
81: writes(" \n"); /* start a new print line */
82: writes("cycle: ");
83: writed( cycle );
84: writes(" CMPF2 test ");
85: writed( test_no );
86: writes(", subtest 1 (Reg./Reg. Data) - BAD FINAL PSL\n");
87: print_cmpf2_data();
88: writes(", data index = ");
89: writed( index );
90: writec('\n');
91: writes(" final Acc = ");
92: write32h( sgl_st_acc );
93: writes(", operand 2 = ");
94: write32h( sgl_value_2 );
95: writec('\n');
96: writes(" initial PSL = ");
97: write32h( init_psl );
98: writes(", final PSL = ");
99: write32h( psl_val );
100: writes(", expected PSL = ");
101: write32h( exp_psl );
102: writes(" \n");
103: }
104: if ( halt_flg )
105: cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
106: if ( loop_on_err ) {
107: force_loop = TRUE; /* set the force loop flag */
108: asm("brw _cmpf2_1_lp1"); /* and loop */
109: }; /* end of loop-on-error */
110: } /* end of compare error */
111: } while( ++status_index < 3 );
112: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
113: } while( index++ < max_cmpf_1_index );
114: } /* end of subtest 1 */
115:
116:
117:
118: /****************************************************************************
119: *
120: * SUBTEST 2 - CMPF2 test - cache / cache data
121: *
122: ****************************************************************************/
123: cmpf2_2()
124: {
125: force_loop = FALSE;
126: subtest = 2;
127: index = 0;
128: do
129: {
130: sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
131: sgl_value_2 = cmpf_1_data[index].two;
132: sgl_expected = cmpf_1_data[index].flag; /* get expected results */
133: index2 = 0; /* clear Acc. data index */
134: do
135: {
136: sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
137: status_index = 0; /* clear the status index */
138: do
139: {
140: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
141: /*
142: * If LOOP ON ERROR is set, this is the loop for this subtest.
143: * The force loop flag is set after the first error.
144: */
145: asm("_cmpf2_2_lp1:");
146: asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
147: asm("ldf _sgl_ld_acc"); /* load the accumulator */
148: asm("tstl _sgl_dummy1"); /* generate initial status */
149: asm("movpsl _init_psl"); /* save the initial status */
150: asm("cmpf2 _sgl_value_1,_sgl_value_2"); /* compare the data */
151: asm("movpsl _psl_val"); /* save the final status */
152: asm("stf _sgl_st_acc"); /* save the acc */
153: if( force_loop ) /* loop? */
154: asm("brb _cmpf2_2_lp1");; /* run the loop again */
155: exp_psl = init_psl; /* get the initial PSL */
156: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
157: if( sgl_expected == ZERO )
158: exp_psl |= PSL_Z; /* expect the ZERO bit set */
159: if( sgl_expected == NEGATIVE )
160: exp_psl |= PSL_N; /* expect the NEG bit set */
161: if( psl_val != exp_psl ) /* COMPARE the values */
162: {
163: errcnt++; /* bump the error count */
164: if ( prt_error ) {
165: writes(" \n"); /* start a new print line */
166: writes("cycle: ");
167: writed( cycle );
168: writes(" CMPF2 test ");
169: writed( test_no );
170: writes(", subtest 2 (Cache/Cache Data) - BAD FINAL PSL\n");
171: print_cmpf2_data();
172: writes(", data index = ");
173: writed( index );
174: writec('\n');
175: writes(" final Acc = ");
176: write32h( sgl_st_acc );
177: writes(", operand 2 = ");
178: write32h( sgl_value_2 );
179: writec('\n');
180: writes(" initial PSL = ");
181: write32h( init_psl );
182: writes(", final PSL = ");
183: write32h( psl_val );
184: writes(", expected PSL = ");
185: write32h( exp_psl );
186: writes(" \n");
187: }
188: if ( halt_flg )
189: cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
190: if ( loop_on_err )
191: {
192: force_loop = TRUE; /* set the force loop flag */
193: asm("brw _cmpf2_2_lp1"); /* and loop */
194: }; /* end of loop-on-error */
195: } /* end of compare error */
196: } while( ++status_index < 3 );
197: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
198: } while( index++ < max_cmpf_1_index );
199: } /* end of subtest 2 */
200:
201:
202:
203: /****************************************************************************
204: *
205: * SUBTEST 3 - CMPF2 test - cache / register data
206: *
207: ****************************************************************************/
208: cmpf2_3()
209: {
210: force_loop = FALSE;
211: subtest = 3;
212: index = 0;
213: do
214: {
215: sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
216: sgl_value_2 = cmpf_1_data[index].two;
217: sgl_expected = cmpf_1_data[index].flag; /* get expected results */
218: index2 = 0; /* clear Acc. data index */
219: do
220: {
221: sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
222: status_index = 0; /* clear the status index */
223: do
224: {
225: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
226: /*
227: * If LOOP ON ERROR is set, this is the loop for this subtest.
228: * The force loop flag is set after the first error.
229: */
230: asm("_cmpf2_3_lp1:");
231: asm("ldf _sgl_ld_acc"); /* load the accmulator */
232: asm("movl _sgl_value_2,r5"); /* move operand #2 to r5 */
233: asm("tstl _sgl_dummy1"); /* generate initial status */
234: asm("movpsl _init_psl"); /* save the initial status */
235: asm("cmpf2 _sgl_value_1,r5"); /* compare the data */
236: asm("movpsl _psl_val"); /* save the final status */
237: asm("stf _sgl_st_acc"); /* save the acc */
238: if( force_loop ) /* loop? */
239: asm("brb _cmpf2_3_lp1");; /* run the loop again */
240: exp_psl = init_psl; /* get the initial PSL */
241: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
242: if( sgl_expected == ZERO )
243: exp_psl |= PSL_Z; /* expect the ZERO bit set */
244: if( sgl_expected == NEGATIVE )
245: exp_psl |= PSL_N; /* expect the NEG bit set */
246: if( psl_val != exp_psl ) /* COMPARE the values */
247: {
248: errcnt++; /* bump the error count */
249: if ( prt_error ) {
250: writes(" \n"); /* start a new print line */
251: writes("cycle: ");
252: writed( cycle );
253: writes(" CMPF2 test ");
254: writed( test_no );
255: writes(", subtest 3 (Cache/Reg. Data) - BAD FINAL PSL\n");
256: print_cmpf2_data();
257: writes(", data index = ");
258: writed( index );
259: writec('\n');
260: writes(" final Acc = ");
261: write32h( sgl_st_acc );
262: writes(", operand 2 = ");
263: write32h( sgl_value_2 );
264: writec('\n');
265: writes(" initial PSL = ");
266: write32h( init_psl );
267: writes(", final PSL = ");
268: write32h( psl_val );
269: writes(", expected PSL = ");
270: write32h( exp_psl );
271: writes(" \n");
272: }
273: if ( halt_flg )
274: cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
275: if ( loop_on_err )
276: {
277: force_loop = TRUE; /* set the force loop flag */
278: asm("brw _cmpf2_3_lp1"); /* and loop */
279: }; /* end of loop-on-error */
280: } /* end of compare error */
281: } while( ++status_index < 3 );
282: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
283: } while( index++ < max_cmpf_1_index );
284: } /* end of subtest 3 */
285:
286:
287:
288: /****************************************************************************
289: *
290: * SUBTEST 4 - CMPF2 test - register / cache data
291: *
292: ****************************************************************************/
293: cmpf2_4()
294: {
295: force_loop = FALSE;
296: subtest = 4;
297: index = 0;
298: do
299: {
300: sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
301: sgl_value_2 = cmpf_1_data[index].two;
302: sgl_expected = cmpf_1_data[index].flag; /* get expected results */
303: index2 = 0; /* clear Acc. data index */
304: do
305: {
306: sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
307: status_index = 0; /* clear the status index */
308: do
309: {
310: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
311: /*
312: * If LOOP ON ERROR is set, this is the loop for this subtest.
313: * The force loop flag is set after the first error.
314: */
315: asm("_cmpf2_4_lp1:");
316: asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
317: asm("movl _sgl_value_1,r4"); /* move operand #1 to r4 */
318: asm("ldf r3"); /* load the accumulator */
319: asm("tstl _sgl_dummy1"); /* generate initial status */
320: asm("movpsl _init_psl"); /* save the initial status */
321: asm("cmpf2 r4,_sgl_value_2"); /* compare the data */
322: asm("movpsl _psl_val"); /* save the final status */
323: asm("stf _sgl_st_acc"); /* save the acc */
324: if( force_loop ) /* loop? */
325: asm("brb _cmpf2_4_lp1");; /* run the loop again */
326: exp_psl = init_psl; /* get the initial PSL */
327: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
328: if( sgl_expected == ZERO )
329: exp_psl |= PSL_Z; /* expect the ZERO bit set */
330: if( sgl_expected == NEGATIVE )
331: exp_psl |= PSL_N; /* expect the NEG bit set */
332: if( psl_val != exp_psl ) /* COMPARE the values */
333: {
334: errcnt++; /* bump the error count */
335: if ( prt_error ) {
336: writes(" \n"); /* start a new print line */
337: writes("cycle: ");
338: writed( cycle );
339: writes(" CMPF2 test ");
340: writed( test_no );
341: writes(", subtest 4 (Reg./Cache Data) - BAD FINAL PSL\n");
342: print_cmpf2_data();
343: writes(", data index = ");
344: writed( index );
345: writec('\n');
346: writes(" final Acc = ");
347: write32h( sgl_st_acc );
348: writes(", operand 2 = ");
349: write32h( sgl_value_2 );
350: writec('\n');
351: writes(" initial PSL = ");
352: write32h( init_psl );
353: writes(", final PSL = ");
354: write32h( psl_val );
355: writes(", expected PSL = ");
356: write32h( exp_psl );
357: writes(" \n");
358: }
359: if ( halt_flg )
360: cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
361: if ( loop_on_err )
362: {
363: force_loop = TRUE; /* set the force loop flag */
364: asm("jmp _cmpf2_4_lp1"); /* and loop */
365: } /* end of loop-on-error */
366: } /* end of compare error */
367: } while( ++status_index < 3 );
368: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
369: } while( index++ < max_cmpf_1_index );
370: } /* end of subtest 4 */
371:
372:
373:
374: /************************************************************************
375: *
376: * SUBTEST 5 - Check for register corruption
377: *
378: ************************************************************************/
379: cmpf2_5()
380: {
381: force_loop = FALSE; /* clear force_loop flg */
382: subtest = 5;
383: fill_reg_buf( load_regs ); /* get pattern for regs */
384: index = 0;
385: do
386: {
387: sgl_value_1 = cmpf_1_data[index].one; /* data to load */
388: sgl_value_2 = cmpf_1_data[index].two; /* data to compare */
389: /*
390: * If LOOP ON ERROR is set, this is the loop for this subtest.
391: * The force loop flag is set after the first error.
392: */
393: asm("_cmpf2_5_lp1:");
394: asm("ldf $0x40800000"); /* LOAD the accumulator */
395: asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
396: asm("cmpf2 _sgl_value_1,_sgl_value_2"); /* compare the data */
397: asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
398: asm("stf _sgl_st_acc"); /* save the acc */
399: if( force_loop ) /* loop? */
400: asm("brb _cmpf2_5_lp1");; /* run the loop again */
401: /*
402: * Now compare the stored register values to those that were loaded
403: */
404: index2 = 0;
405: while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
406: index2++; /* check reg values */
407:
408: if( index2 < 13 ) { /* error if index2 < 13 */
409: errcnt++; /* bump the error count */
410: if ( prt_error ) {
411: writes(" \n"); /* start a new print line */
412: writes("cycle: ");
413: writed( cycle );
414: writes(", CMPF2 test ");
415: writed( test_no );
416: writes(", subtest 5 - A REGISTER WAS MODIFIED\n");
417: print_cmpf2_data();
418: writec('\n');
419: writes(" final Acc = ");
420: write32h( sgl_st_acc );
421: writes(", operand 2 = ");
422: write32h( sgl_value_2 );
423: writec('\n');
424: writes("register ");
425: writed( index2 );
426: writes(" = ");
427: write32h( store_regs[ index2 ] );
428: writes(", should be = ");
429: write32h( load_regs[ index2 ] );
430: writes("\n");
431: }
432: if ( halt_flg )
433: cmpf2_er_halt( BAD_REG_HLT ); /* halt on the error */
434: if ( loop_on_err )
435: {
436: force_loop = TRUE; /* set the force loop flag */
437: asm("jmp _cmpf2_5_lp1"); /* and loop */
438: }; /* end of loop-on-error */
439: } /* end of compare error */
440: } while( index++ < max_cmpf_1_index );
441: } /* end of subtest 5 */
442:
443:
444:
445: /****************************************************************************
446: *
447: * SUBTEST 6 - CMPF2 test Accumulator stability test
448: *
449: ****************************************************************************/
450: cmpf2_6()
451: {
452: force_loop = FALSE;
453: subtest = 6;
454: index = 0;
455: do
456: {
457: sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
458: sgl_value_2 = cmpf_1_data[index].two;
459: index2 = 0; /* clear Acc. data index */
460: do
461: {
462: sgl_ld_acc = ldf_1_data[index2].ld; /* get the Accumulator data */
463: sgl_expected = ldf_1_data[index2++].exp; /* get expected Acc. */
464: /*
465: * If LOOP ON ERROR is set, this is the loop for this subtest.
466: * The force loop flag is set after the first error.
467: */
468: asm("_cmpf2_6_lp1:");
469: asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
470: asm("ldf r3"); /* load the accumulator */
471: asm("cmpf2 _sgl_value_1,_sgl_value_2");/* compare the operands */
472: asm("stf _sgl_st_acc"); /* store the accumulator */
473: if( force_loop ) /* loop? */
474: asm("brb _cmpf2_6_lp1");; /* run the loop again */
475: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
476: errcnt++; /* bump the error count */
477: if ( prt_error ) {
478: writes(" \n"); /* start a new print line */
479: writes("cycle: ");
480: writed( cycle );
481: writes(" CMPF2 test ");
482: writed( test_no );
483: writes(", subtest 6 (Acc. Corr.) - THE ACC WAS MODIFIED\n");
484: print_cmpf2_data();
485: writes(", index = ");
486: writed( index );
487: writec('\n');
488: writes(" final Acc = ");
489: write32h( sgl_st_acc );
490: writes(", operand 2 = ");
491: write32h( sgl_value_2 );
492: writec('\n');
493: writes("expected Acc = ");
494: write32h( sgl_expected );
495: writec('\n');
496: }
497: if ( halt_flg ) /* halt on error? */
498: cmpf2_er_halt( BAD_ACC_HLT );
499: if ( loop_on_err )
500: {
501: force_loop = TRUE; /* set the force loop flag */
502: asm("jmp _cmpf2_6_lp1"); /* and loop */
503: }; /* end of loop-on-error */
504: } /* end of compare error */
505: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
506: } while( index++ < max_cmpf_1_index );
507: } /* end of subtest 6 */
508:
509:
510:
511: /****************************************************************************
512: *
513: * SUBTEST 7 - CMPF2 test - piped entry
514: *
515: ****************************************************************************/
516: cmpf2_7()
517: {
518: force_loop = FALSE;
519: subtest = 7;
520: index = 0;
521: do
522: {
523: sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
524: sgl_value_2 = cmpf_1_data[index].two;
525: sgl_expected = cmpf_1_data[index].flag; /* get expected results */
526: index2 = 0; /* clear Acc. data index */
527: do
528: {
529: sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
530: status_index = 0; /* clear the status index */
531: do
532: {
533: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
534: /*
535: * If LOOP ON ERROR is set, this is the loop for this subtest.
536: * The force loop flag is set after the first error.
537: */
538: asm("_cmpf2_7_lp1:");
539: asm("movl $0,r0"); /* zero the reg */
540: asm("ldf r0"); /* load a zero in the acc */
541: asm("addf _sgl_ld_acc"); /* add initial data to acc */
542: asm("tstl _sgl_dummy1"); /* generate initial status */
543: asm("movpsl _init_psl"); /* save the initial status */
544: asm("cmpf2 _sgl_value_1,_sgl_value_2"); /* compare the data */
545: asm("movpsl _psl_val"); /* save the final status */
546: asm("stf _sgl_st_acc"); /* save the acc */
547: if( force_loop ) /* loop? */
548: asm("brb _cmpf2_7_lp1");; /* run the loop again */
549: exp_psl = init_psl; /* get the initial PSL */
550: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
551: if( sgl_expected == ZERO )
552: exp_psl |= PSL_Z; /* expect the ZERO bit set */
553: if( sgl_expected == NEGATIVE )
554: exp_psl |= PSL_N; /* expect the NEG bit set */
555: if( psl_val != exp_psl ) /* COMPARE the values */
556: {
557: errcnt++; /* bump the error count */
558: if ( prt_error ) {
559: writes(" \n"); /* start a new print line */
560: writes("cycle: ");
561: writed( cycle );
562: writes(" CMPF2 test ");
563: writed( test_no );
564: writes(", subtest 7 (Piped Entry) - BAD FINAL PSL\n");
565: print_cmpf2_data();
566: writes(", data index = ");
567: writed( index );
568: writec('\n');
569: writes(" final Acc = ");
570: write32h( sgl_st_acc );
571: writes(", operand 2 = ");
572: write32h( sgl_value_2 );
573: writec('\n');
574: writes(" initial PSL = ");
575: write32h( init_psl );
576: writes(", final PSL = ");
577: write32h( psl_val );
578: writes(", expected PSL = ");
579: write32h( exp_psl );
580: writes(" \n");
581: }
582: if ( halt_flg )
583: cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
584: if ( loop_on_err )
585: {
586: force_loop = TRUE; /* set the force loop flag */
587: asm("brw _cmpf2_7_lp1"); /* and loop */
588: }; /* end of loop-on-error */
589: } /* end of compare error */
590: } while( ++status_index < 3 );
591: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
592: } while( index++ < max_cmpf_1_index );
593: } /* end of subtest 7 */
594:
595:
596:
597: /****************************************************************************
598: *
599: * SUBTEST 8 - CMPF2 piped exit test
600: *
601: ****************************************************************************/
602: cmpf2_8()
603: {
604: force_loop = FALSE;
605: subtest = 6;
606: index = 0;
607: do
608: {
609: sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
610: sgl_value_2 = cmpf_1_data[index].two;
611: index2 = 0; /* clear Acc. data index */
612: do
613: {
614: sgl_ld_acc = ldf_1_data[index2].ld; /* get the Accumulator data */
615: sgl_expected = ldf_1_data[index2++].exp; /* get expected Acc. */
616: /*
617: * If LOOP ON ERROR is set, this is the loop for this subtest.
618: * The force loop flag is set after the first error.
619: */
620: asm("_cmpf2_8_lp1:");
621: asm("movl $0,r0"); /* move a zero to r0 */
622: asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
623: asm("ldf r3"); /* load the accumulator */
624: asm("cmpf2 _sgl_value_1,_sgl_value_2");/* compare the operands */
625: asm("addf r0"); /* add a zero to the acc */
626: asm("stf _sgl_st_acc"); /* store the accumulator */
627: if( force_loop ) /* loop? */
628: asm("brb _cmpf2_8_lp1");; /* run the loop again */
629: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
630: errcnt++; /* bump the error count */
631: if ( prt_error ) {
632: writes(" \n"); /* start a new print line */
633: writes("cycle: ");
634: writed( cycle );
635: writes(" CMPF2 test ");
636: writed( test_no );
637: writes(", subtest 8 (Piped Exit) - THE ACC WAS MODIFIED\n");
638: print_cmpf2_data();
639: writes(", data index = ");
640: writed( index );
641: writec('\n');
642: writes(" final Acc = ");
643: write32h( sgl_st_acc );
644: writes(", operand 2 = ");
645: write32h( sgl_value_2 );
646: writec('\n');
647: writes("expected Acc = ");
648: write32h( sgl_expected );
649: writec('\n');
650: }
651: if ( halt_flg ) /* halt on error? */
652: cmpf2_er_halt( BAD_ACC_HLT );
653: if ( loop_on_err )
654: {
655: force_loop = TRUE; /* set the force loop flag */
656: asm("jmp _cmpf2_8_lp1"); /* and loop */
657: }; /* end of loop-on-error */
658: } /* end of compare error */
659: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
660: } while( index++ < max_cmpf_1_index );
661: } /* end of subtest 8 */
662:
663:
664:
665: /**************************************************************************
666: *
667: * PRINT THE DATA AND STORE RESULTS
668: *
669: * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
670: * operand = xxxxxxxx, expected = xxxxxxxx
671: **************************************************************************/
672: print_cmpf2_data()
673: {
674: writes(" initial Acc = ");
675: write32h( sgl_ld_acc );
676: writes(", operand 1 = ");
677: write32h( sgl_value_1 );
678: }
679:
680:
681:
682: /**************************************************************************
683: *
684: * HALT ON ERROR ROUTINE
685: *
686: **************************************************************************/
687: cmpf2_er_halt( halt_code )
688: int halt_code;
689: {
690: sgl_dummy1 = halt_code; /* get the error type */
691: asm("movl _test_no,r0"); /* r0 = test number */
692: asm("movl _subtest,r1"); /* r1 = subtest number */
693: asm("movl _sgl_dummy1,r2"); /* r2 = error code */
694: asm("movl _cycle,r3"); /* r3 = cycle count */
695: asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
696: asm("movl _sgl_value_1,r5"); /* r5 = operand 1 */
697: asm("movl _sgl_value_2,r6"); /* r6 = operand 2 */
698: asm("movl _psl_val,r7"); /* r7 = actual PSL */
699: if( halt_code == BAD_ACC_HLT ) {
700: asm("movl _sgl_st_acc,r8"); /* r8 = actual value */
701: asm("movl _sgl_expected,r9"); /* r9 = expected value */
702: } else
703: if( halt_code == BAD_REG_HLT ) {
704: sgl_dummy1 = load_regs[index2];
705: sgl_dummy2 = store_regs[index2];
706: asm("movl _index2,r8"); /* r8 = bad register # */
707: asm("movl _sgl_dummy2,r9"); /* r9 = actual value */
708: asm("movl _sgl_dummy1,r10"); /* r10 = expected value */
709: } else
710: if( halt_code == BAD_PSL_HLT ) {
711: asm("movl _exp_psl,r7"); /* r8 = expected PSL */
712: asm("movl _index,r9"); /* r9 = data index */
713: };
714: asm("halt"); /* HALT ... */
715: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.