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