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