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