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