![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe9.lst 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.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / fpevent |
1.1 root 1: 1 00000000 LL0:
2: 2 00000000 .data
3: 3 00000488 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe9
6: 6 00000000 _pipe9:
7: 7 0001208C 0000 .word L381
8: 8 0001208E #
9: 9 0001208E # #include "evt_defs.h"
10: 10 0001208E #
11: 11 0001208E # /*
12: 12 0001208E # *********************************************************************
13: 13 0001208E # * FPP PIPELINED EVENTS TEST #9
14: 14 0001208E # *
15: 15 0001208E # * This test will execute the following code: "LDF DIVF CVLF $2"
16: 16 0001208E # * with a divide by zero fault on the DIVF. We will make sure that:
17: 17 0001208E # * 1. The fault is detected, and
18: 18 0001208E # * 2. the convert instruction is not executed.
19: 19 0001208E # *********************************************************************
20: 20 0001208E # */
21: 21 0001208E # pipe9()
22: 22 0001208E # {
23: 23 0001208E 13 0146 jbr L383
24: 24 00012091 L384:
25: 25 00012091 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
26: 26 00012091 ed 6d effffffff4 moval (r13),_pre_event_fp
27: 27 00012098 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
28: 28 00012098 ed 6e efffffffed moval (r14),_pre_event_sp
29: 29 0001209F # precision = SGL;
30: 30 0001209F 0d 01 efffffffe6 movl $1,_precision
31: 31 000120A6 # test_event = ARITH_CODE; /* expect an arithmetic fault */
32: 32 000120A6 0d 34 efffffffdf movl $52,_test_event
33: 33 000120AD # exp_code = FLT_0_DIV_CODE; /* - specificly div by 0 */
34: 34 000120AD 0d 03 efffffffd8 movl $3,_exp_code
35: 35 000120B4 # exp_event = FALSE; /* ... but not yet */
36: 36 000120B4 4d efffffffd2 clrl _exp_event
37: 37 000120BA # asm("movab _pipe9_ret,_event_return"); /* set event return address */
38: 38 000120BA e9 ef000000c7 efffffffc7 movab _pipe9_ret,_event_return
39: 39 000120C5 # max_index = zero_divide_cnt; /* set max operand index */
40: 40 000120C5 0d efffffffc1 efffffffbc movl _zero_divide_cnt,_max_index
41: 41 000120D0 # for( index = 0; index < max_index; index++ )
42: 42 000120D0 4d efffffffb6 clrl _index
43: 43 000120D6 L387:
44: 44 000120D6 1d efffffffb0 efffffffab cmpl _index,_max_index
45: 45 000120E1 91 03 13 00f0 jgeq L386
46: 46 000120E6 # {
47: 47 000120E6 # dbl_ld_acc = zero_divide_data[index].op_1; /* get the Acc data */
48: 48 000120E6 48 04 efffffff9f 50 shll $4,_index,r0
49: 49 000120EE 0c 8f00000000 50 addl2 $_zero_divide_data,r0
50: 50 000120F5 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4
51: 51 000120FD 0d 60 efffffff88 movl (r0),_dbl_ld_acc
52: 52 00012104 # dbl_value_1 = zero_divide_data[index].op_2; /* get the '0' data */
53: 53 00012104 48 04 efffffff81 50 shll $4,_index,r0
54: 54 0001210C 0c 8f00000008 50 addl2 $_zero_divide_data+8,r0
55: 55 00012113 0d a004 efffffff75 movl 4(r0),_dbl_value_1+4
56: 56 0001211B 0d 60 efffffff6a movl (r0),_dbl_value_1
57: 57 00012122 # if( dbl_ld_acc.m & 0x7f800000 )
58: 58 00012122 3d 8f7f800000 efffffff5f bitl $2139095040,_dbl_ld_acc
59: 59 0001212D 31 0d jeql L388
60: 60 0001212F # dbl_expected.m = dbl_ld_acc.m; /* The final Acc s/b */
61: 61 0001212F 0d efffffff57 efffffff52 movl _dbl_ld_acc,_dbl_expected
62: 62 0001213A # else
63: 63 0001213A 11 06 jbr L389
64: 64 0001213C L388:
65: 65 0001213C # dbl_expected.m = 0; /* = the initial Acc */
66: 66 0001213C 4d efffffff4a clrl _dbl_expected
67: 67 00012142 L389:
68: 68 00012142 # asm("bispsw $0x60"); /* enable ovfl,undfl */
69: 69 00012142 8b 8860 bispsw $0x60
70: 70 00012145 # asm(".globl _pipe9_lp1");
71: 71 00012145 .globl _pipe9_lp1
72: 72 00012145 # asm("_pipe9_lp1:");
73: 73 00012145 _pipe9_lp1:
74: 74 00012145 # asm("ldf _dbl_ld_acc"); /* load the Acc. */
75: 75 00012145 06 efffffff41 ldf _dbl_ld_acc
76: 76 0001214B # exp_event = test_event; /* expect event soon */
77: 77 0001214B 0d efffffff3b efffffff36 movl _test_event,_exp_event
78: 78 00012156 # asm("divf _dbl_value_1"); /* trigger the event */
79: 79 00012156 f6 efffffff30 divf _dbl_value_1
80: 80 0001215C # asm("cvlf $2"); /* shouldn't get here*/
81: 81 0001215C 76 02 cvlf $2
82: 82 0001215E # /*
83: 83 0001215E # * If we got to here then there was no event
84: 84 0001215E # */
85: 85 0001215E # if( force_loop )
86: 86 0001215E 5d efffffff28 tstl _force_loop
87: 87 00012164 31 03 jeql L390
88: 88 00012166 # asm("brw _pipe9_lp1");; /* loop on the error */
89: Assemb0002984C # asm("brw _pipe9_lp1");; /* loop on the error */
90: "pipe90002984C 89: WARNING: brw: destination label is external
91: 89 00012166 13 ffdc brw _pipe9_lp1
92: 90 00012169 L390:
93: 91 00012169 # exp_event = FALSE; /* reset event expected flag */
94: 92 00012169 4d efffffff1d clrl _exp_event
95: 93 0001216F # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
96: 94 0001216F 0d efffffff17 5d movl _pre_event_fp,fp
97: 95 00012176 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
98: 96 00012176 0d efffffff10 5e movl _pre_event_sp,sp
99: 97 0001217D # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
100: 98 0001217D 9b 8860 bicpsw $0x60
101: 99 00012180 # no_pipe9_evt();; /* report the error */
102: 100 00012180 fe 04 ef00000053 callf $4,_no_pipe9_evt
103: 101 00012187 # /*
104: 102 00012187 # * Come here after the event
105: 103 00012187 # */
106: 104 00012187 # asm(".globl _pipe9_ret");
107: 105 00012187 .globl _pipe9_ret
108: 106 00012187 # asm("_pipe9_ret:");
109: 107 00012187 _pipe9_ret:
110: 108 00012187 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
111: 109 00012187 0d effffffeff 5d movl _pre_event_fp,fp
112: 110 0001218E # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
113: 111 0001218E 0d effffffef8 5e movl _pre_event_sp,sp
114: 112 00012195 # if( force_loop )
115: 113 00012195 5d effffffef1 tstl _force_loop
116: 114 0001219B 31 03 jeql L392
117: 115 0001219D # asm("brw _pipe9_lp1");; /* loop on the error */
118: "pipe90002984C 116: WARNING: brw: destination label is external
119: 116 0001219D 13 ffa5 brw _pipe9_lp1
120: 117 000121A0 L392:
121: 118 000121A0 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
122: 119 000121A0 9b 8860 bicpsw $0x60
123: 120 000121A3 # if( post_evt_acc.m != dbl_expected.m ) /* was the Acc modified? */
124: 121 000121A3 1d effffffee3 effffffede cmpl _post_evt_acc,_dbl_expected
125: 122 000121AE 31 1d jeql L393
126: 123 000121B0 # {
127: 124 000121B0 # if( post_evt_acc.m == 0x41000000 ) /* is Acc. = 2.0 ? */
128: 125 000121B0 1d effffffed6 8f41000000 cmpl _post_evt_acc,$1090519040
129: 126 000121BB 21 09 jneq L394
130: 127 000121BD # pipe9_queue_er(); /* queue not cleared error */
131: 128 000121BD fe 04 ef00000168 callf $4,_pipe9_queue_er
132: 129 000121C4 # else
133: 130 000121C4 11 07 jbr L396
134: 131 000121C6 L394:
135: 132 000121C6 # bad_pipe9_result(); /* incorrect result error */
136: 133 000121C6 fe 04 ef00000093 callf $4,_bad_pipe9_result
137: 134 000121CD L396:
138: 135 000121CD # }
139: 136 000121CD # }
140: 137 000121CD L393:
141: 138 000121CD L385:
142: 139 000121CD 6d effffffeb9 incl _index
143: 140 000121D3 13 ff00 jbr L387
144: 141 000121D6 L386:
145: 142 000121D6 # }
146: 143 000121D6 40 ret#2
147: 144 000121D7 .set L381,0x0
148: 145 000121D7 L383:
149: 146 000121D7 13 feb7 jbr L384
150: 147 000121DA .data
151: 148 00000488 * .text
152: 149 000121DA .align 1
153: 150 000121DA .globl _no_pipe9_evt
154: 151 000121DA _no_pipe9_evt:
155: 152 000121DA 0000 .word L398
156: 153 000121DC #
157: 154 000121DC #
158: 155 000121DC #
159: 156 000121DC # /****************************************************************************
160: 157 000121DC # * Report an "EVENT NOT DETECTED" error
161: 158 000121DC # *
162: 159 000121DC # * Cycle: xx. EVT test xx. subtest xx. No 'divide by 0' fault seen. index = xx
163: 160 000121DC # * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF)
164: 161 000121DC # * op1 = xxxxxxxx, op2 = xxxxxxxx
165: 162 000121DC # ****************************************************************************/
166: 163 000121DC # no_pipe9_evt()
167: 164 000121DC # {
168: 165 000121DC 11 7f jbr L400
169: 166 000121DE L401:
170: 167 000121DE # errcnt++; /* bump the error count */
171: 168 000121DE 6d effffffea8 incl _errcnt
172: 169 000121E4 # if ( prt_error )
173: 170 000121E4 5d effffffea2 tstl _prt_error
174: 171 000121EA 31 4a jeql L402
175: 172 000121EC # {
176: 173 000121EC # print_pipe9_er( ". No 'divide by 0' fault seen." );
177: 174 000121EC .data 1
178: 175 00000488 * L404:
179: 176 00000488 * 2E204E6F20276469766964652 .ascii ". No 'divide by 0' fault seen.\0"
180: 06279203027206661756C7420
181: 7365656E2E00
182: 177 000004a7 * .text
183: 178 000121EC dd 8f00000488 pushl $L404
184: 179 000121F2 fe 08 ef000001ff callf $8,_print_pipe9_er
185: 180 000121F9 # writes("op1 = ");
186: 181 000121F9 .data 1
187: 182 000004a7 * L406:
188: 183 000004a7 * 6F7031203D2000 .ascii "op1 = \0"
189: 184 000004ae * .text
190: 185 000121F9 dd 8f000004a7 pushl $L406
191: 186 000121FF fe 08 effffffe86 callf $8,_writes
192: 187 00012206 # write32h( dbl_ld_acc.m );
193: 188 00012206 dd effffffe80 pushl _dbl_ld_acc
194: 189 0001220C fe 08 effffffe79 callf $8,_write32h
195: 190 00012213 # writes(", op2 = ");
196: 191 00012213 .data 1
197: 192 000004ae * L408:
198: 193 000004ae * 2C2020206F7032203D2000 .ascii ", op2 = \0"
199: 194 000004b9 * .text
200: 195 00012213 dd 8f000004ae pushl $L408
201: 196 00012219 fe 08 effffffe6c callf $8,_writes
202: 197 00012220 # write32h( dbl_value_1.m );
203: 198 00012220 dd effffffe66 pushl _dbl_value_1
204: 199 00012226 fe 08 effffffe5f callf $8,_write32h
205: 200 0001222D # writec('\n');
206: 201 0001222D dd 0a pushl $10
207: 202 0001222F fe 08 effffffe56 callf $8,_writec
208: 203 00012236 # }
209: 204 00012236 # if ( halt_flg ) /* halt on error? */
210: 205 00012236 L402:
211: 206 00012236 5d effffffe50 tstl _halt_flg
212: 207 0001223C 31 09 jeql L410
213: 208 0001223E # pipe9_halt( 1 ); /* halt with a code of 1 */
214: 209 0001223E dd 01 pushl $1
215: 210 00012240 fe 08 ef0000025d callf $8,_pipe9_halt
216: 211 00012247 # if ( loop_on_err )
217: 212 00012247 L410:
218: 213 00012247 5d effffffe3f tstl _loop_on_err
219: 214 0001224D 31 0d jeql L412
220: 215 0001224F # {
221: 216 0001224F # force_loop = TRUE; /* set the force loop flag */
222: 217 0001224F 0d 01 effffffe36 movl $1,_force_loop
223: 218 00012256 # asm("jmp _pipe9_lp1"); /* and loop */
224: 219 00012256 71 effffffee9 jmp _pipe9_lp1
225: 220 0001225C # };
226: 221 0001225C L412:
227: 222 0001225C # }
228: 223 0001225C 40 ret#2
229: 224 0001225D .set L398,0x0
230: 225 0001225D L400:
231: 226 0001225D 13 ff7e jbr L401
232: 227 00012260 .data
233: 228 00000488 * .text
234: 229 00012260 .align 1
235: 230 00012260 .globl _bad_pipe9_result
236: 231 00012260 _bad_pipe9_result:
237: 232 00012260 0000 .word L413
238: 233 00012262 #
239: 234 00012262 #
240: 235 00012262 #
241: 236 00012262 #
242: 237 00012262 # /****************************************************************************
243: 238 00012262 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
244: 239 00012262 # *
245: 240 00012262 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
246: 241 00012262 # * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF)
247: 242 00012262 # * The 'Convert '2' to Floating Point' should not be executed.
248: 243 00012262 # * op_1 = xxxxxxxx, op2 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx
249: 244 00012262 # ****************************************************************************/
250: 245 00012262 # bad_pipe9_result()
251: 246 00012262 # {
252: 247 00012262 13 00c3 jbr L415
253: 248 00012265 L416:
254: 249 00012265 # errcnt++; /* bump the error count */
255: 250 00012265 6d effffffe21 incl _errcnt
256: 251 0001226B # if ( prt_error )
257: 252 0001226B 5d effffffe1b tstl _prt_error
258: 253 00012271 21 03 13 008b jeql L417
259: 254 00012276 # {
260: 255 00012276 # print_pipe9_er( ". Bad final Accumulator" );
261: 256 00012276 .data 1
262: 257 000004b9 * L418:
263: 258 000004b9 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
264: 16363756D756C61746F7200
265: 259 000004d1 * .text
266: 260 00012276 dd 8f000004b9 pushl $L418
267: 261 0001227C fe 08 ef00000175 callf $8,_print_pipe9_er
268: 262 00012283 # writes(
269: 263 00012283 # "The 'Convert '2' to Floating Point' should not be executed\n");
270: 264 00012283 .data 1
271: 265 000004d1 * L419:
272: 266 000004d1 * 5468652027436F6E766572742 .ascii "The 'Convert '2' to Floating Point' should not be executed\12\0"
273: 027322720746F20466C6F6174
274: 696E6720506F696E742720736
275: 86F756C64206E6F7420626520
276: 65786563757465640A00
277: 267 0000050d * .text
278: 268 00012283 dd 8f000004d1 pushl $L419
279: 269 00012289 fe 08 effffffdfc callf $8,_writes
280: 270 00012290 # writes("op1 = ");
281: 271 00012290 .data 1
282: 272 0000050d * L420:
283: 273 0000050d * 6F7031203D2000 .ascii "op1 = \0"
284: 274 00000514 * .text
285: 275 00012290 dd 8f0000050d pushl $L420
286: 276 00012296 fe 08 effffffdef callf $8,_writes
287: 277 0001229D # write32h( dbl_ld_acc.m );
288: 278 0001229D dd effffffde9 pushl _dbl_ld_acc
289: 279 000122A3 fe 08 effffffde2 callf $8,_write32h
290: 280 000122AA # writes(", op1 = ");
291: 281 000122AA .data 1
292: 282 00000514 * L421:
293: 283 00000514 * 2C206F7031203D2000 .ascii ", op1 = \0"
294: 284 0000051d * .text
295: 285 000122AA dd 8f00000514 pushl $L421
296: 286 000122B0 fe 08 effffffdd5 callf $8,_writes
297: 287 000122B7 # write32h( dbl_value_1.m );
298: 288 000122B7 dd effffffdcf pushl _dbl_value_1
299: 289 000122BD fe 08 effffffdc8 callf $8,_write32h
300: 290 000122C4 # writes(", final Acc. = ");
301: 291 000122C4 .data 1
302: 292 0000051d * L422:
303: 293 0000051d * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0"
304: 03D2000
305: 294 0000052d * .text
306: 295 000122C4 dd 8f0000051d pushl $L422
307: 296 000122CA fe 08 effffffdbb callf $8,_writes
308: 297 000122D1 # write32h( post_evt_acc.m );
309: 298 000122D1 dd effffffdb5 pushl _post_evt_acc
310: 299 000122D7 fe 08 effffffdae callf $8,_write32h
311: 300 000122DE # writes(", expected = ");
312: 301 000122DE .data 1
313: 302 0000052d * L423:
314: 303 0000052d * 2C206578706563746564203D2 .ascii ", expected = \0"
315: 000
316: 304 0000053b * .text
317: 305 000122DE dd 8f0000052d pushl $L423
318: 306 000122E4 fe 08 effffffda1 callf $8,_writes
319: 307 000122EB # write32h( dbl_expected.m ); /* the expected result = 0 */
320: 308 000122EB dd effffffd9b pushl _dbl_expected
321: 309 000122F1 fe 08 effffffd94 callf $8,_write32h
322: 310 000122F8 # writec('\n');
323: 311 000122F8 dd 0a pushl $10
324: 312 000122FA fe 08 effffffd8b callf $8,_writec
325: 313 00012301 # }
326: 314 00012301 # if ( halt_flg ) /* halt on error? */
327: 315 00012301 L417:
328: 316 00012301 5d effffffd85 tstl _halt_flg
329: 317 00012307 31 09 jeql L424
330: 318 00012309 # pipe9_halt( 2 ); /* halt with a code of 2 */
331: 319 00012309 dd 02 pushl $2
332: 320 0001230B fe 08 ef00000192 callf $8,_pipe9_halt
333: 321 00012312 # if ( loop_on_err )
334: 322 00012312 L424:
335: 323 00012312 5d effffffd74 tstl _loop_on_err
336: 324 00012318 31 0d jeql L425
337: 325 0001231A # {
338: 326 0001231A # force_loop = TRUE; /* set the force loop flag */
339: 327 0001231A 0d 01 effffffd6b movl $1,_force_loop
340: 328 00012321 # asm("jmp _pipe9_lp1"); /* and loop */
341: 329 00012321 71 effffffe1e jmp _pipe9_lp1
342: 330 00012327 # };
343: 331 00012327 L425:
344: 332 00012327 # }
345: 333 00012327 40 ret#2
346: 334 00012328 .set L413,0x0
347: 335 00012328 L415:
348: 336 00012328 13 ff3a jbr L416
349: 337 0001232B .data
350: 338 00000488 * .text
351: 339 0001232B 00 .align 1
352: 340 0001232C .globl _pipe9_queue_er
353: 341 0001232C _pipe9_queue_er:
354: 342 0001232C 0000 .word L426
355: 343 0001232E #
356: 344 0001232E #
357: 345 0001232E #
358: 346 0001232E #
359: 347 0001232E #
360: 348 0001232E # /****************************************************************************
361: 349 0001232E # * Report an "FPP queue not cleared" message
362: 350 0001232E # *
363: 351 0001232E # * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx
364: 352 0001232E # * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF)
365: 353 0001232E # * The 'Convert '2' to Floating Point' was apparently executed.
366: 354 0001232E # * op1 = xxxxxxxx, op2 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx
367: 355 0001232E # ****************************************************************************/
368: 356 0001232E # pipe9_queue_er()
369: 357 0001232E # {
370: 358 0001232E 13 00c3 jbr L428
371: 359 00012331 L429:
372: 360 00012331 # errcnt++; /* bump the error count */
373: 361 00012331 6d effffffd55 incl _errcnt
374: 362 00012337 # if ( prt_error )
375: 363 00012337 5d effffffd4f tstl _prt_error
376: 364 0001233D 21 03 13 008b jeql L430
377: 365 00012342 # {
378: 366 00012342 # print_pipe9_er( ". Fpp queue not cleared" );
379: 367 00012342 .data 1
380: 368 0000053b * L431:
381: 369 0000053b * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0"
382: E6F7420636C656172656400
383: 370 00000553 * .text
384: 371 00012342 dd 8f0000053b pushl $L431
385: 372 00012348 fe 08 ef000000a9 callf $8,_print_pipe9_er
386: 373 0001234F # writes(
387: 374 0001234F # "The 'Convert '2' to Floating Point' was apparently executed.\n");
388: 375 0001234F .data 1
389: 376 00000553 * L432:
390: 377 00000553 * 5468652027436F6E766572742 .ascii "The 'Convert '2' to Floating Point' was apparently executed.\12\0"
391: 027322720746F20466C6F6174
392: 696E6720506F696E742720776
393: 173206170706172656E746C79
394: 2065786563757465642E0A00
395: 378 00000591 * .text
396: 379 0001234F dd 8f00000553 pushl $L432
397: 380 00012355 fe 08 effffffd30 callf $8,_writes
398: 381 0001235C # writes("op1 = ");
399: 382 0001235C .data 1
400: 383 00000591 * L433:
401: 384 00000591 * 6F7031203D2000 .ascii "op1 = \0"
402: 385 00000598 * .text
403: 386 0001235C dd 8f00000591 pushl $L433
404: 387 00012362 fe 08 effffffd23 callf $8,_writes
405: 388 00012369 # write32h( dbl_ld_acc.m );
406: 389 00012369 dd effffffd1d pushl _dbl_ld_acc
407: 390 0001236F fe 08 effffffd16 callf $8,_write32h
408: 391 00012376 # writes(", op1 = ");
409: 392 00012376 .data 1
410: 393 00000598 * L434:
411: 394 00000598 * 2C206F7031203D2000 .ascii ", op1 = \0"
412: 395 000005a1 * .text
413: 396 00012376 dd 8f00000598 pushl $L434
414: 397 0001237C fe 08 effffffd09 callf $8,_writes
415: 398 00012383 # write32h( dbl_value_1.m );
416: 399 00012383 dd effffffd03 pushl _dbl_value_1
417: 400 00012389 fe 08 effffffcfc callf $8,_write32h
418: 401 00012390 # writes(", final Acc. = ");
419: 402 00012390 .data 1
420: 403 000005a1 * L435:
421: 404 000005a1 * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0"
422: 03D2000
423: 405 000005b1 * .text
424: 406 00012390 dd 8f000005a1 pushl $L435
425: 407 00012396 fe 08 effffffcef callf $8,_writes
426: 408 0001239D # write32h( post_evt_acc.m );
427: 409 0001239D dd effffffce9 pushl _post_evt_acc
428: 410 000123A3 fe 08 effffffce2 callf $8,_write32h
429: 411 000123AA # writes(", expected = ");
430: 412 000123AA .data 1
431: 413 000005b1 * L436:
432: 414 000005b1 * 2C206578706563746564203D2 .ascii ", expected = \0"
433: 000
434: 415 000005bf * .text
435: 416 000123AA dd 8f000005b1 pushl $L436
436: 417 000123B0 fe 08 effffffcd5 callf $8,_writes
437: 418 000123B7 # write32h( 0x80000000 ); /* the expected result = 0 */
438: 419 000123B7 dd 8f80000000 pushl $-2147483648
439: 420 000123BD fe 08 effffffcc8 callf $8,_write32h
440: 421 000123C4 # writec('\n');
441: 422 000123C4 dd 0a pushl $10
442: 423 000123C6 fe 08 effffffcbf callf $8,_writec
443: 424 000123CD # }
444: 425 000123CD # if ( halt_flg ) /* halt on error? */
445: 426 000123CD L430:
446: 427 000123CD 5d effffffcb9 tstl _halt_flg
447: 428 000123D3 31 09 jeql L437
448: 429 000123D5 # pipe9_halt( 3 ); /* halt with a code of 3 */
449: 430 000123D5 dd 03 pushl $3
450: 431 000123D7 fe 08 ef000000c6 callf $8,_pipe9_halt
451: 432 000123DE # if ( loop_on_err )
452: 433 000123DE L437:
453: 434 000123DE 5d effffffca8 tstl _loop_on_err
454: 435 000123E4 31 0d jeql L438
455: 436 000123E6 # {
456: 437 000123E6 # force_loop = TRUE; /* set the force loop flag */
457: 438 000123E6 0d 01 effffffc9f movl $1,_force_loop
458: 439 000123ED # asm("jmp _pipe9_lp1"); /* and loop */
459: 440 000123ED 71 effffffd52 jmp _pipe9_lp1
460: 441 000123F3 # };
461: 442 000123F3 L438:
462: 443 000123F3 # }
463: 444 000123F3 40 ret#2
464: 445 000123F4 .set L426,0x0
465: 446 000123F4 L428:
466: 447 000123F4 13 ff3a jbr L429
467: 448 000123F7 .data
468: 449 00000488 * .text
469: 450 000123F7 00 .align 1
470: 451 000123F8 .globl _print_pipe9_er
471: 452 000123F8 _print_pipe9_er:
472: 453 000123F8 0000 .word L439
473: 454 000123FA #
474: 455 000123FA #
475: 456 000123FA #
476: 457 000123FA #
477: 458 000123FA # /****************************************************************************
478: 459 000123FA # * Report an error message of the form:
479: 460 000123FA # *
480: 461 000123FA # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
481: 462 000123FA # * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF)
482: 463 000123FA # ****************************************************************************/
483: 464 000123FA # print_pipe9_er( msg )
484: 465 000123FA # char *msg; /* error message to print */
485: 466 000123FA # {
486: 467 000123FA 13 00a3 jbr L441
487: 468 000123FD L442:
488: 469 000123FD # if( errcnt == 1 ) /* 1st error? */
489: 470 000123FD 1d effffffc89 01 cmpl _errcnt,$1
490: 471 00012404 21 0d jneq L443
491: 472 00012406 # writes(" \n"); /* start a new print line */
492: 473 00012406 .data 1
493: 474 000005bf * L444:
494: 475 000005bf * 200A00 .ascii " \12\0"
495: 476 000005c2 * .text
496: 477 00012406 dd 8f000005bf pushl $L444
497: 478 0001240C fe 08 effffffc79 callf $8,_writes
498: 479 00012413 # writes("Cycle: ");
499: 480 00012413 L443:
500: 481 00012413 .data 1
501: 482 000005c2 * L445:
502: 483 000005c2 * 4379636C653A2000 .ascii "Cycle: \0"
503: 484 000005ca * .text
504: 485 00012413 dd 8f000005c2 pushl $L445
505: 486 00012419 fe 08 effffffc6c callf $8,_writes
506: 487 00012420 # writed( cycle );
507: 488 00012420 dd effffffc66 pushl _cycle
508: 489 00012426 fe 08 effffffc5f callf $8,_writed
509: 490 0001242D # writes(" EVT test ");
510: 491 0001242D .data 1
511: 492 000005ca * L447:
512: 493 000005ca * 202045565420746573742000 .ascii " EVT test \0"
513: 494 000005d6 * .text
514: 495 0001242D dd 8f000005ca pushl $L447
515: 496 00012433 fe 08 effffffc52 callf $8,_writes
516: 497 0001243A # writed( test_no );
517: 498 0001243A dd effffffc4c pushl _test_no
518: 499 00012440 fe 08 effffffc45 callf $8,_writed
519: 500 00012447 # writes(". subtest ");
520: 501 00012447 .data 1
521: 502 000005d6 * L448:
522: 503 000005d6 * 2E20737562746573742000 .ascii ". subtest \0"
523: 504 000005e1 * .text
524: 505 00012447 dd 8f000005d6 pushl $L448
525: 506 0001244D fe 08 effffffc38 callf $8,_writes
526: 507 00012454 # writed( subtest );
527: 508 00012454 dd effffffc32 pushl _subtest
528: 509 0001245A fe 08 effffffc2b callf $8,_writed
529: 510 00012461 # writes( msg ); /* print the message */
530: 511 00012461 dd ad04 pushl 4(fp)
531: 512 00012464 fe 08 effffffc21 callf $8,_writes
532: 513 0001246B # writes(" index = ");
533: 514 0001246B .data 1
534: 515 000005e1 * L449:
535: 516 000005e1 * 20696E646578203D2000 .ascii " index = \0"
536: 517 000005eb * .text
537: 518 0001246B dd 8f000005e1 pushl $L449
538: 519 00012471 fe 08 effffffc14 callf $8,_writes
539: 520 00012478 # writed( index );
540: 521 00012478 dd effffffc0e pushl _index
541: 522 0001247E fe 08 effffffc07 callf $8,_writed
542: 523 00012485 # writes("\ninst = LDF op1, DIVF op2, CVLF '2'");
543: 524 00012485 .data 1
544: 525 000005eb * L450:
545: 526 000005eb * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1, DIVF op2, CVLF '2'\0"
546: F70312C2044495646206F7032
547: 2C2043564C462027322700
548: 527 0000060f * .text
549: 528 00012485 dd 8f000005eb pushl $L450
550: 529 0001248B fe 08 effffffbfa callf $8,_writes
551: 530 00012492 # writes(" ('divide by 0' fault on DIVF)\n");
552: 531 00012492 .data 1
553: 532 0000060f * L451:
554: 533 0000060f * 2020202028276469766964652 .ascii " ('divide by 0' fault on DIVF)\12\0"
555: 06279203027206661756C7420
556: 6F6E2044495646290A00
557: 534 00000632 * .text
558: 535 00012492 dd 8f0000060f pushl $L451
559: 536 00012498 fe 08 effffffbed callf $8,_writes
560: 537 0001249F # }
561: 538 0001249F 40 ret#2
562: 539 000124A0 .set L439,0x0
563: 540 000124A0 L441:
564: 541 000124A0 13 ff5a jbr L442
565: 542 000124A3 .data
566: 543 00000488 * .text
567: 544 000124A3 00 .align 1
568: 545 000124A4 .globl _pipe9_halt
569: 546 000124A4 _pipe9_halt:
570: 547 000124A4 0000 .word L452
571: 548 000124A6 #
572: 549 000124A6 #
573: 550 000124A6 #
574: 551 000124A6 # /****************************************************************************
575: 552 000124A6 # * halt on error routine
576: 553 000124A6 # ****************************************************************************/
577: 554 000124A6 # pipe9_halt( code )
578: 555 000124A6 # int code; /* error code to halt with */
579: 556 000124A6 # {
580: 557 000124A6 11 6a jbr L454
581: 558 000124A8 L455:
582: 559 000124A8 # err_code = code;
583: 560 000124A8 0d ad04 effffffbdc movl 4(fp),_err_code
584: 561 000124B0 # sgl_value_1 = dbl_ld_acc.m;
585: 562 000124B0 0d effffffbd6 effffffbd1 movl _dbl_ld_acc,_sgl_value_1
586: 563 000124BB # sgl_value_2 = dbl_value_1.m;
587: 564 000124BB 0d effffffbcb effffffbc6 movl _dbl_value_1,_sgl_value_2
588: 565 000124C6 # sgl_value_3 = post_evt_acc.m;
589: 566 000124C6 0d effffffbc0 effffffbbb movl _post_evt_acc,_sgl_value_3
590: 567 000124D1 # asm("movl _test_no,r0"); /* r0 = test number */
591: 568 000124D1 0d effffffbb5 50 movl _test_no,r0
592: 569 000124D8 # asm("movl _subtest,r1"); /* r1 = subtest number */
593: 570 000124D8 0d effffffbae 51 movl _subtest,r1
594: 571 000124DF # asm("movl _err_code,r2"); /* r2 = error code */
595: 572 000124DF 0d effffffba7 52 movl _err_code,r2
596: 573 000124E6 # asm("movl _cycle,r3"); /* r3 = cycle count */
597: 574 000124E6 0d effffffba0 53 movl _cycle,r3
598: 575 000124ED # asm("movl _sgl_value_1,r4"); /* r4 = initial accumulator */
599: 576 000124ED 0d effffffb99 54 movl _sgl_value_1,r4
600: 577 000124F4 # asm("movl _sgl_value_2,r5"); /* r5 = divide operand */
601: 578 000124F4 0d effffffb92 55 movl _sgl_value_2,r5
602: 579 000124FB # asm("movl _sgl_value_3,r6"); /* r6 = final accumulator */
603: 580 000124FB 0d effffffb8b 56 movl _sgl_value_3,r6
604: 581 00012502 # asm("movl $0x80000000,r7"); /* r7 = expected accumulator */
605: 582 00012502 0d 8f80000000 57 movl $0x80000000,r7
606: 583 00012509 # asm("movl _index,r8"); /* r8 = data index */
607: 584 00012509 0d effffffb7d 58 movl _index,r8
608: 585 00012510 # asm("halt"); /* HALT ... */
609: 586 00012510 00 halt
610: 587 00012511 # }
611: 588 00012511 40 ret#2
612: 589 00012512 .set L452,0x0
613: 590 00012512 L454:
614: 591 00012512 11 94 jbr L455
615: 592 00000488 * .data
616: 592 00000488 * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.