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