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