![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mull3.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 mull3.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: * MULL3 -MULTIPLY INTEGER 3 INSTRUCTION TEST
7: *
8: *****************************************************************************/
9: mull3()
10: {
11: asm(".globl _mull3_t");
12: asm("_mull3_t:"); /* entry address */
13: if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
14: {
15: writes(" MULL3");
16: }
17: mull3_1(); /* register data / SGL acc. */
18: mull3_2(); /* memory data / DBL acc. */
19: mull3_3(); /* register corruption test */
20: mull3_4(); /* PSL corruption test */
21: mull3_5(); /* pipelined entry test */
22: mull3_6(); /* pipelined exit test */
23: asm("jmp *return"); /* return to the test monitor */
24: }
25:
26:
27:
28: /************************************************************************
29: *
30: * SUBTEST 1 - register addressing / single precsion accumulator
31: *
32: ************************************************************************/
33: mull3_1()
34: {
35: force_loop = FALSE;
36: subtest = 1;
37: for( index = 0; index < max_mull_1_index; index++ ) {
38: sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
39: sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
40: sgl_value_4 = mull_1_data[index].exp; /* get expected results */
41: sgl_ld_acc = 0x12345678; /* set acc data pattern */
42: sgl_expected = sgl_ld_acc; /* final Acc expected */
43: /*
44: * If LOOP ON ERROR is set, this is the loop for this subtest.
45: */
46: asm("_mull3_1_lp1:");
47: asm("movl _sgl_value_1,r3"); /* move the 1st data to r3 */
48: asm("movl _sgl_value_2,r4"); /* move the 2nd data to r4 */
49: asm("ldf _sgl_ld_acc"); /* load the acc */
50: asm("mull3 r3,r4,r5"); /* do the multiply */
51: asm("nop");
52: asm("stf _sgl_st_acc"); /* save the acc */
53: if( force_loop )
54: asm("brb _mull3_1_lp1");;
55: asm("movl r5,_sgl_value_3");
56: if( sgl_expected != sgl_st_acc ) { /* COMPARE the values */
57: errcnt++; /* bump the error count */
58: if ( prt_error ) {
59: print_mull3_error("(Reg. Data) -THE ACC WAS MODIFIED");
60: writes("initial Acc = ");
61: write32h( sgl_ld_acc );
62: writes(", final Acc = ");
63: write32h( sgl_st_acc );
64: writes("\n expected Acc = ");
65: write32h( sgl_expected );
66: writec('\n');
67: }
68: if ( halt_flg ) /* halt on error? */
69: mull3_halt( 4 );
70: if ( loop_on_err ) {
71: force_loop = TRUE; /* set the force loop flag */
72: asm("jmp _mull3_1_lp1"); /* and loop */
73: } /* end of loop-on-error */
74: } /* end of acc corr error */
75: if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */
76: {
77: errcnt++; /* bump the error count */
78: if ( prt_error ) {
79: print_mull3_error("(Reg. Data) -BAD MULTIPLY RESULT");
80: }
81: if ( halt_flg ) /* halt on error? */
82: mull3_halt( 1 );
83: if ( loop_on_err ) {
84: force_loop = TRUE; /* set the force loop flag */
85: asm("jmp _mull3_1_lp1"); /* and loop */
86: } /* end of loop-on-error */
87: } /* end of multiply error */
88: }
89: } /* end of subtest 1 */
90:
91:
92:
93: /************************************************************************
94: *
95: * SUBTEST 2 - cache addressing / double precsion accumulator
96: *
97: ************************************************************************/
98: mull3_2()
99: {
100: force_loop = FALSE;
101: subtest = 2;
102: for( index = 0; index < max_mull_1_index; index++ ) {
103: sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
104: sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
105: sgl_value_4 = mull_1_data[index].exp; /* get expected results */
106: dbl_ld_acc.m = 0x12345678; /* set acc data pattern */
107: dbl_ld_acc.l = 0x9abcdef0;
108: dbl_expected.m = dbl_ld_acc.m; /* final Acc expected */
109: dbl_expected.l = dbl_ld_acc.l;
110: /*
111: * If LOOP ON ERROR is set, this is the loop for this subtest.
112: */
113: asm("_mull3_2_lp1:");
114: asm("ldd _dbl_ld_acc"); /* load the acc */
115: asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3");
116: asm("nop");
117: asm("std _dbl_st_acc"); /* save the acc */
118: if( force_loop )
119: asm("brb _mull3_2_lp1");;
120: if( (dbl_expected.m != dbl_st_acc.m) || /* COMPARE the Acc */
121: (dbl_expected.l != dbl_st_acc.l) ) {
122: errcnt++; /* bump the error count */
123: if ( prt_error ) {
124: print_mull3_error("(Memory data) -THE ACC WAS MODIFIED");
125: writes("initial Acc = ");
126: write32h( dbl_ld_acc.m );
127: writec(' ');
128: write32h( dbl_ld_acc.l );
129: writes(", final Acc = ");
130: write32h( dbl_st_acc.m );
131: writec(' ');
132: write32h( dbl_st_acc.l );
133: writes("\n expected Acc = ");
134: write32h( dbl_expected.m );
135: writec(' ');
136: write32h( dbl_expected.l );
137: writec('\n');
138: }
139: if ( halt_flg ) /* halt on error? */
140: mull3_halt( 4 );
141: if ( loop_on_err ) {
142: force_loop = TRUE; /* set the force loop flag */
143: asm("jmp _mull3_2_lp1"); /* and loop */
144: } /* end of loop-on-error */
145: } /* end of acc corr error */
146: if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */
147: {
148: errcnt++; /* bump the error count */
149: if ( prt_error ) {
150: print_mull3_error("(Memory data) -BAD MULTIPLY RESULT");
151: }
152: if ( halt_flg ) /* halt on error? */
153: mull3_halt( 1 );
154: if ( loop_on_err ) {
155: force_loop = TRUE; /* set the force loop flag */
156: asm("jmp _mull3_2_lp1"); /* and loop */
157: } /* end of loop-on-error */
158: } /* end of multiply error */
159: }
160: } /* end of subtest 2 */
161:
162:
163:
164: /************************************************************************
165: *
166: * SUBTEST 3 - register corruption test
167: *
168: ************************************************************************/
169: mull3_3()
170: {
171: force_loop = FALSE;
172: subtest = 2;
173: fill_reg_buf( load_regs ); /* get pattern for registers */
174: for( index = 0; index < max_mull_1_index; index++ ) {
175: sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
176: sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
177: sgl_value_4 = mull_1_data[index].exp; /* get expected results */
178: /*
179: * If LOOP ON ERROR is set, this is the loop for this subtest.
180: */
181: asm("_mull3_3_lp1:");
182: asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
183: asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3");
184: asm("nop");
185: asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
186: if( force_loop )
187: asm("brb _mull3_3_lp1");
188: /*
189: * Now check the result
190: */
191: index2 = 0;
192: while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
193: index2++; /* check reg values */
194: if( index2 < 13 ) { /* error if index2 < 13 */
195: errcnt++; /* bump the error count */
196: if ( prt_error ) {
197: print_mull3_error(" -A REGISTER WAS MODIFIED");
198: writes("register ");
199: writeh( index2 );
200: writes(" = ");
201: write32h( store_regs[index2] );
202: writes(", should be = ");
203: write32h( load_regs[index2] );
204: writec('\n');
205: }
206: if ( halt_flg ) /* halt on error? */
207: mull3_halt( 2 );
208: if ( loop_on_err ) {
209: force_loop = TRUE; /* set the force loop flag */
210: asm("jmp _mull3_3_lp1"); /* and loop */
211: }; /* end of loop-on-error */
212: } /* end of multiply error */
213: }
214: } /* end of subtest 3 */
215:
216:
217:
218: /************************************************************************
219: *
220: * SUBTEST 4 - PSL corruption test
221: *
222: ************************************************************************/
223: mull3_4()
224: {
225: force_loop = FALSE;
226: subtest = 4;
227: status_index = 0;
228: for( index = 0; index < max_mull_1_index; index++ ) {
229: sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
230: sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
231: sgl_value_4 = mull_1_data[index].exp; /* get expected results */
232: sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */
233: /*
234: * If LOOP ON ERROR is set, this is the loop for this subtest.
235: */
236: asm("_mull3_4_lp1:");
237: asm("tstl _sgl_dummy1");
238: asm("movpsl _init_psl"); /* save the initial PSL */
239: asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3");
240: asm("movpsl _psl_val"); /* save the final PSL */
241: if( force_loop )
242: asm("brb _mull3_4_lp1");
243: /*
244: * Now check the result
245: */
246: exp_psl = init_psl & 0xffffff3; /* strip off the PSL status */
247: if( sgl_value_4 < 0 ) /* check the MULL result */
248: exp_psl |= PSL_N; /* set the NEGATIVE bit */
249: if( !sgl_value_4 )
250: exp_psl |= PSL_Z; /* set the ZERO bit */
251: if( psl_val != exp_psl ) { /* was the final PSL correct */
252: errcnt++; /* bump the error count */
253: if ( prt_error ) {
254: print_mull3_error(" -INCORRECT FINAL PSL");
255: writes("initial PSL = ");
256: write32h( init_psl );
257: writes(", final PSL = ");
258: write32h( psl_val );
259: writes(", expected PSL = ");
260: write32h( exp_psl );
261: writec('\n');
262: }
263: if ( halt_flg ) /* halt on error? */
264: mull3_halt( 3 );
265: if ( loop_on_err ) {
266: force_loop = TRUE; /* set the force loop flag */
267: asm("jmp _mull3_4_lp1"); /* and loop */
268: }; /* end of loop-on-error */
269: }; /* end of error */
270: if( ++status_index >= 3 )
271: status_index = 0;
272: }
273: } /* end of subtest 4 */
274:
275:
276:
277: /************************************************************************
278: *
279: * SUBTEST 5 - Pipelined Entry test
280: *
281: ************************************************************************/
282: mull3_5()
283: {
284: force_loop = FALSE;
285: subtest = 5;
286: for( index = 0; index < max_mull_1_index; index++ ) {
287: sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
288: sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
289: sgl_value_4 = mull_1_data[index].exp; /* get expected results */
290: sgl_ld_acc = 0x12345678; /* set acc data pattern */
291: sgl_expected = sgl_ld_acc; /* final Acc expected */
292: sgl_value_10 = 0x40800000; /* floating "1.0" */
293: /*
294: * If LOOP ON ERROR is set, this is the loop for this subtest.
295: */
296: asm("_mull3_5_lp1:");
297: asm("ldf _sgl_ld_acc"); /* load the acc */
298: asm("mulf _sgl_value_10"); /* do a floating multiply */
299: asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3");
300: asm("stf _sgl_st_acc"); /* save the acc */
301: if( force_loop )
302: asm("brb _mull3_5_lp1");;
303: if( sgl_expected != sgl_st_acc ) { /* COMPARE the values */
304: errcnt++; /* bump the error count */
305: if ( prt_error ) {
306: print_mull3_error("(Piped Entry) -BAD FINAL ACC");
307: writes("initial Acc = ");
308: write32h( sgl_ld_acc );
309: writes(", final Acc = ");
310: write32h( sgl_st_acc );
311: writes("\nFPP operand = ");
312: write32h( sgl_value_10 );
313: writes(", expected Acc = ");
314: write32h( sgl_expected );
315: writec('\n');
316: }
317: if ( halt_flg ) /* halt on error? */
318: mull3_halt( 5 );
319: if ( loop_on_err ) {
320: force_loop = TRUE; /* set the force loop flag */
321: asm("jmp _mull3_5_lp1"); /* and loop */
322: } /* end of loop-on-error */
323: } /* end of acc corr error */
324: if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */
325: {
326: errcnt++; /* bump the error count */
327: if ( prt_error ) {
328: print_mull3_error("(Piped Entry) -BAD MULTIPLY RESULT");
329: }
330: if ( halt_flg ) /* halt on error? */
331: mull3_halt( 1 );
332: if ( loop_on_err ) {
333: force_loop = TRUE; /* set the force loop flag */
334: asm("jmp _mull3_5_lp1"); /* and loop */
335: } /* end of loop-on-error */
336: } /* end of multiply error */
337: }
338: } /* end of subtest 5 */
339:
340:
341:
342: /************************************************************************
343: *
344: * SUBTEST 6 - Pipelined Exit test
345: *
346: ************************************************************************/
347: mull3_6()
348: {
349: force_loop = FALSE;
350: subtest = 6;
351: for( index = 0; index < max_mull_1_index; index++ ) {
352: sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
353: sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
354: sgl_value_4 = mull_1_data[index].exp; /* get expected results */
355: sgl_ld_acc = 0x40800000; /* floating "1.0" */
356: sgl_value_10 = 0x12345678; /* set acc data pattern */
357: sgl_expected = sgl_value_10; /* final Acc expected */
358: /*
359: * If LOOP ON ERROR is set, this is the loop for this subtest.
360: */
361: asm("_mull3_6_lp1:");
362: asm("ldf _sgl_ld_acc"); /* load the acc */
363: asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3");
364: asm("mulf _sgl_value_10"); /* do a floating multiply */
365: asm("stf _sgl_st_acc"); /* save the acc */
366: if( force_loop )
367: asm("brb _mull3_6_lp1");;
368: if( sgl_expected != sgl_st_acc ) { /* COMPARE the values */
369: errcnt++; /* bump the error count */
370: if ( prt_error ) {
371: print_mull3_error("(Piped Exit) -BAD FINAL ACC");
372: writes("initial Acc = ");
373: write32h( sgl_ld_acc );
374: writes(", final Acc = ");
375: write32h( sgl_st_acc );
376: writes("\nFPP operand = ");
377: write32h( sgl_value_10 );
378: writes(", expected Acc = ");
379: write32h( sgl_expected );
380: writec('\n');
381: }
382: if ( halt_flg ) /* halt on error? */
383: mull3_halt( 5 );
384: if ( loop_on_err ) {
385: force_loop = TRUE; /* set the force loop flag */
386: asm("jmp _mull3_6_lp1"); /* and loop */
387: } /* end of loop-on-error */
388: } /* end of acc corr error */
389: if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */
390: {
391: errcnt++; /* bump the error count */
392: if ( prt_error ) {
393: print_mull3_error("(Piped Exit) -BAD MULTIPLY RESULT");
394: }
395: if ( halt_flg ) /* halt on error? */
396: mull3_halt( 1 );
397: if ( loop_on_err ) {
398: force_loop = TRUE; /* set the force loop flag */
399: asm("jmp _mull3_6_lp1"); /* and loop */
400: } /* end of loop-on-error */
401: } /* end of multiply error */
402: }
403: } /* end of subtest 6 */
404:
405:
406:
407: /*****************************************************************************
408: *
409: * Print an error message of the form:
410: *
411: * cycle: xx MULL3 test xx, subtest xx <"your message here">
412: * operand 1 = xxxxxxxx, result = xxxxxxxx, data index = xx
413: * operand 2 = xxxxxxxx, expected = xxxxxxxx
414: *
415: *****************************************************************************/
416: print_mull3_error(msg)
417: char *msg; /* addressing mode msg */
418: {
419: writes(" \n"); /* start a new print line */
420: writes("cycle: ");
421: writed( cycle );
422: writes(" MULL3 test ");
423: writed( test_no );
424: writes(", subtest ");
425: writed( subtest );
426: writes(" ");
427: writes( msg );
428: writes("\n operand 1 = ");
429: write32h( sgl_value_1 );
430: writes(", result = ");
431: write32h( sgl_value_3 );
432: writes(", data index = ");
433: writed( index );
434: writes("\n operand 2 = ");
435: write32h( sgl_value_2 );
436: writes(", expected = ");
437: write32h( sgl_value_4 );
438: writec('\n');
439: }
440:
441:
442:
443: /***************************************************************************
444: *
445: * HALT ON AN ERROR
446: *
447: ***************************************************************************/
448: mull3_halt( code )
449: int code; /* error code to use */
450: {
451: sgl_dummy1 = code; /* save the error code */
452: asm("movl _test_no,r0"); /* r0 = test number */
453: asm("movl _subtest,r1"); /* r1 = subtest number */
454: asm("movl _sgl_dummy1,r2"); /* r2 = error code */
455: asm("movl _cycle,r3"); /* r3 = cycle count */
456: asm("movl _sgl_value_1,r4"); /* r4 = operand 1 */
457: asm("movl _sgl_value_2,r5"); /* r5 = operand 2 */
458: asm("movl _sgl_value_3,r6"); /* r6 = MULL3's result */
459: if( code == 1 ) {
460: asm("movl _sgl_value_4,r7"); /* r7 = expected result */
461: asm("movl _index,r8");; /* r8 = data index */
462: }
463: else if( code == 2 ) { /* corrupted register */
464: sgl_dummy1 = store_regs[index2]; /* get the actual reg data */
465: sgl_dummy2 = load_regs[index2]; /* get the data expected */
466: asm("movl _index2,r7"); /* r7 = register number */
467: asm("movl _sgl_dummy1,r8"); /* r8 = final reg value */
468: asm("movl _sgl_dummy2,r9"); /* r9 = expected value */
469: }
470: else if( code == 3 ) { /* corrupted PSL */
471: asm("movl _init_psl,r7"); /* r7 = initial PSL */
472: asm("movl _psl_val,r8"); /* r8 = final PSL */
473: asm("movl _exp_psl,r9"); /* r9 = expected PSL */
474: }
475: else if( code == 4 ) { /* corrupted Acc */
476: if( subtest == 1 ) { /* single precision */
477: dbl_ld_acc.m = sgl_ld_acc;
478: dbl_ld_acc.l = 0;
479: dbl_st_acc.m = sgl_st_acc;
480: dbl_st_acc.l = 0;
481: dbl_expected.m = sgl_expected;
482: dbl_expected.l = 0;
483: };
484: asm("movl _index,r7"); /* r7 = data index */
485: asm("movl _dbl_ld_acc,r8"); /* r8 = MS initial Acc. */
486: asm("movl _dbl_ld_acc+4,r9"); /* r9 = LS initial Acc. */
487: asm("movl _dbl_st_acc,r10"); /* r10 = MS final Acc. */
488: asm("movl _dbl_st_acc+4,r11"); /* r11 = LS final Acc. */
489: asm("movl _dbl_expected,r12"); /* r12 = MS expected Acc. */
490: asm("movl _dbl_expected+4,r13"); /* r13 = LS expected Acc. */
491: }
492: else if( code == 5 ) { /* bad final Acc */
493: asm("movl _index,r7"); /* r7 = data index */
494: asm("movl _sgl_ld_acc,r8"); /* r8 = initial Acc. */
495: asm("movl _sgl_value_10,r9"); /* r9 = fpp operand */
496: asm("movl _sgl_st_acc,r10"); /* r10 = final Acc. */
497: asm("movl _sgl_expected,r11"); /* r11 = expected Acc. */
498: };
499: asm("halt"); /* HALT ... */
500: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.