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