![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ldfd.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 ldfd.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 root 1:
2: #include "fpp_defs.h"
3:
4:
5: /*****************************************************************************
6: *
7: * LDFD - SINGLE PRECISION FLOATING POINT CONVERT LONG TO FLOAT TEST
8: *
9: *****************************************************************************/
10: ldfd()
11: {
12: asm(".globl _ldfd_t");
13: asm("_ldfd_t:"); /* entry address */
14: if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
15: writes(" LDFD");
16: ldfd_1(); /* load through a register */
17: ldfd_2(); /* load through the cache */
18: ldfd_3(); /* register stability */
19: ldfd_4(); /* PSL stability test */
20: asm("jmp *return"); /* return to the test monitor */
21: }
22:
23:
24:
25: /************************************************************************
26: *
27: * SUBTEST 1
28: *
29: ************************************************************************/
30: ldfd_1()
31: {
32: force_loop = FALSE;
33: subtest = 1;
34: index = 0;
35: do
36: {
37: sgl_ld_acc = ldfd_1_data[index].ld; /* get the operand */
38: dbl_expected.m = ldfd_1_data[index].exp.m;/* get expected result */
39: dbl_expected.l = 0; /* get expected result */
40: /*
41: * If LOOP ON ERROR is set, this is the loop for this subtest.
42: * The force loop flag is set after the first error.
43: */
44: asm("_ldfd_1_lp1:");
45: asm("movl _sgl_ld_acc,r4"); /* get the value to convert */
46: asm("ldfd r4"); /* load the data */
47: asm("std r6"); /* store the result in R8 */
48: if( force_loop )
49: asm("brb _ldfd_1_lp1");; /* loop on the error */
50: /*
51: * end error loop - test the results
52: */
53: asm("movl r6,_dbl_st_acc"); /* move MSW to cache */
54: asm("movl r7,_dbl_st_acc+4"); /* move LSW to cache */
55: if( ( dbl_st_acc.m != dbl_expected.m ) || /* COMPARE the values */
56: ( dbl_st_acc.l != dbl_expected.l ) ){
57: errcnt++; /* bump the error count */
58: if( prt_error ) {
59: writes(" \n"); /* start a new print line */
60: writes("cycle: ");
61: writed( cycle );
62: writes(" LDFD test ");
63: writed( test_no );
64: writes(", subtest 1 (Reg. Data) - BAD FINAL ACC\n");
65: print_ldfd_data();
66: writes(", index = ");
67: writed( index );
68: writec('\n');
69: writes(" operand = ");
70: write32h( sgl_ld_acc );
71: writes(", expected Acc = ");
72: write32h( dbl_expected.m );
73: writec(' ');
74: write32h( dbl_expected.l );
75: writec('\n');
76: }
77: if( halt_flg )
78: ldfd_er_halt( BAD_ACC_HLT ); /* halt on the error */
79: if( loop_on_err ) {
80: force_loop = TRUE; /* set the force loop flag */
81: asm("brw _ldfd_1_lp1");; /* and loop on the error */
82: } /* end of loop on error */
83: } /* end of compare error */
84: } while( index++ < max_ldfd_1_index ); /* end of WHILE loop */
85: } /* end of subtest 1 */
86:
87:
88:
89: /************************************************************************
90: *
91: * SUBTEST 2 - convert through memory
92: *
93: ************************************************************************/
94: ldfd_2()
95: {
96: force_loop = FALSE;
97: subtest = 2;
98: index = 0;
99: do
100: {
101: sgl_ld_acc = ldfd_1_data[index].ld; /* get the operand */
102: dbl_expected.m = ldfd_1_data[index].exp.m;/* get expected result */
103: dbl_expected.l = 0; /* get expected result */
104: /*
105: * If LOOP ON ERROR is set, this is the loop for this subtest.
106: * The force loop flag is set after the first error.
107: */
108: asm("_ldfd_2_lp1:");
109: asm("ldfd _sgl_ld_acc"); /* convert the value */
110: asm("std _dbl_st_acc"); /* store the result */
111: if( force_loop )
112: asm("brb _ldfd_2_lp1");; /* loop on the error */
113: /*
114: * end error loop - test the results
115: */
116: if( ( dbl_st_acc.m != dbl_expected.m ) || /* COMPARE the values */
117: ( dbl_st_acc.l != dbl_expected.l ) ){
118: errcnt++; /* bump the error count */
119: if( prt_error ) {
120: writes(" \n"); /* start a new print line */
121: writes("cycle: ");
122: writed( cycle );
123: writes(" LDFD test ");
124: writed( test_no );
125: writes(", subtest 2 (Cache Data) - BAD FINAL ACC\n");
126: print_ldfd_data();
127: writes(", index = ");
128: writed( index );
129: writec('\n');
130: writes(" operand = ");
131: write32h( sgl_ld_acc );
132: writes(", expected Acc = ");
133: write32h( dbl_expected.m );
134: writec(' ');
135: write32h( dbl_expected.l );
136: writec('\n');
137: }
138: if( halt_flg )
139: ldfd_er_halt( BAD_ACC_HLT ); /* halt on the error */
140: if( loop_on_err ) {
141: force_loop = TRUE; /* set the force loop flag */
142: asm("brw _ldfd_2_lp1");; /* and loop on the error */
143: } /* end of loop on error */
144: } /* end of compare error */
145: } while( index++ < max_ldfd_1_index ); /* end of WHILE loop */
146: } /* end of subtest 2 */
147:
148:
149:
150: /************************************************************************
151: *
152: * SUBTEST 3 - Check for register corruption
153: *
154: ************************************************************************/
155: ldfd_3()
156: {
157: force_loop = FALSE; /* clear force_loop flg */
158: subtest = 3;
159: fill_reg_buf( load_regs ); /* get patterns for regs */
160: index = 0;
161: sgl_ld_acc = ldfd_1_data[index].ld; /* get the operand */
162: /*
163: * If LOOP ON ERROR is set, this is the loop for this subtest.
164: * The force loop flag is set after the first error.
165: */
166: asm("_ldfd_3_lp1:");
167: asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
168: asm("nop");
169: asm("ldfd _sgl_ld_acc"); /* convert the value */
170: asm("nop");
171: asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
172: asm("std _dbl_st_acc"); /* save the acc */
173: if( force_loop )
174: asm("brb _ldfd_3_lp1");; /* loop on the error */
175: /*
176: * Now compare the stored register values to those that were loaded
177: */
178: index2 = 0;
179: while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
180: index2++; /* check reg values */
181: if( index2 < 13 ) { /* error if index2 < 13 */
182: errcnt++; /* bump the error count */
183: if( prt_error ) {
184: writes(" \n"); /* start a new print line */
185: writes("cycle: ");
186: writed( cycle );
187: writes(" LDFD test ");
188: writed( test_no );
189: writes(", subtest 3 - A REGISTER WAS MODIFIED\n");
190: print_ldfd_data(); /* print the operands */
191: writes("\n");
192: writes(" operand = ");
193: write32h( sgl_ld_acc );
194: writes("\n");
195: writes("register "); /* print the information */
196: writed( index2 ); /* about the corrupted */
197: writes(" = "); /* register */
198: write32h( store_regs[index2] );
199: writes(", should be = ");
200: write32h( load_regs[index2] );
201: writes("\n");
202: }
203: if( halt_flg )
204: ldfd_er_halt( BAD_REG_HLT ); /* halt on the error */
205: if( loop_on_err ) {
206: force_loop = TRUE; /* set the force loop flag */
207: asm("brw _ldfd_3_lp1");; /* and loop on the error */
208: } /* end of loop on error */
209: } while( index++ < max_ldfd_1_index ); /* end of reg corruption error */
210: } /* end of subtest 3 */
211:
212:
213:
214: /************************************************************************
215: *
216: * SUBTEST 4 - Check for PSL corruption
217: *
218: ************************************************************************/
219: ldfd_4()
220: {
221: force_loop = FALSE; /* clear force_loop flg */
222: subtest = 4;
223: for( index = 0; index < max_ldfd_1_index; index++ ) {
224: sgl_ld_acc = ldfd_1_data[index].ld; /* get the operand */
225: for( status_index = 0; status_index < 3; status_index++ ) {
226: sgl_dummy1 = status_array[status_index];/* status = +, -, 0 */
227: /*
228: * If LOOP ON ERROR is set, this is the loop for this subtest.
229: * The force loop flag is set after the first error.
230: */
231: asm("_ldfd_4_lp1:");
232: asm("movl _sgl_ld_acc,r4"); /* load the base value */
233: asm("tstl _sgl_dummy1"); /* set the PSL status */
234: asm("movpsl _init_psl"); /* save the initial PSL */
235: asm("nop");
236: asm("ldfd r4"); /* convert the value */
237: asm("nop");
238: asm("movpsl _psl_val"); /* save the final PSL */
239: asm("std _dbl_st_acc"); /* save the acc */
240: if( force_loop )
241: asm("brb _ldfd_4_lp1");; /* loop on the error */
242: /*
243: * Now compare the final PSL to the initial PSL -they should be the same
244: */
245: exp_psl = init_psl;
246: exp_psl |= PSL_DBL;
247: if( psl_val != exp_psl ) {
248: errcnt++; /* bump the error count */
249: if( prt_error ) {
250: writes(" \n"); /* start a new print line */
251: writes("cycle: ");
252: writed( cycle );
253: writes(" LDFD test ");
254: writed( test_no );
255: writes(", subtest 4 - INCORRECT FINAL PSL\n");
256: print_ldfd_data(); /* print operands */
257: writes("\n");
258: writes(" operand = ");
259: write32h( sgl_ld_acc );
260: writes("\n");
261: writes("initial PSL = ");
262: write32h( init_psl );
263: writes(", final PSL = ");
264: write32h( psl_val );
265: writes(", expectd PSL = ");
266: write32h( exp_psl );
267: writes("\n");
268: }
269: if( halt_flg )
270: ldfd_er_halt( BAD_PSL_HLT ); /* halt on error */
271: if( loop_on_err ) {
272: force_loop = TRUE; /* set force loop flag */
273: asm("brw _ldfd_4_lp1");; /* and loop on error */
274: } /* end of loop on error */
275: } /* end of PSL corruption error */
276: } /* end of PSL corruption error */
277: } /* end of data WHILE loop */
278: } /* end of subtest 4 */
279:
280:
281:
282: /**************************************************************************
283: *
284: * PRINT THE DATA AND STORE RESULTS
285: *
286: * initial Acc = xxxxxxxx xxxxxxxx, stored = xxxxxxxx xxxxxxxx, index = xx
287: **************************************************************************/
288: print_ldfd_data()
289: {
290: writes("initial Acc = ");
291: write32h( sgl_ld_acc );
292: writes(", ");
293: writes(" final Acc = ");
294: write32h( dbl_st_acc.m );
295: writec(' ');
296: write32h( dbl_st_acc.l );
297: }
298:
299:
300:
301: /**************************************************************************
302: *
303: * HALT ON ERROR ROUTINE
304: *
305: **************************************************************************/
306: ldfd_er_halt( halt_code )
307: int halt_code;
308: {
309: sgl_value_1 = sgl_ld_acc;
310: sgl_value_2 = dbl_st_acc.m;
311: sgl_value_3 = dbl_st_acc.l;
312: sgl_value_5 = 0;
313: sgl_dummy1 = halt_code; /* get the error type */
314: asm("movl _test_no,r0"); /* r0 = test number */
315: asm("movl _subtest,r1"); /* r1 = subtest number */
316: asm("movl _sgl_dummy1,r2"); /* r2 = error code */
317: asm("movl _cycle,r3"); /* r3 = cycle count */
318: asm("movl _sgl_value_1,r4"); /* r4 = MS operand 1 */
319: asm("movl _sgl_value_5,r5"); /* r5 = LS operand 1 */
320: asm("movl _sgl_value_1,r6"); /* r6 = operand */
321: asm("movl _sgl_value_2,r7"); /* r7 = MS stored */
322: asm("movl _sgl_value_3,r8"); /* r8 = LS stored */
323: if( halt_code == BAD_ACC_HLT ) {
324: sgl_value_1 = dbl_expected.m;
325: sgl_value_2 = dbl_expected.l;
326: asm("movl _sgl_value_1,r9"); /* r9 = MS expected */
327: asm("movl _sgl_value_2,r10"); /* r10 = LS expected */
328: asm("movl _index,r11"); /* r11 = data index */
329: } else
330: if( halt_code == BAD_REG_HLT ) {
331: sgl_dummy1 = load_regs[index2];
332: sgl_dummy2 = store_regs[index2];
333: asm("movl _index2,r9"); /* r9 = bad register # */
334: asm("movl _sgl_dummy2,r10"); /* r10 = actual value */
335: asm("movl _sgl_dummy1,r11"); /* r11 = expected value */
336: } else
337: if( halt_code == BAD_PSL_HLT ) {
338: asm("movl _init_psl,r9"); /* r9 = initial PSL */
339: asm("movl _psl_val,r10"); /* r10 = final PSL */
340: asm("movl _exp_psl,r11"); /* r11 = expected PSL */
341: };
342: asm("halt"); /* HALT ... */
343: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.