![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe15.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 pipe15.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 0000050c * .text
4 00000000 .align 1
5 00000000 .globl _pipe15
6 00000000 _pipe15:
7 00013EF4 0000 .word L381
8 00013EF6 #
9 00013EF6 # #include "evt_defs.h"
10 00013EF6 #
11 00013EF6 # /*
12 00013EF6 # *********************************************************************
13 00013EF6 # * FPP PIPELINED EVENTS TEST #15
14 00013EF6 # *
15 00013EF6 # * This test will execute the following code: "LDF MULF STF"
16 00013EF6 # * with an overflow fault on the MULF. We will make sure that:
17 00013EF6 # * 1. The fault is detected,
18 00013EF6 # * 2. the accumulator is cleared, and
19 00013EF6 # * 3. a floating '0' is stored if anything.
20 00013EF6 # *********************************************************************
21 00013EF6 # */
22 00013EF6 # pipe15()
23 00013EF6 # {
24 00013EF6 13 014b jbr L383
25 00013EF9 L384:
26 00013EF9 # #define PIPE15_PAT 0x12341234
27 00013EF9 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
28 00013EF9 ed 6d effffffff4 moval (r13),_pre_event_fp
29 00013F00 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
30 00013F00 ed 6e efffffffed moval (r14),_pre_event_sp
31 00013F07 # precision = SGL;
32 00013F07 0d 01 efffffffe6 movl $1,_precision
33 00013F0E # test_event = ARITH_CODE; /* expect an arithmetic fault */
34 00013F0E 0d 34 efffffffdf movl $52,_test_event
35 00013F15 # exp_code = FLT_OVFL_CODE; /* - specificly overflow */
36 00013F15 0d 04 efffffffd8 movl $4,_exp_code
37 00013F1C # exp_event = FALSE; /* ... but not yet */
38 00013F1C 4d efffffffd2 clrl _exp_event
39 00013F22 # asm("movab _pipe15_ret,_event_return"); /* set event return address */
40 00013F22 e9 ef000000b9 efffffffc7 movab _pipe15_ret,_event_return
41 00013F2D # max_index = muf_ov_cnt; /* set max operand index */
42 00013F2D 0d efffffffc1 efffffffbc movl _muf_ov_cnt,_max_index
43 00013F38 # for( index = 0; index < max_index; index++ ) {
44 00013F38 4d efffffffb6 clrl _index
45 00013F3E L387:
46 00013F3E 1d efffffffb0 efffffffab cmpl _index,_max_index
47 00013F49 91 03 13 00f5 jgeq L386
48 00013F4E # dbl_ld_acc = muf_ov_dat[index].op_1; /* get the Acc data */
49 00013F4E 48 04 efffffff9f 50 shll $4,_index,r0
50 00013F56 0c 8f00000000 50 addl2 $_muf_ov_dat,r0
51 00013F5D 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4
52 00013F65 0d 60 efffffff88 movl (r0),_dbl_ld_acc
53 00013F6C # dbl_value_1 = muf_ov_dat[index].op_2; /* get the '0' data */
54 00013F6C 48 04 efffffff81 50 shll $4,_index,r0
55 00013F74 0c 8f00000008 50 addl2 $_muf_ov_dat+8,r0
56 00013F7B 0d a004 efffffff75 movl 4(r0),_dbl_value_1+4
57 00013F83 0d 60 efffffff6a movl (r0),_dbl_value_1
58 00013F8A # dbl_value_2.m = PIPE15_PAT; /* background for STF*/
59 00013F8A 0d 8f12341234 efffffff5f movl $305402420,_dbl_value_2
60 00013F95 # asm(".globl _pipe15_lp1");
61 00013F95 .globl _pipe15_lp1
62 00013F95 # asm("_pipe15_lp1:");
63 00013F95 _pipe15_lp1:
64 00013F95 # asm("bispsw $0x60"); /* enable ovfl & undfl events*/
65 00013F95 8b 8860 bispsw $0x60
66 00013F98 # asm("ldf _dbl_ld_acc"); /* load the Acc. */
67 00013F98 06 efffffff56 ldf _dbl_ld_acc
68 00013F9E # exp_event = test_event; /* set the expect event flag */
69 00013F9E 0d efffffff50 efffffff4b movl _test_event,_exp_event
70 00013FA9 # asm("mulf _dbl_value_1"); /* trigger the event */
71 00013FA9 e6 efffffff45 mulf _dbl_value_1
72 00013FAF # asm("stf _dbl_value_2"); /* FPP stores before the evt.*/
73 00013FAF 26 efffffff3f stf _dbl_value_2
74 00013FB5 # /*
75 00013FB5 # * If we got to here then there was no event
76 00013FB5 # */
77 00013FB5 # if( force_loop )
78 00013FB5 5d efffffff39 tstl _force_loop
79 00013FBB 31 06 jeql L388
80 00013FBD # asm("jmp _pipe15_lp1");; /* loop on the error */
81 00013FBD 71 efffffffd2 jmp _pipe15_lp1
82 00013FC3 L388:
83 00013FC3 # exp_event = FALSE; /* reset event expected flag */
84 00013FC3 4d efffffff2b clrl _exp_event
85 00013FC9 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
86 00013FC9 0d efffffff25 5d movl _pre_event_fp,fp
87 00013FD0 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
88 00013FD0 0d efffffff1e 5e movl _pre_event_sp,sp
89 00013FD7 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
90 00013FD7 9b 8860 bicpsw $0x60
91 00013FDA # no_pipe15_evt();; /* report the error */
92 00013FDA fe 04 ef00000067 callf $4,_no_pipe15_evt
93 00013FE1 # /*
94 00013FE1 # * Come here after the event
95 00013FE1 # */
96 00013FE1 # asm(".globl _pipe15_ret");
97 00013FE1 .globl _pipe15_ret
98 00013FE1 # asm("_pipe15_ret:");
99 00013FE1 _pipe15_ret:
100 00013FE1 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
101 00013FE1 0d efffffff0d 5d movl _pre_event_fp,fp
102 00013FE8 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
103 00013FE8 0d efffffff06 5e movl _pre_event_sp,sp
104 00013FEF # if( force_loop )
105 00013FEF 5d effffffeff tstl _force_loop
106 00013FF5 31 06 jeql L390
107 00013FF7 # asm("jmp _pipe15_lp1");; /* loop on the error */
108 00013FF7 71 efffffff98 jmp _pipe15_lp1
109 00013FFD L390:
110 00013FFD # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
111 00013FFD 9b 8860 bicpsw $0x60
112 00014000 # if( post_evt_acc.m ) /* was the Acc cleared? */
113 00014000 5d effffffeee tstl _post_evt_acc
114 00014006 31 09 jeql L391
115 00014008 # bad_pipe15_result(); /* incorrect result error */
116 00014008 fe 04 ef000000f5 callf $4,_bad_pipe15_result
117 0001400F # else if( (dbl_value_2.m ) && /* either a ZERO s/b stored, */
118 0001400F 11 29 jbr L393
119 00014011 L391:
120 00014011 # (dbl_value_2.m != 0x80000000) && /* or a RESERVED OP, */
121 00014011 # (dbl_value_2.m != PIPE15_PAT) ) /* or no store at all */
122 00014011 5d effffffedd tstl _dbl_value_2
123 00014017 31 21 jeql L394
124 00014019 1d effffffed5 8f80000000 cmpl _dbl_value_2,$-2147483648
125 00014024 31 14 jeql L394
126 00014026 1d effffffec8 8f12341234 cmpl _dbl_value_2,$305402420
127 00014031 31 07 jeql L394
128 00014033 # bad_pipe15_store(); /* incorrect store error */
129 00014033 fe 04 ef000001b8 callf $4,_bad_pipe15_store
130 0001403A # }
131 0001403A L394:
132 0001403A L393:
133 0001403A L385:
134 0001403A 6d effffffeb4 incl _index
135 00014040 13 fefb jbr L387
136 00014043 L386:
137 00014043 # }
138 00014043 40 ret#2
139 00014044 .set L381,0x0
140 00014044 L383:
141 00014044 13 feb2 jbr L384
142 00014047 .data
143 0000050c * .text
144 00014047 00 .align 1
145 00014048 .globl _no_pipe15_evt
146 00014048 _no_pipe15_evt:
147 00014048 0000 .word L396
148 0001404A #
149 0001404A #
150 0001404A #
151 0001404A # /****************************************************************************
152 0001404A # * Report an "EVENT NOT DETECTED" error
153 0001404A # *
154 0001404A # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx
155 0001404A # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF)
156 0001404A # * op1 = xxxxxxxx, op2 = xxxxxxxx, init op3 = xxxxxxxx, final op3 = xxxxxxxx
157 0001404A # ****************************************************************************/
158 0001404A # no_pipe15_evt()
159 0001404A # {
160 0001404A 13 00b3 jbr L398
161 0001404D L399:
162 0001404D # errcnt++; /* bump the error count */
163 0001404D 6d effffffea1 incl _errcnt
164 00014053 # if ( prt_error )
165 00014053 5d effffffe9b tstl _prt_error
166 00014059 31 7e jeql L400
167 0001405B # {
168 0001405B # print_pipe15_er( ". No overflow fault seen" );
169 0001405B .data 1
170 0000050c * L402:
171 0000050c * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen\0"
7206661756C74207365656E00
172 00000525 * .text
173 0001405B dd 8f0000050c pushl $L402
174 00014061 fe 08 ef00000266 callf $8,_print_pipe15_er
175 00014068 # writes("op1 = ");
176 00014068 .data 1
177 00000525 * L404:
178 00000525 * 6F7031203D2000 .ascii "op1 = \0"
179 0000052c * .text
180 00014068 dd 8f00000525 pushl $L404
181 0001406E fe 08 effffffe7f callf $8,_writes
182 00014075 # write32h( dbl_ld_acc.m );
183 00014075 dd effffffe79 pushl _dbl_ld_acc
184 0001407B fe 08 effffffe72 callf $8,_write32h
185 00014082 # writes(", op2 = ");
186 00014082 .data 1
187 0000052c * L406:
188 0000052c * 2C20206F7032203D2000 .ascii ", op2 = \0"
189 00000536 * .text
190 00014082 dd 8f0000052c pushl $L406
191 00014088 fe 08 effffffe65 callf $8,_writes
192 0001408F # write32h( dbl_value_1.m );
193 0001408F dd effffffe5f pushl _dbl_value_1
194 00014095 fe 08 effffffe58 callf $8,_write32h
195 0001409C # writes(", init op3 = ");
196 0001409C .data 1
197 00000536 * L407:
198 00000536 * 2C2020696E6974206F7033203 .ascii ", init op3 = \0"
D2000
199 00000545 * .text
200 0001409C dd 8f00000536 pushl $L407
201 000140A2 fe 08 effffffe4b callf $8,_writes
202 000140A9 # write32h( PIPE15_PAT );
203 000140A9 dd 8f12341234 pushl $305402420
204 000140AF fe 08 effffffe3e callf $8,_write32h
205 000140B6 # writes(", final op3 = ");
206 000140B6 .data 1
207 00000545 * L408:
208 00000545 * 2C202066696E616C206F70332 .ascii ", final op3 = \0"
03D2000
209 00000555 * .text
210 000140B6 dd 8f00000545 pushl $L408
211 000140BC fe 08 effffffe31 callf $8,_writes
212 000140C3 # write32h( dbl_value_2.m );
213 000140C3 dd effffffe2b pushl _dbl_value_2
214 000140C9 fe 08 effffffe24 callf $8,_write32h
215 000140D0 # writec('\n');
216 000140D0 dd 0a pushl $10
217 000140D2 fe 08 effffffe1b callf $8,_writec
218 000140D9 # }
219 000140D9 # if ( halt_flg ) /* halt on error? */
220 000140D9 L400:
221 000140D9 5d effffffe15 tstl _halt_flg
222 000140DF 31 09 jeql L410
223 000140E1 # pipe15_halt( 1 ); /* halt with a code of 1 */
224 000140E1 dd 01 pushl $1
225 000140E3 fe 08 ef00000282 callf $8,_pipe15_halt
226 000140EA # if ( loop_on_err )
227 000140EA L410:
228 000140EA 5d effffffe04 tstl _loop_on_err
229 000140F0 31 0d jeql L412
230 000140F2 # {
231 000140F2 # force_loop = TRUE; /* set the force loop flag */
232 000140F2 0d 01 effffffdfb movl $1,_force_loop
233 000140F9 # asm("jmp _pipe15_lp1"); /* and loop */
234 000140F9 71 effffffe96 jmp _pipe15_lp1
235 000140FF # };
236 000140FF L412:
237 000140FF # }
238 000140FF 40 ret#2
239 00014100 .set L396,0x0
240 00014100 L398:
241 00014100 13 ff4a jbr L399
242 00014103 .data
243 0000050c * .text
244 00014103 00 .align 1
245 00014104 .globl _bad_pipe15_result
246 00014104 _bad_pipe15_result:
247 00014104 0000 .word L413
248 00014106 #
249 00014106 #
250 00014106 #
251 00014106 #
252 00014106 # /****************************************************************************
253 00014106 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
254 00014106 # *
255 00014106 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
256 00014106 # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF)
257 00014106 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, initial op3 = xxxxxxxx
258 00014106 # * op2 = xxxxxxxx, expected = xxxxxxxx, final op3 = xxxxxxxx
259 00014106 # ****************************************************************************/
260 00014106 # bad_pipe15_result()
261 00014106 # {
262 00014106 13 00e6 jbr L415
263 00014109 L416:
264 00014109 # errcnt++; /* bump the error count */
265 00014109 6d effffffde5 incl _errcnt
266 0001410F # if ( prt_error )
267 0001410F 5d effffffddf tstl _prt_error
268 00014115 21 03 13 00ae jeql L417
269 0001411A # {
270 0001411A # print_pipe15_er( ". Bad final Accumulator" );
271 0001411A .data 1
272 00000555 * L418:
273 00000555 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
16363756D756C61746F7200
274 0000056d * .text
275 0001411A dd 8f00000555 pushl $L418
276 00014120 fe 08 ef000001a7 callf $8,_print_pipe15_er
277 00014127 # writes("op1 = ");
278 00014127 .data 1
279 0000056d * L419:
280 0000056d * 6F7031203D2000 .ascii "op1 = \0"
281 00000574 * .text
282 00014127 dd 8f0000056d pushl $L419
283 0001412D fe 08 effffffdc0 callf $8,_writes
284 00014134 # write32h( dbl_ld_acc.m );
285 00014134 dd effffffdba pushl _dbl_ld_acc
286 0001413A fe 08 effffffdb3 callf $8,_write32h
287 00014141 # writes(", final Acc. = ");
288 00014141 .data 1
289 00000574 * L420:
290 00000574 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
32E203D2000
291 00000586 * .text
292 00014141 dd 8f00000574 pushl $L420
293 00014147 fe 08 effffffda6 callf $8,_writes
294 0001414E # write32h( post_evt_acc.m );
295 0001414E dd effffffda0 pushl _post_evt_acc
296 00014154 fe 08 effffffd99 callf $8,_write32h
297 0001415B # writes(", initial op3 = ");
298 0001415B .data 1
299 00000586 * L421:
300 00000586 * 2C202020696E697469616C206 .ascii ", initial op3 = \0"
F703320203D2000
301 0000059a * .text
302 0001415B dd 8f00000586 pushl $L421
303 00014161 fe 08 effffffd8c callf $8,_writes
304 00014168 # write32h( PIPE15_PAT );
305 00014168 dd 8f12341234 pushl $305402420
306 0001416E fe 08 effffffd7f callf $8,_write32h
307 00014175 # writes("\nop2 = ");
308 00014175 .data 1
309 0000059a * L422:
310 0000059a * 0A6F7032203D2000 .ascii "\12op2 = \0"
311 000005a2 * .text
312 00014175 dd 8f0000059a pushl $L422
313 0001417B fe 08 effffffd72 callf $8,_writes
314 00014182 # write32h( dbl_value_1.m );
315 00014182 dd effffffd6c pushl _dbl_value_1
316 00014188 fe 08 effffffd65 callf $8,_write32h
317 0001418F # writes(", expected = ");
318 0001418F .data 1
319 000005a2 * L423:
320 000005a2 * 2C20202020206578706563746 .ascii ", expected = \0"
564203D2000
321 000005b4 * .text
322 0001418F dd 8f000005a2 pushl $L423
323 00014195 fe 08 effffffd58 callf $8,_writes
324 0001419C # write32h( 0 ); /* the expected result = 0 */
325 0001419C dd 00 pushl $0
326 0001419E fe 08 effffffd4f callf $8,_write32h
327 000141A5 # writes(", final op3 = ");
328 000141A5 .data 1
329 000005b4 * L424:
330 000005b4 * 2C202020202066696E616C206 .ascii ", final op3 = \0"
F703320203D2000
331 000005c8 * .text
332 000141A5 dd 8f000005b4 pushl $L424
333 000141AB fe 08 effffffd42 callf $8,_writes
334 000141B2 # write32h( dbl_value_2.m );
335 000141B2 dd effffffd3c pushl _dbl_value_2
336 000141B8 fe 08 effffffd35 callf $8,_write32h
337 000141BF # writec('\n');
338 000141BF dd 0a pushl $10
339 000141C1 fe 08 effffffd2c callf $8,_writec
340 000141C8 # }
341 000141C8 # if ( halt_flg ) /* halt on error? */
342 000141C8 L417:
343 000141C8 5d effffffd26 tstl _halt_flg
344 000141CE 31 09 jeql L425
345 000141D0 # pipe15_halt( 2 ); /* halt with a code of 2 */
346 000141D0 dd 02 pushl $2
347 000141D2 fe 08 ef00000193 callf $8,_pipe15_halt
348 000141D9 # if ( loop_on_err )
349 000141D9 L425:
350 000141D9 5d effffffd15 tstl _loop_on_err
351 000141DF 31 0d jeql L426
352 000141E1 # {
353 000141E1 # force_loop = TRUE; /* set the force loop flag */
354 000141E1 0d 01 effffffd0c movl $1,_force_loop
355 000141E8 # asm("jmp _pipe15_lp1"); /* and loop */
356 000141E8 71 effffffda7 jmp _pipe15_lp1
357 000141EE # };
358 000141EE L426:
359 000141EE # }
360 000141EE 40 ret#2
361 000141EF .set L413,0x0
362 000141EF L415:
363 000141EF 13 ff17 jbr L416
364 000141F2 .data
365 0000050c * .text
366 000141F2 .align 1
367 000141F2 .globl _bad_pipe15_store
368 000141F2 _bad_pipe15_store:
369 000141F2 0000 .word L427
370 000141F4 #
371 000141F4 #
372 000141F4 #
373 000141F4 #
374 000141F4 # /****************************************************************************
375 000141F4 # * Report a "BAD RESULT STORED AFTER THE EVENT" error
376 000141F4 # *
377 000141F4 # * Cycle: xx. EVT test xx. subtest xx. Bad STF OP3 result. index = xx
378 000141F4 # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF)
379 000141F4 # * op1 = xxxxxxxx, initial op3 = xxxxxxxx, final Acc. = xxxxxxxx
380 000141F4 # * op2 = xxxxxxxx, final op3 = xxxxxxxx, op3 expected = xxxxxxxx
381 000141F4 # ****************************************************************************/
382 000141F4 # bad_pipe15_store()
383 000141F4 # {
384 000141F4 13 00d4 jbr L429
385 000141F7 L430:
386 000141F7 # errcnt++; /* bump the error count */
387 000141F7 6d effffffcf7 incl _errcnt
388 000141FD # if ( prt_error )
389 000141FD 5d effffffcf1 tstl _prt_error
390 00014203 21 03 13 009c jeql L431
391 00014208 # {
392 00014208 # print_pipe15_er( ". Bad STF OP3 result" );
393 00014208 .data 1
394 000005c8 * L432:
395 000005c8 * 2E2042616420535446204F503 .ascii ". Bad STF OP3 result\0"
320726573756C7400
396 000005dd * .text
397 00014208 dd 8f000005c8 pushl $L432
398 0001420E fe 08 ef000000b9 callf $8,_print_pipe15_er
399 00014215 # writes("op1 = ");
400 00014215 .data 1
401 000005dd * L433:
402 000005dd * 6F7031203D2000 .ascii "op1 = \0"
403 000005e4 * .text
404 00014215 dd 8f000005dd pushl $L433
405 0001421B fe 08 effffffcd2 callf $8,_writes
406 00014222 # write32h( dbl_ld_acc.m );
407 00014222 dd effffffccc pushl _dbl_ld_acc
408 00014228 fe 08 effffffcc5 callf $8,_write32h
409 0001422F # writes(", initial op3 = ");
410 0001422F .data 1
411 000005e4 * L434:
412 000005e4 * 2C2020696E697469616C206F7 .ascii ", initial op3 = \0"
03320203D2000
413 000005f7 * .text
414 0001422F dd 8f000005e4 pushl $L434
415 00014235 fe 08 effffffcb8 callf $8,_writes
416 0001423C # write32h( PIPE15_PAT );
417 0001423C dd 8f12341234 pushl $305402420
418 00014242 fe 08 effffffcab callf $8,_write32h
419 00014249 # writes(", final Acc. = ");
420 00014249 .data 1
421 000005f7 * L435:
422 000005f7 * 2C2020202066696E616C20416 .ascii ", final Acc. = \0"
3632E203D2000
423 0000060a * .text
424 00014249 dd 8f000005f7 pushl $L435
425 0001424F fe 08 effffffc9e callf $8,_writes
426 00014256 # write32h( post_evt_acc.m );
427 00014256 dd effffffc98 pushl _post_evt_acc
428 0001425C fe 08 effffffc91 callf $8,_write32h
429 00014263 # writes("\nop2 = ");
430 00014263 .data 1
431 0000060a * L436:
432 0000060a * 0A6F7032203D2000 .ascii "\12op2 = \0"
433 00000612 * .text
434 00014263 dd 8f0000060a pushl $L436
435 00014269 fe 08 effffffc84 callf $8,_writes
436 00014270 # write32h( dbl_value_1.m );
437 00014270 dd effffffc7e pushl _dbl_value_1
438 00014276 fe 08 effffffc77 callf $8,_write32h
439 0001427D # writes(", final op3 = ");
440 0001427D .data 1
441 00000612 * L437:
442 00000612 * 2C2020202066696E616C206F7 .ascii ", final op3 = \0"
03320203D2000
443 00000625 * .text
444 0001427D dd 8f00000612 pushl $L437
445 00014283 fe 08 effffffc6a callf $8,_writes
446 0001428A # write32h( dbl_value_2.m );
447 0001428A dd effffffc64 pushl _dbl_value_2
448 00014290 fe 08 effffffc5d callf $8,_write32h
449 00014297 # writes(", op3 expected = 80000000\n"); /* exp = Reserved Op */
450 00014297 .data 1
451 00000625 * L438:
452 00000625 * 2C20206F70332065787065637 .ascii ", op3 expected = 80000000\12\0"
46564203D2038303030303030
300A00
453 00000641 * .text
454 00014297 dd 8f00000625 pushl $L438
455 0001429D fe 08 effffffc50 callf $8,_writes
456 000142A4 # }
457 000142A4 # if ( halt_flg ) /* halt on error? */
458 000142A4 L431:
459 000142A4 5d effffffc4a tstl _halt_flg
460 000142AA 31 09 jeql L439
461 000142AC # pipe15_halt( 3 ); /* halt with a code of 2 */
462 000142AC dd 03 pushl $3
463 000142AE fe 08 ef000000b7 callf $8,_pipe15_halt
464 000142B5 # if ( loop_on_err )
465 000142B5 L439:
466 000142B5 5d effffffc39 tstl _loop_on_err
467 000142BB 31 0d jeql L440
468 000142BD # {
469 000142BD # force_loop = TRUE; /* set the force loop flag */
470 000142BD 0d 01 effffffc30 movl $1,_force_loop
471 000142C4 # asm("jmp _pipe15_lp1"); /* and loop */
472 000142C4 71 effffffccb jmp _pipe15_lp1
473 000142CA # };
474 000142CA L440:
475 000142CA # }
476 000142CA 40 ret#2
477 000142CB .set L427,0x0
478 000142CB L429:
479 000142CB 13 ff29 jbr L430
480 000142CE .data
481 0000050c * .text
482 000142CE .align 1
483 000142CE .globl _print_pipe15_er
484 000142CE _print_pipe15_er:
485 000142CE 0000 .word L441
486 000142D0 #
487 000142D0 #
488 000142D0 #
489 000142D0 #
490 000142D0 #
491 000142D0 #
492 000142D0 # /****************************************************************************
493 000142D0 # * Report an error message of the form:
494 000142D0 # *
495 000142D0 # * Cycle: xx. EVT test xx. subtest xx. <your message here>. index = xx
496 000142D0 # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF)
497 000142D0 # ****************************************************************************/
498 000142D0 # print_pipe15_er( msg )
499 000142D0 # char *msg; /* error message to print */
500 000142D0 # {
501 000142D0 13 0096 jbr L443
502 000142D3 L444:
503 000142D3 # if( errcnt == 1 ) /* 1st error? */
504 000142D3 1d effffffc1b 01 cmpl _errcnt,$1
505 000142DA 21 0d jneq L445
506 000142DC # writes(" \n"); /* start a new print line */
507 000142DC .data 1
508 00000641 * L446:
509 00000641 * 200A00 .ascii " \12\0"
510 00000644 * .text
511 000142DC dd 8f00000641 pushl $L446
512 000142E2 fe 08 effffffc0b callf $8,_writes
513 000142E9 # writes("Cycle: ");
514 000142E9 L445:
515 000142E9 .data 1
516 00000644 * L447:
517 00000644 * 4379636C653A2000 .ascii "Cycle: \0"
518 0000064c * .text
519 000142E9 dd 8f00000644 pushl $L447
520 000142EF fe 08 effffffbfe callf $8,_writes
521 000142F6 # writed( cycle );
522 000142F6 dd effffffbf8 pushl _cycle
523 000142FC fe 08 effffffbf1 callf $8,_writed
524 00014303 # writes(" EVT test ");
525 00014303 .data 1
526 0000064c * L449:
527 0000064c * 202045565420746573742000 .ascii " EVT test \0"
528 00000658 * .text
529 00014303 dd 8f0000064c pushl $L449
530 00014309 fe 08 effffffbe4 callf $8,_writes
531 00014310 # writed( test_no );
532 00014310 dd effffffbde pushl _test_no
533 00014316 fe 08 effffffbd7 callf $8,_writed
534 0001431D # writes(". subtest ");
535 0001431D .data 1
536 00000658 * L450:
537 00000658 * 2E20737562746573742000 .ascii ". subtest \0"
538 00000663 * .text
539 0001431D dd 8f00000658 pushl $L450
540 00014323 fe 08 effffffbca callf $8,_writes
541 0001432A # writed( subtest );
542 0001432A dd effffffbc4 pushl _subtest
543 00014330 fe 08 effffffbbd callf $8,_writed
544 00014337 # writes( msg ); /* print the message */
545 00014337 dd ad04 pushl 4(fp)
546 0001433A fe 08 effffffbb3 callf $8,_writes
547 00014341 # writes(". index = ");
548 00014341 .data 1
549 00000663 * L451:
550 00000663 * 2E20696E646578203D2000 .ascii ". index = \0"
551 0000066e * .text
552 00014341 dd 8f00000663 pushl $L451
553 00014347 fe 08 effffffba6 callf $8,_writes
554 0001434E # writed( index );
555 0001434E dd effffffba0 pushl _index
556 00014354 fe 08 effffffb99 callf $8,_writed
557 0001435B # writes(
558 0001435B # "\ninst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF)\n");
559 0001435B .data 1
560 0000066e * L452:
561 0000066e * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1, MULF op2, STF op3 (overflow fault on the MUL"
F70312C204D554C46206F7032
2C20535446206F70332020202
0286F766572666C6F77206661
756C74206F6E20746865204D5
54C
562 000006ae * 46290A00 .ascii "F)\12\0"
563 000006b2 * .text
564 0001435B dd 8f0000066e pushl $L452
565 00014361 fe 08 effffffb8c callf $8,_writes
566 00014368 # }
567 00014368 40 ret#2
568 00014369 .set L441,0x0
569 00014369 L443:
570 00014369 13 ff67 jbr L444
571 0001436C .data
572 0000050c * .text
573 0001436C .align 1
574 0001436C .globl _pipe15_halt
575 0001436C _pipe15_halt:
576 0001436C 0000 .word L453
577 0001436E #
578 0001436E #
579 0001436E #
580 0001436E # /****************************************************************************
581 0001436E # * halt on error routine
582 0001436E # ****************************************************************************/
583 0001436E # pipe15_halt( code )
584 0001436E # int code; /* error code to halt with */
585 0001436E # {
586 0001436E 13 008b jbr L455
587 00014371 L456:
588 00014371 # err_code = code;
589 00014371 0d ad04 effffffb7b movl 4(fp),_err_code
590 00014379 # sgl_value_1 = dbl_ld_acc.m;
591 00014379 0d effffffb75 effffffb70 movl _dbl_ld_acc,_sgl_value_1
592 00014384 # sgl_value_2 = dbl_value_1.m;
593 00014384 0d effffffb6a effffffb65 movl _dbl_value_1,_sgl_value_2
594 0001438F # sgl_value_3 = post_evt_acc.m;
595 0001438F 0d effffffb5f effffffb5a movl _post_evt_acc,_sgl_value_3
596 0001439A # sgl_value_4 = PIPE15_PAT;
597 0001439A 0d 8f12341234 effffffb4f movl $305402420,_sgl_value_4
598 000143A5 # sgl_value_5 = dbl_value_2.m;
599 000143A5 0d effffffb49 effffffb44 movl _dbl_value_2,_sgl_value_5
600 000143B0 # asm("movl _test_no,r0"); /* r0 = test number */
601 000143B0 0d effffffb3e 50 movl _test_no,r0
602 000143B7 # asm("movl _subtest,r1"); /* r1 = subtest number */
603 000143B7 0d effffffb37 51 movl _subtest,r1
604 000143BE # asm("movl _err_code,r2"); /* r2 = error code */
605 000143BE 0d effffffb30 52 movl _err_code,r2
606 000143C5 # asm("movl _cycle,r3"); /* r3 = cycle count */
607 000143C5 0d effffffb29 53 movl _cycle,r3
608 000143CC # asm("movl _sgl_value_1,r4"); /* r4 = initial acc. */
609 000143CC 0d effffffb22 54 movl _sgl_value_1,r4
610 000143D3 # asm("movl _sgl_value_2,r5"); /* r5 = MULF operand */
611 000143D3 0d effffffb1b 55 movl _sgl_value_2,r5
612 000143DA # asm("movl _sgl_value_3,r6"); /* r6 = final acc. */
613 000143DA 0d effffffb14 56 movl _sgl_value_3,r6
614 000143E1 # asm("clrl r7"); /* r7 = expected acc. */
615 000143E1 4d 57 clrl r7
616 000143E3 # asm("movl _sgl_value_4,r8"); /* r8 = initial op3 value */
617 000143E3 0d effffffb0b 58 movl _sgl_value_4,r8
618 000143EA # asm("movl _sgl_value_5,r9"); /* r9 = final op3 value */
619 000143EA 0d effffffb04 59 movl _sgl_value_5,r9
620 000143F1 # asm("clrl r10"); /* r10 = expected op3 value */
621 000143F1 4d 5a clrl r10
622 000143F3 # asm("movl _index,r11"); /* r11 = data index */
623 000143F3 0d effffffafb 5b movl _index,r11
624 000143FA # asm("halt"); /* HALT ... */
625 000143FA 00 halt
626 000143FB # }
627 000143FB 40 ret#2
628 000143FC .set L453,0x0
629 000143FC L455:
630 000143FC 13 ff72 jbr L456
631 000143FF .data
631 000282F3 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.