![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe6.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 pipe6.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 #6 MONITOR
7: *
8: * This test will do:
9: *
10: * LDF(0) ADDF(y) STF CVLF(x) SUBF(0) STF
11: *
12: * where x is the fmacro1 CVLF data, and y is the expected result of the CVLF.
13: * This test verifies the CVLF after the STF and the SUBF after the CVLF.
14: *****************************************************************************/
15: pipe_6()
16: {
17: asm(".globl _pipeline_6_t");
18: asm("_pipeline_6_t:"); /* entry address */
19: if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
20: {
21: writes(" PIPE_6 ");
22: }
23: subtest = 1;
24: pipe6_1(); /* data in REGs, no NOPs */
25: subtest++; /* increment subtest num */
26: pipe6_2(); /* data in REGs, 1 NOP */
27: subtest++; /* increment subtest num */
28: pipe6_3(); /* data in REGs, 2 NOPs */
29: subtest++; /* increment subtest num */
30: pipe6_4(); /* data in REGs, 3 NOPs */
31: subtest++; /* increment subtest num */
32: pipe6_5(); /* data in CACHE, no NOPs */
33: subtest++; /* increment subtest num */
34: pipe6_6(); /* data in CACHE, 1 NOP */
35: subtest++; /* increment subtest num */
36: pipe6_7(); /* data in CACHE, 2 NOPs */
37: subtest++; /* increment subtest num */
38: pipe6_8(); /* data in CACHE, 3 NOPs */
39: subtest++; /* increment subtest num */
40: pipe6_9(); /* data on STACK, no NOPs */
41: subtest++; /* increment subtest num */
42: pipe6_10(); /* data via FP no NOPs */
43: asm("jmp *return"); /* return to the test monitor */
44: }
45:
46:
47:
48:
49:
50:
51: /************************************************************************
52: *
53: * SUBTEST 1
54: * data in registers, no NO-OPs
55: *
56: ************************************************************************/
57: pipe6_1()
58: {
59: force_loop = FALSE; /* clear the force_loop flag */
60: index = 0;
61: do
62: {
63: sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
64: sgl_expected = cvlf_1_data[index].exp; /* get expected results */
65: sgl_value_2 = 0; /* floating '0' */
66: /*
67: * If LOOP ON ERROR is set, this is the loop for this subtest.
68: * The force loop flag is set after the first error.
69: */
70: asm("_pipe6_1_lp1:");
71: asm("movl _sgl_value_1,r4"); /* move the data to r4 */
72: asm("movl _sgl_value_2,r5"); /* move data to r5 */
73: asm("movl _sgl_expected,r6"); /* save the expected result*/
74: asm("ldf r5"); /* load a floating '0' */
75: asm("addf r6"); /* add the expected value */
76: asm("stf r7"); /* store the result */
77: asm("cvlf r4"); /* convert the operand */
78: asm("subf r5"); /* subtract a floating '0' */
79: asm("stf r8"); /* store the result */
80: if( force_loop )
81: asm("brb _pipe6_1_lp1");; /* loop on the error */
82: /*
83: * verify the results
84: */
85: asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
86: asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
87: if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
88: (sgl_value_6 != sgl_expected) )
89: {
90: errcnt++; /* bump the error count */
91: if ( prt_error )
92: print_pipe6_er("Reg. Data, no NO-OPs");
93: if ( halt_flg ) /* halt on error? */
94: pipe6_er_hlt( subtest );
95: if ( loop_on_err ) {
96: force_loop = TRUE; /* set the force loop flag */
97: asm("jmp _pipe6_1_lp1"); /* and loop */
98: }
99: } /* end of compare error */
100: } while( index++ < max_cvlf_1_index );
101: } /* end of subtest 1 */
102:
103:
104:
105:
106:
107:
108: /************************************************************************
109: *
110: * SUBTEST 2
111: * data in registers, 1 NO-OP
112: *
113: ************************************************************************/
114: pipe6_2()
115: {
116: force_loop = FALSE; /* clear the force_loop flag */
117: index = 0;
118: do
119: {
120: sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
121: sgl_expected = cvlf_1_data[index].exp; /* get expected results */
122: sgl_value_2 = 0x00000000; /* floating '0' */
123: /*
124: * If LOOP ON ERROR is set, this is the loop for this subtest.
125: * The force loop flag is set after the first error.
126: */
127: asm("_pipe6_2_lp1:");
128: asm("movl _sgl_value_1,r4"); /* move the data to r4 */
129: asm("movl _sgl_value_2,r5"); /* move data to r5 */
130: asm("movl _sgl_expected,r6"); /* save the expected result*/
131: asm("ldf r5"); /* load a floating '0' */
132: asm("nop");
133: asm("addf r6"); /* add the expected value */
134: asm("nop");
135: asm("stf r7"); /* store the result */
136: asm("nop");
137: asm("cvlf r4"); /* convert the operand */
138: asm("nop");
139: asm("subf r5"); /* subtract a floating '0' */
140: asm("nop");
141: asm("stf r8"); /* store the result */
142: if( force_loop )
143: asm("brb _pipe6_2_lp1");; /* loop on the error */
144: /*
145: * verify the results
146: */
147: asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
148: asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
149: if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
150: (sgl_value_6 != sgl_expected) )
151: {
152: errcnt++; /* bump the error count */
153: if ( prt_error )
154: print_pipe6_er("Reg. Data, 1 NO-OP");
155: if ( halt_flg ) /* halt on error? */
156: pipe6_er_hlt( subtest );
157: if ( loop_on_err ) {
158: force_loop = TRUE; /* set the force loop flag */
159: asm("jmp _pipe6_2_lp1"); /* and loop */
160: }
161: } /* end of compare error */
162: } while( index++ < max_cvlf_1_index );
163: } /* end of subtest 2 */
164:
165:
166:
167:
168:
169:
170: /************************************************************************
171: *
172: * SUBTEST 3
173: * data in registers, 2 NO-OPs
174: *
175: ************************************************************************/
176: pipe6_3()
177: {
178: force_loop = FALSE; /* clear the force_loop flag */
179: index = 0;
180: do
181: {
182: sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
183: sgl_expected = cvlf_1_data[index].exp; /* get expected results */
184: sgl_value_2 = 0x00000000; /* floating '0' */
185: /*
186: * If LOOP ON ERROR is set, this is the loop for this subtest.
187: * The force loop flag is set after the first error.
188: */
189: asm("_pipe6_3_lp1:");
190: asm("movl _sgl_value_1,r4"); /* move the data to r4 */
191: asm("movl _sgl_value_2,r5"); /* move data to r5 */
192: asm("movl _sgl_expected,r6"); /* save the expected result*/
193: asm("ldf r5"); /* load a floating '0' */
194: asm("nop");
195: asm("nop");
196: asm("addf r6"); /* add the expected value */
197: asm("nop");
198: asm("nop");
199: asm("stf r7"); /* store the result */
200: asm("nop");
201: asm("nop");
202: asm("cvlf r4"); /* convert the operand */
203: asm("nop");
204: asm("nop");
205: asm("subf r5"); /* subtract a floating '0' */
206: asm("nop");
207: asm("nop");
208: asm("stf r8"); /* store the result */
209: if( force_loop )
210: asm("brb _pipe6_3_lp1");; /* loop on the error */
211: /*
212: * verify the results
213: */
214: asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
215: asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
216: if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
217: (sgl_value_6 != sgl_expected) )
218: {
219: errcnt++; /* bump the error count */
220: if ( prt_error )
221: print_pipe6_er("Reg. Data, 2 NO-OPs");
222: if ( halt_flg ) /* halt on error? */
223: pipe6_er_hlt( subtest );
224: if ( loop_on_err ) {
225: force_loop = TRUE; /* set the force loop flag */
226: asm("jmp _pipe6_3_lp1"); /* and loop */
227: }
228: } /* end of compare error */
229: } while( index++ < max_cvlf_1_index );
230: } /* end of subtest 3 */
231:
232:
233:
234:
235:
236:
237: /************************************************************************
238: *
239: * SUBTEST 4
240: * data in registers, 3 NO-OPs
241: *
242: ************************************************************************/
243: pipe6_4()
244: {
245: force_loop = FALSE; /* clear the force_loop flag */
246: index = 0;
247: do
248: {
249: sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
250: sgl_expected = cvlf_1_data[index].exp; /* get expected results */
251: sgl_value_2 = 0x00000000; /* floating '0' */
252: /*
253: * If LOOP ON ERROR is set, this is the loop for this subtest.
254: * The force loop flag is set after the first error.
255: */
256: asm("_pipe6_4_lp1:");
257: asm("movl _sgl_value_1,r4"); /* move the data to r4 */
258: asm("movl _sgl_value_2,r5"); /* move data to r5 */
259: asm("movl _sgl_expected,r6"); /* save the expected result*/
260: asm("ldf r5"); /* load a floating '0' */
261: asm("nop");
262: asm("nop");
263: asm("nop");
264: asm("addf r6"); /* add the expected value */
265: asm("nop");
266: asm("nop");
267: asm("nop");
268: asm("stf r7"); /* store the result */
269: asm("nop");
270: asm("nop");
271: asm("nop");
272: asm("cvlf r4"); /* convert the operand */
273: asm("nop");
274: asm("nop");
275: asm("nop");
276: asm("subf r5"); /* subtract a floating '0' */
277: asm("nop");
278: asm("nop");
279: asm("nop");
280: asm("stf r8"); /* store the result */
281: if( force_loop )
282: asm("brb _pipe6_4_lp1");; /* loop on the error */
283: /*
284: * verify the results
285: */
286: asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
287: asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
288: if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
289: (sgl_value_6 != sgl_expected) )
290: {
291: errcnt++; /* bump the error count */
292: if ( prt_error )
293: print_pipe6_er("Reg. Data, 3 NO-OPs");
294: if ( halt_flg ) /* halt on error? */
295: pipe6_er_hlt( subtest );
296: if ( loop_on_err ) {
297: force_loop = TRUE; /* set the force loop flag */
298: asm("jmp _pipe6_4_lp1"); /* and loop */
299: }
300: } /* end of compare error */
301: } while( index++ < max_cvlf_1_index );
302: } /* end of subtest 4 */
303:
304:
305:
306:
307:
308:
309:
310: /************************************************************************
311: *
312: * SUBTEST 5
313: * data in Cache, no NO-OPs
314: *
315: ************************************************************************/
316: pipe6_5()
317: {
318: force_loop = FALSE; /* clear the force_loop flag */
319: index = 0;
320: do
321: {
322: sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
323: sgl_expected = cvlf_1_data[index].exp; /* get expected results */
324: sgl_value_2 = 0x00000000; /* floating '0' */
325: /*
326: * If LOOP ON ERROR is set, this is the loop for this subtest.
327: * The force loop flag is set after the first error.
328: */
329: asm("_pipe6_5_lp1:");
330: asm("ldf _sgl_value_2"); /* load a floating '0' */
331: asm("addf _sgl_expected"); /* add the expected value */
332: asm("stf _sgl_st_acc"); /* store the result */
333: asm("cvlf _sgl_value_1"); /* convert the int operand */
334: asm("subf _sgl_value_2"); /* subtract a floating '0' */
335: asm("stf _sgl_value_6"); /* store the result */
336: if( force_loop )
337: asm("brb _pipe6_5_lp1");; /* loop on the error */
338: /*
339: * verify the results
340: */
341: if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
342: (sgl_value_6 != sgl_expected) )
343: {
344: errcnt++; /* bump the error count */
345: if ( prt_error )
346: print_pipe6_er("Cache Data, no NO-OPs");
347: if ( halt_flg ) /* halt on error? */
348: pipe6_er_hlt( subtest );
349: if ( loop_on_err ) {
350: force_loop = TRUE; /* set the force loop flag */
351: asm("jmp _pipe6_5_lp1"); /* and loop */
352: }
353: } /* end of compare error */
354: } while( index++ < max_cvlf_1_index );
355: } /* end of subtest 5 */
356:
357:
358:
359:
360:
361:
362: /************************************************************************
363: *
364: * SUBTEST 6
365: * data in Cache, 1 NO-OP
366: *
367: ************************************************************************/
368: pipe6_6()
369: {
370: force_loop = FALSE; /* clear the force_loop flag */
371: index = 0;
372: do
373: {
374: sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
375: sgl_expected = cvlf_1_data[index].exp; /* get expected results */
376: sgl_value_2 = 0x00000000; /* floating '0' */
377: /*
378: * If LOOP ON ERROR is set, this is the loop for this subtest.
379: * The force loop flag is set after the first error.
380: */
381: asm("_pipe6_6_lp1:");
382: asm("ldf _sgl_value_2"); /* load a floating '0' */
383: asm("nop");
384: asm("addf _sgl_expected"); /* add the expected value */
385: asm("nop");
386: asm("stf _sgl_st_acc"); /* store the result */
387: asm("nop");
388: asm("cvlf _sgl_value_1"); /* convert the int operand */
389: asm("nop");
390: asm("subf _sgl_value_2"); /* subtract a floating '0' */
391: asm("nop");
392: asm("stf _sgl_value_6"); /* store the result */
393: if( force_loop )
394: asm("brb _pipe6_6_lp1");; /* loop on the error */
395: /*
396: * verify the results
397: */
398: if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
399: (sgl_value_6 != sgl_expected) )
400: {
401: errcnt++; /* bump the error count */
402: if ( prt_error )
403: print_pipe6_er("Cache Data, 1 NO-OP");
404: if ( halt_flg ) /* halt on error? */
405: pipe6_er_hlt( subtest );
406: if ( loop_on_err ) {
407: force_loop = TRUE; /* set the force loop flag */
408: asm("jmp _pipe6_6_lp1"); /* and loop */
409: }
410: } /* end of compare error */
411: } while( index++ < max_cvlf_1_index );
412: } /* end of subtest 6 */
413:
414:
415:
416:
417:
418:
419: /************************************************************************
420: *
421: * SUBTEST 7
422: * data in Cache, 2 NO-OPs
423: *
424: ************************************************************************/
425: pipe6_7()
426: {
427: force_loop = FALSE; /* clear the force_loop flag */
428: index = 0;
429: do
430: {
431: sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
432: sgl_expected = cvlf_1_data[index].exp; /* get expected results */
433: sgl_value_2 = 0x00000000; /* floating '0' */
434: /*
435: * If LOOP ON ERROR is set, this is the loop for this subtest.
436: * The force loop flag is set after the first error.
437: */
438: asm("_pipe6_7_lp1:");
439: asm("ldf _sgl_value_2"); /* load a floating '0' */
440: asm("nop");
441: asm("nop");
442: asm("addf _sgl_expected"); /* add the expected value */
443: asm("nop");
444: asm("nop");
445: asm("stf _sgl_st_acc"); /* store the result */
446: asm("nop");
447: asm("nop");
448: asm("cvlf _sgl_value_1"); /* convert the int operand */
449: asm("nop");
450: asm("nop");
451: asm("subf _sgl_value_2"); /* subtract a floating '0' */
452: asm("nop");
453: asm("nop");
454: asm("stf _sgl_value_6"); /* store the result */
455: if( force_loop )
456: asm("brb _pipe6_7_lp1");; /* loop on the error */
457: /*
458: * verify the results
459: */
460: if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
461: (sgl_value_6 != sgl_expected) )
462: {
463: errcnt++; /* bump the error count */
464: if ( prt_error )
465: print_pipe6_er("Cache Data, 2 NO-OPs");
466: if ( halt_flg ) /* halt on error? */
467: pipe6_er_hlt( subtest );
468: if ( loop_on_err ) {
469: force_loop = TRUE; /* set the force loop flag */
470: asm("jmp _pipe6_7_lp1"); /* and loop */
471: }
472: } /* end of compare error */
473: } while( index++ < max_cvlf_1_index );
474: } /* end of subtest 7 */
475:
476:
477:
478:
479:
480:
481: /************************************************************************
482: *
483: * SUBTEST 8
484: * data in Cache, 3 NO-OPs
485: *
486: ************************************************************************/
487: pipe6_8()
488: {
489: force_loop = FALSE; /* clear the force_loop flag */
490: index = 0;
491: do
492: {
493: sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
494: sgl_expected = cvlf_1_data[index].exp; /* get expected results */
495: sgl_value_2 = 0x00000000; /* floating '0' */
496: /*
497: * If LOOP ON ERROR is set, this is the loop for this subtest.
498: * The force loop flag is set after the first error.
499: */
500: asm("_pipe6_8_lp1:");
501: asm("ldf _sgl_value_2"); /* load a floating '0' */
502: asm("nop");
503: asm("nop");
504: asm("nop");
505: asm("addf _sgl_expected"); /* add the expected value */
506: asm("nop");
507: asm("nop");
508: asm("nop");
509: asm("stf _sgl_st_acc"); /* store the result */
510: asm("nop");
511: asm("nop");
512: asm("nop");
513: asm("cvlf _sgl_value_1"); /* convert the int operand */
514: asm("nop");
515: asm("nop");
516: asm("nop");
517: asm("subf _sgl_value_2"); /* subtract a floating '0' */
518: asm("nop");
519: asm("nop");
520: asm("nop");
521: asm("stf _sgl_value_6"); /* store the result */
522: if( force_loop )
523: asm("brb _pipe6_8_lp1");; /* loop on the error */
524: /*
525: * verify the results
526: */
527: if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
528: (sgl_value_6 != sgl_expected) )
529: {
530: errcnt++; /* bump the error count */
531: if ( prt_error )
532: print_pipe6_er("Cache Data, 3 NO-OPs");
533: if ( halt_flg ) /* halt on error? */
534: pipe6_er_hlt( subtest );
535: if ( loop_on_err ) {
536: force_loop = TRUE; /* set the force loop flag */
537: asm("jmp _pipe6_8_lp1"); /* and loop */
538: }
539: } /* end of compare error */
540: } while( index++ < max_cvlf_1_index );
541: } /* end of subtest 8 */
542:
543:
544:
545:
546:
547:
548: /*****************************************************************************
549: *
550: * SUBTEST 9
551: * data on the stack, no NO-OPs
552: *
553: *****************************************************************************/
554: pipe6_9()
555: {
556: asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
557: asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
558: force_loop = FALSE; /* clear the force_loop flag */
559: index = 0;
560: do
561: {
562: sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
563: sgl_expected = cvlf_1_data[index].exp; /* get expected results */
564: sgl_value_2 = 0x00000000; /* floating '0' */
565: asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
566: /*
567: * If LOOP ON ERROR is set, this is the loop for this subtest.
568: * The force loop flag is set after the first error.
569: */
570: asm("_pipe6_9_lp1:");
571: asm("moval _pointer_data,r14"); /* set the stack pointer */
572: asm("movl _sgl_value_2,-(r14)"); /* push a floating '0' */
573: asm("movl _sgl_value_1,-(r14)"); /* push the operand */
574: asm("movl _sgl_expected,-(r14)"); /* push the expected result*/
575: asm("movl _sgl_value_2,-(r14)"); /* push a floating '0' */
576: /*
577: * now pop the data off the stack
578: */
579:
580: asm("ldf (r14)+"); /* load the '0' value */
581: asm("addf (r14)+"); /* add the expected result */
582: asm("stf r5"); /* store the result */
583: asm("cvlf (r14)+"); /* convert the integer op */
584: asm("subf (r14)+"); /* subtract a floating '0' */
585: asm("stf r6"); /* store the result */
586: if( force_loop )
587: asm("brb _pipe6_9_lp1");; /* loop on the error */
588: /*
589: * verify the results
590: */
591: asm("movl r5,_sgl_st_acc"); /* get the 1st store value */
592: asm("movl r6,_sgl_value_6"); /* get the 2nd store value */
593: asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
594: if( (sgl_st_acc != sgl_expected) || /* verify the results... */
595: (sgl_value_6 != sgl_expected) ||
596: (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
597: {
598: asm("movl _pre_event_fp,r13"); /* restore frame pointer */
599: asm("movl _pre_event_sp,r14"); /* restore stack pointer */
600: errcnt++; /* bump the error count */
601: if ( prt_error ) {
602: print_pipe4_er("POP data from the STACK");
603: writes("final Stack Pointer = ");
604: write32h( sgl_value_5 );
605: writes(", expected SP = ");
606: write32h( sgl_value_4 );
607: writes("\n");
608: }
609: if ( halt_flg ) /* halt on error? */
610: pipe6_er_hlt( subtest );
611: if ( loop_on_err ) {
612: force_loop = TRUE; /* set the force loop flag */
613: asm("jmp _pipe6_9_lp1"); /* and loop */
614: }
615: } /* end of compare error */
616: } while( index++ < max_cvlf_1_index );
617: asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
618: asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
619: } /* end of subtest 9 */
620:
621:
622:
623:
624:
625:
626: /******************************************************************************
627: *
628: * SUBTEST 10
629: * get data via indexed FRAME pointer
630: *
631: * ADDR INDEX DATA
632: * pointer_data 4 <the 1st STF result goes here>
633: * pointer_data-4 3 <the 2nd STF result goes here>
634: * pointer_data-8 2 <integer operand>
635: * pointer_data-12 1 <floating '0'>
636: * pointer_data-16 0 <floating operand> ( point FP here )
637: *
638: ******************************************************************************/
639: pipe6_10()
640: {
641: asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
642: asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
643: force_loop = FALSE; /* clear the force_loop flag */
644: index = 0;
645: do
646: {
647: sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
648: sgl_expected = cvlf_1_data[index].exp; /* get expected results */
649: sgl_value_2 = 0x00000000; /* floating '0' */
650: asm("moval _pointer_data,_sgl_value_4"); /* get store data's addr */
651: sgl_value_4 -= 8; /* decrement it by 8 (bytes)*/
652: asm("movl _sgl_value_1,*_sgl_value_4"); /* set the integer op. */
653: sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
654: asm("movl _sgl_value_2,*_sgl_value_4"); /* set the floating '0' */
655: sgl_value_4 -= 4; /* get FRAME PTR address */
656: asm("movl _sgl_expected,*_sgl_value_4"); /* set the floating op. */
657: /*
658: * If LOOP ON ERROR is set, this is the loop for this subtest.
659: * The force loop flag is set after the first error.
660: */
661: asm("_pipe6_10_lp1:");
662: asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
663: asm("movl $1,r1"); /* r1 index = 1 ( '0' ) */
664: asm("movl $2,r2"); /* r2 index = 2 (int. op.) */
665: asm("movl $3,r3"); /* r3 index = 3 (2nd store) */
666: asm("movl $4,r4"); /* r4 index = 4 (1st store) */
667: asm("clrl r5"); /* r5 index = 0 (sgl. op.) */
668: asm("ldf (r13)[r1]"); /* load a '0' (indx=1) */
669: asm("addf (r13)[r5]"); /* add the operand (indx=0) */
670: asm("stf (r13)[r4]"); /* 1st store (indx=4) */
671: asm("cvlf (r13)[r2]"); /* convert the int (indx=2) */
672: asm("subf (r13)[r1]"); /* subtract a '0' (indx=1) */
673: asm("stf (r13)[r3]"); /* 2nd store (indx=3) */
674: if( force_loop )
675: asm("brb _pipe6_10_lp1");; /* loop on the error */
676: /*
677: * verify the results
678: */
679: sgl_st_acc = pointer_data; /* save 1st stored value */
680: asm("moval _pointer_data,_sgl_value_5"); /* get addr of 1st stf */
681: sgl_value_5 -= 4; /* decrement by 4 (bytes) */
682: asm("movl *_sgl_value_5,_sgl_value_6"); /* save 2nd store value */
683: asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
684: if( (sgl_st_acc != sgl_expected) || /* verify the results... */
685: (sgl_value_6 != sgl_expected) ||
686: (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
687: {
688: asm("movl _pre_event_fp,r13"); /* restore frame pointer */
689: asm("movl _pre_event_sp,r14"); /* restore stack pointer */
690: errcnt++; /* bump the error count */
691: if ( prt_error ) {
692: print_pipe6_er("indexed FP addressing");
693: writes("final Frame Pointer = ");
694: writeh( sgl_value_5 );
695: writes(", expected FP = ");
696: writeh( sgl_value_4 );
697: writes("\n");
698: }
699: if ( halt_flg ) /* halt on error? */
700: pipe6_er_hlt( subtest );
701: if ( loop_on_err ) {
702: force_loop = TRUE; /* set the force loop flag */
703: asm("jmp _pipe6_10_lp1"); /* and loop */
704: }
705: } /* end of compare error */
706: } while( index++ < max_cvlf_1_index );
707: asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
708: asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
709: } /* end of subtest 10 */
710:
711:
712: /******************************************************************************
713: *
714: *
715: * print an error in the following form
716: *
717: * operand 1 = xxxxxxxx, 1st store = xxxxxxxx, data index = dd
718: * operand 2 = xxxxxxxx, 2nd store = xxxxxxxx
719: * expected Acc = xxxxxxxx
720: *
721: ******************************************************************************/
722: print_pipe6_er(msg)
723: char *msg;
724: {
725: writes("\n"); /* start a new print line */
726: writes("cycle: ");
727: writed( cycle );
728: writes(" test ");
729: writed( test_no );
730: writes(" (Pipe 6), subtest ");
731: writed( subtest );
732: writes(" error - ");
733: writes( msg );
734: writec('\n');
735: writes(" LDF(0.0), ADDF(op1), STF, CVLF(op2), SUBF(0.0), STF\n");
736: writes("operand 1 = ");
737: write32h( sgl_expected );
738: writes(", 1st store = ");
739: write32h( sgl_st_acc );
740: writes(", data index = ");
741: writed( index );
742: writec('\n');
743: writes("operand 2 = ");
744: write32h( sgl_value_1 );
745: writes(", 2nd store = ");
746: write32h( sgl_value_6 );
747: writec('\n');
748: writes(" expected Acc = ");
749: write32h( sgl_expected );
750: writec('\n');
751: }
752:
753:
754:
755:
756:
757: /******************************************************************************
758: *
759: * HALT ON ERROR ROUTINE
760: *
761: * halt with the necessary information saved in the registers
762: *
763: ******************************************************************************/
764: pipe6_er_hlt( subtest )
765: int subtest;
766: {
767: asm("movl _test_no,r0"); /* r0 = test number */
768: asm("movl _subtest,r1"); /* r1 = subtest number */
769: asm("movl $1,r2"); /* r2 = error code */
770: asm("movl _cycle,r3"); /* r3 = cycle count */
771: asm("movl _sgl_expected,r4"); /* r4 = 1st operand */
772: asm("movl _sgl_value_1,r5"); /* r5 = 2nd operand */
773: asm("movl _sgl_st_acc,r6"); /* r6 = 1st word stored */
774: asm("movl _sgl_value_6,r7"); /* r6 = 2nd word stored */
775: asm("movl _sgl_expected,r8"); /* r8 = sgl expected */
776: asm("movl _index,r9"); /* r9 = data index */
777: asm("movl _sgl_value_2,r10"); /* r10 = floating zero */
778: if( subtest == 9 ) {
779: asm("movl _sgl_value_5,r11"); /* r11= final SP value */
780: asm("movl _sgl_value_4,r12"); /* r12= expected SP value */
781: } else
782: if( subtest == 10 ) {
783: asm("movl _sgl_value_5,r11"); /* r11= final FP value */
784: asm("movl _sgl_value_4,r12"); /* r12= expected FP value */
785: };
786: asm(".globl _pipe6_1_hlt");
787: asm("_pipe6_1_hlt:"); /* PC after the halt */
788: asm("halt"); /* HALT ... */
789: } /* end of halt on error */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.