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