![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe9.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 / fpevent|
Return to pipe9.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / fpevent |
1.1 root 1:
2: #include "evt_defs.h"
3:
4: /*
5: *********************************************************************
6: * FPP PIPELINED EVENTS TEST #9
7: *
8: * This test will execute the following code: "LDF DIVF CVLF $2"
9: * with a divide by zero fault on the DIVF. We will make sure that:
10: * 1. The fault is detected, and
11: * 2. the convert instruction is not executed.
12: *********************************************************************
13: */
14: pipe9()
15: {
16: asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
17: asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
18: precision = SGL;
19: test_event = ARITH_CODE; /* expect an arithmetic fault */
20: exp_code = FLT_0_DIV_CODE; /* - specificly div by 0 */
21: exp_event = FALSE; /* ... but not yet */
22: asm("movab _pipe9_ret,_event_return"); /* set event return address */
23: max_index = zero_divide_cnt; /* set max operand index */
24: for( index = 0; index < max_index; index++ )
25: {
26: dbl_ld_acc = zero_divide_data[index].op_1; /* get the Acc data */
27: dbl_value_1 = zero_divide_data[index].op_2; /* get the '0' data */
28: if( dbl_ld_acc.m & 0x7f800000 )
29: dbl_expected.m = dbl_ld_acc.m; /* The final Acc s/b */
30: else
31: dbl_expected.m = 0; /* = the initial Acc */
32: asm("bispsw $0x60"); /* enable ovfl,undfl */
33: asm(".globl _pipe9_lp1");
34: asm("_pipe9_lp1:");
35: asm("ldf _dbl_ld_acc"); /* load the Acc. */
36: exp_event = test_event; /* expect event soon */
37: asm("divf _dbl_value_1"); /* trigger the event */
38: asm("cvlf $2"); /* shouldn't get here*/
39: /*
40: * If we got to here then there was no event
41: */
42: if( force_loop )
43: asm("brw _pipe9_lp1");; /* loop on the error */
44: exp_event = FALSE; /* reset event expected flag */
45: asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
46: asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
47: asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
48: no_pipe9_evt();; /* report the error */
49: /*
50: * Come here after the event
51: */
52: asm(".globl _pipe9_ret");
53: asm("_pipe9_ret:");
54: asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
55: asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
56: if( force_loop )
57: asm("brw _pipe9_lp1");; /* loop on the error */
58: asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
59: if( post_evt_acc.m != dbl_expected.m ) /* was the Acc modified? */
60: {
61: if( post_evt_acc.m == 0x41000000 ) /* is Acc. = 2.0 ? */
62: pipe9_queue_er(); /* queue not cleared error */
63: else
64: bad_pipe9_result(); /* incorrect result error */
65: }
66: }
67: }
68:
69:
70:
71: /****************************************************************************
72: * Report an "EVENT NOT DETECTED" error
73: *
74: * Cycle: xx. EVT test xx. subtest xx. No 'divide by 0' fault seen. index = xx
75: * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF)
76: * op1 = xxxxxxxx, op2 = xxxxxxxx
77: ****************************************************************************/
78: no_pipe9_evt()
79: {
80: errcnt++; /* bump the error count */
81: if ( prt_error )
82: {
83: print_pipe9_er( ". No 'divide by 0' fault seen." );
84: writes("op1 = ");
85: write32h( dbl_ld_acc.m );
86: writes(", op2 = ");
87: write32h( dbl_value_1.m );
88: writec('\n');
89: }
90: if ( halt_flg ) /* halt on error? */
91: pipe9_halt( 1 ); /* halt with a code of 1 */
92: if ( loop_on_err )
93: {
94: force_loop = TRUE; /* set the force loop flag */
95: asm("jmp _pipe9_lp1"); /* and loop */
96: };
97: }
98:
99:
100:
101:
102: /****************************************************************************
103: * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
104: *
105: * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
106: * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF)
107: * The 'Convert '2' to Floating Point' should not be executed.
108: * op_1 = xxxxxxxx, op2 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx
109: ****************************************************************************/
110: bad_pipe9_result()
111: {
112: errcnt++; /* bump the error count */
113: if ( prt_error )
114: {
115: print_pipe9_er( ". Bad final Accumulator" );
116: writes(
117: "The 'Convert '2' to Floating Point' should not be executed\n");
118: writes("op1 = ");
119: write32h( dbl_ld_acc.m );
120: writes(", op1 = ");
121: write32h( dbl_value_1.m );
122: writes(", final Acc. = ");
123: write32h( post_evt_acc.m );
124: writes(", expected = ");
125: write32h( dbl_expected.m ); /* the expected result = 0 */
126: writec('\n');
127: }
128: if ( halt_flg ) /* halt on error? */
129: pipe9_halt( 2 ); /* halt with a code of 2 */
130: if ( loop_on_err )
131: {
132: force_loop = TRUE; /* set the force loop flag */
133: asm("jmp _pipe9_lp1"); /* and loop */
134: };
135: }
136:
137:
138:
139:
140:
141: /****************************************************************************
142: * Report an "FPP queue not cleared" message
143: *
144: * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx
145: * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF)
146: * The 'Convert '2' to Floating Point' was apparently executed.
147: * op1 = xxxxxxxx, op2 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx
148: ****************************************************************************/
149: pipe9_queue_er()
150: {
151: errcnt++; /* bump the error count */
152: if ( prt_error )
153: {
154: print_pipe9_er( ". Fpp queue not cleared" );
155: writes(
156: "The 'Convert '2' to Floating Point' was apparently executed.\n");
157: writes("op1 = ");
158: write32h( dbl_ld_acc.m );
159: writes(", op1 = ");
160: write32h( dbl_value_1.m );
161: writes(", final Acc. = ");
162: write32h( post_evt_acc.m );
163: writes(", expected = ");
164: write32h( 0x80000000 ); /* the expected result = 0 */
165: writec('\n');
166: }
167: if ( halt_flg ) /* halt on error? */
168: pipe9_halt( 3 ); /* halt with a code of 3 */
169: if ( loop_on_err )
170: {
171: force_loop = TRUE; /* set the force loop flag */
172: asm("jmp _pipe9_lp1"); /* and loop */
173: };
174: }
175:
176:
177:
178:
179: /****************************************************************************
180: * Report an error message of the form:
181: *
182: * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
183: * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF)
184: ****************************************************************************/
185: print_pipe9_er( msg )
186: char *msg; /* error message to print */
187: {
188: if( errcnt == 1 ) /* 1st error? */
189: writes(" \n"); /* start a new print line */
190: writes("Cycle: ");
191: writed( cycle );
192: writes(" EVT test ");
193: writed( test_no );
194: writes(". subtest ");
195: writed( subtest );
196: writes( msg ); /* print the message */
197: writes(" index = ");
198: writed( index );
199: writes("\ninst = LDF op1, DIVF op2, CVLF '2'");
200: writes(" ('divide by 0' fault on DIVF)\n");
201: }
202:
203:
204:
205: /****************************************************************************
206: * halt on error routine
207: ****************************************************************************/
208: pipe9_halt( code )
209: int code; /* error code to halt with */
210: {
211: err_code = code;
212: sgl_value_1 = dbl_ld_acc.m;
213: sgl_value_2 = dbl_value_1.m;
214: sgl_value_3 = post_evt_acc.m;
215: asm("movl _test_no,r0"); /* r0 = test number */
216: asm("movl _subtest,r1"); /* r1 = subtest number */
217: asm("movl _err_code,r2"); /* r2 = error code */
218: asm("movl _cycle,r3"); /* r3 = cycle count */
219: asm("movl _sgl_value_1,r4"); /* r4 = initial accumulator */
220: asm("movl _sgl_value_2,r5"); /* r5 = divide operand */
221: asm("movl _sgl_value_3,r6"); /* r6 = final accumulator */
222: asm("movl $0x80000000,r7"); /* r7 = expected accumulator */
223: asm("movl _index,r8"); /* r8 = data index */
224: asm("halt"); /* HALT ... */
225: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.