![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmpd2.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 cmpd2.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: *
7: * CMPD2 -COMPARE 2 DBL OPERANDS TO EACH OTHER -IGNORE THE ACCUMULATOR
8: *
9: *****************************************************************************/
10: cmpd2()
11: {
12: asm(".globl _cmpd2_t");
13: asm("_cmpd2_t:"); /* entry address */
14: if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
15: writes(" CMPD2");
16: cmpd2_1(); /* register / register data */
17: cmpd2_2(); /* cache / cache data */
18: cmpd2_3(); /* cache / register data */
19: cmpd2_4(); /* register / cache data */
20: cmpd2_5(); /* acc. corruption test */
21: cmpd2_6(); /* register corruption test */
22: asm("jmp *return"); /* return to the test monitor */
23: }
24:
25:
26:
27: /****************************************************************************
28: *
29: * SUBTEST 1 - CMPD2 test -register / register data
30: *
31: ****************************************************************************/
32: cmpd2_1()
33: {
34: force_loop = FALSE;
35: subtest = 1;
36: index = 0;
37: do
38: {
39: dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */
40: dbl_value_2 = cmpd_1_data[index].two;
41: sgl_expected = cmpd_1_data[index].flag; /* get expected results */
42: sgl_value_1 = dbl_value_1.m;
43: sgl_value_2 = dbl_value_1.l;
44: sgl_value_3 = dbl_value_2.m;
45: sgl_value_4 = dbl_value_2.l;
46: index2 = 0; /* clear Acc. data index */
47: do
48: {
49: dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */
50: asm("ldd _dbl_ld_acc"); /* load the accumulator */
51: status_index = 0; /* clear the status index */
52: do
53: {
54: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
55: /*
56: * If LOOP ON ERROR is set, this is the loop for this subtest.
57: * The force loop flag is set after the first error.
58: */
59: asm("_cmpd2_1_lp1:");
60: asm("movl _sgl_value_1,r4"); /* r4 = operand #1's MSW */
61: asm("movl _sgl_value_2,r5"); /* r5 = operand #1's LSW */
62: asm("movl _sgl_value_3,r6"); /* r6 = operand #2's MSW */
63: asm("movl _sgl_value_4,r7"); /* r7 = operand #2's LSW */
64: asm("nop");
65: asm("tstl _sgl_dummy1"); /* generate initial status */
66: asm("movpsl _init_psl"); /* save the initial status */
67: asm("cmpd2 r4,r6"); /* compare the operands */
68: asm("movpsl _psl_val"); /* save the final status */
69: asm("std _dbl_st_acc"); /* save the acc */
70: if( force_loop ) /* loop? */
71: asm("brb _cmpd2_1_lp1");; /* run the loop again */
72: exp_psl = init_psl; /* get the initial PSL */
73: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
74: if( sgl_expected == ZERO )
75: exp_psl |= PSL_Z; /* expect the ZERO bit set */
76: if( sgl_expected == NEGATIVE )
77: exp_psl |= PSL_N; /* expect the NEG bit set */
78: if( psl_val != exp_psl ) { /* COMPARE the values */
79: errcnt++; /* bump the error count */
80: if ( prt_error ) {
81: writes(" \n"); /* start a new print line */
82: writes("cycle: ");
83: writed( cycle );
84: writes(" CMPD2 test ");
85: writed( test_no );
86: writes(", subtest 1 (Reg./Reg. Data) - BAD FINAL PSL\n");
87: print_cmpd2_data();
88: writes(", index = ");
89: writed( index );
90: writec('\n');
91: writes(" final Acc = ");
92: write32h( dbl_st_acc.m );
93: writec(' ');
94: write32h( dbl_st_acc.l );
95: writes(", operand 2 = ");
96: write32h( sgl_value_3);
97: writec(' ');
98: write32h( sgl_value_4);
99: writec('\n');
100: writes(" initial PSL = ");
101: write32h( init_psl );
102: writes(", final PSL = ");
103: write32h( psl_val );
104: writes(", expected PSL = ");
105: write32h( exp_psl );
106: writes(" \n");
107: }
108: if ( halt_flg )
109: cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */
110: if ( loop_on_err ) {
111: force_loop = TRUE; /* set the force loop flag */
112: asm("brw _cmpd2_1_lp1"); /* and loop */
113: }; /* end of loop-on-error */
114: } /* end of compare error */
115: } while( ++status_index < 3 );
116: index2++;
117: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
118: } while( index++ < max_cmpd_1_index );
119: } /* end of subtest 1 */
120:
121:
122:
123: /****************************************************************************
124: *
125: * SUBTEST 2 - CMPD2 test - cache / cache data
126: *
127: ****************************************************************************/
128: cmpd2_2()
129: {
130: force_loop = FALSE;
131: subtest = 2;
132: index = 0;
133: do
134: {
135: dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */
136: dbl_value_2 = cmpd_1_data[index].two;
137: sgl_value_1 = dbl_value_1.m;
138: sgl_value_2 = dbl_value_1.l;
139: sgl_value_3 = dbl_value_2.m;
140: sgl_value_4 = dbl_value_2.l;
141: sgl_expected = cmpd_1_data[index].flag; /* get expected results */
142: index2 = 0; /* clear Acc. data index */
143: do
144: {
145: dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */
146: asm("ldd _dbl_ld_acc"); /* load the accumulator */
147: status_index = 0; /* clear the status index */
148: do
149: {
150: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
151: /*
152: * If LOOP ON ERROR is set, this is the loop for this subtest.
153: * The force loop flag is set after the first error.
154: */
155: asm("_cmpd2_2_lp1:");
156: asm("tstl _sgl_dummy1"); /* generate initial status */
157: asm("movpsl _init_psl"); /* save the initial status */
158: asm("nop");
159: asm("cmpd2 _dbl_value_1,_dbl_value_2"); /* compare the data */
160: asm("nop");
161: asm("movpsl _psl_val"); /* save the final status */
162: asm("std _dbl_st_acc"); /* save the acc */
163: if( force_loop ) /* loop? */
164: asm("brb _cmpd2_2_lp1");; /* run the loop again */
165: exp_psl = init_psl; /* get the initial PSL */
166: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
167: if( sgl_expected == ZERO )
168: exp_psl |= PSL_Z; /* expect the ZERO bit set */
169: if( sgl_expected == NEGATIVE )
170: exp_psl |= PSL_N; /* expect the NEG bit set */
171: if( psl_val != exp_psl ) { /* COMPARE the values */
172: errcnt++; /* bump the error count */
173: if ( prt_error ) {
174: writes(" \n"); /* start a new print line */
175: writes("cycle: ");
176: writed( cycle );
177: writes(" CMPD2 test ");
178: writed( test_no );
179: writes(", subtest 2 (Cache/Cache Data) - BAD FINAL PSL\n");
180: print_cmpd2_data();
181: writes(", index = ");
182: writed( index );
183: writec('\n');
184: writes(" final Acc = ");
185: write32h( dbl_st_acc.m );
186: writec(' ');
187: write32h( dbl_st_acc.l );
188: writes(", operand 2 = ");
189: write32h( sgl_value_3);
190: writec(' ');
191: write32h( sgl_value_4);
192: writec('\n');
193: writes(" initial PSL = ");
194: write32h( init_psl );
195: writes(", final PSL = ");
196: write32h( psl_val );
197: writes(", expected PSL = ");
198: write32h( exp_psl );
199: writes(" \n");
200: }
201: if ( halt_flg )
202: cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */
203: if ( loop_on_err )
204: {
205: force_loop = TRUE; /* set the force loop flag */
206: asm("brw _cmpd2_2_lp1"); /* and loop */
207: }; /* end of loop-on-error */
208: } /* end of compare error */
209: } while( ++status_index < 3 );
210: index2++;
211: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
212: } while( index++ < max_cmpd_1_index );
213: } /* end of subtest 2 */
214:
215:
216:
217: /****************************************************************************
218: *
219: * SUBTEST 3 - CMPD2 test - cache / register data
220: *
221: ****************************************************************************/
222: cmpd2_3()
223: {
224: force_loop = FALSE;
225: subtest = 3;
226: index = 0;
227: do
228: {
229: dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */
230: dbl_value_2 = cmpd_1_data[index].two;
231: sgl_value_1 = dbl_value_1.m;
232: sgl_value_2 = dbl_value_1.l;
233: sgl_value_3 = dbl_value_2.m;
234: sgl_value_4 = dbl_value_2.l;
235: sgl_expected = cmpd_1_data[index].flag; /* get expected results */
236: index2 = 0; /* clear Acc. data index */
237: do
238: {
239: dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */
240: asm("ldd _dbl_ld_acc"); /* load the accumulator */
241: status_index = 0; /* clear the status index */
242: do
243: {
244: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
245: /*
246: * If LOOP ON ERROR is set, this is the loop for this subtest.
247: * The force loop flag is set after the first error.
248: */
249: asm("_cmpd2_3_lp1:");
250: asm("movl _sgl_value_3,r4"); /* move operand #2's MSW,r4 */
251: asm("movl _sgl_value_4,r5"); /* move operand #2's LSW,r5 */
252: asm("tstl _sgl_dummy1"); /* generate initial status */
253: asm("movpsl _init_psl"); /* save the initial status */
254: asm("nop");
255: asm("cmpd2 _dbl_value_1,r4"); /* compare the data */
256: asm("nop");
257: asm("movpsl _psl_val"); /* save the final status */
258: asm("std _sgl_st_acc"); /* save the acc */
259: if( force_loop ) /* loop? */
260: asm("brb _cmpd2_3_lp1");; /* run the loop again */
261: exp_psl = init_psl; /* get the initial PSL */
262: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
263: if( sgl_expected == ZERO )
264: exp_psl |= PSL_Z; /* expect the ZERO bit set */
265: if( sgl_expected == NEGATIVE )
266: exp_psl |= PSL_N; /* expect the NEG bit set */
267: if( psl_val != exp_psl ) { /* COMPARE the values */
268: errcnt++; /* bump the error count */
269: if ( prt_error ) {
270: writes(" \n"); /* start a new print line */
271: writes("cycle: ");
272: writed( cycle );
273: writes(" CMPD2 test ");
274: writed( test_no );
275: writes(", subtest 3 (Cache/Reg. Data) - BAD FINAL PSL\n");
276: print_cmpd2_data();
277: writes(", index = ");
278: writed( index );
279: writec('\n');
280: writes(" final Acc = ");
281: write32h( dbl_st_acc.m );
282: writec(' ');
283: write32h( dbl_st_acc.l );
284: writes(", operand 2 = ");
285: write32h( sgl_value_3);
286: writec(' ');
287: write32h( sgl_value_4);
288: writec('\n');
289: writes(" initial PSL = ");
290: write32h( init_psl );
291: writes(", final PSL = ");
292: write32h( psl_val );
293: writes(", expected PSL = ");
294: write32h( exp_psl );
295: writes(" \n");
296: }
297: if ( halt_flg )
298: cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */
299: if ( loop_on_err )
300: {
301: force_loop = TRUE; /* set the force loop flag */
302: asm("brw _cmpd2_3_lp1"); /* and loop */
303: }; /* end of loop-on-error */
304: } /* end of compare error */
305: } while( ++status_index < 3 );
306: index2++;
307: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
308: } while( index++ < max_cmpd_1_index );
309: } /* end of subtest 3 */
310:
311:
312:
313: /****************************************************************************
314: *
315: * SUBTEST 4 - CMPD2 test - register / cache data
316: *
317: ****************************************************************************/
318: cmpd2_4()
319: {
320: force_loop = FALSE;
321: subtest = 4;
322: index = 0;
323: do
324: {
325: dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */
326: dbl_value_2 = cmpd_1_data[index].two;
327: sgl_value_1 = dbl_value_1.m;
328: sgl_value_2 = dbl_value_1.l;
329: sgl_value_3 = dbl_value_2.m;
330: sgl_value_4 = dbl_value_2.l;
331: sgl_expected = cmpd_1_data[index].flag; /* get expected results */
332: index2 = 0; /* clear Acc. data index */
333: do
334: {
335: dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */
336: asm("ldd _dbl_ld_acc"); /* load the accumulator */
337: status_index = 0; /* clear the status index */
338: do
339: {
340: sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
341: /*
342: * If LOOP ON ERROR is set, this is the loop for this subtest.
343: * The force loop flag is set after the first error.
344: */
345: asm("_cmpd2_4_lp1:");
346: asm("movl _sgl_value_1,r2"); /* move operand #1,s MSW,r2 */
347: asm("movl _sgl_value_2,r3"); /* move operand #1's LSW,r3 */
348: asm("tstl _sgl_dummy1"); /* generate initial status */
349: asm("movpsl _init_psl"); /* save the initial status */
350: asm("nop");
351: asm("cmpd2 r2,_dbl_value_2"); /* compare the data */
352: asm("nop");
353: asm("movpsl _psl_val"); /* save the final status */
354: asm("std _dbl_st_acc"); /* save the acc */
355: if( force_loop ) /* loop? */
356: asm("brb _cmpd2_4_lp1");; /* run the loop again */
357: exp_psl = init_psl; /* get the initial PSL */
358: exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
359: if( sgl_expected == ZERO )
360: exp_psl |= PSL_Z; /* expect the ZERO bit set */
361: if( sgl_expected == NEGATIVE )
362: exp_psl |= PSL_N; /* expect the NEG bit set */
363: if( psl_val != exp_psl ) { /* COMPARE the values */
364: errcnt++; /* bump the error count */
365: if ( prt_error ) {
366: writes(" \n"); /* start a new print line */
367: writes("cycle: ");
368: writed( cycle );
369: writes(" CMPD2 test ");
370: writed( test_no );
371: writes(", subtest 4 (Reg./Cache Data) - BAD FINAL PSL\n");
372: print_cmpd2_data();
373: writes(", index = ");
374: writed( index );
375: writec('\n');
376: writes(" final Acc = ");
377: write32h( dbl_st_acc.m );
378: writec(' ');
379: write32h( dbl_st_acc.l );
380: writes(", operand 2 = ");
381: write32h( sgl_value_3);
382: writec(' ');
383: write32h( sgl_value_4);
384: writec('\n');
385: writes(" initial PSL = ");
386: write32h( init_psl );
387: writes(", final PSL = ");
388: write32h( psl_val );
389: writes(", expected PSL = ");
390: write32h( exp_psl );
391: writes(" \n");
392: }
393: if ( halt_flg )
394: cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */
395: if ( loop_on_err )
396: {
397: force_loop = TRUE; /* set the force loop flag */
398: asm("jmp _cmpd2_4_lp1"); /* and loop */
399: } /* end of loop-on-error */
400: } /* end of compare error */
401: } while( ++status_index < 3 ); /* end of status loop */
402: index2++;
403: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
404: } while( index++ < max_cmpd_1_index );
405: } /* end of subtest 4 */
406:
407:
408:
409: /************************************************************************
410: *
411: * SUBTEST 5 - Check for register corruption
412: *
413: ************************************************************************/
414: cmpd2_5()
415: {
416: force_loop = FALSE; /* clear force_loop flg */
417: subtest = 5;
418: fill_reg_buf( load_regs ); /* get pattern for regs */
419: index = 0;
420: do
421: {
422: dbl_value_1 = cmpd_1_data[index].one; /* data to load */
423: dbl_value_2 = cmpd_1_data[index].two; /* data to compare */
424: dbl_ld_acc.m = 0x40800000; /* get acc data */
425: dbl_ld_acc.l = 0x10101010; /* get acc data */
426: sgl_value_1 = dbl_value_1.m;
427: sgl_value_2 = dbl_value_1.l;
428: sgl_value_3 = dbl_value_2.m;
429: sgl_value_4 = dbl_value_2.l;
430: asm("ldd _dbl_ld_acc"); /* load the acc */
431: /*
432: * If LOOP ON ERROR is set, this is the loop for this subtest.
433: * The force loop flag is set after the first error.
434: */
435: asm("_cmpd2_5_lp1:");
436: asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
437: asm("nop");
438: asm("cmpd2 _dbl_value_1,_dbl_value_2"); /* compare the data */
439: asm("nop");
440: asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
441: asm("std _dbl_st_acc"); /* save the acc */
442: if( force_loop ) /* loop? */
443: asm("brb _cmpd2_5_lp1");; /* run the loop again */
444: /*
445: * Now compare the stored register values to those that were loaded
446: */
447: index2 = 0;
448: while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
449: index2++; /* check reg values */
450: if( index2 < 13 ) { /* error if index2 < 13 */
451: errcnt++; /* bump the error count */
452: if ( prt_error ) {
453: writes(" \n"); /* start a new print line */
454: writes("cycle: ");
455: writed( cycle );
456: writes(", CMPD2 test ");
457: writed( test_no );
458: writes(", subtest 5 - A REGISTER WAS MODIFIED\n");
459: print_cmpd2_data();
460: writec('\n');
461: writes(" final Acc = ");
462: write32h( dbl_st_acc.m );
463: writec(' ');
464: write32h( dbl_st_acc.l );
465: writes(", operand 2 = ");
466: write32h( sgl_value_3);
467: writec(' ');
468: write32h( sgl_value_4);
469: writec('\n');
470: writes("register ");
471: writed( index2 );
472: writes(" = ");
473: write32h( store_regs[ index2 ] );
474: writes(", should be = ");
475: write32h( load_regs[ index2 ] );
476: writes("\n");
477: }
478: if ( halt_flg )
479: cmpd2_er_halt( BAD_REG_HLT ); /* halt on the error */
480: if ( loop_on_err )
481: {
482: force_loop = TRUE; /* set the force loop flag */
483: asm("jmp _cmpd2_5_lp1"); /* and loop */
484: }; /* end of loop-on-error */
485: } /* end of compare error */
486: } while( index++ < max_cmpd_1_index );
487: } /* end of subtest 5 */
488:
489:
490:
491: /****************************************************************************
492: *
493: * SUBTEST 6 - CMPD2 test Accumulator stability test
494: *
495: ****************************************************************************/
496: cmpd2_6()
497: {
498: force_loop = FALSE;
499: subtest = 6;
500: index = 0;
501: do
502: {
503: dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */
504: dbl_value_2 = cmpd_1_data[index].two;
505: sgl_value_1 = dbl_value_1.m;
506: sgl_value_2 = dbl_value_1.l;
507: sgl_value_3 = dbl_value_2.m;
508: sgl_value_4 = dbl_value_2.l;
509: index2 = 0; /* clear Acc. data index */
510: do
511: {
512: dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */
513: if( !(dbl_ld_acc.m & 0x7f800000 ) ) {
514: dbl_expected.m = 0; /* expect a '0' stored */
515: dbl_expected.l = 0;
516: } else
517: dbl_expected = dbl_ld_acc;
518: asm("ldd _dbl_ld_acc"); /* load the acc */
519: /*
520: * If LOOP ON ERROR is set, this is the loop for this subtest.
521: * The force loop flag is set after the first error.
522: */
523: asm("_cmpd2_6_lp1:");
524: asm("nop");
525: asm("cmpd2 _dbl_value_1,_dbl_value_2");/* compare the operands */
526: asm("nop");
527: asm("std _dbl_st_acc"); /* store the accumulator */
528: if( force_loop ) /* loop? */
529: asm("brb _cmpd2_6_lp1");; /* run the loop again */
530: if( (dbl_st_acc.m != dbl_expected.m) || /* compare the final */
531: (dbl_st_acc.l != dbl_expected.l) ) { /* results */
532: errcnt++; /* bump the error count */
533: if ( prt_error ) {
534: writes(" \n"); /* start a new print line */
535: writes("cycle: ");
536: writed( cycle );
537: writes(" CMPD2 test ");
538: writed( test_no );
539: writes(", subtest 6 - BAD FINAL ACC\n");
540: print_cmpd2_data();
541: writes(", index = ");
542: writed( index );
543: writec('\n');
544: writes(" final Acc = ");
545: write32h( dbl_st_acc.m );
546: writec(' ');
547: write32h( dbl_st_acc.l );
548: writes(", operand 2 = ");
549: write32h( sgl_value_3);
550: writec(' ');
551: write32h( sgl_value_4);
552: writec('\n');
553: writes("expected Acc = ");
554: write32h( dbl_expected.m );
555: writec(' ');
556: write32h( dbl_expected.l );
557: writec('\n');
558: }
559: if ( halt_flg ) /* halt on error? */
560: cmpd2_er_halt( BAD_ACC_HLT );
561: if ( loop_on_err )
562: {
563: force_loop = TRUE; /* set the force loop flag */
564: asm("jmp _cmpd2_6_lp1"); /* and loop */
565: }; /* end of loop-on-error */
566: } /* end of compare error */
567: index2++;
568: } while( (index2 < 10) && (index2 < max_ldf_1_index) );
569: } while( index++ < max_cmpd_1_index );
570: } /* end of subtest 6 */
571:
572:
573:
574: /**************************************************************************
575: *
576: * PRINT THE DATA AND STORE RESULTS
577: *
578: * initial Acc = xxxxxxxx xxxxxxxx, operand 1 = xxxxxxxx xxxxxxxx
579: **************************************************************************/
580: print_cmpd2_data()
581: {
582: writes(" initial Acc = ");
583: write32h( dbl_ld_acc.m );
584: writec(' ');
585: write32h( dbl_ld_acc.l );
586: writes(", operand 1 = ");
587: write32h( sgl_value_1 );
588: writec(' ');
589: write32h( sgl_value_2 );
590: }
591:
592:
593:
594: /**************************************************************************
595: *
596: * HALT ON ERROR ROUTINE
597: *
598: **************************************************************************/
599: cmpd2_er_halt( halt_code )
600: int halt_code;
601: {
602: sgl_value_1 = dbl_value_1.m;
603: sgl_value_2 = dbl_value_1.l;
604: sgl_value_3 = dbl_value_2.m;
605: sgl_value_4 = dbl_value_2.l;
606: sgl_value_5 = dbl_ld_acc.m;
607: sgl_value_6 = dbl_ld_acc.l;
608: sgl_value_7 = dbl_st_acc.m;
609: sgl_value_8 = dbl_st_acc.l;
610: sgl_dummy1 = halt_code; /* get the error type */
611: asm("movl _test_no,r0"); /* r0 = test number */
612: asm("movl _subtest,r1"); /* r1 = subtest number */
613: asm("movl _sgl_dummy1,r2"); /* r2 = error code */
614: asm("movl _cycle,r3"); /* r3 = cycle count */
615: asm("movl _sgl_value_5,r4"); /* r4 = MS acc loaded */
616: asm("movl _sgl_value_6,r5"); /* r5 = LS acc loaded */
617: asm("movl _sgl_value_1,r6"); /* r6 = MS operand 1 */
618: asm("movl _sgl_value_2,r7"); /* r7 = MS operand 1 */
619: asm("movl _sgl_value_3,r8"); /* r8 = MS operand 2 */
620: asm("movl _sgl_value_4,r9"); /* r9 = MS operand 2 */
621: asm("movl _psl_val,r10"); /* r10 = actual PSL */
622: if( halt_code == BAD_ACC_HLT ) {
623: sgl_value_1 = dbl_expected.m;
624: sgl_value_2 = dbl_expected.l;
625: asm("movl _sgl_value_7,r11"); /* r11 = MS stored */
626: asm("movl _sgl_value_8,r12"); /* r12 = LS stored */
627: asm("movl _sgl_value_1,r13"); /* r13 = MS expected */
628: asm("movl _sgl_value_2,r14"); /* r14 = LS expected */
629: } else
630: if( halt_code == BAD_REG_HLT ) {
631: sgl_dummy1 = load_regs[index2];
632: sgl_dummy2 = store_regs[index2];
633: asm("movl _index2,r11"); /* r11 = bad register # */
634: asm("movl _sgl_dummy2,r12"); /* r12 = actual value */
635: asm("movl _sgl_dummy1,r13"); /* r13 = expected value */
636: } else
637: if( halt_code == BAD_PSL_HLT ) {
638: asm("movl _exp_psl,r11"); /* r11 = expected PSL */
639: asm("movl _index,r12"); /* r12 = data index */
640: };
641: asm("halt"); /* HALT ... */
642: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.