![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe10.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 pipe10.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 00000560 * .text
4 00000000 .align 1
5 00000000 .globl _pipe10
6 00000000 _pipe10:
7 00012514 0000 .word L381
8 00012516 #
9 00012516 # #include "evt_defs.h"
10 00012516 #
11 00012516 # /*
12 00012516 # *********************************************************************
13 00012516 # * FPP PIPELINED EVENTS TEST #10
14 00012516 # *
15 00012516 # * This test will execute the following code: "LDD MULD CVLF $2"
16 00012516 # * with an underflow fault on the MULD. We will make sure that:
17 00012516 # * 1. The fault is detected, and
18 00012516 # * 2. the convert instruction is not executed.
19 00012516 # *********************************************************************
20 00012516 # */
21 00012516 # pipe10()
22 00012516 # {
23 00012516 13 0129 jbr L383
24 00012519 L384:
25 00012519 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
26 00012519 ed 6d effffffff4 moval (r13),_pre_event_fp
27 00012520 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
28 00012520 ed 6e efffffffed moval (r14),_pre_event_sp
29 00012527 # precision = DBL;
30 00012527 0d 02 efffffffe6 movl $2,_precision
31 0001252E # test_event = ARITH_CODE; /* expect an arithmetic fault */
32 0001252E 0d 34 efffffffdf movl $52,_test_event
33 00012535 # exp_code = FLT_UNDFL_CODE; /* - specificly underflow */
34 00012535 0d 05 efffffffd8 movl $5,_exp_code
35 0001253C # exp_event = FALSE; /* ... but not yet */
36 0001253C 4d efffffffd2 clrl _exp_event
37 00012542 # asm("movab _pipe10_ret,_event_return"); /* set event return address */
38 00012542 e9 ef000000a7 efffffffc7 movab _pipe10_ret,_event_return
39 0001254D # max_index = mud_u_cnt; /* set max operand index */
40 0001254D 0d efffffffc1 efffffffbc movl _mud_u_cnt,_max_index
41 00012558 # for( index = 0; index < max_index; index++ )
42 00012558 4d efffffffb6 clrl _index
43 0001255E L387:
44 0001255E 1d efffffffb0 efffffffab cmpl _index,_max_index
45 00012569 91 03 13 00d3 jgeq L386
46 0001256E # {
47 0001256E # dbl_ld_acc = mud_u_dat[index].op_1; /* get the Acc data */
48 0001256E 48 04 efffffff9f 50 shll $4,_index,r0
49 00012576 0c 8f00000000 50 addl2 $_mud_u_dat,r0
50 0001257D 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4
51 00012585 0d 60 efffffff88 movl (r0),_dbl_ld_acc
52 0001258C # dbl_value_1 = mud_u_dat[index].op_2; /* get the B operand */
53 0001258C 48 04 efffffff81 50 shll $4,_index,r0
54 00012594 0c 8f00000008 50 addl2 $_mud_u_dat+8,r0
55 0001259B 0d a004 efffffff75 movl 4(r0),_dbl_value_1+4
56 000125A3 0d 60 efffffff6a movl (r0),_dbl_value_1
57 000125AA # asm("bispsw $0x60"); /* enable ovfl&undfl */
58 000125AA 8b 8860 bispsw $0x60
59 000125AD # asm(".globl _pipe10_lp1");
60 000125AD .globl _pipe10_lp1
61 000125AD # asm("_pipe10_lp1:");
62 000125AD _pipe10_lp1:
63 000125AD # asm("ldd _dbl_ld_acc"); /* load the Acc. */
64 000125AD 07 efffffff61 ldd _dbl_ld_acc
65 000125B3 # exp_event = test_event; /* expect event soon */
66 000125B3 0d efffffff5b efffffff56 movl _test_event,_exp_event
67 000125BE # asm("muld _dbl_value_1"); /* trigger the event */
68 000125BE e7 efffffff50 muld _dbl_value_1
69 000125C4 # asm("cvlf $2"); /* shouldn't get here*/
70 000125C4 76 02 cvlf $2
71 000125C6 # /*
72 000125C6 # * If we got to here then there was no event
73 000125C6 # */
74 000125C6 # if( force_loop )
75 000125C6 5d efffffff48 tstl _force_loop
76 000125CC 31 03 jeql L388
77 000125CE # asm("brw _pipe10_lp1");; /* loop on the error */
Assemb00029CD4 # asm("brw _pipe10_lp1");; /* loop on the error */
"pipe100012514 e 78: WARNING: brw: destination label is external
78 000125CE 13 ffdc brw _pipe10_lp1
79 000125D1 L388:
80 000125D1 # exp_event = FALSE; /* reset event expected flag */
81 000125D1 4d efffffff3d clrl _exp_event
82 000125D7 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
83 000125D7 0d efffffff37 5d movl _pre_event_fp,fp
84 000125DE # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
85 000125DE 0d efffffff30 5e movl _pre_event_sp,sp
86 000125E5 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
87 000125E5 9b 8860 bicpsw $0x60
88 000125E8 # no_pipe10_evt();; /* report the error */
89 000125E8 fe 04 ef00000057 callf $4,_no_pipe10_evt
90 000125EF # /*
91 000125EF # * Come here after the event
92 000125EF # */
93 000125EF # asm(".globl _pipe10_ret");
94 000125EF .globl _pipe10_ret
95 000125EF # asm("_pipe10_ret:");
96 000125EF _pipe10_ret:
97 000125EF # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
98 000125EF 0d efffffff1f 5d movl _pre_event_fp,fp
99 000125F6 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
100 000125F6 0d efffffff18 5e movl _pre_event_sp,sp
101 000125FD # if( force_loop )
102 000125FD 5d efffffff11 tstl _force_loop
103 00012603 31 03 jeql L390
104 00012605 # asm("brw _pipe10_lp1");; /* loop on the error */
"pipe100012514 e 105: WARNING: brw: destination label is external
105 00012605 13 ffa5 brw _pipe10_lp1
106 00012608 L390:
107 00012608 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
108 00012608 9b 8860 bicpsw $0x60
109 0001260B # if( post_evt_acc.m == 0x41000000 ) /* is the Acc. = floating 2? */
110 0001260B 1d efffffff03 8f41000000 cmpl _post_evt_acc,$1090519040
111 00012616 21 09 jneq L391
112 00012618 # pipe10_queue_er(); /* queue not cleared error */
113 00012618 fe 04 ef000001f7 callf $4,_pipe10_queue_er
114 0001261F # else if( (post_evt_acc.m) || (post_evt_acc.l) ) /* is Acc = 0? */
115 0001261F 11 17 jbr L393
116 00012621 L391:
117 00012621 5d effffffeed tstl _post_evt_acc
118 00012627 21 08 jneq L9999
119 00012629 5d effffffee9 tstl _post_evt_acc+4
120 0001262F 31 07 jeql L394
121 00012631 L9999:
122 00012631 # bad_pipe10_result(); /* incorrect result error */
123 00012631 fe 04 ef000000c2 callf $4,_bad_pipe10_result
124 00012638 #
125 00012638 # }
126 00012638 L394:
127 00012638 L393:
128 00012638 L385:
129 00012638 6d effffffed6 incl _index
130 0001263E 13 ff1d jbr L387
131 00012641 L386:
132 00012641 # }
133 00012641 40 ret#2
134 00012642 .set L381,0x0
135 00012642 L383:
136 00012642 13 fed4 jbr L384
137 00012645 .data
138 00000560 * .text
139 00012645 00 .align 1
140 00012646 .globl _no_pipe10_evt
141 00012646 _no_pipe10_evt:
142 00012646 0000 .word L396
143 00012648 #
144 00012648 #
145 00012648 #
146 00012648 # /****************************************************************************
147 00012648 # * Report an "EVENT NOT DETECTED" error
148 00012648 # *
149 00012648 # * Cycle: xx. EVT test xx. subtest xx. index = xx. No underflow fault seen.
150 00012648 # * inst = LDD op1, MULD op2, CVLF '2' (underflow fault on the MULD)
151 00012648 # * op1 = xxxxxxxx xxxxxxxx, op2 = xxxxxxxx xxxxxxxx
152 00012648 # ****************************************************************************/
153 00012648 # no_pipe10_evt()
154 00012648 # {
155 00012648 13 00ab jbr L398
156 0001264B L399:
157 0001264B # errcnt++; /* bump the error count */
158 0001264B 6d effffffec3 incl _errcnt
159 00012651 # if ( prt_error )
160 00012651 5d effffffebd tstl _prt_error
161 00012657 31 76 jeql L400
162 00012659 # {
163 00012659 # print_pipe10_er( ". No underflow fault seen." );
164 00012659 .data 1
165 00000560 * L402:
166 00000560 * 2E204E6F20756E646572666C6 .ascii ". No underflow fault seen.\0"
F77206661756C74207365656E
2E00
167 0000057b * .text
168 00012659 dd 8f00000560 pushl $L402
169 0001265F fe 08 ef000002cc callf $8,_print_pipe10_er
170 00012666 # writes("op1 = ");
171 00012666 .data 1
172 0000057b * L404:
173 0000057b * 6F7031203D2000 .ascii "op1 = \0"
174 00000582 * .text
175 00012666 dd 8f0000057b pushl $L404
176 0001266C fe 08 effffffea1 callf $8,_writes
177 00012673 # write32h( dbl_ld_acc.m );
178 00012673 dd effffffe9b pushl _dbl_ld_acc
179 00012679 fe 08 effffffe94 callf $8,_write32h
180 00012680 # writec(' ');
181 00012680 dd 20 pushl $32
182 00012682 fe 08 effffffe8b callf $8,_writec
183 00012689 # write32h( dbl_ld_acc.l );
184 00012689 dd effffffe89 pushl _dbl_ld_acc+4
185 0001268F fe 08 effffffe7e callf $8,_write32h
186 00012696 # writes(", op2 = ");
187 00012696 .data 1
188 00000582 * L407:
189 00000582 * 2C2020206F7032203D2000 .ascii ", op2 = \0"
190 0000058d * .text
191 00012696 dd 8f00000582 pushl $L407
192 0001269C fe 08 effffffe71 callf $8,_writes
193 000126A3 # write32h( dbl_value_1.m );
194 000126A3 dd effffffe6b pushl _dbl_value_1
195 000126A9 fe 08 effffffe64 callf $8,_write32h
196 000126B0 # writec(' ');
197 000126B0 dd 20 pushl $32
198 000126B2 fe 08 effffffe5b callf $8,_writec
199 000126B9 # write32h( dbl_value_1.l );
200 000126B9 dd effffffe59 pushl _dbl_value_1+4
201 000126BF fe 08 effffffe4e callf $8,_write32h
202 000126C6 # writec('\n');
203 000126C6 dd 0a pushl $10
204 000126C8 fe 08 effffffe45 callf $8,_writec
205 000126CF # }
206 000126CF # if ( halt_flg ) /* halt on error? */
207 000126CF L400:
208 000126CF 5d effffffe3f tstl _halt_flg
209 000126D5 31 09 jeql L408
210 000126D7 # pipe10_halt( 1 ); /* halt with a code of 1 */
211 000126D7 dd 01 pushl $1
212 000126D9 fe 08 ef000002f0 callf $8,_pipe10_halt
213 000126E0 # if ( loop_on_err )
214 000126E0 L408:
215 000126E0 5d effffffe2e tstl _loop_on_err
216 000126E6 31 0d jeql L410
217 000126E8 # {
218 000126E8 # force_loop = TRUE; /* set the force loop flag */
219 000126E8 0d 01 effffffe25 movl $1,_force_loop
220 000126EF # asm("jmp _pipe10_lp1"); /* and loop */
221 000126EF 71 effffffeb8 jmp _pipe10_lp1
222 000126F5 # };
223 000126F5 L410:
224 000126F5 # }
225 000126F5 40 ret#2
226 000126F6 .set L396,0x0
227 000126F6 L398:
228 000126F6 13 ff52 jbr L399
229 000126F9 .data
230 00000560 * .text
231 000126F9 00 .align 1
232 000126FA .globl _bad_pipe10_result
233 000126FA _bad_pipe10_result:
234 000126FA 0000 .word L411
235 000126FC #
236 000126FC #
237 000126FC #
238 000126FC #
239 000126FC # /****************************************************************************
240 000126FC # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
241 000126FC # *
242 000126FC # * Cycle: xx. EVT test xx. subtest xx. index = xx. Bad final Accumulator.
243 000126FC # * inst = LDD op1, MULD op2, CVLF '2' (underflow fault on the MULD)
244 000126FC # * The 'Convert '2' to Floating Point' should not be executed.
245 000126FC # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
246 000126FC # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
247 000126FC # ****************************************************************************/
248 000126FC # bad_pipe10_result()
249 000126FC # {
250 000126FC 13 0113 jbr L413
251 000126FF L414:
252 000126FF # errcnt++; /* bump the error count */
253 000126FF 6d effffffe0f incl _errcnt
254 00012705 # if ( prt_error )
255 00012705 5d effffffe09 tstl _prt_error
256 0001270B 21 03 13 00db jeql L415
257 00012710 # {
258 00012710 # print_pipe10_er( ". Bad final Accumulator" );
259 00012710 .data 1
260 0000058d * L416:
261 0000058d * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
16363756D756C61746F7200
262 000005a5 * .text
263 00012710 dd 8f0000058d pushl $L416
264 00012716 fe 08 ef00000215 callf $8,_print_pipe10_er
265 0001271D # writes(
266 0001271D # "The 'Convert '2' to Floating Point' should not be executed\n");
267 0001271D .data 1
268 000005a5 * L417:
269 000005a5 * 5468652027436F6E766572742 .ascii "The 'Convert '2' to Floating Point' should not be executed\12\0"
027322720746F20466C6F6174
696E6720506F696E742720736
86F756C64206E6F7420626520
65786563757465640A00
270 000005e1 * .text
271 0001271D dd 8f000005a5 pushl $L417
272 00012723 fe 08 effffffdea callf $8,_writes
273 0001272A # writes("op1 = ");
274 0001272A .data 1
275 000005e1 * L418:
276 000005e1 * 6F7031203D2000 .ascii "op1 = \0"
277 000005e8 * .text
278 0001272A dd 8f000005e1 pushl $L418
279 00012730 fe 08 effffffddd callf $8,_writes
280 00012737 # write32h( dbl_ld_acc.m );
281 00012737 dd effffffdd7 pushl _dbl_ld_acc
282 0001273D fe 08 effffffdd0 callf $8,_write32h
283 00012744 # writec(' ');
284 00012744 dd 20 pushl $32
285 00012746 fe 08 effffffdc7 callf $8,_writec
286 0001274D # write32h( dbl_ld_acc.l );
287 0001274D dd effffffdc5 pushl _dbl_ld_acc+4
288 00012753 fe 08 effffffdba callf $8,_write32h
289 0001275A # writes(", final Acc. = ");
290 0001275A .data 1
291 000005e8 * L419:
292 000005e8 * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0"
03D2000
293 000005f8 * .text
294 0001275A dd 8f000005e8 pushl $L419
295 00012760 fe 08 effffffdad callf $8,_writes
296 00012767 # write32h( post_evt_acc.l );
297 00012767 dd effffffdab pushl _post_evt_acc+4
298 0001276D fe 08 effffffda0 callf $8,_write32h
299 00012774 # writec(' ');
300 00012774 dd 20 pushl $32
301 00012776 fe 08 effffffd97 callf $8,_writec
302 0001277D # write32h( post_evt_acc.l );
303 0001277D dd effffffd95 pushl _post_evt_acc+4
304 00012783 fe 08 effffffd8a callf $8,_write32h
305 0001278A # writes("\nop2 = ");
306 0001278A .data 1
307 000005f8 * L420:
308 000005f8 * 0A6F7032203D2000 .ascii "\12op2 = \0"
309 00000600 * .text
310 0001278A dd 8f000005f8 pushl $L420
311 00012790 fe 08 effffffd7d callf $8,_writes
312 00012797 # write32h( dbl_value_1.m );
313 00012797 dd effffffd77 pushl _dbl_value_1
314 0001279D fe 08 effffffd70 callf $8,_write32h
315 000127A4 # writec(' ');
316 000127A4 dd 20 pushl $32
317 000127A6 fe 08 effffffd67 callf $8,_writec
318 000127AD # write32h( dbl_value_1.l );
319 000127AD dd effffffd65 pushl _dbl_value_1+4
320 000127B3 fe 08 effffffd5a callf $8,_write32h
321 000127BA # writes(", expected = ");
322 000127BA .data 1
323 00000600 * L421:
324 00000600 * 2C20202065787065637465642 .ascii ", expected = \0"
03D2000
325 00000610 * .text
326 000127BA dd 8f00000600 pushl $L421
327 000127C0 fe 08 effffffd4d callf $8,_writes
328 000127C7 # write32h( 0 ); /* the expected result = 0 */
329 000127C7 dd 00 pushl $0
330 000127C9 fe 08 effffffd44 callf $8,_write32h
331 000127D0 # writec(' ');
332 000127D0 dd 20 pushl $32
333 000127D2 fe 08 effffffd3b callf $8,_writec
334 000127D9 # write32h( 0 );
335 000127D9 dd 00 pushl $0
336 000127DB fe 08 effffffd32 callf $8,_write32h
337 000127E2 # writec('\n');
338 000127E2 dd 0a pushl $10
339 000127E4 fe 08 effffffd29 callf $8,_writec
340 000127EB # }
341 000127EB # if ( halt_flg ) /* halt on error? */
342 000127EB L415:
343 000127EB 5d effffffd23 tstl _halt_flg
344 000127F1 31 09 jeql L422
345 000127F3 # pipe10_halt( 2 ); /* halt with a code of 2 */
346 000127F3 dd 02 pushl $2
347 000127F5 fe 08 ef000001d4 callf $8,_pipe10_halt
348 000127FC # if ( loop_on_err )
349 000127FC L422:
350 000127FC 5d effffffd12 tstl _loop_on_err
351 00012802 31 0d jeql L423
352 00012804 # {
353 00012804 # force_loop = TRUE; /* set the force loop flag */
354 00012804 0d 01 effffffd09 movl $1,_force_loop
355 0001280B # asm("jmp _pipe10_lp1"); /* and loop */
356 0001280B 71 effffffd9c jmp _pipe10_lp1
357 00012811 # };
358 00012811 L423:
359 00012811 # }
360 00012811 40 ret#2
361 00012812 .set L411,0x0
362 00012812 L413:
363 00012812 13 feea jbr L414
364 00012815 .data
365 00000560 * .text
366 00012815 00 .align 1
367 00012816 .globl _pipe10_queue_er
368 00012816 _pipe10_queue_er:
369 00012816 0000 .word L424
370 00012818 #
371 00012818 #
372 00012818 #
373 00012818 #
374 00012818 #
375 00012818 # /****************************************************************************
376 00012818 # * Report an "FPP queue not cleared" message
377 00012818 # *
378 00012818 # * Cycle: xx. EVT test xx. subtest xx. index = xx. Fpp queue not cleared.
379 00012818 # * inst = LDD op1, MULD op2, CVLF '2' (underflow fault on the MULD)
380 00012818 # * The 'Convert '2' to Floating Point' was apparently executed.
381 00012818 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
382 00012818 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
383 00012818 # ****************************************************************************/
384 00012818 # pipe10_queue_er()
385 00012818 # {
386 00012818 13 0113 jbr L426
387 0001281B L427:
388 0001281B # errcnt++; /* bump the error count */
389 0001281B 6d effffffcf3 incl _errcnt
390 00012821 # if ( prt_error )
391 00012821 5d effffffced tstl _prt_error
392 00012827 21 03 13 00db jeql L428
393 0001282C # {
394 0001282C # print_pipe10_er( ". Fpp queue not cleared" );
395 0001282C .data 1
396 00000610 * L429:
397 00000610 * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0"
E6F7420636C656172656400
398 00000628 * .text
399 0001282C dd 8f00000610 pushl $L429
400 00012832 fe 08 ef000000f9 callf $8,_print_pipe10_er
401 00012839 # writes(
402 00012839 # "The 'Convert '2' to Floating Point' was apparently executed.\n");
403 00012839 .data 1
404 00000628 * L430:
405 00000628 * 5468652027436F6E766572742 .ascii "The 'Convert '2' to Floating Point' was apparently executed.\12\0"
027322720746F20466C6F6174
696E6720506F696E742720776
173206170706172656E746C79
2065786563757465642E0A00
406 00000666 * .text
407 00012839 dd 8f00000628 pushl $L430
408 0001283F fe 08 effffffcce callf $8,_writes
409 00012846 # writes("op1 = ");
410 00012846 .data 1
411 00000666 * L431:
412 00000666 * 6F7031203D2000 .ascii "op1 = \0"
413 0000066d * .text
414 00012846 dd 8f00000666 pushl $L431
415 0001284C fe 08 effffffcc1 callf $8,_writes
416 00012853 # write32h( dbl_ld_acc.m );
417 00012853 dd effffffcbb pushl _dbl_ld_acc
418 00012859 fe 08 effffffcb4 callf $8,_write32h
419 00012860 # writec(' ');
420 00012860 dd 20 pushl $32
421 00012862 fe 08 effffffcab callf $8,_writec
422 00012869 # write32h( dbl_ld_acc.l );
423 00012869 dd effffffca9 pushl _dbl_ld_acc+4
424 0001286F fe 08 effffffc9e callf $8,_write32h
425 00012876 # writes(", final Acc. = ");
426 00012876 .data 1
427 0000066d * L432:
428 0000066d * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0"
03D2000
429 0000067d * .text
430 00012876 dd 8f0000066d pushl $L432
431 0001287C fe 08 effffffc91 callf $8,_writes
432 00012883 # write32h( post_evt_acc.m );
433 00012883 dd effffffc8b pushl _post_evt_acc
434 00012889 fe 08 effffffc84 callf $8,_write32h
435 00012890 # writec(' ');
436 00012890 dd 20 pushl $32
437 00012892 fe 08 effffffc7b callf $8,_writec
438 00012899 # write32h( post_evt_acc.l );
439 00012899 dd effffffc79 pushl _post_evt_acc+4
440 0001289F fe 08 effffffc6e callf $8,_write32h
441 000128A6 # writes("\nop2 = ");
442 000128A6 .data 1
443 0000067d * L433:
444 0000067d * 0A6F7032203D2000 .ascii "\12op2 = \0"
445 00000685 * .text
446 000128A6 dd 8f0000067d pushl $L433
447 000128AC fe 08 effffffc61 callf $8,_writes
448 000128B3 # write32h( dbl_value_1.m );
449 000128B3 dd effffffc5b pushl _dbl_value_1
450 000128B9 fe 08 effffffc54 callf $8,_write32h
451 000128C0 # writec(' ');
452 000128C0 dd 20 pushl $32
453 000128C2 fe 08 effffffc4b callf $8,_writec
454 000128C9 # write32h( dbl_value_1.l );
455 000128C9 dd effffffc49 pushl _dbl_value_1+4
456 000128CF fe 08 effffffc3e callf $8,_write32h
457 000128D6 # writes(", expected = ");
458 000128D6 .data 1
459 00000685 * L434:
460 00000685 * 2C20202065787065637465642 .ascii ", expected = \0"
03D2000
461 00000695 * .text
462 000128D6 dd 8f00000685 pushl $L434
463 000128DC fe 08 effffffc31 callf $8,_writes
464 000128E3 # write32h( 0 ); /* the expected result = 0 */
465 000128E3 dd 00 pushl $0
466 000128E5 fe 08 effffffc28 callf $8,_write32h
467 000128EC # writec(' ');
468 000128EC dd 20 pushl $32
469 000128EE fe 08 effffffc1f callf $8,_writec
470 000128F5 # write32h( 0 );
471 000128F5 dd 00 pushl $0
472 000128F7 fe 08 effffffc16 callf $8,_write32h
473 000128FE # writec('\n');
474 000128FE dd 0a pushl $10
475 00012900 fe 08 effffffc0d callf $8,_writec
476 00012907 # }
477 00012907 # if ( halt_flg ) /* halt on error? */
478 00012907 L428:
479 00012907 5d effffffc07 tstl _halt_flg
480 0001290D 31 09 jeql L435
481 0001290F # pipe10_halt( 3 ); /* halt with a code of 3 */
482 0001290F dd 03 pushl $3
483 00012911 fe 08 ef000000b8 callf $8,_pipe10_halt
484 00012918 # if ( loop_on_err )
485 00012918 L435:
486 00012918 5d effffffbf6 tstl _loop_on_err
487 0001291E 31 0d jeql L436
488 00012920 # {
489 00012920 # force_loop = TRUE; /* set the force loop flag */
490 00012920 0d 01 effffffbed movl $1,_force_loop
491 00012927 # asm("jmp _pipe10_lp1"); /* and loop */
492 00012927 71 effffffc80 jmp _pipe10_lp1
493 0001292D # };
494 0001292D L436:
495 0001292D # }
496 0001292D 40 ret#2
497 0001292E .set L424,0x0
498 0001292E L426:
499 0001292E 13 feea jbr L427
500 00012931 .data
501 00000560 * .text
502 00012931 00 .align 1
503 00012932 .globl _print_pipe10_er
504 00012932 _print_pipe10_er:
505 00012932 0000 .word L437
506 00012934 #
507 00012934 #
508 00012934 #
509 00012934 #
510 00012934 # /****************************************************************************
511 00012934 # * Report an error message of the form:
512 00012934 # *
513 00012934 # * Cycle: xx. EVT test xx. subtest xx. index = xx. <your message here>
514 00012934 # * inst = LDD op1, MULD op2, CVLF '2' (underflow fault on the MULD)
515 00012934 # ****************************************************************************/
516 00012934 # print_pipe10_er( msg )
517 00012934 # char *msg; /* error message to print */
518 00012934 # {
519 00012934 13 0096 jbr L439
520 00012937 L440:
521 00012937 # if( errcnt == 1 ) /* 1st error? */
522 00012937 1d effffffbd7 01 cmpl _errcnt,$1
523 0001293E 21 0d jneq L441
524 00012940 # writes(" \n"); /* start a new print line */
525 00012940 .data 1
526 00000695 * L442:
527 00000695 * 200A00 .ascii " \12\0"
528 00000698 * .text
529 00012940 dd 8f00000695 pushl $L442
530 00012946 fe 08 effffffbc7 callf $8,_writes
531 0001294D # writes("Cycle: ");
532 0001294D L441:
533 0001294D .data 1
534 00000698 * L443:
535 00000698 * 4379636C653A2000 .ascii "Cycle: \0"
536 000006a0 * .text
537 0001294D dd 8f00000698 pushl $L443
538 00012953 fe 08 effffffbba callf $8,_writes
539 0001295A # writed( cycle );
540 0001295A dd effffffbb4 pushl _cycle
541 00012960 fe 08 effffffbad callf $8,_writed
542 00012967 # writes(" EVT test ");
543 00012967 .data 1
544 000006a0 * L445:
545 000006a0 * 202045565420746573742000 .ascii " EVT test \0"
546 000006ac * .text
547 00012967 dd 8f000006a0 pushl $L445
548 0001296D fe 08 effffffba0 callf $8,_writes
549 00012974 # writed( test_no );
550 00012974 dd effffffb9a pushl _test_no
551 0001297A fe 08 effffffb93 callf $8,_writed
552 00012981 # writes(". subtest ");
553 00012981 .data 1
554 000006ac * L446:
555 000006ac * 2E20737562746573742000 .ascii ". subtest \0"
556 000006b7 * .text
557 00012981 dd 8f000006ac pushl $L446
558 00012987 fe 08 effffffb86 callf $8,_writes
559 0001298E # writed( subtest );
560 0001298E dd effffffb80 pushl _subtest
561 00012994 fe 08 effffffb79 callf $8,_writed
562 0001299B # writes(". index = ");
563 0001299B .data 1
564 000006b7 * L447:
565 000006b7 * 2E20696E646578203D2000 .ascii ". index = \0"
566 000006c2 * .text
567 0001299B dd 8f000006b7 pushl $L447
568 000129A1 fe 08 effffffb6c callf $8,_writes
569 000129A8 # writed( index );
570 000129A8 dd effffffb66 pushl _index
571 000129AE fe 08 effffffb5f callf $8,_writed
572 000129B5 # writes( msg ); /* print the message */
573 000129B5 dd ad04 pushl 4(fp)
574 000129B8 fe 08 effffffb55 callf $8,_writes
575 000129BF # writes(
576 000129BF # "\ninst = LDD op1, MULD op2, CVLF '2' (underflow fault on the MULD)\n");
577 000129BF .data 1
578 000006c2 * L448:
579 000006c2 * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1, MULD op2, CVLF '2' (underflow fault on the M"
F70312C204D554C44206F7032
2C2043564C462027322720202
02028756E646572666C6F7720
6661756C74206F6E207468652
04D
580 00000702 * 554C44290A00 .ascii "ULD)\12\0"
581 00000708 * .text
582 000129BF dd 8f000006c2 pushl $L448
583 000129C5 fe 08 effffffb48 callf $8,_writes
584 000129CC # }
585 000129CC 40 ret#2
586 000129CD .set L437,0x0
587 000129CD L439:
588 000129CD 13 ff67 jbr L440
589 000129D0 .data
590 00000560 * .text
591 000129D0 .align 1
592 000129D0 .globl _pipe10_halt
593 000129D0 _pipe10_halt:
594 000129D0 0000 .word L449
595 000129D2 #
596 000129D2 #
597 000129D2 #
598 000129D2 # /****************************************************************************
599 000129D2 # * halt on error routine
600 000129D2 # ****************************************************************************/
601 000129D2 # pipe10_halt( code )
602 000129D2 # int code; /* error code to halt with */
603 000129D2 # {
604 000129D2 13 009b jbr L451
605 000129D5 L452:
606 000129D5 # err_code = code;
607 000129D5 0d ad04 effffffb37 movl 4(fp),_err_code
608 000129DD # sgl_value_1 = dbl_ld_acc.m;
609 000129DD 0d effffffb31 effffffb2c movl _dbl_ld_acc,_sgl_value_1
610 000129E8 # sgl_value_2 = dbl_ld_acc.l;
611 000129E8 0d effffffb2a effffffb21 movl _dbl_ld_acc+4,_sgl_value_2
612 000129F3 # sgl_value_3 = dbl_value_1.m;
613 000129F3 0d effffffb1b effffffb16 movl _dbl_value_1,_sgl_value_3
614 000129FE # sgl_value_4 = dbl_value_1.l;
615 000129FE 0d effffffb14 effffffb0b movl _dbl_value_1+4,_sgl_value_4
616 00012A09 # sgl_value_5 = post_evt_acc.m;
617 00012A09 0d effffffb05 effffffb00 movl _post_evt_acc,_sgl_value_5
618 00012A14 # sgl_value_6 = post_evt_acc.l;
619 00012A14 0d effffffafe effffffaf5 movl _post_evt_acc+4,_sgl_value_6
620 00012A1F # asm("movl _test_no,r0"); /* r0 = test number */
621 00012A1F 0d effffffaef 50 movl _test_no,r0
622 00012A26 # asm("movl _subtest,r1"); /* r1 = subtest number */
623 00012A26 0d effffffae8 51 movl _subtest,r1
624 00012A2D # asm("movl _err_code,r2"); /* r2 = error code */
625 00012A2D 0d effffffae1 52 movl _err_code,r2
626 00012A34 # asm("movl _cycle,r3"); /* r3 = cycle count */
627 00012A34 0d effffffada 53 movl _cycle,r3
628 00012A3B # asm("movl _sgl_value_1,r4"); /* r4 = MSW of operand 1 */
629 00012A3B 0d effffffad3 54 movl _sgl_value_1,r4
630 00012A42 # asm("movl _sgl_value_2,r5"); /* r5 = LSW of operand 1 */
631 00012A42 0d effffffacc 55 movl _sgl_value_2,r5
632 00012A49 # asm("movl _sgl_value_3,r6"); /* r6 = MSW of operand 2 */
633 00012A49 0d effffffac5 56 movl _sgl_value_3,r6
634 00012A50 # asm("movl _sgl_value_4,r7"); /* r7 = LSW of operand 2 */
635 00012A50 0d effffffabe 57 movl _sgl_value_4,r7
636 00012A57 # asm("movl _sgl_value_5,r8"); /* r8 = MSW of final Acc. */
637 00012A57 0d effffffab7 58 movl _sgl_value_5,r8
638 00012A5E # asm("movl _sgl_value_6,r9"); /* r9 = LSW of final Acc. */
639 00012A5E 0d effffffab0 59 movl _sgl_value_6,r9
640 00012A65 # asm("clrl r10"); /* r10 = 0 (expected Acc.) */
641 00012A65 4d 5a clrl r10
642 00012A67 # asm("movl _index,r11"); /* r11 = data index */
643 00012A67 0d effffffaa7 5b movl _index,r11
644 00012A6E # asm("halt"); /* HALT ... */
645 00012A6E 00 halt
646 00012A6F # }
647 00012A6F 40 ret#2
648 00012A70 .set L449,0x0
649 00012A70 L451:
650 00012A70 13 ff62 jbr L452
651 00012A73 .data
651 00024F87 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.