![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe13.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 pipe13.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 00000468 * .text
4 00000000 .align 1
5 00000000 .globl _pipe13
6 00000000 _pipe13:
7 00013404 0000 .word L381
8 00013406 #
9 00013406 # #include "evt_defs.h"
10 00013406 #
11 00013406 # /*
12 00013406 # *********************************************************************
13 00013406 # * FPP PIPELINED EVENTS TEST #13
14 00013406 # *
15 00013406 # * This test will execute the following code: "LDF CVFL NEGF"
16 00013406 # * with an integer overflow fault on the CVFL. We will make sure that:
17 00013406 # * 1. The fault is detected, and
18 00013406 # * 2. the NEGF instruction is not executed.
19 00013406 # *********************************************************************
20 00013406 # */
21 00013406 # pipe13()
22 00013406 # {
23 00013406 13 0135 jbr L383
24 00013409 L384:
25 00013409 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
26 00013409 ed 6d effffffff4 moval (r13),_pre_event_fp
27 00013410 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
28 00013410 ed 6e efffffffed moval (r14),_pre_event_sp
29 00013417 # precision = SGL;
30 00013417 0d 01 efffffffe6 movl $1,_precision
31 0001341E # test_event = ARITH_CODE; /* expect an arithmetic fault */
32 0001341E 0d 34 efffffffdf movl $52,_test_event
33 00013425 # exp_code = INT_OVFL_CODE; /* - specificly underflow */
34 00013425 0d 01 efffffffd8 movl $1,_exp_code
35 0001342C # exp_event = FALSE; /* ... but not yet */
36 0001342C 4d efffffffd2 clrl _exp_event
37 00013432 # asm("movab _pipe13_ret,_event_return"); /* set event return address */
38 00013432 e9 ef000000ae efffffffc7 movab _pipe13_ret,_event_return
39 0001343D # max_index = cvdl_ov_cnt; /* set max operand index */
40 0001343D 0d efffffffc1 efffffffbc movl _cvdl_ov_cnt,_max_index
41 00013448 # for( index = 0; index < max_index; index++ )
42 00013448 4d efffffffb6 clrl _index
43 0001344E L387:
44 0001344E 1d efffffffb0 efffffffab cmpl _index,_max_index
45 00013459 91 03 13 00df jgeq L386
46 0001345E # {
47 0001345E # dbl_ld_acc = cvfl_ov_dat[index].op_1; /* get the Acc data */
48 0001345E 48 04 efffffff9f 50 shll $4,_index,r0
49 00013466 0c 8f00000000 50 addl2 $_cvfl_ov_dat,r0
50 0001346D 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4
51 00013475 0d 60 efffffff88 movl (r0),_dbl_ld_acc
52 0001347C # if( dbl_ld_acc.m & 0x7f800000 )
53 0001347C 3d 8f7f800000 efffffff7d bitl $2139095040,_dbl_ld_acc
54 00013487 31 0d jeql L388
55 00013489 # dbl_expected.m = dbl_ld_acc.m; /* Acc shouldn't change */
56 00013489 0d efffffff75 efffffff70 movl _dbl_ld_acc,_dbl_expected
57 00013494 # else
58 00013494 11 06 jbr L389
59 00013496 L388:
60 00013496 # dbl_expected.m = 0; /* expect a 'good 0' */
61 00013496 4d efffffff68 clrl _dbl_expected
62 0001349C L389:
63 0001349C # asm("bispsw $0x60"); /* enable ovfl,undfl */
64 0001349C 8b 8860 bispsw $0x60
65 0001349F # asm(".globl _pipe13_lp1");
66 0001349F .globl _pipe13_lp1
67 0001349F # asm("_pipe13_lp1:");
68 0001349F _pipe13_lp1:
69 0001349F # asm("ldf _dbl_ld_acc"); /* load the Acc. */
70 0001349F 06 efffffff5f ldf _dbl_ld_acc
71 000134A5 # exp_event = test_event; /* expect event soon */
72 000134A5 0d efffffff59 efffffff54 movl _test_event,_exp_event
73 000134B0 # asm("cvfl _dbl_value_1"); /* trigger the event */
74 000134B0 86 efffffff4e cvfl _dbl_value_1
75 000134B6 # asm("negf"); /* shouldn't get here*/
76 000134B6 b6 negf
77 000134B7 # /*
78 000134B7 # * If we got to here then there was no event
79 000134B7 # */
80 000134B7 # if( force_loop )
81 000134B7 5d efffffff47 tstl _force_loop
82 000134BD 31 03 jeql L390
83 000134BF # asm("brw _pipe13_lp1");; /* loop on the error */
Assemb0002ABC4 # asm("brw _pipe13_lp1");; /* loop on the error */
"pipe100013407 e 84: WARNING: brw: destination label is external
84 000134BF 13 ffdd brw _pipe13_lp1
85 000134C2 L390:
86 000134C2 # exp_event = FALSE; /* reset event expected flag */
87 000134C2 4d efffffff3c clrl _exp_event
88 000134C8 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
89 000134C8 9b 8860 bicpsw $0x60
90 000134CB # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
91 000134CB 0d efffffff33 5d movl _pre_event_fp,fp
92 000134D2 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
93 000134D2 0d efffffff2c 5e movl _pre_event_sp,sp
94 000134D9 # asm("stf _dbl_st_acc"); /* save the accumulator */
95 000134D9 26 efffffff25 stf _dbl_st_acc
96 000134DF # no_pipe13_evt();; /* report the error */
97 000134DF fe 04 ef0000005c callf $4,_no_pipe13_evt
98 000134E6 # /*
99 000134E6 # * Come here after the event
100 000134E6 # */
101 000134E6 # asm(".globl _pipe13_ret");
102 000134E6 .globl _pipe13_ret
103 000134E6 # asm("_pipe13_ret:");
104 000134E6 _pipe13_ret:
105 000134E6 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
106 000134E6 0d efffffff18 5d movl _pre_event_fp,fp
107 000134ED # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
108 000134ED 0d efffffff11 5e movl _pre_event_sp,sp
109 000134F4 # if( force_loop )
110 000134F4 5d efffffff0a tstl _force_loop
111 000134FA 31 03 jeql L392
112 000134FC # asm("brw _pipe13_lp1");; /* loop on the error */
"pipe100013407 e 113: WARNING: brw: destination label is external
113 000134FC 13 ffa0 brw _pipe13_lp1
114 000134FF L392:
115 000134FF # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
116 000134FF 9b 8860 bicpsw $0x60
117 00013502 # if( post_evt_acc.m == (dbl_ld_acc.m ^ 0x80000000) )
118 00013502 dc 8f80000000 effffffef7 xorl3 $-2147483648,_dbl_ld_acc,r0
50
119 0001350E 1d effffffef0 50 cmpl _post_evt_acc,r0
120 00013515 21 09 jneq L393
121 00013517 # pipe13_queue_er(); /* the NEGF was executed */
122 00013517 fe 04 ef00000174 callf $4,_pipe13_queue_er
123 0001351E # else if( post_evt_acc.m != dbl_expected.m ) /* Acc modified? */
124 0001351E 11 14 jbr L395
125 00013520 L393:
126 00013520 1d effffffede effffffed9 cmpl _post_evt_acc,_dbl_expected
127 0001352B 31 07 jeql L396
128 0001352D # bad_pipe13_result(); /* incorrect result error */
129 0001352D fe 04 ef000000b0 callf $4,_bad_pipe13_result
130 00013534 #
131 00013534 # }
132 00013534 L396:
133 00013534 L395:
134 00013534 L385:
135 00013534 6d effffffeca incl _index
136 0001353A 13 ff11 jbr L387
137 0001353D L386:
138 0001353D # }
139 0001353D 40 ret#2
140 0001353E .set L381,0x0
141 0001353E L383:
142 0001353E 13 fec8 jbr L384
143 00013541 .data
144 00000468 * .text
145 00013541 00 .align 1
146 00013542 .globl _no_pipe13_evt
147 00013542 _no_pipe13_evt:
148 00013542 0000 .word L398
149 00013544 #
150 00013544 #
151 00013544 #
152 00013544 # /****************************************************************************
153 00013544 # * Report an "EVENT NOT DETECTED" error
154 00013544 # *
155 00013544 # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx
156 00013544 # * inst = LDF op1, CVFL op2, NEGF (integer overflow fault on the CVDF)
157 00013544 # * op1 = xxxxxxxx, op2 = xxxxxxxx, final Acc. = xxxxxxxx
158 00013544 # ****************************************************************************/
159 00013544 # no_pipe13_evt()
160 00013544 # {
161 00013544 13 0099 jbr L400
162 00013547 L401:
163 00013547 # errcnt++; /* bump the error count */
164 00013547 6d effffffeb7 incl _errcnt
165 0001354D # if ( prt_error )
166 0001354D 5d effffffeb1 tstl _prt_error
167 00013553 31 64 jeql L402
168 00013555 # {
169 00013555 # print_pipe13_er( ". No overflow fault seen." );
170 00013555 .data 1
171 00000468 * L404:
172 00000468 * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen.\0"
7206661756C74207365656E2E
00
173 00000482 * .text
174 00013555 dd 8f00000468 pushl $L404
175 0001355B fe 08 ef000001fc callf $8,_print_pipe13_er
176 00013562 # writes("op1 = ");
177 00013562 .data 1
178 00000482 * L406:
179 00000482 * 6F7031203D2000 .ascii "op1 = \0"
180 00000489 * .text
181 00013562 dd 8f00000482 pushl $L406
182 00013568 fe 08 effffffe95 callf $8,_writes
183 0001356F # write32h( dbl_ld_acc.m );
184 0001356F dd effffffe8f pushl _dbl_ld_acc
185 00013575 fe 08 effffffe88 callf $8,_write32h
186 0001357C # writes(", op2 = ");
187 0001357C .data 1
188 00000489 * L408:
189 00000489 * 2C2020206F7032203D2000 .ascii ", op2 = \0"
190 00000494 * .text
191 0001357C dd 8f00000489 pushl $L408
192 00013582 fe 08 effffffe7b callf $8,_writes
193 00013589 # write32h( dbl_value_1.m );
194 00013589 dd effffffe75 pushl _dbl_value_1
195 0001358F fe 08 effffffe6e callf $8,_write32h
196 00013596 # writes(", final Acc. = ");
197 00013596 .data 1
198 00000494 * L409:
199 00000494 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
32E203D2000
200 000004a6 * .text
201 00013596 dd 8f00000494 pushl $L409
202 0001359C fe 08 effffffe61 callf $8,_writes
203 000135A3 # write32h( dbl_st_acc.m );
204 000135A3 dd effffffe5b pushl _dbl_st_acc
205 000135A9 fe 08 effffffe54 callf $8,_write32h
206 000135B0 # writec('\n');
207 000135B0 dd 0a pushl $10
208 000135B2 fe 08 effffffe4b callf $8,_writec
209 000135B9 # }
210 000135B9 # if ( halt_flg ) /* halt on error? */
211 000135B9 L402:
212 000135B9 5d effffffe45 tstl _halt_flg
213 000135BF 31 09 jeql L411
214 000135C1 # pipe13_halt( 1 ); /* halt with a code of 1 */
215 000135C1 dd 01 pushl $1
216 000135C3 fe 08 ef00000232 callf $8,_pipe13_halt
217 000135CA # if ( loop_on_err )
218 000135CA L411:
219 000135CA 5d effffffe34 tstl _loop_on_err
220 000135D0 31 0d jeql L413
221 000135D2 # {
222 000135D2 # force_loop = TRUE; /* set the force loop flag */
223 000135D2 0d 01 effffffe2b movl $1,_force_loop
224 000135D9 # asm("jmp _pipe13_lp1"); /* and loop */
225 000135D9 71 effffffec0 jmp _pipe13_lp1
226 000135DF # };
227 000135DF L413:
228 000135DF # }
229 000135DF 40 ret#2
230 000135E0 .set L398,0x0
231 000135E0 L400:
232 000135E0 13 ff64 jbr L401
233 000135E3 .data
234 00000468 * .text
235 000135E3 00 .align 1
236 000135E4 .globl _bad_pipe13_result
237 000135E4 _bad_pipe13_result:
238 000135E4 0000 .word L414
239 000135E6 #
240 000135E6 #
241 000135E6 #
242 000135E6 #
243 000135E6 # /****************************************************************************
244 000135E6 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
245 000135E6 # *
246 000135E6 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
247 000135E6 # * inst = LDF op1, CVFL op2, NEGF (integer overflow fault on the CVDF)
248 000135E6 # * The NEGF instruction should not be executed.
249 000135E6 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx
250 000135E6 # ****************************************************************************/
251 000135E6 # bad_pipe13_result()
252 000135E6 # {
253 000135E6 13 00a6 jbr L416
254 000135E9 L417:
255 000135E9 # errcnt++; /* bump the error count */
256 000135E9 6d effffffe15 incl _errcnt
257 000135EF # if ( prt_error )
258 000135EF 5d effffffe0f tstl _prt_error
259 000135F5 31 71 jeql L418
260 000135F7 # {
261 000135F7 # print_pipe13_er( ". Bad final Accumulator" );
262 000135F7 .data 1
263 000004a6 * L419:
264 000004a6 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
16363756D756C61746F7200
265 000004be * .text
266 000135F7 dd 8f000004a6 pushl $L419
267 000135FD fe 08 ef0000015a callf $8,_print_pipe13_er
268 00013604 # writes(
269 00013604 # "The NEGF instruction should not be executed\n");
270 00013604 .data 1
271 000004be * L420:
272 000004be * 546865204E45474620696E737 .ascii "The NEGF instruction should not be executed\12\0"
472756374696F6E2073686F75
6C64206E6F742062652065786
563757465640A00
273 000004eb * .text
274 00013604 dd 8f000004be pushl $L420
275 0001360A fe 08 effffffdf3 callf $8,_writes
276 00013611 # writes("op1 = ");
277 00013611 .data 1
278 000004eb * L421:
279 000004eb * 6F7031203D2000 .ascii "op1 = \0"
280 000004f2 * .text
281 00013611 dd 8f000004eb pushl $L421
282 00013617 fe 08 effffffde6 callf $8,_writes
283 0001361E # write32h( dbl_ld_acc.m );
284 0001361E dd effffffde0 pushl _dbl_ld_acc
285 00013624 fe 08 effffffdd9 callf $8,_write32h
286 0001362B # writes(", final Acc. = ");
287 0001362B .data 1
288 000004f2 * L422:
289 000004f2 * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
E203D2000
290 00000503 * .text
291 0001362B dd 8f000004f2 pushl $L422
292 00013631 fe 08 effffffdcc callf $8,_writes
293 00013638 # write32h( post_evt_acc.m );
294 00013638 dd effffffdc6 pushl _post_evt_acc
295 0001363E fe 08 effffffdbf callf $8,_write32h
296 00013645 # writes(", expected = ");
297 00013645 .data 1
298 00000503 * L423:
299 00000503 * 2C20206578706563746564203 .ascii ", expected = \0"
D2000
300 00000512 * .text
301 00013645 dd 8f00000503 pushl $L423
302 0001364B fe 08 effffffdb2 callf $8,_writes
303 00013652 # write32h( dbl_expected.m ); /* expected = initial data */
304 00013652 dd effffffdac pushl _dbl_expected
305 00013658 fe 08 effffffda5 callf $8,_write32h
306 0001365F # writec('\n');
307 0001365F dd 0a pushl $10
308 00013661 fe 08 effffffd9c callf $8,_writec
309 00013668 # }
310 00013668 # if ( halt_flg ) /* halt on error? */
311 00013668 L418:
312 00013668 5d effffffd96 tstl _halt_flg
313 0001366E 31 09 jeql L424
314 00013670 # pipe13_halt( 2 ); /* halt with a code of 2 */
315 00013670 dd 02 pushl $2
316 00013672 fe 08 ef00000183 callf $8,_pipe13_halt
317 00013679 # if ( loop_on_err )
318 00013679 L424:
319 00013679 5d effffffd85 tstl _loop_on_err
320 0001367F 31 0d jeql L425
321 00013681 # {
322 00013681 # force_loop = TRUE; /* set the force loop flag */
323 00013681 0d 01 effffffd7c movl $1,_force_loop
324 00013688 # asm("jmp _pipe13_lp1"); /* and loop */
325 00013688 71 effffffe11 jmp _pipe13_lp1
326 0001368E # };
327 0001368E L425:
328 0001368E # }
329 0001368E 40 ret#2
330 0001368F .set L414,0x0
331 0001368F L416:
332 0001368F 13 ff57 jbr L417
333 00013692 .data
334 00000468 * .text
335 00013692 .align 1
336 00013692 .globl _pipe13_queue_er
337 00013692 _pipe13_queue_er:
338 00013692 0000 .word L426
339 00013694 #
340 00013694 #
341 00013694 #
342 00013694 #
343 00013694 #
344 00013694 # /****************************************************************************
345 00013694 # * Report an "FPP queue not cleared" message
346 00013694 # *
347 00013694 # * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx
348 00013694 # * inst = LDF op1, CVFL op2, NEGF (integer overflow fault on the CVDF)
349 00013694 # * The NEGF instruction was apparently executed.
350 00013694 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx
351 00013694 # * op2 = xxxxxxxx, expected = xxxxxxxx
352 00013694 # ****************************************************************************/
353 00013694 # pipe13_queue_er()
354 00013694 # {
355 00013694 13 00c3 jbr L428
356 00013697 L429:
357 00013697 # errcnt++; /* bump the error count */
358 00013697 6d effffffd67 incl _errcnt
359 0001369D # if ( prt_error )
360 0001369D 5d effffffd61 tstl _prt_error
361 000136A3 21 03 13 008b jeql L430
362 000136A8 # {
363 000136A8 # print_pipe13_er( ". Fpp queue not cleared" );
364 000136A8 .data 1
365 00000512 * L431:
366 00000512 * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0"
E6F7420636C656172656400
367 0000052a * .text
368 000136A8 dd 8f00000512 pushl $L431
369 000136AE fe 08 ef000000a9 callf $8,_print_pipe13_er
370 000136B5 # writes(
371 000136B5 # "The NEGF instruction was apparently executed.\n");
372 000136B5 .data 1
373 0000052a * L432:
374 0000052a * 546865204E45474620696E737 .ascii "The NEGF instruction was apparently executed.\12\0"
472756374696F6E2077617320
6170706172656E746C7920657
86563757465642E0A00
375 00000559 * .text
376 000136B5 dd 8f0000052a pushl $L432
377 000136BB fe 08 effffffd42 callf $8,_writes
378 000136C2 # writes("op1 = ");
379 000136C2 .data 1
380 00000559 * L433:
381 00000559 * 6F7031203D2000 .ascii "op1 = \0"
382 00000560 * .text
383 000136C2 dd 8f00000559 pushl $L433
384 000136C8 fe 08 effffffd35 callf $8,_writes
385 000136CF # write32h( dbl_ld_acc.m );
386 000136CF dd effffffd2f pushl _dbl_ld_acc
387 000136D5 fe 08 effffffd28 callf $8,_write32h
388 000136DC # writes(", final Acc. = ");
389 000136DC .data 1
390 00000560 * L434:
391 00000560 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
32E203D2000
392 00000572 * .text
393 000136DC dd 8f00000560 pushl $L434
394 000136E2 fe 08 effffffd1b callf $8,_writes
395 000136E9 # write32h( post_evt_acc.m );
396 000136E9 dd effffffd15 pushl _post_evt_acc
397 000136EF fe 08 effffffd0e callf $8,_write32h
398 000136F6 # writes("\nop2 = ");
399 000136F6 .data 1
400 00000572 * L435:
401 00000572 * 0A6F7032203D2000 .ascii "\12op2 = \0"
402 0000057a * .text
403 000136F6 dd 8f00000572 pushl $L435
404 000136FC fe 08 effffffd01 callf $8,_writes
405 00013703 # write32h( dbl_value_1.m );
406 00013703 dd effffffcfb pushl _dbl_value_1
407 00013709 fe 08 effffffcf4 callf $8,_write32h
408 00013710 # writes(", expected = ");
409 00013710 .data 1
410 0000057a * L436:
411 0000057a * 2C20202020206578706563746 .ascii ", expected = \0"
564203D2000
412 0000058c * .text
413 00013710 dd 8f0000057a pushl $L436
414 00013716 fe 08 effffffce7 callf $8,_writes
415 0001371D # write32h( dbl_expected.m ); /* expected = initial data */
416 0001371D dd effffffce1 pushl _dbl_expected
417 00013723 fe 08 effffffcda callf $8,_write32h
418 0001372A # writec('\n');
419 0001372A dd 0a pushl $10
420 0001372C fe 08 effffffcd1 callf $8,_writec
421 00013733 # }
422 00013733 # if ( halt_flg ) /* halt on error? */
423 00013733 L430:
424 00013733 5d effffffccb tstl _halt_flg
425 00013739 31 09 jeql L437
426 0001373B # pipe13_halt( 3 ); /* halt with a code of 3 */
427 0001373B dd 03 pushl $3
428 0001373D fe 08 ef000000b8 callf $8,_pipe13_halt
429 00013744 # if ( loop_on_err )
430 00013744 L437:
431 00013744 5d effffffcba tstl _loop_on_err
432 0001374A 31 0d jeql L438
433 0001374C # {
434 0001374C # force_loop = TRUE; /* set the force loop flag */
435 0001374C 0d 01 effffffcb1 movl $1,_force_loop
436 00013753 # asm("jmp _pipe13_lp1"); /* and loop */
437 00013753 71 effffffd46 jmp _pipe13_lp1
438 00013759 # };
439 00013759 L438:
440 00013759 # }
441 00013759 40 ret#2
442 0001375A .set L426,0x0
443 0001375A L428:
444 0001375A 13 ff3a jbr L429
445 0001375D .data
446 00000468 * .text
447 0001375D 00 .align 1
448 0001375E .globl _print_pipe13_er
449 0001375E _print_pipe13_er:
450 0001375E 0000 .word L439
451 00013760 #
452 00013760 #
453 00013760 #
454 00013760 #
455 00013760 # /****************************************************************************
456 00013760 # * Report an error message of the form:
457 00013760 # *
458 00013760 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
459 00013760 # * inst = LDF op1, CVFL op2, NEGF (integer overflow fault on the CVDF)
460 00013760 # ****************************************************************************/
461 00013760 # print_pipe13_er( msg )
462 00013760 # char *msg; /* error message to print */
463 00013760 # {
464 00013760 13 0096 jbr L441
465 00013763 L442:
466 00013763 # if( errcnt == 1 ) /* 1st error? */
467 00013763 1d effffffc9b 01 cmpl _errcnt,$1
468 0001376A 21 0d jneq L443
469 0001376C # writes(" \n"); /* start a new print line */
470 0001376C .data 1
471 0000058c * L444:
472 0000058c * 200A00 .ascii " \12\0"
473 0000058f * .text
474 0001376C dd 8f0000058c pushl $L444
475 00013772 fe 08 effffffc8b callf $8,_writes
476 00013779 # writes("Cycle: ");
477 00013779 L443:
478 00013779 .data 1
479 0000058f * L445:
480 0000058f * 4379636C653A2000 .ascii "Cycle: \0"
481 00000597 * .text
482 00013779 dd 8f0000058f pushl $L445
483 0001377F fe 08 effffffc7e callf $8,_writes
484 00013786 # writed( cycle );
485 00013786 dd effffffc78 pushl _cycle
486 0001378C fe 08 effffffc71 callf $8,_writed
487 00013793 # writes(" EVT test ");
488 00013793 .data 1
489 00000597 * L447:
490 00000597 * 202045565420746573742000 .ascii " EVT test \0"
491 000005a3 * .text
492 00013793 dd 8f00000597 pushl $L447
493 00013799 fe 08 effffffc64 callf $8,_writes
494 000137A0 # writed( test_no );
495 000137A0 dd effffffc5e pushl _test_no
496 000137A6 fe 08 effffffc57 callf $8,_writed
497 000137AD # writes(". subtest ");
498 000137AD .data 1
499 000005a3 * L448:
500 000005a3 * 2E20737562746573742000 .ascii ". subtest \0"
501 000005ae * .text
502 000137AD dd 8f000005a3 pushl $L448
503 000137B3 fe 08 effffffc4a callf $8,_writes
504 000137BA # writed( subtest );
505 000137BA dd effffffc44 pushl _subtest
506 000137C0 fe 08 effffffc3d callf $8,_writed
507 000137C7 # writes( msg ); /* print the message */
508 000137C7 dd ad04 pushl 4(fp)
509 000137CA fe 08 effffffc33 callf $8,_writes
510 000137D1 # writes(" index = ");
511 000137D1 .data 1
512 000005ae * L449:
513 000005ae * 20696E646578203D2000 .ascii " index = \0"
514 000005b8 * .text
515 000137D1 dd 8f000005ae pushl $L449
516 000137D7 fe 08 effffffc26 callf $8,_writes
517 000137DE # writed( index );
518 000137DE dd effffffc20 pushl _index
519 000137E4 fe 08 effffffc19 callf $8,_writed
520 000137EB # writes(
521 000137EB # "\ninst = LDF op1, CVFL op2, NEGF (integer overflow fault on the CVDF)\n");
522 000137EB .data 1
523 000005b8 * L450:
524 000005b8 * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1, CVFL op2, NEGF (integer overflow fault on th"
F70312C204356464C206F7032
2C204E4547462020202028696
E7465676572206F766572666C
6F77206661756C74206F6E207
468
525 000005f8 * 652043564446290A00 .ascii "e CVDF)\12\0"
526 00000601 * .text
527 000137EB dd 8f000005b8 pushl $L450
528 000137F1 fe 08 effffffc0c callf $8,_writes
529 000137F8 # }
530 000137F8 40 ret#2
531 000137F9 .set L439,0x0
532 000137F9 L441:
533 000137F9 13 ff67 jbr L442
534 000137FC .data
535 00000468 * .text
536 000137FC .align 1
537 000137FC .globl _pipe13_halt
538 000137FC _pipe13_halt:
539 000137FC 0000 .word L451
540 000137FE #
541 000137FE #
542 000137FE #
543 000137FE # /****************************************************************************
544 000137FE # * halt on error routine
545 000137FE # ****************************************************************************/
546 000137FE # pipe13_halt( code )
547 000137FE # int code; /* error code to halt with */
548 000137FE # {
549 000137FE 11 6a jbr L453
550 00013800 L454:
551 00013800 # err_code = code;
552 00013800 0d ad04 effffffbfc movl 4(fp),_err_code
553 00013808 # sgl_value_1 = dbl_ld_acc.m;
554 00013808 0d effffffbf6 effffffbf1 movl _dbl_ld_acc,_sgl_value_1
555 00013813 # sgl_value_2 = post_evt_acc.m;
556 00013813 0d effffffbeb effffffbe6 movl _post_evt_acc,_sgl_value_2
557 0001381E # sgl_value_3 = dbl_value_1.m;
558 0001381E 0d effffffbe0 effffffbdb movl _dbl_value_1,_sgl_value_3
559 00013829 # asm("movl _test_no,r0"); /* r0 = test number */
560 00013829 0d effffffbd5 50 movl _test_no,r0
561 00013830 # asm("movl _subtest,r1"); /* r1 = subtest number */
562 00013830 0d effffffbce 51 movl _subtest,r1
563 00013837 # asm("movl _err_code,r2"); /* r2 = error code */
564 00013837 0d effffffbc7 52 movl _err_code,r2
565 0001383E # asm("movl _cycle,r3"); /* r3 = cycle count */
566 0001383E 0d effffffbc0 53 movl _cycle,r3
567 00013845 # asm("movl _sgl_value_1,r4"); /* r4 = initial Acc. */
568 00013845 0d effffffbb9 54 movl _sgl_value_1,r4
569 0001384C # asm("movl _sgl_value_2,r5"); /* r5 = post event Acc. */
570 0001384C 0d effffffbb2 55 movl _sgl_value_2,r5
571 00013853 # asm("movl _sgl_value_3,r6"); /* r6 = integer stored */
572 00013853 0d effffffbab 56 movl _sgl_value_3,r6
573 0001385A # asm("movl _sgl_value_4,r7"); /* r7 = expected Acc. */
574 0001385A 0d effffffba4 57 movl _sgl_value_4,r7
575 00013861 # asm("movl _index,r8"); /* r8 = data index */
576 00013861 0d effffffb9d 58 movl _index,r8
577 00013868 # asm("halt"); /* HALT ... */
578 00013868 00 halt
579 00013869 # }
580 00013869 40 ret#2
581 0001386A .set L451,0x0
582 0001386A L453:
583 0001386A 11 94 jbr L454
584 00000468 * .data
584 00000468 * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.