![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe11.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 pipe11.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 0000048c * .text
4 00000000 .align 1
5 00000000 .globl _pipe11
6 00000000 _pipe11:
7 00012A74 0000 .word L381
8 00012A76 #
9 00012A76 #
10 00012A76 # #include "evt_defs.h"
11 00012A76 #
12 00012A76 # /*
13 00012A76 # *********************************************************************
14 00012A76 # * FPP PIPELINED EVENTS TEST #11
15 00012A76 # *
16 00012A76 # * This test will execute the following code: "LDF ADDF CVLF"
17 00012A76 # * with an overflow fault on the ADDF. We will make sure that:
18 00012A76 # * 1. The fault is detected, and
19 00012A76 # * 2. the Convert Longword Intger to SGL Floating instruction is not executed.
20 00012A76 # *********************************************************************
21 00012A76 # */
22 00012A76 # pipe11()
23 00012A76 # {
24 00012A76 13 012f jbr L383
25 00012A79 L384:
26 00012A79 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
27 00012A79 ed 6d effffffff4 moval (r13),_pre_event_fp
28 00012A80 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
29 00012A80 ed 6e efffffffed moval (r14),_pre_event_sp
30 00012A87 # precision = SGL;
31 00012A87 0d 01 efffffffe6 movl $1,_precision
32 00012A8E # test_event = ARITH_CODE; /* expect an arithmetic fault */
33 00012A8E 0d 34 efffffffdf movl $52,_test_event
34 00012A95 # exp_code = FLT_OVFL_CODE; /* - specificly overflow */
35 00012A95 0d 04 efffffffd8 movl $4,_exp_code
36 00012A9C # exp_event = FALSE; /* ... but not yet */
37 00012A9C 4d efffffffd2 clrl _exp_event
38 00012AA2 # asm("movab _pipe11_ret,_event_return"); /* set event return address */
39 00012AA2 e9 ef000000b5 efffffffc7 movab _pipe11_ret,_event_return
40 00012AAD # dbl_value_2.m = 24; /* set the CVLF data */
41 00012AAD 0d 18 efffffffc0 movl $24,_dbl_value_2
42 00012AB4 # max_index = adf_ov_cnt; /* set max operand index */
43 00012AB4 0d efffffffba efffffffb5 movl _adf_ov_cnt,_max_index
44 00012ABF # for( index = 0; index < max_index; index++ )
45 00012ABF 4d efffffffaf clrl _index
46 00012AC5 L387:
47 00012AC5 1d efffffffa9 efffffffa4 cmpl _index,_max_index
48 00012AD0 91 03 13 00d2 jgeq L386
49 00012AD5 # {
50 00012AD5 # dbl_ld_acc = adf_ov_dat[index].op_1; /* get the Acc data */
51 00012AD5 48 04 efffffff98 50 shll $4,_index,r0
52 00012ADD 0c 8f00000000 50 addl2 $_adf_ov_dat,r0
53 00012AE4 0d a004 efffffff8c movl 4(r0),_dbl_ld_acc+4
54 00012AEC 0d 60 efffffff81 movl (r0),_dbl_ld_acc
55 00012AF3 # dbl_value_1 = adf_ov_dat[index].op_2; /* get the '0' data */
56 00012AF3 48 04 efffffff7a 50 shll $4,_index,r0
57 00012AFB 0c 8f00000008 50 addl2 $_adf_ov_dat+8,r0
58 00012B02 0d a004 efffffff6e movl 4(r0),_dbl_value_1+4
59 00012B0A 0d 60 efffffff63 movl (r0),_dbl_value_1
60 00012B11 # asm(".globl _pipe11_lp1");
61 00012B11 .globl _pipe11_lp1
62 00012B11 # asm("_pipe11_lp1:");
63 00012B11 _pipe11_lp1:
64 00012B11 # asm("bispsw $0x60"); /* enable ovfl & undfl events*/
65 00012B11 8b 8860 bispsw $0x60
66 00012B14 # asm("movl _dbl_value_2,r4"); /* set the dummy load data */
67 00012B14 0d efffffff5a 54 movl _dbl_value_2,r4
68 00012B1B # asm("ldf _dbl_ld_acc"); /* load the Acc. */
69 00012B1B 06 efffffff53 ldf _dbl_ld_acc
70 00012B21 # exp_event = test_event; /* set the expect event flag */
71 00012B21 0d efffffff4d efffffff48 movl _test_event,_exp_event
72 00012B2C # asm("addf _dbl_value_1"); /* trigger the event */
73 00012B2C c6 efffffff42 addf _dbl_value_1
74 00012B32 # asm("cvlf r4"); /* we shouldn't get to here */
75 00012B32 76 54 cvlf r4
76 00012B34 # /*
77 00012B34 # * If we got to here then there was no event
78 00012B34 # */
79 00012B34 # if( force_loop )
80 00012B34 5d efffffff3a tstl _force_loop
81 00012B3A 31 03 jeql L388
82 00012B3C # asm("brw _pipe11_lp1");; /* loop on the error */
Assemb0002A234 # asm("brw _pipe11_lp1");; /* loop on the error */
"pipe100012A75 e 83: WARNING: brw: destination label is external
83 00012B3C 13 ffd2 brw _pipe11_lp1
84 00012B3F L388:
85 00012B3F # exp_event = FALSE; /* reset event expected flag */
86 00012B3F 4d efffffff2f clrl _exp_event
87 00012B45 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
88 00012B45 9b 8860 bicpsw $0x60
89 00012B48 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
90 00012B48 0d efffffff26 5d movl _pre_event_fp,fp
91 00012B4F # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
92 00012B4F 0d efffffff1f 5e movl _pre_event_sp,sp
93 00012B56 # no_pipe11_evt();; /* report the error */
94 00012B56 fe 04 ef0000004f callf $4,_no_pipe11_evt
95 00012B5D # /*
96 00012B5D # * Come here after the event
97 00012B5D # */
98 00012B5D # asm(".globl _pipe11_ret");
99 00012B5D .globl _pipe11_ret
100 00012B5D # asm("_pipe11_ret:");
101 00012B5D _pipe11_ret:
102 00012B5D # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
103 00012B5D 0d efffffff11 5d movl _pre_event_fp,fp
104 00012B64 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
105 00012B64 0d efffffff0a 5e movl _pre_event_sp,sp
106 00012B6B # if( force_loop )
107 00012B6B 5d efffffff03 tstl _force_loop
108 00012B71 31 03 jeql L390
109 00012B73 # asm("brw _pipe11_lp1");; /* loop on the error */
"pipe100012A75 e 110: WARNING: brw: destination label is external
110 00012B73 13 ff9b brw _pipe11_lp1
111 00012B76 L390:
112 00012B76 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
113 00012B76 9b 8860 bicpsw $0x60
114 00012B79 # if( post_evt_acc.m == 0x42c00000 ) /* Acc = CVLF data? ( 24.0 ) */
115 00012B79 1d effffffef5 8f42c00000 cmpl _post_evt_acc,$1119879168
116 00012B84 21 09 jneq L391
117 00012B86 # pipe11_queue_er(); /* yes it was -error! error! */
118 00012B86 fe 04 ef00000187 callf $4,_pipe11_queue_er
119 00012B8D # else if( post_evt_acc.m ) /* was the Acc cleared? */
120 00012B8D 11 0f jbr L393
121 00012B8F L391:
122 00012B8F 5d effffffedf tstl _post_evt_acc
123 00012B95 31 07 jeql L394
124 00012B97 # bad_pipe11_result(); /* incorrect result error */
125 00012B97 fe 04 ef00000094 callf $4,_bad_pipe11_result
126 00012B9E #
127 00012B9E # }
128 00012B9E L394:
129 00012B9E L393:
130 00012B9E L385:
131 00012B9E 6d effffffed0 incl _index
132 00012BA4 13 ff1e jbr L387
133 00012BA7 L386:
134 00012BA7 # }
135 00012BA7 40 ret#2
136 00012BA8 .set L381,0x0
137 00012BA8 L383:
138 00012BA8 13 fece jbr L384
139 00012BAB .data
140 0000048c * .text
141 00012BAB 00 .align 1
142 00012BAC .globl _no_pipe11_evt
143 00012BAC _no_pipe11_evt:
144 00012BAC 0000 .word L396
145 00012BAE #
146 00012BAE #
147 00012BAE #
148 00012BAE # /****************************************************************************
149 00012BAE # * Report an "EVENT NOT DETECTED" error
150 00012BAE # *
151 00012BAE # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx
152 00012BAE # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF)
153 00012BAE # * op1 = xxxxxxxx, op2 = xxxxxxxx
154 00012BAE # ****************************************************************************/
155 00012BAE # no_pipe11_evt()
156 00012BAE # {
157 00012BAE 11 7f jbr L398
158 00012BB0 L399:
159 00012BB0 # errcnt++; /* bump the error count */
160 00012BB0 6d effffffebe incl _errcnt
161 00012BB6 # if ( prt_error )
162 00012BB6 5d effffffeb8 tstl _prt_error
163 00012BBC 31 4a jeql L400
164 00012BBE # {
165 00012BBE # print_pipe11_er( ". No overflow fault seen" );
166 00012BBE .data 1
167 0000048c * L402:
168 0000048c * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen\0"
7206661756C74207365656E00
169 000004a5 * .text
170 00012BBE dd 8f0000048c pushl $L402
171 00012BC4 fe 08 ef0000022b callf $8,_print_pipe11_er
172 00012BCB # writes("op1 = ");
173 00012BCB .data 1
174 000004a5 * L404:
175 000004a5 * 6F7031203D2000 .ascii "op1 = \0"
176 000004ac * .text
177 00012BCB dd 8f000004a5 pushl $L404
178 00012BD1 fe 08 effffffe9c callf $8,_writes
179 00012BD8 # write32h( dbl_ld_acc.m );
180 00012BD8 dd effffffe96 pushl _dbl_ld_acc
181 00012BDE fe 08 effffffe8f callf $8,_write32h
182 00012BE5 # writes(", op2 = ");
183 00012BE5 .data 1
184 000004ac * L406:
185 000004ac * 2C2020206F7032203D2000 .ascii ", op2 = \0"
186 000004b7 * .text
187 00012BE5 dd 8f000004ac pushl $L406
188 00012BEB fe 08 effffffe82 callf $8,_writes
189 00012BF2 # write32h( dbl_value_1.m );
190 00012BF2 dd effffffe7c pushl _dbl_value_1
191 00012BF8 fe 08 effffffe75 callf $8,_write32h
192 00012BFF # writec('\n');
193 00012BFF dd 0a pushl $10
194 00012C01 fe 08 effffffe6c callf $8,_writec
195 00012C08 # }
196 00012C08 # if ( halt_flg ) /* halt on error? */
197 00012C08 L400:
198 00012C08 5d effffffe66 tstl _halt_flg
199 00012C0E 31 09 jeql L408
200 00012C10 # pipe11_halt( 1 ); /* halt with a code of 1 */
201 00012C10 dd 01 pushl $1
202 00012C12 fe 08 ef0000027b callf $8,_pipe11_halt
203 00012C19 # if ( loop_on_err )
204 00012C19 L408:
205 00012C19 5d effffffe55 tstl _loop_on_err
206 00012C1F 31 0d jeql L410
207 00012C21 # {
208 00012C21 # force_loop = TRUE; /* set the force loop flag */
209 00012C21 0d 01 effffffe4c movl $1,_force_loop
210 00012C28 # asm("jmp _pipe11_lp1"); /* and loop */
211 00012C28 71 effffffee3 jmp _pipe11_lp1
212 00012C2E # };
213 00012C2E L410:
214 00012C2E # }
215 00012C2E 40 ret#2
216 00012C2F .set L396,0x0
217 00012C2F L398:
218 00012C2F 13 ff7e jbr L399
219 00012C32 .data
220 0000048c * .text
221 00012C32 .align 1
222 00012C32 .globl _bad_pipe11_result
223 00012C32 _bad_pipe11_result:
224 00012C32 0000 .word L411
225 00012C34 #
226 00012C34 #
227 00012C34 #
228 00012C34 #
229 00012C34 # /****************************************************************************
230 00012C34 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
231 00012C34 # *
232 00012C34 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
233 00012C34 # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF)
234 00012C34 # * The CVLF should not be executed.
235 00012C34 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, op3 = xxxxxxxx
236 00012C34 # * op2 = xxxxxxxx, expected = xxxxxxxx
237 00012C34 # ****************************************************************************/
238 00012C34 # bad_pipe11_result()
239 00012C34 # {
240 00012C34 13 00d9 jbr L413
241 00012C37 L414:
242 00012C37 # errcnt++; /* bump the error count */
243 00012C37 6d effffffe37 incl _errcnt
244 00012C3D # if ( prt_error )
245 00012C3D 5d effffffe31 tstl _prt_error
246 00012C43 21 03 13 00a1 jeql L415
247 00012C48 # {
248 00012C48 # print_pipe11_er( ". Bad final Accumulator" );
249 00012C48 .data 1
250 000004b7 * L416:
251 000004b7 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
16363756D756C61746F7200
252 000004cf * .text
253 00012C48 dd 8f000004b7 pushl $L416
254 00012C4E fe 08 ef000001a1 callf $8,_print_pipe11_er
255 00012C55 # writes(
256 00012C55 # "The CVLF should not be executed\n");
257 00012C55 .data 1
258 000004cf * L417:
259 000004cf * 5468652043564C462073686F7 .ascii "The CVLF should not be executed\12\0"
56C64206E6F74206265206578
6563757465640A00
260 000004f0 * .text
261 00012C55 dd 8f000004cf pushl $L417
262 00012C5B fe 08 effffffe12 callf $8,_writes
263 00012C62 # writes("op1 = ");
264 00012C62 .data 1
265 000004f0 * L418:
266 000004f0 * 6F7031203D2000 .ascii "op1 = \0"
267 000004f7 * .text
268 00012C62 dd 8f000004f0 pushl $L418
269 00012C68 fe 08 effffffe05 callf $8,_writes
270 00012C6F # write32h( dbl_ld_acc.m );
271 00012C6F dd effffffdff pushl _dbl_ld_acc
272 00012C75 fe 08 effffffdf8 callf $8,_write32h
273 00012C7C # writes(", final Acc. = ");
274 00012C7C .data 1
275 000004f7 * L419:
276 000004f7 * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
E203D2000
277 00000508 * .text
278 00012C7C dd 8f000004f7 pushl $L419
279 00012C82 fe 08 effffffdeb callf $8,_writes
280 00012C89 # write32h( post_evt_acc.m );
281 00012C89 dd effffffde5 pushl _post_evt_acc
282 00012C8F fe 08 effffffdde callf $8,_write32h
283 00012C96 # writes(", op3 = ");
284 00012C96 .data 1
285 00000508 * L420:
286 00000508 * 2C2020206F7033203D2000 .ascii ", op3 = \0"
287 00000513 * .text
288 00012C96 dd 8f00000508 pushl $L420
289 00012C9C fe 08 effffffdd1 callf $8,_writes
290 00012CA3 # write32h( dbl_value_2.m );
291 00012CA3 dd effffffdcb pushl _dbl_value_2
292 00012CA9 fe 08 effffffdc4 callf $8,_write32h
293 00012CB0 # writes("\nop2 = ");
294 00012CB0 .data 1
295 00000513 * L421:
296 00000513 * 0A6F7032203D2000 .ascii "\12op2 = \0"
297 0000051b * .text
298 00012CB0 dd 8f00000513 pushl $L421
299 00012CB6 fe 08 effffffdb7 callf $8,_writes
300 00012CBD # write32h( dbl_value_1.m );
301 00012CBD dd effffffdb1 pushl _dbl_value_1
302 00012CC3 fe 08 effffffdaa callf $8,_write32h
303 00012CCA # writes(", expected = ");
304 00012CCA .data 1
305 0000051b * L422:
306 0000051b * 2C20202020657870656374656 .ascii ", expected = \0"
4203D2000
307 0000052c * .text
308 00012CCA dd 8f0000051b pushl $L422
309 00012CD0 fe 08 effffffd9d callf $8,_writes
310 00012CD7 # write32h( 0 ); /* the expected result = 0 */
311 00012CD7 dd 00 pushl $0
312 00012CD9 fe 08 effffffd94 callf $8,_write32h
313 00012CE0 # writec('\n');
314 00012CE0 dd 0a pushl $10
315 00012CE2 fe 08 effffffd8b callf $8,_writec
316 00012CE9 # }
317 00012CE9 # if ( halt_flg ) /* halt on error? */
318 00012CE9 L415:
319 00012CE9 5d effffffd85 tstl _halt_flg
320 00012CEF 31 09 jeql L423
321 00012CF1 # pipe11_halt( 2 ); /* halt with a code of 2 */
322 00012CF1 dd 02 pushl $2
323 00012CF3 fe 08 ef0000019a callf $8,_pipe11_halt
324 00012CFA # if ( loop_on_err )
325 00012CFA L423:
326 00012CFA 5d effffffd74 tstl _loop_on_err
327 00012D00 31 0d jeql L424
328 00012D02 # {
329 00012D02 # force_loop = TRUE; /* set the force loop flag */
330 00012D02 0d 01 effffffd6b movl $1,_force_loop
331 00012D09 # asm("jmp _pipe11_lp1"); /* and loop */
332 00012D09 71 effffffe02 jmp _pipe11_lp1
333 00012D0F # };
334 00012D0F L424:
335 00012D0F # }
336 00012D0F 40 ret#2
337 00012D10 .set L411,0x0
338 00012D10 L413:
339 00012D10 13 ff24 jbr L414
340 00012D13 .data
341 0000048c * .text
342 00012D13 00 .align 1
343 00012D14 .globl _pipe11_queue_er
344 00012D14 _pipe11_queue_er:
345 00012D14 0000 .word L425
346 00012D16 #
347 00012D16 #
348 00012D16 #
349 00012D16 #
350 00012D16 #
351 00012D16 # /****************************************************************************
352 00012D16 # * Report an "FPP queue not cleared" message
353 00012D16 # *
354 00012D16 # * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx
355 00012D16 # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF)
356 00012D16 # * The CVLF should not have been executed but apparently was.
357 00012D16 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, op3 = xxxxxxxx
358 00012D16 # * op2 = xxxxxxxx, expected = xxxxxxxx
359 00012D16 # ****************************************************************************/
360 00012D16 # pipe11_queue_er()
361 00012D16 # {
362 00012D16 13 00d9 jbr L427
363 00012D19 L428:
364 00012D19 # errcnt++; /* bump the error count */
365 00012D19 6d effffffd55 incl _errcnt
366 00012D1F # if ( prt_error )
367 00012D1F 5d effffffd4f tstl _prt_error
368 00012D25 21 03 13 00a1 jeql L429
369 00012D2A # {
370 00012D2A # print_pipe11_er( ". Fpp queue not cleared" );
371 00012D2A .data 1
372 0000052c * L430:
373 0000052c * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0"
E6F7420636C656172656400
374 00000544 * .text
375 00012D2A dd 8f0000052c pushl $L430
376 00012D30 fe 08 ef000000bf callf $8,_print_pipe11_er
377 00012D37 # writes(
378 00012D37 # "The CVLF should not have been executed but apparently was.\n");
379 00012D37 .data 1
380 00000544 * L431:
381 00000544 * 5468652043564C462073686F7 .ascii "The CVLF should not have been executed but apparently was.\12\0"
56C64206E6F74206861766520
6265656E20657865637574656
420627574206170706172656E
746C79207761732E0A00
382 00000580 * .text
383 00012D37 dd 8f00000544 pushl $L431
384 00012D3D fe 08 effffffd30 callf $8,_writes
385 00012D44 # writes("op1 = ");
386 00012D44 .data 1
387 00000580 * L432:
388 00000580 * 6F7031203D2000 .ascii "op1 = \0"
389 00000587 * .text
390 00012D44 dd 8f00000580 pushl $L432
391 00012D4A fe 08 effffffd23 callf $8,_writes
392 00012D51 # write32h( dbl_ld_acc.m );
393 00012D51 dd effffffd1d pushl _dbl_ld_acc
394 00012D57 fe 08 effffffd16 callf $8,_write32h
395 00012D5E # writes(", final Acc. = ");
396 00012D5E .data 1
397 00000587 * L433:
398 00000587 * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
E203D2000
399 00000598 * .text
400 00012D5E dd 8f00000587 pushl $L433
401 00012D64 fe 08 effffffd09 callf $8,_writes
402 00012D6B # write32h( post_evt_acc.m );
403 00012D6B dd effffffd03 pushl _post_evt_acc
404 00012D71 fe 08 effffffcfc callf $8,_write32h
405 00012D78 # writes(", op3 = ");
406 00012D78 .data 1
407 00000598 * L434:
408 00000598 * 2C20206F7033203D2000 .ascii ", op3 = \0"
409 000005a2 * .text
410 00012D78 dd 8f00000598 pushl $L434
411 00012D7E fe 08 effffffcef callf $8,_writes
412 00012D85 # write32h( dbl_value_2.m );
413 00012D85 dd effffffce9 pushl _dbl_value_2
414 00012D8B fe 08 effffffce2 callf $8,_write32h
415 00012D92 # writes("\nop2 = ");
416 00012D92 .data 1
417 000005a2 * L435:
418 000005a2 * 0A6F7032203D2000 .ascii "\12op2 = \0"
419 000005aa * .text
420 00012D92 dd 8f000005a2 pushl $L435
421 00012D98 fe 08 effffffcd5 callf $8,_writes
422 00012D9F # write32h( dbl_value_1.m );
423 00012D9F dd effffffccf pushl _dbl_value_1
424 00012DA5 fe 08 effffffcc8 callf $8,_write32h
425 00012DAC # writes(", expected = ");
426 00012DAC .data 1
427 000005aa * L436:
428 000005aa * 2C20202020657870656374656 .ascii ", expected = \0"
4203D2000
429 000005bb * .text
430 00012DAC dd 8f000005aa pushl $L436
431 00012DB2 fe 08 effffffcbb callf $8,_writes
432 00012DB9 # write32h( 0 ); /* the expected result = 0 */
433 00012DB9 dd 00 pushl $0
434 00012DBB fe 08 effffffcb2 callf $8,_write32h
435 00012DC2 # writec('\n');
436 00012DC2 dd 0a pushl $10
437 00012DC4 fe 08 effffffca9 callf $8,_writec
438 00012DCB # }
439 00012DCB # if ( halt_flg ) /* halt on error? */
440 00012DCB L429:
441 00012DCB 5d effffffca3 tstl _halt_flg
442 00012DD1 31 09 jeql L437
443 00012DD3 # pipe11_halt( 3 ); /* halt with a code of 3 */
444 00012DD3 dd 03 pushl $3
445 00012DD5 fe 08 ef000000b8 callf $8,_pipe11_halt
446 00012DDC # if ( loop_on_err )
447 00012DDC L437:
448 00012DDC 5d effffffc92 tstl _loop_on_err
449 00012DE2 31 0d jeql L438
450 00012DE4 # {
451 00012DE4 # force_loop = TRUE; /* set the force loop flag */
452 00012DE4 0d 01 effffffc89 movl $1,_force_loop
453 00012DEB # asm("jmp _pipe11_lp1"); /* and loop */
454 00012DEB 71 effffffd20 jmp _pipe11_lp1
455 00012DF1 # };
456 00012DF1 L438:
457 00012DF1 # }
458 00012DF1 40 ret#2
459 00012DF2 .set L425,0x0
460 00012DF2 L427:
461 00012DF2 13 ff24 jbr L428
462 00012DF5 .data
463 0000048c * .text
464 00012DF5 00 .align 1
465 00012DF6 .globl _print_pipe11_er
466 00012DF6 _print_pipe11_er:
467 00012DF6 0000 .word L439
468 00012DF8 #
469 00012DF8 #
470 00012DF8 #
471 00012DF8 #
472 00012DF8 # /****************************************************************************
473 00012DF8 # * Report an error message of the form:
474 00012DF8 # *
475 00012DF8 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
476 00012DF8 # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF)
477 00012DF8 # ****************************************************************************/
478 00012DF8 # print_pipe11_er( msg )
479 00012DF8 # char *msg; /* error message to print */
480 00012DF8 # {
481 00012DF8 13 0096 jbr L441
482 00012DFB L442:
483 00012DFB # if( errcnt == 1 ) /* 1st error? */
484 00012DFB 1d effffffc73 01 cmpl _errcnt,$1
485 00012E02 21 0d jneq L443
486 00012E04 # writes(" \n"); /* start a new print line */
487 00012E04 .data 1
488 000005bb * L444:
489 000005bb * 200A00 .ascii " \12\0"
490 000005be * .text
491 00012E04 dd 8f000005bb pushl $L444
492 00012E0A fe 08 effffffc63 callf $8,_writes
493 00012E11 # writes("Cycle: ");
494 00012E11 L443:
495 00012E11 .data 1
496 000005be * L445:
497 000005be * 4379636C653A2000 .ascii "Cycle: \0"
498 000005c6 * .text
499 00012E11 dd 8f000005be pushl $L445
500 00012E17 fe 08 effffffc56 callf $8,_writes
501 00012E1E # writed( cycle );
502 00012E1E dd effffffc50 pushl _cycle
503 00012E24 fe 08 effffffc49 callf $8,_writed
504 00012E2B # writes(" EVT test ");
505 00012E2B .data 1
506 000005c6 * L447:
507 000005c6 * 202045565420746573742000 .ascii " EVT test \0"
508 000005d2 * .text
509 00012E2B dd 8f000005c6 pushl $L447
510 00012E31 fe 08 effffffc3c callf $8,_writes
511 00012E38 # writed( test_no );
512 00012E38 dd effffffc36 pushl _test_no
513 00012E3E fe 08 effffffc2f callf $8,_writed
514 00012E45 # writes(". subtest ");
515 00012E45 .data 1
516 000005d2 * L448:
517 000005d2 * 2E20737562746573742000 .ascii ". subtest \0"
518 000005dd * .text
519 00012E45 dd 8f000005d2 pushl $L448
520 00012E4B fe 08 effffffc22 callf $8,_writes
521 00012E52 # writed( subtest );
522 00012E52 dd effffffc1c pushl _subtest
523 00012E58 fe 08 effffffc15 callf $8,_writed
524 00012E5F # writes( msg ); /* print the message */
525 00012E5F dd ad04 pushl 4(fp)
526 00012E62 fe 08 effffffc0b callf $8,_writes
527 00012E69 # writes(". index = ");
528 00012E69 .data 1
529 000005dd * L449:
530 000005dd * 2E20696E646578203D2000 .ascii ". index = \0"
531 000005e8 * .text
532 00012E69 dd 8f000005dd pushl $L449
533 00012E6F fe 08 effffffbfe callf $8,_writes
534 00012E76 # writed( index );
535 00012E76 dd effffffbf8 pushl _index
536 00012E7C fe 08 effffffbf1 callf $8,_writed
537 00012E83 # writes(
538 00012E83 # "\ninst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF)\n");
539 00012E83 .data 1
540 000005e8 * L450:
541 000005e8 * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the AD"
F70312C2041444446206F7032
2C2043564C46206F703320202
020286F766572666C6F772066
61756C74206F6E20746865204
144
542 00000628 * 4446290A00 .ascii "DF)\12\0"
543 0000062d * .text
544 00012E83 dd 8f000005e8 pushl $L450
545 00012E89 fe 08 effffffbe4 callf $8,_writes
546 00012E90 # }
547 00012E90 40 ret#2
548 00012E91 .set L439,0x0
549 00012E91 L441:
550 00012E91 13 ff67 jbr L442
551 00012E94 .data
552 0000048c * .text
553 00012E94 .align 1
554 00012E94 .globl _pipe11_halt
555 00012E94 _pipe11_halt:
556 00012E94 0000 .word L451
557 00012E96 #
558 00012E96 #
559 00012E96 #
560 00012E96 # /****************************************************************************
561 00012E96 # * halt on error routine
562 00012E96 # ****************************************************************************/
563 00012E96 # pipe11_halt( code )
564 00012E96 # int code; /* error code to halt with */
565 00012E96 # {
566 00012E96 11 65 jbr L453
567 00012E98 L454:
568 00012E98 # err_code = code;
569 00012E98 0d ad04 effffffbd4 movl 4(fp),_err_code
570 00012EA0 # sgl_value_1 = dbl_ld_acc.m;
571 00012EA0 0d effffffbce effffffbc9 movl _dbl_ld_acc,_sgl_value_1
572 00012EAB # sgl_value_2 = dbl_value_1.m;
573 00012EAB 0d effffffbc3 effffffbbe movl _dbl_value_1,_sgl_value_2
574 00012EB6 # sgl_value_3 = post_evt_acc.m;
575 00012EB6 0d effffffbb8 effffffbb3 movl _post_evt_acc,_sgl_value_3
576 00012EC1 # asm("movl _test_no,r0"); /* r0 = test number */
577 00012EC1 0d effffffbad 50 movl _test_no,r0
578 00012EC8 # asm("movl _subtest,r1"); /* r1 = subtest number */
579 00012EC8 0d effffffba6 51 movl _subtest,r1
580 00012ECF # asm("movl _err_code,r2"); /* r2 = error code */
581 00012ECF 0d effffffb9f 52 movl _err_code,r2
582 00012ED6 # asm("movl _cycle,r3"); /* r3 = cycle count */
583 00012ED6 0d effffffb98 53 movl _cycle,r3
584 00012EDD # asm("movl _sgl_value_1,r4"); /* r4 = initial accumulator */
585 00012EDD 0d effffffb91 54 movl _sgl_value_1,r4
586 00012EE4 # asm("movl _sgl_value_2,r5"); /* r5 = ADDF operand */
587 00012EE4 0d effffffb8a 55 movl _sgl_value_2,r5
588 00012EEB # asm("movl _sgl_value_3,r6"); /* r6 = final accumulator */
589 00012EEB 0d effffffb83 56 movl _sgl_value_3,r6
590 00012EF2 # asm("clrl r7"); /* r7 = expected accumulator */
591 00012EF2 4d 57 clrl r7
592 00012EF4 # asm("movl _index,r8"); /* r8 = data index */
593 00012EF4 0d effffffb7a 58 movl _index,r8
594 00012EFB # asm("halt"); /* HALT ... */
595 00012EFB 00 halt
596 00012EFC # }
597 00012EFC 40 ret#2
598 00012EFD .set L451,0x0
599 00012EFD L453:
600 00012EFD 11 99 jbr L454
601 00012EFF .data
601 00025973 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.