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