![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe5.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 pipe5.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 000005d4 * .text
4 00000000 .align 1
5 00000000 .globl _pipe5
6 00000000 _pipe5:
7 000109F0 0000 .word L381
8 000109F2 #
9 000109F2 # #include "evt_defs.h"
10 000109F2 #
11 000109F2 # /*
12 000109F2 # *********************************************************************
13 000109F2 # * FPP PIPELINED EVENTS TEST #5
14 000109F2 # *
15 000109F2 # * This test will execute the following code: "LDD MULD LDF"
16 000109F2 # * with an reserved operand fault on the MULD. We will make sure that:
17 000109F2 # * 1. The fault is detected,
18 000109F2 # * 2. the negate instruction is not executed.
19 000109F2 # *********************************************************************
20 000109F2 # */
21 000109F2 # pipe5()
22 000109F2 # {
23 000109F2 13 0129 jbr L383
24 000109F5 L384:
25 000109F5 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
26 000109F5 ed 6d effffffff4 moval (r13),_pre_event_fp
27 000109FC # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
28 000109FC ed 6e efffffffed moval (r14),_pre_event_sp
29 00010A03 # precision = DBL;
30 00010A03 0d 02 efffffffe6 movl $2,_precision
31 00010A0A # test_event = RESOP_CODE; /* reserved op fault expected */
32 00010A0A 0d 2d efffffffdf movl $45,_test_event
33 00010A11 # exp_event = FALSE; /* ... but not yet */
34 00010A11 4d efffffffd9 clrl _exp_event
35 00010A17 # asm("movab _pipe5_ret,_event_return"); /* post event addr */
36 00010A17 e9 ef000000b6 efffffffce movab _pipe5_ret,_event_return
37 00010A22 # for( index = 0; index < flt_resop_cnt; index++ )
38 00010A22 4d efffffffc8 clrl _index
39 00010A28 L387:
40 00010A28 1d efffffffc2 efffffffbd cmpl _index,_flt_resop_cnt
41 00010A33 91 03 13 00e5 jgeq L386
42 00010A38 # {
43 00010A38 # dbl_ld_acc = acc_data[ index ];
44 00010A38 48 03 efffffffb1 50 shll $3,_index,r0
45 00010A40 0c 8f00000000 50 addl2 $_acc_data,r0
46 00010A47 0d a004 efffffffa5 movl 4(r0),_dbl_ld_acc+4
47 00010A4F 0d 60 efffffff9a movl (r0),_dbl_ld_acc
48 00010A56 # dbl_value_1 = flt_resops[ index ].op_1;
49 00010A56 48 04 efffffff93 50 shll $4,_index,r0
50 00010A5E 0c 8f00000000 50 addl2 $_flt_resops,r0
51 00010A65 0d a004 efffffff87 movl 4(r0),_dbl_value_1+4
52 00010A6D 0d 60 efffffff7c movl (r0),_dbl_value_1
53 00010A74 # dbl_value_3.m = 0x12345678; /* get dummy load value */
54 00010A74 0d 8f12345678 efffffff71 movl $305419896,_dbl_value_3
55 00010A7F # dbl_value_3.l = 0xabcdef01; /* get dummy load value */
56 00010A7F 0d 8fabcdef01 efffffff6a movl $-1412567295,_dbl_value_3+4
57 00010A8A # asm(".globl _pipe5_lp1");
58 00010A8A .globl _pipe5_lp1
59 00010A8A # asm("_pipe5_lp1:");
60 00010A8A _pipe5_lp1:
61 00010A8A # asm("bispsw $0x60"); /* enable ovfl & undfl */
62 00010A8A 8b 8860 bispsw $0x60
63 00010A8D # asm("ldd _dbl_ld_acc"); /* load the Acc. */
64 00010A8D 07 efffffff5d ldd _dbl_ld_acc
65 00010A93 # exp_event = test_event; /* expect event soon */
66 00010A93 0d efffffff57 efffffff52 movl _test_event,_exp_event
67 00010A9E # asm("muld _dbl_value_1"); /* cause the event */
68 00010A9E e7 efffffff4c muld _dbl_value_1
69 00010AA4 # asm("ldd _dbl_value_3"); /* we shouldn't get here */
70 00010AA4 07 efffffff46 ldd _dbl_value_3
71 00010AAA # /*
72 00010AAA # * If we got to here then there was no event
73 00010AAA # */
74 00010AAA # if( force_loop )
75 00010AAA 5d efffffff40 tstl _force_loop
76 00010AB0 31 03 jeql L388
77 00010AB2 # asm("brw _pipe5_lp1");; /* loop on the error */
Assemb000281B0 # asm("brw _pipe5_lp1");; /* loop on the error */
"pipe5000281B0 78: WARNING: brw: destination label is external
78 00010AB2 13 ffd5 brw _pipe5_lp1
79 00010AB5 L388:
80 00010AB5 # exp_event = FALSE; /* reset event expected flag */
81 00010AB5 4d efffffff35 clrl _exp_event
82 00010ABB # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
83 00010ABB 0d efffffff2f 5d movl _pre_event_fp,fp
84 00010AC2 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
85 00010AC2 0d efffffff28 5e movl _pre_event_sp,sp
86 00010AC9 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
87 00010AC9 9b 8860 bicpsw $0x60
88 00010ACC # no_pipe5_evt();; /* report the error */
89 00010ACC fe 04 ef0000004f callf $4,_no_pipe5_evt
90 00010AD3 # /*
91 00010AD3 # * Come here after the event
92 00010AD3 # */
93 00010AD3 # asm(".globl _pipe5_ret");
94 00010AD3 .globl _pipe5_ret
95 00010AD3 # asm("_pipe5_ret:");
96 00010AD3 _pipe5_ret:
97 00010AD3 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
98 00010AD3 0d efffffff17 5d movl _pre_event_fp,fp
99 00010ADA # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
100 00010ADA 0d efffffff10 5e movl _pre_event_sp,sp
101 00010AE1 # if( force_loop )
102 00010AE1 5d efffffff09 tstl _force_loop
103 00010AE7 31 03 jeql L390
104 00010AE9 # asm("brw _pipe5_lp1");; /* loop on the error */
"pipe5000281B0 105: WARNING: brw: destination label is external
105 00010AE9 13 ff9e brw _pipe5_lp1
106 00010AEC L390:
107 00010AEC # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
108 00010AEC 9b 8860 bicpsw $0x60
109 00010AEF # if( post_evt_acc.m == dbl_value_3.m )
110 00010AEF 1d effffffefb effffffef6 cmpl _post_evt_acc,_dbl_value_3
111 00010AFA 21 09 jneq L391
112 00010AFC # pipe5_queue(); /* fpp queue not cleared */
113 00010AFC fe 04 ef00000225 callf $4,_pipe5_queue
114 00010B03 # else if( post_evt_acc.m ) /* was the Acc. cleared? */
115 00010B03 11 0f jbr L393
116 00010B05 L391:
117 00010B05 5d effffffee5 tstl _post_evt_acc
118 00010B0B 31 07 jeql L394
119 00010B0D # bad_pipe5_result(); /* incorrect result error */
120 00010B0D fe 04 ef000000de callf $4,_bad_pipe5_result
121 00010B14 # }
122 00010B14 L394:
123 00010B14 L393:
124 00010B14 L385:
125 00010B14 6d effffffed6 incl _index
126 00010B1A 13 ff0b jbr L387
127 00010B1D L386:
128 00010B1D # }
129 00010B1D 40 ret#2
130 00010B1E .set L381,0x0
131 00010B1E L383:
132 00010B1E 13 fed4 jbr L384
133 00010B21 .data
134 000005d4 * .text
135 00010B21 00 .align 1
136 00010B22 .globl _no_pipe5_evt
137 00010B22 _no_pipe5_evt:
138 00010B22 0000 .word L396
139 00010B24 #
140 00010B24 #
141 00010B24 #
142 00010B24 # /****************************************************************************
143 00010B24 # * Report an "EVENT NOT DETECTED" error
144 00010B24 # *
145 00010B24 # * Cycle: xx. EVT test xx. subtest xx. no reserved op fault. index = xx
146 00010B24 # * inst = LDD op1, MULD op2, LDF op3 (reserved operand fault on MULL3)
147 00010B24 # * op1 = xxxxxxxx xxxxxxxx, op2 = xxxxxxxx xxxxxxxx, op3 = xxxxxxxx
148 00010B24 # ****************************************************************************/
149 00010B24 # no_pipe5_evt()
150 00010B24 # {
151 00010B24 13 00c8 jbr L398
152 00010B27 L399:
153 00010B27 # errcnt++; /* bump the error count */
154 00010B27 6d effffffec3 incl _errcnt
155 00010B2D # if ( prt_error )
156 00010B2D 5d effffffebd tstl _prt_error
157 00010B33 21 03 13 0090 jeql L400
158 00010B38 # {
159 00010B38 # print_pipe5_er( ". no reserved op fault.");
160 00010B38 .data 1
161 000005d4 * L402:
162 000005d4 * 2E206E6F20726573657276656 .ascii ". no reserved op fault.\0"
4206F70206661756C742E00
163 000005ec * .text
164 00010B38 dd 8f000005d4 pushl $L402
165 00010B3E fe 08 ef00000319 callf $8,_print_pipe5_er
166 00010B45 # writes("op1 = ");
167 00010B45 .data 1
168 000005ec * L404:
169 000005ec * 6F7031203D2000 .ascii "op1 = \0"
170 000005f3 * .text
171 00010B45 dd 8f000005ec pushl $L404
172 00010B4B fe 08 effffffe9e callf $8,_writes
173 00010B52 # write32h( dbl_ld_acc.m );
174 00010B52 dd effffffe98 pushl _dbl_ld_acc
175 00010B58 fe 08 effffffe91 callf $8,_write32h
176 00010B5F # writec(' ');
177 00010B5F dd 20 pushl $32
178 00010B61 fe 08 effffffe88 callf $8,_writec
179 00010B68 # write32h( dbl_ld_acc.l );
180 00010B68 dd effffffe86 pushl _dbl_ld_acc+4
181 00010B6E fe 08 effffffe7b callf $8,_write32h
182 00010B75 # writes(", op2 = ");
183 00010B75 .data 1
184 000005f3 * L407:
185 000005f3 * 2C20206F7032203D2000 .ascii ", op2 = \0"
186 000005fd * .text
187 00010B75 dd 8f000005f3 pushl $L407
188 00010B7B fe 08 effffffe6e callf $8,_writes
189 00010B82 # write32h( dbl_value_1.m );
190 00010B82 dd effffffe68 pushl _dbl_value_1
191 00010B88 fe 08 effffffe61 callf $8,_write32h
192 00010B8F # writec(' ');
193 00010B8F dd 20 pushl $32
194 00010B91 fe 08 effffffe58 callf $8,_writec
195 00010B98 # write32h( dbl_value_1.l );
196 00010B98 dd effffffe56 pushl _dbl_value_1+4
197 00010B9E fe 08 effffffe4b callf $8,_write32h
198 00010BA5 # writes(", op3 = ");
199 00010BA5 .data 1
200 000005fd * L408:
201 000005fd * 2C20206F7033203D2000 .ascii ", op3 = \0"
202 00000607 * .text
203 00010BA5 dd 8f000005fd pushl $L408
204 00010BAB fe 08 effffffe3e callf $8,_writes
205 00010BB2 # write32h( dbl_value_3.m );
206 00010BB2 dd effffffe38 pushl _dbl_value_3
207 00010BB8 fe 08 effffffe31 callf $8,_write32h
208 00010BBF # writec('\n');
209 00010BBF dd 0a pushl $10
210 00010BC1 fe 08 effffffe28 callf $8,_writec
211 00010BC8 # }
212 00010BC8 # if ( halt_flg ) /* halt on error? */
213 00010BC8 L400:
214 00010BC8 5d effffffe22 tstl _halt_flg
215 00010BCE 31 09 jeql L409
216 00010BD0 # pipe5_halt( 1 );
217 00010BD0 dd 01 pushl $1
218 00010BD2 fe 08 ef00000331 callf $8,_pipe5_halt
219 00010BD9 # if ( loop_on_err )
220 00010BD9 L409:
221 00010BD9 5d effffffe11 tstl _loop_on_err
222 00010BDF 31 0d jeql L411
223 00010BE1 # {
224 00010BE1 # force_loop = TRUE; /* set the force loop flag */
225 00010BE1 0d 01 effffffe08 movl $1,_force_loop
226 00010BE8 # asm("jmp _pipe5_lp1"); /* and loop */
227 00010BE8 71 effffffe9c jmp _pipe5_lp1
228 00010BEE # };
229 00010BEE L411:
230 00010BEE # }
231 00010BEE 40 ret#2
232 00010BEF .set L396,0x0
233 00010BEF L398:
234 00010BEF 13 ff35 jbr L399
235 00010BF2 .data
236 000005d4 * .text
237 00010BF2 .align 1
238 00010BF2 .globl _bad_pipe5_result
239 00010BF2 _bad_pipe5_result:
240 00010BF2 0000 .word L412
241 00010BF4 #
242 00010BF4 #
243 00010BF4 #
244 00010BF4 #
245 00010BF4 # /****************************************************************************
246 00010BF4 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
247 00010BF4 # *
248 00010BF4 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
249 00010BF4 # * inst = LDD op1, MULD op2, LDF op3 (reserved operand fault on MULL3)
250 00010BF4 # * The LDF should not have been executed.
251 00010BF4 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
252 00010BF4 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
253 00010BF4 # * op3 = xxxxxxxx
254 00010BF4 # ****************************************************************************/
255 00010BF4 # bad_pipe5_result()
256 00010BF4 # {
257 00010BF4 13 012d jbr L414
258 00010BF7 L415:
259 00010BF7 # errcnt++; /* bump the error count */
260 00010BF7 6d effffffdf3 incl _errcnt
261 00010BFD # if ( prt_error )
262 00010BFD 5d effffffded tstl _prt_error
263 00010C03 21 03 13 00f5 jeql L416
264 00010C08 # {
265 00010C08 # print_pipe5_er(". Bad final Accumulator.");
266 00010C08 .data 1
267 00000607 * L417:
268 00000607 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator.\0"
16363756D756C61746F722E00
269 00000620 * .text
270 00010C08 dd 8f00000607 pushl $L417
271 00010C0E fe 08 ef00000249 callf $8,_print_pipe5_er
272 00010C15 # writes("The LDF should not have been executed.\n");
273 00010C15 .data 1
274 00000620 * L418:
275 00000620 * 546865204C44462073686F756 .ascii "The LDF should not have been executed.\12\0"
C64206E6F7420686176652062
65656E2065786563757465642
E0A00
276 00000648 * .text
277 00010C15 dd 8f00000620 pushl $L418
278 00010C1B fe 08 effffffdce callf $8,_writes
279 00010C22 # writes("op1 = ");
280 00010C22 .data 1
281 00000648 * L419:
282 00000648 * 6F7031203D2000 .ascii "op1 = \0"
283 0000064f * .text
284 00010C22 dd 8f00000648 pushl $L419
285 00010C28 fe 08 effffffdc1 callf $8,_writes
286 00010C2F # write32h( dbl_value_1.m );
287 00010C2F dd effffffdbb pushl _dbl_value_1
288 00010C35 fe 08 effffffdb4 callf $8,_write32h
289 00010C3C # writec(' ');
290 00010C3C dd 20 pushl $32
291 00010C3E fe 08 effffffdab callf $8,_writec
292 00010C45 # write32h( dbl_value_1.l );
293 00010C45 dd effffffda9 pushl _dbl_value_1+4
294 00010C4B fe 08 effffffd9e callf $8,_write32h
295 00010C52 # writes(", final Acc. = ");
296 00010C52 .data 1
297 0000064f * L420:
298 0000064f * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
E203D2000
299 00000660 * .text
300 00010C52 dd 8f0000064f pushl $L420
301 00010C58 fe 08 effffffd91 callf $8,_writes
302 00010C5F # write32h( post_evt_acc.m );
303 00010C5F dd effffffd8b pushl _post_evt_acc
304 00010C65 fe 08 effffffd84 callf $8,_write32h
305 00010C6C # writec(' ');
306 00010C6C dd 20 pushl $32
307 00010C6E fe 08 effffffd7b callf $8,_writec
308 00010C75 # write32h( post_evt_acc.l );
309 00010C75 dd effffffd79 pushl _post_evt_acc+4
310 00010C7B fe 08 effffffd6e callf $8,_write32h
311 00010C82 # writes("\nop2 = ");
312 00010C82 .data 1
313 00000660 * L421:
314 00000660 * 0A6F7032203D2000 .ascii "\12op2 = \0"
315 00000668 * .text
316 00010C82 dd 8f00000660 pushl $L421
317 00010C88 fe 08 effffffd61 callf $8,_writes
318 00010C8F # write32h( dbl_value_2.m );
319 00010C8F dd effffffd5b pushl _dbl_value_2
320 00010C95 fe 08 effffffd54 callf $8,_write32h
321 00010C9C # writec(' ');
322 00010C9C dd 20 pushl $32
323 00010C9E fe 08 effffffd4b callf $8,_writec
324 00010CA5 # write32h( dbl_value_2.l );
325 00010CA5 dd effffffd49 pushl _dbl_value_2+4
326 00010CAB fe 08 effffffd3e callf $8,_write32h
327 00010CB2 # writes(", expected = ");
328 00010CB2 .data 1
329 00000668 * L422:
330 00000668 * 2C20202020657870656374656 .ascii ", expected = \0"
4203D2000
331 00000679 * .text
332 00010CB2 dd 8f00000668 pushl $L422
333 00010CB8 fe 08 effffffd31 callf $8,_writes
334 00010CBF # write32h( 0 );
335 00010CBF dd 00 pushl $0
336 00010CC1 fe 08 effffffd28 callf $8,_write32h
337 00010CC8 # writec(' ');
338 00010CC8 dd 20 pushl $32
339 00010CCA fe 08 effffffd1f callf $8,_writec
340 00010CD1 # write32h( 0 );
341 00010CD1 dd 00 pushl $0
342 00010CD3 fe 08 effffffd16 callf $8,_write32h
343 00010CDA # writes("\nop_3 = ");
344 00010CDA .data 1
345 00000679 * L423:
346 00000679 * 0A6F705F33203D2000 .ascii "\12op_3 = \0"
347 00000682 * .text
348 00010CDA dd 8f00000679 pushl $L423
349 00010CE0 fe 08 effffffd09 callf $8,_writes
350 00010CE7 # write32h( dbl_value_3.m );
351 00010CE7 dd effffffd03 pushl _dbl_value_3
352 00010CED fe 08 effffffcfc callf $8,_write32h
353 00010CF4 # writec('\n');
354 00010CF4 dd 0a pushl $10
355 00010CF6 fe 08 effffffcf3 callf $8,_writec
356 00010CFD # }
357 00010CFD # if ( halt_flg ) /* halt on error? */
358 00010CFD L416:
359 00010CFD 5d effffffced tstl _halt_flg
360 00010D03 31 09 jeql L424
361 00010D05 # pipe5_halt( 2 );
362 00010D05 dd 02 pushl $2
363 00010D07 fe 08 ef000001fc callf $8,_pipe5_halt
364 00010D0E # if ( loop_on_err )
365 00010D0E L424:
366 00010D0E 5d effffffcdc tstl _loop_on_err
367 00010D14 31 0d jeql L425
368 00010D16 # {
369 00010D16 # force_loop = TRUE; /* set the force loop flag */
370 00010D16 0d 01 effffffcd3 movl $1,_force_loop
371 00010D1D # asm("jmp _pipe5_lp1"); /* and loop */
372 00010D1D 71 effffffd67 jmp _pipe5_lp1
373 00010D23 # };
374 00010D23 L425:
375 00010D23 # }
376 00010D23 40 ret#2
377 00010D24 .set L412,0x0
378 00010D24 L414:
379 00010D24 13 fed0 jbr L415
380 00010D27 .data
381 000005d4 * .text
382 00010D27 00 .align 1
383 00010D28 .globl _pipe5_queue
384 00010D28 _pipe5_queue:
385 00010D28 0000 .word L426
386 00010D2A #
387 00010D2A #
388 00010D2A #
389 00010D2A #
390 00010D2A #
391 00010D2A # /****************************************************************************
392 00010D2A # * Report an "FPP Queue apparently not cleared" error
393 00010D2A # *
394 00010D2A # * Cycle: xx. EVT test xx. subtest xx. Fpp Queue not cleared. index = xx
395 00010D2A # * inst = LDD op1, MULD op2, LDF op3 (reserved operand fault on MULD)
396 00010D2A # * The LDF should not have been executed but apparently was.
397 00010D2A # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
398 00010D2A # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
399 00010D2A # * op3 = xxxxxxxx
400 00010D2A # ****************************************************************************/
401 00010D2A # pipe5_queue()
402 00010D2A # {
403 00010D2A 13 012d jbr L428
404 00010D2D L429:
405 00010D2D # errcnt++; /* bump the error count */
406 00010D2D 6d effffffcbd incl _errcnt
407 00010D33 # if ( prt_error )
408 00010D33 5d effffffcb7 tstl _prt_error
409 00010D39 21 03 13 00f5 jeql L430
410 00010D3E # {
411 00010D3E # print_pipe5_er(". Fpp Queue not cleared.");
412 00010D3E .data 1
413 00000682 * L431:
414 00000682 * 2E20467070205175657565206 .ascii ". Fpp Queue not cleared.\0"
E6F7420636C65617265642E00
415 0000069b * .text
416 00010D3E dd 8f00000682 pushl $L431
417 00010D44 fe 08 ef00000113 callf $8,_print_pipe5_er
418 00010D4B # writes(
419 00010D4B # "The NEGF should not have been executed but apparently was.\n");
420 00010D4B .data 1
421 0000069b * L432:
422 0000069b * 546865204E4547462073686F7 .ascii "The NEGF should not have been executed but apparently was.\12\0"
56C64206E6F74206861766520
6265656E20657865637574656
420627574206170706172656E
746C79207761732E0A00
423 000006d7 * .text
424 00010D4B dd 8f0000069b pushl $L432
425 00010D51 fe 08 effffffc98 callf $8,_writes
426 00010D58 # writes("op1 = ");
427 00010D58 .data 1
428 000006d7 * L433:
429 000006d7 * 6F7031203D2000 .ascii "op1 = \0"
430 000006de * .text
431 00010D58 dd 8f000006d7 pushl $L433
432 00010D5E fe 08 effffffc8b callf $8,_writes
433 00010D65 # write32h( dbl_value_1.m );
434 00010D65 dd effffffc85 pushl _dbl_value_1
435 00010D6B fe 08 effffffc7e callf $8,_write32h
436 00010D72 # writec(' ');
437 00010D72 dd 20 pushl $32
438 00010D74 fe 08 effffffc75 callf $8,_writec
439 00010D7B # write32h( dbl_value_1.l );
440 00010D7B dd effffffc73 pushl _dbl_value_1+4
441 00010D81 fe 08 effffffc68 callf $8,_write32h
442 00010D88 # writes(", final Acc. = ");
443 00010D88 .data 1
444 000006de * L434:
445 000006de * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
E203D2000
446 000006ef * .text
447 00010D88 dd 8f000006de pushl $L434
448 00010D8E fe 08 effffffc5b callf $8,_writes
449 00010D95 # write32h( post_evt_acc.m );
450 00010D95 dd effffffc55 pushl _post_evt_acc
451 00010D9B fe 08 effffffc4e callf $8,_write32h
452 00010DA2 # writec(' ');
453 00010DA2 dd 20 pushl $32
454 00010DA4 fe 08 effffffc45 callf $8,_writec
455 00010DAB # write32h( post_evt_acc.l );
456 00010DAB dd effffffc43 pushl _post_evt_acc+4
457 00010DB1 fe 08 effffffc38 callf $8,_write32h
458 00010DB8 # writes("\nop2 = ");
459 00010DB8 .data 1
460 000006ef * L435:
461 000006ef * 0A6F7032203D2000 .ascii "\12op2 = \0"
462 000006f7 * .text
463 00010DB8 dd 8f000006ef pushl $L435
464 00010DBE fe 08 effffffc2b callf $8,_writes
465 00010DC5 # write32h( dbl_value_2.m );
466 00010DC5 dd effffffc25 pushl _dbl_value_2
467 00010DCB fe 08 effffffc1e callf $8,_write32h
468 00010DD2 # writec(' ');
469 00010DD2 dd 20 pushl $32
470 00010DD4 fe 08 effffffc15 callf $8,_writec
471 00010DDB # write32h( dbl_value_2.l );
472 00010DDB dd effffffc13 pushl _dbl_value_2+4
473 00010DE1 fe 08 effffffc08 callf $8,_write32h
474 00010DE8 # writes(", expected = ");
475 00010DE8 .data 1
476 000006f7 * L436:
477 000006f7 * 2C20202020657870656374656 .ascii ", expected = \0"
4203D2000
478 00000708 * .text
479 00010DE8 dd 8f000006f7 pushl $L436
480 00010DEE fe 08 effffffbfb callf $8,_writes
481 00010DF5 # write32h( 0 );
482 00010DF5 dd 00 pushl $0
483 00010DF7 fe 08 effffffbf2 callf $8,_write32h
484 00010DFE # writec(' ');
485 00010DFE dd 20 pushl $32
486 00010E00 fe 08 effffffbe9 callf $8,_writec
487 00010E07 # write32h( 0 );
488 00010E07 dd 00 pushl $0
489 00010E09 fe 08 effffffbe0 callf $8,_write32h
490 00010E10 # writes("\nop_3 = ");
491 00010E10 .data 1
492 00000708 * L437:
493 00000708 * 0A6F705F33203D2000 .ascii "\12op_3 = \0"
494 00000711 * .text
495 00010E10 dd 8f00000708 pushl $L437
496 00010E16 fe 08 effffffbd3 callf $8,_writes
497 00010E1D # write32h( dbl_value_3.m );
498 00010E1D dd effffffbcd pushl _dbl_value_3
499 00010E23 fe 08 effffffbc6 callf $8,_write32h
500 00010E2A # writec('\n');
501 00010E2A dd 0a pushl $10
502 00010E2C fe 08 effffffbbd callf $8,_writec
503 00010E33 # }
504 00010E33 # if ( halt_flg ) /* halt on error? */
505 00010E33 L430:
506 00010E33 5d effffffbb7 tstl _halt_flg
507 00010E39 31 09 jeql L438
508 00010E3B # pipe5_halt( 3 );
509 00010E3B dd 03 pushl $3
510 00010E3D fe 08 ef000000c6 callf $8,_pipe5_halt
511 00010E44 # if ( loop_on_err )
512 00010E44 L438:
513 00010E44 5d effffffba6 tstl _loop_on_err
514 00010E4A 31 0d jeql L439
515 00010E4C # {
516 00010E4C # force_loop = TRUE; /* set the force loop flag */
517 00010E4C 0d 01 effffffb9d movl $1,_force_loop
518 00010E53 # asm("jmp _pipe5_lp1"); /* and loop */
519 00010E53 71 effffffc31 jmp _pipe5_lp1
520 00010E59 # };
521 00010E59 L439:
522 00010E59 # }
523 00010E59 40 ret#2
524 00010E5A .set L426,0x0
525 00010E5A L428:
526 00010E5A 13 fed0 jbr L429
527 00010E5D .data
528 000005d4 * .text
529 00010E5D 00 .align 1
530 00010E5E .globl _print_pipe5_er
531 00010E5E _print_pipe5_er:
532 00010E5E 0000 .word L440
533 00010E60 #
534 00010E60 #
535 00010E60 #
536 00010E60 # /****************************************************************************
537 00010E60 # * print an error message of the form:
538 00010E60 # *
539 00010E60 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
540 00010E60 # * inst = LDD op1, MULD op2, LDF op3 (reserved operand fault on MULD)
541 00010E60 # ****************************************************************************/
542 00010E60 # print_pipe5_er( msg )
543 00010E60 # char *msg; /* error message to print */
544 00010E60 # {
545 00010E60 13 00a3 jbr L442
546 00010E63 L443:
547 00010E63 # if( errcnt == 1 ) /* 1st error? */
548 00010E63 1d effffffb87 01 cmpl _errcnt,$1
549 00010E6A 21 0d jneq L444
550 00010E6C # writes(" \n"); /* start a new print line */
551 00010E6C .data 1
552 00000711 * L445:
553 00000711 * 200A00 .ascii " \12\0"
554 00000714 * .text
555 00010E6C dd 8f00000711 pushl $L445
556 00010E72 fe 08 effffffb77 callf $8,_writes
557 00010E79 # writes("Cycle: ");
558 00010E79 L444:
559 00010E79 .data 1
560 00000714 * L446:
561 00000714 * 4379636C653A2000 .ascii "Cycle: \0"
562 0000071c * .text
563 00010E79 dd 8f00000714 pushl $L446
564 00010E7F fe 08 effffffb6a callf $8,_writes
565 00010E86 # writed( cycle );
566 00010E86 dd effffffb64 pushl _cycle
567 00010E8C fe 08 effffffb5d callf $8,_writed
568 00010E93 # writes(" EVT test ");
569 00010E93 .data 1
570 0000071c * L448:
571 0000071c * 202045565420746573742000 .ascii " EVT test \0"
572 00000728 * .text
573 00010E93 dd 8f0000071c pushl $L448
574 00010E99 fe 08 effffffb50 callf $8,_writes
575 00010EA0 # writed( test_no );
576 00010EA0 dd effffffb4a pushl _test_no
577 00010EA6 fe 08 effffffb43 callf $8,_writed
578 00010EAD # writes(". subtest ");
579 00010EAD .data 1
580 00000728 * L449:
581 00000728 * 2E20737562746573742000 .ascii ". subtest \0"
582 00000733 * .text
583 00010EAD dd 8f00000728 pushl $L449
584 00010EB3 fe 08 effffffb36 callf $8,_writes
585 00010EBA # writed( subtest );
586 00010EBA dd effffffb30 pushl _subtest
587 00010EC0 fe 08 effffffb29 callf $8,_writed
588 00010EC7 # writes( msg ); /* print the error message */
589 00010EC7 dd ad04 pushl 4(fp)
590 00010ECA fe 08 effffffb1f callf $8,_writes
591 00010ED1 # writes(" index = ");
592 00010ED1 .data 1
593 00000733 * L450:
594 00000733 * 20696E646578203D2000 .ascii " index = \0"
595 0000073d * .text
596 00010ED1 dd 8f00000733 pushl $L450
597 00010ED7 fe 08 effffffb12 callf $8,_writes
598 00010EDE # writed( index );
599 00010EDE dd effffffb0c pushl _index
600 00010EE4 fe 08 effffffb05 callf $8,_writed
601 00010EEB # writes("\ninst = LDD op1; MULD op2; LDFop3");
602 00010EEB .data 1
603 0000073d * L451:
604 0000073d * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1; MULD op2; LDFop3\0"
F70313B204D554C44206F7032
3B204C44466F703300
605 0000075f * .text
606 00010EEB dd 8f0000073d pushl $L451
607 00010EF1 fe 08 effffffaf8 callf $8,_writes
608 00010EF8 # writes(" (reserved operand fault on MULL3)\n");
609 00010EF8 .data 1
610 0000075f * L452:
611 0000075f * 20287265736572766564206F7 .ascii " (reserved operand fault on MULL3)\12\0"
06572616E64206661756C7420
6F6E204D554C4C33290A00
612 00000783 * .text
613 00010EF8 dd 8f0000075f pushl $L452
614 00010EFE fe 08 effffffaeb callf $8,_writes
615 00010F05 # }
616 00010F05 40 ret#2
617 00010F06 .set L440,0x0
618 00010F06 L442:
619 00010F06 13 ff5a jbr L443
620 00010F09 .data
621 000005d4 * .text
622 00010F09 00 .align 1
623 00010F0A .globl _pipe5_halt
624 00010F0A _pipe5_halt:
625 00010F0A 0000 .word L453
626 00010F0C #
627 00010F0C #
628 00010F0C #
629 00010F0C # /****************************************************************************
630 00010F0C # * Halt on Error routine
631 00010F0C # ****************************************************************************/
632 00010F0C # pipe5_halt( code )
633 00010F0C # int code; /* error code to halt with */
634 00010F0C # {
635 00010F0C 13 00af jbr L455
636 00010F0F L456:
637 00010F0F # err_code = code;
638 00010F0F 0d ad04 effffffad9 movl 4(fp),_err_code
639 00010F17 # sgl_value_4 = dbl_ld_acc.m;
640 00010F17 0d effffffad3 efffffface movl _dbl_ld_acc,_sgl_value_4
641 00010F22 # sgl_value_5 = dbl_ld_acc.l;
642 00010F22 0d effffffacc effffffac3 movl _dbl_ld_acc+4,_sgl_value_5
643 00010F2D # sgl_value_6 = dbl_value_1.m;
644 00010F2D 0d effffffabd effffffab8 movl _dbl_value_1,_sgl_value_6
645 00010F38 # sgl_value_7 = dbl_value_1.l;
646 00010F38 0d effffffab6 effffffaad movl _dbl_value_1+4,_sgl_value_7
647 00010F43 # asm("movl _test_no,r0"); /* r0 = test number */
648 00010F43 0d effffffaa7 50 movl _test_no,r0
649 00010F4A # asm("movl _subtest,r1"); /* r1 = subtest number */
650 00010F4A 0d effffffaa0 51 movl _subtest,r1
651 00010F51 # asm("movl _err_code,r2"); /* r2 = error code */
652 00010F51 0d effffffa99 52 movl _err_code,r2
653 00010F58 # asm("movl _cycle,r3"); /* r3 = cycle count */
654 00010F58 0d effffffa92 53 movl _cycle,r3
655 00010F5F # asm("movl _sgl_value_4,r4"); /* r4 = MSW of operand 1 */
656 00010F5F 0d effffffa8b 54 movl _sgl_value_4,r4
657 00010F66 # asm("movl _sgl_value_5,r5"); /* r5 = LSW of operand 1 */
658 00010F66 0d effffffa84 55 movl _sgl_value_5,r5
659 00010F6D # asm("movl _sgl_value_6,r6"); /* r6 = MSW of operand 2 */
660 00010F6D 0d effffffa7d 56 movl _sgl_value_6,r6
661 00010F74 # asm("movl _sgl_value_7,r7"); /* r7 = LSW of operand 2 */
662 00010F74 0d effffffa76 57 movl _sgl_value_7,r7
663 00010F7B # asm("movl _sgl_value_8,r8"); /* r8 = operand 3 */
664 00010F7B 0d effffffa6f 58 movl _sgl_value_8,r8
665 00010F82 # if( code == 1 )
666 00010F82 1d ad04 01 cmpl 4(fp),$1
667 00010F86 21 09 jneq L457
668 00010F88 # asm("movl _index,r9"); /* r9 = data index */
669 00010F88 0d effffffa62 59 movl _index,r9
670 00010F8F # else {
671 00010F8F 11 2b jbr L458
672 00010F91 L457:
673 00010F91 # sgl_value_6 = post_evt_acc.m;
674 00010F91 0d effffffa59 effffffa54 movl _post_evt_acc,_sgl_value_6
675 00010F9C # sgl_value_7 = post_evt_acc.l;
676 00010F9C 0d effffffa52 effffffa49 movl _post_evt_acc+4,_sgl_value_7
677 00010FA7 # asm("movl _sgl_value_6,r9"); /* r9 = MSW of final acc. */
678 00010FA7 0d effffffa43 59 movl _sgl_value_6,r9
679 00010FAE # asm("movl _sgl_value_7,r10"); /* r10 = LSW of final acc. */
680 00010FAE 0d effffffa3c 5a movl _sgl_value_7,r10
681 00010FB5 # asm("movl _index,r11"); /* r11 = data index */
682 00010FB5 0d effffffa35 5b movl _index,r11
683 00010FBC # }
684 00010FBC L458:
685 00010FBC # asm("halt");; /* HALT ... */
686 00010FBC 00 halt
687 00010FBD # }
688 00010FBD 40 ret#2
689 00010FBE .set L453,0x0
690 00010FBE L455:
691 00010FBE 13 ff4e jbr L456
692 00010FC1 .data
692 000219B1 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.