![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe2.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 pipe2.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 000006a8 * .text
4 00000000 .align 1
5 00000000 .globl _pipe2
6 00000000 _pipe2:
7 0000F9A8 0000 .word L381
8 0000F9AA #
9 0000F9AA # #include "evt_defs.h"
10 0000F9AA #
11 0000F9AA # /*
12 0000F9AA # *********************************************************************
13 0000F9AA # * FPP PIPELINED EVENTS TEST #2
14 0000F9AA # *
15 0000F9AA # * This test will execute the following code: "LDD MULD MTPR LDD"
16 0000F9AA # * with a reserved operand fault on the MTPR. We will make sure that:
17 0000F9AA # * 1. The fault is detected,
18 0000F9AA # * 2. the multiply operation completes, and
19 0000F9AA # * 3. the 2nd load instruction is not executed.
20 0000F9AA # *
21 0000F9AA # * NOTE: pipe6 also uses this test's data patterns
22 0000F9AA # *********************************************************************
23 0000F9AA # */
24 0000F9AA # pipe2()
25 0000F9AA # {
26 0000F9AA 13 0173 jbr L383
27 0000F9AD L384:
28 0000F9AD # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
29 0000F9AD ed 6d effffffff4 moval (r13),_pre_event_fp
30 0000F9B4 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
31 0000F9B4 ed 6e efffffffed moval (r14),_pre_event_sp
32 0000F9BB # precision = DBL;
33 0000F9BB 0d 02 efffffffe6 movl $2,_precision
34 0000F9C2 # test_event = RESOP_CODE; /* alignment fault expected */
35 0000F9C2 0d 2d efffffffdf movl $45,_test_event
36 0000F9C9 # exp_event = FALSE; /* ... but not yet */
37 0000F9C9 4d efffffffd9 clrl _exp_event
38 0000F9CF # asm("movab _pipe2_ret,_event_return"); /* set post - event return */
39 0000F9CF e9 ef000000d8 efffffffce movab _pipe2_ret,_event_return
40 0000F9DA # dbl_value_2.m = 0x12345678; /* data pattern for the */
41 0000F9DA 0d 8f12345678 efffffffc3 movl $305419896,_dbl_value_2
42 0000F9E5 # dbl_value_2.l = 0xfedcba98; /* 2nd LDD instruction */
43 0000F9E5 0d 8ffedcba98 efffffffbc movl $-19088744,_dbl_value_2+4
44 0000F9F0 # for( index = 0; index < max_pipe2_index; index++ )
45 0000F9F0 4d efffffffb2 clrl _index
46 0000F9F6 L387:
47 0000F9F6 1d efffffffac efffffffa7 cmpl _index,_max_pipe2_index
48 0000FA01 91 03 13 0119 jgeq L386
49 0000FA06 # {
50 0000FA06 # dbl_ld_acc = pipe2_data[index].op_1; /* get the data */
51 0000FA06 5c 18 efffffff9b 50 mull3 $24,_index,r0
52 0000FA0E 0c 8f00000000 50 addl2 $_pipe2_data,r0
53 0000FA15 0d a004 efffffff8f movl 4(r0),_dbl_ld_acc+4
54 0000FA1D 0d 60 efffffff84 movl (r0),_dbl_ld_acc
55 0000FA24 # dbl_value_1 = pipe2_data[index].op_2;
56 0000FA24 5c 18 efffffff7d 50 mull3 $24,_index,r0
57 0000FA2C 0c 8f00000008 50 addl2 $_pipe2_data+8,r0
58 0000FA33 0d a004 efffffff71 movl 4(r0),_dbl_value_1+4
59 0000FA3B 0d 60 efffffff66 movl (r0),_dbl_value_1
60 0000FA42 # dbl_expected = pipe2_data[index].exp;
61 0000FA42 5c 18 efffffff5f 50 mull3 $24,_index,r0
62 0000FA4A 0c 8f00000010 50 addl2 $_pipe2_data+16,r0
63 0000FA51 0d a004 efffffff53 movl 4(r0),_dbl_expected+4
64 0000FA59 0d 60 efffffff48 movl (r0),_dbl_expected
65 0000FA60 # asm(".globl _pipe2_lp1");
66 0000FA60 .globl _pipe2_lp1
67 0000FA60 # asm("_pipe2_lp1:");
68 0000FA60 _pipe2_lp1:
69 0000FA60 # asm("bispsw $0x60"); /* enable ovfl & undfl */
70 0000FA60 8b 8860 bispsw $0x60
71 0000FA63 # asm("ldd _dbl_ld_acc"); /* load the Acc. */
72 0000FA63 07 efffffff3f ldd _dbl_ld_acc
73 0000FA69 # exp_event = test_event; /* expect event soon */
74 0000FA69 0d efffffff39 efffffff34 movl _test_event,_exp_event
75 0000FA74 # asm("muld _dbl_value_1"); /* start the multiply */
76 0000FA74 e7 efffffff2e muld _dbl_value_1
77 0000FA7A # asm("mtpr $1,$0x40");; /* trigger the fault */
78 0000FA7A ad 01 8840 mtpr $1,$0x40
79 0000FA7E # asm("ldd _dbl_value_2"); /* we shouldn't get to here */
80 0000FA7E 07 efffffff24 ldd _dbl_value_2
81 0000FA84 # /*
82 0000FA84 # * If we got to here then there was no event
83 0000FA84 # */
84 0000FA84 # if( force_loop )
85 0000FA84 5d efffffff1e tstl _force_loop
86 0000FA8A 31 03 jeql L388
87 0000FA8C # asm("brw _pipe2_lp1");; /* loop on the error */
Assemb00027168 # asm("brw _pipe2_lp1");; /* loop on the error */
"pipe200027168 88: WARNING: brw: destination label is external
88 0000FA8C 13 ffd1 brw _pipe2_lp1
89 0000FA8F L388:
90 0000FA8F # exp_event = FALSE; /* reset event expected flag */
91 0000FA8F 4d efffffff13 clrl _exp_event
92 0000FA95 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
93 0000FA95 0d efffffff0d 5d movl _pre_event_fp,fp
94 0000FA9C # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
95 0000FA9C 0d efffffff06 5e movl _pre_event_sp,sp
96 0000FAA3 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
97 0000FAA3 9b 8860 bicpsw $0x60
98 0000FAA6 # no_pipe2_evt();; /* report the error */
99 0000FAA6 fe 04 ef00000077 callf $4,_no_pipe2_evt
100 0000FAAD # /*
101 0000FAAD # * Come here after the event
102 0000FAAD # */
103 0000FAAD # asm(".globl _pipe2_ret");
104 0000FAAD .globl _pipe2_ret
105 0000FAAD # asm("_pipe2_ret:");
106 0000FAAD _pipe2_ret:
107 0000FAAD # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
108 0000FAAD 0d effffffef5 5d movl _pre_event_fp,fp
109 0000FAB4 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
110 0000FAB4 0d effffffeee 5e movl _pre_event_sp,sp
111 0000FABB # if( force_loop )
112 0000FABB 5d effffffee7 tstl _force_loop
113 0000FAC1 31 03 jeql L390
114 0000FAC3 # asm("brw _pipe2_lp1");; /* loop on the error */
"pipe200027168 115: WARNING: brw: destination label is external
115 0000FAC3 13 ff9a brw _pipe2_lp1
116 0000FAC6 L390:
117 0000FAC6 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
118 0000FAC6 9b 8860 bicpsw $0x60
119 0000FAC9 # if( post_evt_acc.l != dbl_expected.l )
120 0000FAC9 1d effffffedd effffffed8 cmpl _post_evt_acc+4,_dbl_expected+4
121 0000FAD4 31 09 jeql L391
122 0000FAD6 # bad_pipe2_result(); /* incorrect result error */
123 0000FAD6 fe 04 ef00000103 callf $4,_bad_pipe2_result
124 0000FADD # else if( post_evt_acc.m != dbl_expected.m )
125 0000FADD 11 37 jbr L393
126 0000FADF L391:
127 0000FADF 1d effffffec3 effffffebe cmpl _post_evt_acc,_dbl_expected
128 0000FAEA 31 2a jeql L394
129 0000FAEC # {
130 0000FAEC # if( (post_evt_acc.m == dbl_value_2.m) &&
131 0000FAEC # (post_evt_acc.l == dbl_value_2.l) )
132 0000FAEC 1d effffffeb6 effffffeb1 cmpl _post_evt_acc,_dbl_value_2
133 0000FAF7 21 16 jneq L395
134 0000FAF9 1d effffffead effffffea8 cmpl _post_evt_acc+4,_dbl_value_2+4
135 0000FB04 21 09 jneq L395
136 0000FB06 # pipe2_queue_er(); /* queue not cleared error */
137 0000FB06 fe 04 ef00000237 callf $4,_pipe2_queue_er
138 0000FB0D # else
139 0000FB0D 11 07 jbr L397
140 0000FB0F L395:
141 0000FB0F # bad_pipe2_result(); /* incorrect result error */
142 0000FB0F fe 04 ef000000ca callf $4,_bad_pipe2_result
143 0000FB16 L397:
144 0000FB16 # }
145 0000FB16 # }
146 0000FB16 L394:
147 0000FB16 L393:
148 0000FB16 L385:
149 0000FB16 6d effffffe8c incl _index
150 0000FB1C 13 fed7 jbr L387
151 0000FB1F L386:
152 0000FB1F # }
153 0000FB1F 40 ret#2
154 0000FB20 .set L381,0x0
155 0000FB20 L383:
156 0000FB20 13 fe8a jbr L384
157 0000FB23 .data
158 000006a8 * .text
159 0000FB23 00 .align 1
160 0000FB24 .globl _no_pipe2_evt
161 0000FB24 _no_pipe2_evt:
162 0000FB24 0000 .word L398
163 0000FB26 #
164 0000FB26 #
165 0000FB26 #
166 0000FB26 # /****************************************************************************
167 0000FB26 # * Report an "EVENT NOT DETECTED" error
168 0000FB26 # *
169 0000FB26 # * Cycle: xx. EVT test xx. subtest xx. No Reserved Operand fault. index = xx
170 0000FB26 # * inst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3 (Reserved Op. fault on MTPR)
171 0000FB26 # * op1 = xxxxxxxx xxxxxxxx, op2 = xxxxxxxx xxxxxxxx
172 0000FB26 # ****************************************************************************/
173 0000FB26 # no_pipe2_evt()
174 0000FB26 # {
175 0000FB26 13 00b3 jbr L400
176 0000FB29 L401:
177 0000FB29 # errcnt++; /* bump the error count */
178 0000FB29 6d effffffe79 incl _errcnt
179 0000FB2F # if ( prt_error ) {
180 0000FB2F 5d effffffe73 tstl _prt_error
181 0000FB35 31 7e jeql L402
182 0000FB37 # print_pipe2_err( " No Reserved Operand fault." );
183 0000FB37 .data 1
184 000006a8 * L404:
185 000006a8 * 20204E6F20526573657276656 .ascii " No Reserved Operand fault.\0"
4204F706572616E6420666175
6C742E00
186 000006c5 * .text
187 0000FB37 dd 8f000006a8 pushl $L404
188 0000FB3D fe 08 ef00000364 callf $8,_print_pipe2_err
189 0000FB44 # writes("op1 = ");
190 0000FB44 .data 1
191 000006c5 * L406:
192 000006c5 * 6F7031203D2000 .ascii "op1 = \0"
193 000006cc * .text
194 0000FB44 dd 8f000006c5 pushl $L406
195 0000FB4A fe 08 effffffe57 callf $8,_writes
196 0000FB51 # write32h( dbl_ld_acc.m );
197 0000FB51 dd effffffe51 pushl _dbl_ld_acc
198 0000FB57 fe 08 effffffe4a callf $8,_write32h
199 0000FB5E # writes(" ");
200 0000FB5E .data 1
201 000006cc * L408:
202 000006cc * 2000 .ascii " \0"
203 000006ce * .text
204 0000FB5E dd 8f000006cc pushl $L408
205 0000FB64 fe 08 effffffe3d callf $8,_writes
206 0000FB6B # write32h( dbl_ld_acc.l );
207 0000FB6B dd effffffe3b pushl _dbl_ld_acc+4
208 0000FB71 fe 08 effffffe30 callf $8,_write32h
209 0000FB78 # writes(", op2 = ");
210 0000FB78 .data 1
211 000006ce * L409:
212 000006ce * 2C2020206F7032203D2000 .ascii ", op2 = \0"
213 000006d9 * .text
214 0000FB78 dd 8f000006ce pushl $L409
215 0000FB7E fe 08 effffffe23 callf $8,_writes
216 0000FB85 # write32h( dbl_value_1.m );
217 0000FB85 dd effffffe1d pushl _dbl_value_1
218 0000FB8B fe 08 effffffe16 callf $8,_write32h
219 0000FB92 # writes(" ");
220 0000FB92 .data 1
221 000006d9 * L410:
222 000006d9 * 2000 .ascii " \0"
223 000006db * .text
224 0000FB92 dd 8f000006d9 pushl $L410
225 0000FB98 fe 08 effffffe09 callf $8,_writes
226 0000FB9F # write32h( dbl_value_1.l );
227 0000FB9F dd effffffe07 pushl _dbl_value_1+4
228 0000FBA5 fe 08 effffffdfc callf $8,_write32h
229 0000FBAC # writec('\n');
230 0000FBAC dd 0a pushl $10
231 0000FBAE fe 08 effffffdf3 callf $8,_writec
232 0000FBB5 # }
233 0000FBB5 # if ( halt_flg ) /* halt on error? */
234 0000FBB5 L402:
235 0000FBB5 5d effffffded tstl _halt_flg
236 0000FBBB 31 09 jeql L412
237 0000FBBD # pipe2_halt( 1 ); /* halt with a code of 1 */
238 0000FBBD dd 01 pushl $1
239 0000FBBF fe 08 ef0000038e callf $8,_pipe2_halt
240 0000FBC6 # if ( loop_on_err ) {
241 0000FBC6 L412:
242 0000FBC6 5d effffffddc tstl _loop_on_err
243 0000FBCC 31 0d jeql L414
244 0000FBCE # force_loop = TRUE; /* set the force loop flag */
245 0000FBCE 0d 01 effffffdd3 movl $1,_force_loop
246 0000FBD5 # asm("jmp _pipe2_lp1"); /* and loop */
247 0000FBD5 71 effffffe85 jmp _pipe2_lp1
248 0000FBDB # };
249 0000FBDB L414:
250 0000FBDB # }
251 0000FBDB 40 ret#2
252 0000FBDC .set L398,0x0
253 0000FBDC L400:
254 0000FBDC 13 ff4a jbr L401
255 0000FBDF .data
256 000006a8 * .text
257 0000FBDF 00 .align 1
258 0000FBE0 .globl _bad_pipe2_result
259 0000FBE0 _bad_pipe2_result:
260 0000FBE0 0000 .word L415
261 0000FBE2 #
262 0000FBE2 #
263 0000FBE2 #
264 0000FBE2 #
265 0000FBE2 # /****************************************************************************
266 0000FBE2 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
267 0000FBE2 # *
268 0000FBE2 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
269 0000FBE2 # * inst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3 (Reserved Op. fault on MTPR)
270 0000FBE2 # * The 2nd LDD should not be executed.
271 0000FBE2 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
272 0000FBE2 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
273 0000FBE2 # * op3 = xxxxxxxx xxxxxxxx
274 0000FBE2 # ****************************************************************************/
275 0000FBE2 # bad_pipe2_result()
276 0000FBE2 # {
277 0000FBE2 13 015b jbr L417
278 0000FBE5 L418:
279 0000FBE5 # errcnt++; /* bump the error count */
280 0000FBE5 6d effffffdbd incl _errcnt
281 0000FBEB # if ( prt_error ) {
282 0000FBEB 5d effffffdb7 tstl _prt_error
283 0000FBF1 21 03 13 0123 jeql L419
284 0000FBF6 # print_pipe2_err( ". Bad final Accumulator." );
285 0000FBF6 .data 1
286 000006db * L420:
287 000006db * 2E204261642066696E616C204 .ascii ". Bad final Accumulator.\0"
16363756D756C61746F722E00
288 000006f4 * .text
289 0000FBF6 dd 8f000006db pushl $L420
290 0000FBFC fe 08 ef000002a5 callf $8,_print_pipe2_err
291 0000FC03 # writes("The 2nd LDD should not be executed\n");
292 0000FC03 .data 1
293 000006f4 * L421:
294 000006f4 * 54686520326E64204C4444207 .ascii "The 2nd LDD should not be executed\12\0"
3686F756C64206E6F74206265
2065786563757465640A00
295 00000718 * .text
296 0000FC03 dd 8f000006f4 pushl $L421
297 0000FC09 fe 08 effffffd98 callf $8,_writes
298 0000FC10 # writes("op1 = ");
299 0000FC10 .data 1
300 00000718 * L422:
301 00000718 * 6F7031203D2000 .ascii "op1 = \0"
302 0000071f * .text
303 0000FC10 dd 8f00000718 pushl $L422
304 0000FC16 fe 08 effffffd8b callf $8,_writes
305 0000FC1D # write32h( dbl_ld_acc.m );
306 0000FC1D dd effffffd85 pushl _dbl_ld_acc
307 0000FC23 fe 08 effffffd7e callf $8,_write32h
308 0000FC2A # writes(" ");
309 0000FC2A .data 1
310 0000071f * L423:
311 0000071f * 2000 .ascii " \0"
312 00000721 * .text
313 0000FC2A dd 8f0000071f pushl $L423
314 0000FC30 fe 08 effffffd71 callf $8,_writes
315 0000FC37 # write32h( dbl_ld_acc.l );
316 0000FC37 dd effffffd6f pushl _dbl_ld_acc+4
317 0000FC3D fe 08 effffffd64 callf $8,_write32h
318 0000FC44 # writes(", final Acc. = ");
319 0000FC44 .data 1
320 00000721 * L424:
321 00000721 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
32E203D2000
322 00000733 * .text
323 0000FC44 dd 8f00000721 pushl $L424
324 0000FC4A fe 08 effffffd57 callf $8,_writes
325 0000FC51 # write32h( post_evt_acc.m );
326 0000FC51 dd effffffd51 pushl _post_evt_acc
327 0000FC57 fe 08 effffffd4a callf $8,_write32h
328 0000FC5E # writec(' ');
329 0000FC5E dd 20 pushl $32
330 0000FC60 fe 08 effffffd41 callf $8,_writec
331 0000FC67 # write32h( post_evt_acc.l );
332 0000FC67 dd effffffd3f pushl _post_evt_acc+4
333 0000FC6D fe 08 effffffd34 callf $8,_write32h
334 0000FC74 # writes("\nop2 = ");
335 0000FC74 .data 1
336 00000733 * L425:
337 00000733 * 0A6F7032203D2000 .ascii "\12op2 = \0"
338 0000073b * .text
339 0000FC74 dd 8f00000733 pushl $L425
340 0000FC7A fe 08 effffffd27 callf $8,_writes
341 0000FC81 # write32h( dbl_value_1.m );
342 0000FC81 dd effffffd21 pushl _dbl_value_1
343 0000FC87 fe 08 effffffd1a callf $8,_write32h
344 0000FC8E # writes(" ");
345 0000FC8E .data 1
346 0000073b * L426:
347 0000073b * 2000 .ascii " \0"
348 0000073d * .text
349 0000FC8E dd 8f0000073b pushl $L426
350 0000FC94 fe 08 effffffd0d callf $8,_writes
351 0000FC9B # write32h( dbl_value_1.l );
352 0000FC9B dd effffffd0b pushl _dbl_value_1+4
353 0000FCA1 fe 08 effffffd00 callf $8,_write32h
354 0000FCA8 # writes(", expected = ");
355 0000FCA8 .data 1
356 0000073d * L427:
357 0000073d * 2C20202065787065637465642 .ascii ", expected = \0"
020203D2000
358 0000074f * .text
359 0000FCA8 dd 8f0000073d pushl $L427
360 0000FCAE fe 08 effffffcf3 callf $8,_writes
361 0000FCB5 # write32h( dbl_expected.m );
362 0000FCB5 dd effffffced pushl _dbl_expected
363 0000FCBB fe 08 effffffce6 callf $8,_write32h
364 0000FCC2 # writes(" ");
365 0000FCC2 .data 1
366 0000074f * L428:
367 0000074f * 2000 .ascii " \0"
368 00000751 * .text
369 0000FCC2 dd 8f0000074f pushl $L428
370 0000FCC8 fe 08 effffffcd9 callf $8,_writes
371 0000FCCF # write32h( dbl_expected.l );
372 0000FCCF dd effffffcd7 pushl _dbl_expected+4
373 0000FCD5 fe 08 effffffccc callf $8,_write32h
374 0000FCDC # writes("\nop3 = ");
375 0000FCDC .data 1
376 00000751 * L429:
377 00000751 * 0A6F7033203D2000 .ascii "\12op3 = \0"
378 00000759 * .text
379 0000FCDC dd 8f00000751 pushl $L429
380 0000FCE2 fe 08 effffffcbf callf $8,_writes
381 0000FCE9 # write32h( dbl_value_2.m );
382 0000FCE9 dd effffffcb9 pushl _dbl_value_2
383 0000FCEF fe 08 effffffcb2 callf $8,_write32h
384 0000FCF6 # writes(" ");
385 0000FCF6 .data 1
386 00000759 * L430:
387 00000759 * 2000 .ascii " \0"
388 0000075b * .text
389 0000FCF6 dd 8f00000759 pushl $L430
390 0000FCFC fe 08 effffffca5 callf $8,_writes
391 0000FD03 # write32h( dbl_value_2.l );
392 0000FD03 dd effffffca3 pushl _dbl_value_2+4
393 0000FD09 fe 08 effffffc98 callf $8,_write32h
394 0000FD10 # writec('\n');
395 0000FD10 dd 0a pushl $10
396 0000FD12 fe 08 effffffc8f callf $8,_writec
397 0000FD19 # }
398 0000FD19 # if ( halt_flg ) /* halt on error? */
399 0000FD19 L419:
400 0000FD19 5d effffffc89 tstl _halt_flg
401 0000FD1F 31 09 jeql L431
402 0000FD21 # pipe2_halt( 2 ); /* halt with a code of 2 */
403 0000FD21 dd 02 pushl $2
404 0000FD23 fe 08 ef0000022a callf $8,_pipe2_halt
405 0000FD2A # if ( loop_on_err ) {
406 0000FD2A L431:
407 0000FD2A 5d effffffc78 tstl _loop_on_err
408 0000FD30 31 0d jeql L432
409 0000FD32 # force_loop = TRUE; /* set the force loop flag */
410 0000FD32 0d 01 effffffc6f movl $1,_force_loop
411 0000FD39 # asm("jmp _pipe2_lp1"); /* and loop */
412 0000FD39 71 effffffd21 jmp _pipe2_lp1
413 0000FD3F # };
414 0000FD3F L432:
415 0000FD3F # }
416 0000FD3F 40 ret#2
417 0000FD40 .set L415,0x0
418 0000FD40 L417:
419 0000FD40 13 fea2 jbr L418
420 0000FD43 .data
421 000006a8 * .text
422 0000FD43 00 .align 1
423 0000FD44 .globl _pipe2_queue_er
424 0000FD44 _pipe2_queue_er:
425 0000FD44 0000 .word L433
426 0000FD46 #
427 0000FD46 #
428 0000FD46 #
429 0000FD46 #
430 0000FD46 # /****************************************************************************
431 0000FD46 # * Report an "FPP Queue not cleared" error
432 0000FD46 # *
433 0000FD46 # * Cycle: xx. EVT test xx. subtest xx. FPP queue not cleared. index = xx
434 0000FD46 # * inst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3 (Reserved Op. fault on MTPR)
435 0000FD46 # * The 2nd LDD should not have been executed but apparently was.
436 0000FD46 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
437 0000FD46 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
438 0000FD46 # * op3 = xxxxxxxx xxxxxxxx
439 0000FD46 # ****************************************************************************/
440 0000FD46 # pipe2_queue_er()
441 0000FD46 # {
442 0000FD46 13 015b jbr L435
443 0000FD49 L436:
444 0000FD49 # errcnt++; /* bump the error count */
445 0000FD49 6d effffffc59 incl _errcnt
446 0000FD4F # if ( prt_error ) {
447 0000FD4F 5d effffffc53 tstl _prt_error
448 0000FD55 21 03 13 0123 jeql L437
449 0000FD5A # print_pipe2_err( ". FPP queue not cleared." );
450 0000FD5A .data 1
451 0000075b * L438:
452 0000075b * 2E20465050207175657565206 .ascii ". FPP queue not cleared.\0"
E6F7420636C65617265642E00
453 00000774 * .text
454 0000FD5A dd 8f0000075b pushl $L438
455 0000FD60 fe 08 ef00000141 callf $8,_print_pipe2_err
456 0000FD67 # writes(
457 0000FD67 # "The 2nd LDD should not have been executed but apparently was.\n");
458 0000FD67 .data 1
459 00000774 * L439:
460 00000774 * 54686520326E64204C4444207 .ascii "The 2nd LDD should not have been executed but apparently was.\12\0"
3686F756C64206E6F74206861
7665206265656E20657865637
5746564206275742061707061
72656E746C79207761732E0A0
0
461 000007b3 * .text
462 0000FD67 dd 8f00000774 pushl $L439
463 0000FD6D fe 08 effffffc34 callf $8,_writes
464 0000FD74 # writes("op1 = ");
465 0000FD74 .data 1
466 000007b3 * L440:
467 000007b3 * 6F7031203D2000 .ascii "op1 = \0"
468 000007ba * .text
469 0000FD74 dd 8f000007b3 pushl $L440
470 0000FD7A fe 08 effffffc27 callf $8,_writes
471 0000FD81 # write32h( dbl_ld_acc.m );
472 0000FD81 dd effffffc21 pushl _dbl_ld_acc
473 0000FD87 fe 08 effffffc1a callf $8,_write32h
474 0000FD8E # writes(" ");
475 0000FD8E .data 1
476 000007ba * L441:
477 000007ba * 2000 .ascii " \0"
478 000007bc * .text
479 0000FD8E dd 8f000007ba pushl $L441
480 0000FD94 fe 08 effffffc0d callf $8,_writes
481 0000FD9B # write32h( dbl_ld_acc.l );
482 0000FD9B dd effffffc0b pushl _dbl_ld_acc+4
483 0000FDA1 fe 08 effffffc00 callf $8,_write32h
484 0000FDA8 # writes(", final Acc. = ");
485 0000FDA8 .data 1
486 000007bc * L442:
487 000007bc * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
32E203D2000
488 000007ce * .text
489 0000FDA8 dd 8f000007bc pushl $L442
490 0000FDAE fe 08 effffffbf3 callf $8,_writes
491 0000FDB5 # write32h( post_evt_acc.m );
492 0000FDB5 dd effffffbed pushl _post_evt_acc
493 0000FDBB fe 08 effffffbe6 callf $8,_write32h
494 0000FDC2 # writec(' ');
495 0000FDC2 dd 20 pushl $32
496 0000FDC4 fe 08 effffffbdd callf $8,_writec
497 0000FDCB # write32h( post_evt_acc.l );
498 0000FDCB dd effffffbdb pushl _post_evt_acc+4
499 0000FDD1 fe 08 effffffbd0 callf $8,_write32h
500 0000FDD8 # writes("\nop2 = ");
501 0000FDD8 .data 1
502 000007ce * L443:
503 000007ce * 0A6F7032203D2000 .ascii "\12op2 = \0"
504 000007d6 * .text
505 0000FDD8 dd 8f000007ce pushl $L443
506 0000FDDE fe 08 effffffbc3 callf $8,_writes
507 0000FDE5 # write32h( dbl_value_1.m );
508 0000FDE5 dd effffffbbd pushl _dbl_value_1
509 0000FDEB fe 08 effffffbb6 callf $8,_write32h
510 0000FDF2 # writes(" ");
511 0000FDF2 .data 1
512 000007d6 * L444:
513 000007d6 * 2000 .ascii " \0"
514 000007d8 * .text
515 0000FDF2 dd 8f000007d6 pushl $L444
516 0000FDF8 fe 08 effffffba9 callf $8,_writes
517 0000FDFF # write32h( dbl_value_1.l );
518 0000FDFF dd effffffba7 pushl _dbl_value_1+4
519 0000FE05 fe 08 effffffb9c callf $8,_write32h
520 0000FE0C # writes(", expected = ");
521 0000FE0C .data 1
522 000007d8 * L445:
523 000007d8 * 2C20202065787065637465642 .ascii ", expected = \0"
020203D2000
524 000007ea * .text
525 0000FE0C dd 8f000007d8 pushl $L445
526 0000FE12 fe 08 effffffb8f callf $8,_writes
527 0000FE19 # write32h( dbl_expected.m );
528 0000FE19 dd effffffb89 pushl _dbl_expected
529 0000FE1F fe 08 effffffb82 callf $8,_write32h
530 0000FE26 # writes(" ");
531 0000FE26 .data 1
532 000007ea * L446:
533 000007ea * 2000 .ascii " \0"
534 000007ec * .text
535 0000FE26 dd 8f000007ea pushl $L446
536 0000FE2C fe 08 effffffb75 callf $8,_writes
537 0000FE33 # write32h( dbl_expected.l );
538 0000FE33 dd effffffb73 pushl _dbl_expected+4
539 0000FE39 fe 08 effffffb68 callf $8,_write32h
540 0000FE40 # writes("\nop3 = ");
541 0000FE40 .data 1
542 000007ec * L447:
543 000007ec * 0A6F7033203D2000 .ascii "\12op3 = \0"
544 000007f4 * .text
545 0000FE40 dd 8f000007ec pushl $L447
546 0000FE46 fe 08 effffffb5b callf $8,_writes
547 0000FE4D # write32h( dbl_value_2.m );
548 0000FE4D dd effffffb55 pushl _dbl_value_2
549 0000FE53 fe 08 effffffb4e callf $8,_write32h
550 0000FE5A # writes(" ");
551 0000FE5A .data 1
552 000007f4 * L448:
553 000007f4 * 2000 .ascii " \0"
554 000007f6 * .text
555 0000FE5A dd 8f000007f4 pushl $L448
556 0000FE60 fe 08 effffffb41 callf $8,_writes
557 0000FE67 # write32h( dbl_value_2.l );
558 0000FE67 dd effffffb3f pushl _dbl_value_2+4
559 0000FE6D fe 08 effffffb34 callf $8,_write32h
560 0000FE74 # writec('\n');
561 0000FE74 dd 0a pushl $10
562 0000FE76 fe 08 effffffb2b callf $8,_writec
563 0000FE7D # }
564 0000FE7D # if ( halt_flg ) /* halt on error? */
565 0000FE7D L437:
566 0000FE7D 5d effffffb25 tstl _halt_flg
567 0000FE83 31 09 jeql L449
568 0000FE85 # pipe2_halt( 3 ); /* halt with a code of 3 */
569 0000FE85 dd 03 pushl $3
570 0000FE87 fe 08 ef000000c6 callf $8,_pipe2_halt
571 0000FE8E # if ( loop_on_err ) {
572 0000FE8E L449:
573 0000FE8E 5d effffffb14 tstl _loop_on_err
574 0000FE94 31 0d jeql L450
575 0000FE96 # force_loop = TRUE; /* set the force loop flag */
576 0000FE96 0d 01 effffffb0b movl $1,_force_loop
577 0000FE9D # asm("jmp _pipe2_lp1"); /* and loop */
578 0000FE9D 71 effffffbbd jmp _pipe2_lp1
579 0000FEA3 # };
580 0000FEA3 L450:
581 0000FEA3 # }
582 0000FEA3 40 ret#2
583 0000FEA4 .set L433,0x0
584 0000FEA4 L435:
585 0000FEA4 13 fea2 jbr L436
586 0000FEA7 .data
587 000006a8 * .text
588 0000FEA7 00 .align 1
589 0000FEA8 .globl _print_pipe2_err
590 0000FEA8 _print_pipe2_err:
591 0000FEA8 0000 .word L451
592 0000FEAA #
593 0000FEAA #
594 0000FEAA #
595 0000FEAA #
596 0000FEAA #
597 0000FEAA # /****************************************************************************
598 0000FEAA # * Report an error message of the form
599 0000FEAA # *
600 0000FEAA # * Cycle: xx. EVT test xx. subtest xx <your message here> index = xx
601 0000FEAA # * inst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3 (fault expected on the MTPR)
602 0000FEAA # ****************************************************************************/
603 0000FEAA # print_pipe2_err( msg )
604 0000FEAA # char *msg; /* pointer to error message */
605 0000FEAA # {
606 0000FEAA 13 00a3 jbr L453
607 0000FEAD L454:
608 0000FEAD # if( errcnt == 1 ) /* 1st error? */
609 0000FEAD 1d effffffaf5 01 cmpl _errcnt,$1
610 0000FEB4 21 0d jneq L455
611 0000FEB6 # writes(" \n"); /* start a new print line */
612 0000FEB6 .data 1
613 000007f6 * L456:
614 000007f6 * 200A00 .ascii " \12\0"
615 000007f9 * .text
616 0000FEB6 dd 8f000007f6 pushl $L456
617 0000FEBC fe 08 effffffae5 callf $8,_writes
618 0000FEC3 # writes("Cycle: ");
619 0000FEC3 L455:
620 0000FEC3 .data 1
621 000007f9 * L457:
622 000007f9 * 4379636C653A2000 .ascii "Cycle: \0"
623 00000801 * .text
624 0000FEC3 dd 8f000007f9 pushl $L457
625 0000FEC9 fe 08 effffffad8 callf $8,_writes
626 0000FED0 # writed( cycle );
627 0000FED0 dd effffffad2 pushl _cycle
628 0000FED6 fe 08 effffffacb callf $8,_writed
629 0000FEDD # writes(" EVT test ");
630 0000FEDD .data 1
631 00000801 * L459:
632 00000801 * 202045565420746573742000 .ascii " EVT test \0"
633 0000080d * .text
634 0000FEDD dd 8f00000801 pushl $L459
635 0000FEE3 fe 08 effffffabe callf $8,_writes
636 0000FEEA # writed( test_no );
637 0000FEEA dd effffffab8 pushl _test_no
638 0000FEF0 fe 08 effffffab1 callf $8,_writed
639 0000FEF7 # writes(". subtest ");
640 0000FEF7 .data 1
641 0000080d * L460:
642 0000080d * 2E20737562746573742000 .ascii ". subtest \0"
643 00000818 * .text
644 0000FEF7 dd 8f0000080d pushl $L460
645 0000FEFD fe 08 effffffaa4 callf $8,_writes
646 0000FF04 # writed( subtest );
647 0000FF04 dd effffffa9e pushl _subtest
648 0000FF0A fe 08 effffffa97 callf $8,_writed
649 0000FF11 # writes( msg ); /* print the error message */
650 0000FF11 dd ad04 pushl 4(fp)
651 0000FF14 fe 08 effffffa8d callf $8,_writes
652 0000FF1B # writes(" index = ");
653 0000FF1B .data 1
654 00000818 * L461:
655 00000818 * 20696E646578203D2000 .ascii " index = \0"
656 00000822 * .text
657 0000FF1B dd 8f00000818 pushl $L461
658 0000FF21 fe 08 effffffa80 callf $8,_writes
659 0000FF28 # writed( index );
660 0000FF28 dd effffffa7a pushl _index
661 0000FF2E fe 08 effffffa73 callf $8,_writed
662 0000FF35 # writes("\ninst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3");
663 0000FF35 .data 1
664 00000822 * L462:
665 00000822 * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3\0"
F70312C204D554C44206F7032
2C204D54505220312C3078343
02C204C4444206F703300
666 00000852 * .text
667 0000FF35 dd 8f00000822 pushl $L462
668 0000FF3B fe 08 effffffa66 callf $8,_writes
669 0000FF42 # writes(" (Reserved Op. fault on the MTPR)\n");
670 0000FF42 .data 1
671 00000852 * L463:
672 00000852 * 20285265736572766564204F7 .ascii " (Reserved Op. fault on the MTPR)\12\0"
02E206661756C74206F6E2074
6865204D545052290A00
673 00000875 * .text
674 0000FF42 dd 8f00000852 pushl $L463
675 0000FF48 fe 08 effffffa59 callf $8,_writes
676 0000FF4F # }
677 0000FF4F 40 ret#2
678 0000FF50 .set L451,0x0
679 0000FF50 L453:
680 0000FF50 13 ff5a jbr L454
681 0000FF53 .data
682 000006a8 * .text
683 0000FF53 00 .align 1
684 0000FF54 .globl _pipe2_halt
685 0000FF54 _pipe2_halt:
686 0000FF54 0000 .word L464
687 0000FF56 #
688 0000FF56 #
689 0000FF56 # /****************************************************************************
690 0000FF56 # * Error Halt Routine
691 0000FF56 # ****************************************************************************/
692 0000FF56 # pipe2_halt( code )
693 0000FF56 # int code; /* halt code to use */
694 0000FF56 # {
695 0000FF56 13 00f1 jbr L466
696 0000FF59 L467:
697 0000FF59 # err_code = code;
698 0000FF59 0d ad04 effffffa47 movl 4(fp),_err_code
699 0000FF61 # sgl_value_1 = dbl_ld_acc.m;
700 0000FF61 0d effffffa41 effffffa3c movl _dbl_ld_acc,_sgl_value_1
701 0000FF6C # sgl_value_2 = dbl_ld_acc.l;
702 0000FF6C 0d effffffa3a effffffa31 movl _dbl_ld_acc+4,_sgl_value_2
703 0000FF77 # sgl_value_3 = dbl_value_1.m;
704 0000FF77 0d effffffa2b effffffa26 movl _dbl_value_1,_sgl_value_3
705 0000FF82 # sgl_value_4 = dbl_value_1.l;
706 0000FF82 0d effffffa24 effffffa1b movl _dbl_value_1+4,_sgl_value_4
707 0000FF8D # asm("movl _test_no,r0"); /* r0 = test number */
708 0000FF8D 0d effffffa15 50 movl _test_no,r0
709 0000FF94 # asm("movl _subtest,r1"); /* r1 = subtest number */
710 0000FF94 0d effffffa0e 51 movl _subtest,r1
711 0000FF9B # asm("movl _err_code,r2"); /* r2 = error code */
712 0000FF9B 0d effffffa07 52 movl _err_code,r2
713 0000FFA2 # asm("movl _cycle,r3"); /* r3 = cycle count */
714 0000FFA2 0d effffffa00 53 movl _cycle,r3
715 0000FFA9 # asm("movl _sgl_value_1,r4"); /* r4 = MSW of operand 1 */
716 0000FFA9 0d effffff9f9 54 movl _sgl_value_1,r4
717 0000FFB0 # asm("movl _sgl_value_2,r5"); /* r5 = LSW of operand 1 */
718 0000FFB0 0d effffff9f2 55 movl _sgl_value_2,r5
719 0000FFB7 # asm("movl _sgl_value_3,r6"); /* r6 = MSW of operand 2 */
720 0000FFB7 0d effffff9eb 56 movl _sgl_value_3,r6
721 0000FFBE # asm("movl _sgl_value_4,r7"); /* r7 = LSW of operand 2 */
722 0000FFBE 0d effffff9e4 57 movl _sgl_value_4,r7
723 0000FFC5 # if( code == 1 ) {
724 0000FFC5 1d ad04 01 cmpl 4(fp),$1
725 0000FFC9 21 0a jneq L468
726 0000FFCB # asm("movl _index,r8"); /* r8 = data index */
727 0000FFCB 0d effffff9d7 58 movl _index,r8
728 0000FFD2 # asm("halt"); /* HALT ... */
729 0000FFD2 00 halt
730 0000FFD3 # } else {
731 0000FFD3 11 73 jbr L469
732 0000FFD5 L468:
733 0000FFD5 # sgl_value_1 = post_evt_acc.m;
734 0000FFD5 0d effffff9cd effffff9c8 movl _post_evt_acc,_sgl_value_1
735 0000FFE0 # sgl_value_2 = post_evt_acc.l;
736 0000FFE0 0d effffff9c6 effffff9bd movl _post_evt_acc+4,_sgl_value_2
737 0000FFEB # sgl_value_3 = dbl_expected.m;
738 0000FFEB 0d effffff9b7 effffff9b2 movl _dbl_expected,_sgl_value_3
739 0000FFF6 # sgl_value_4 = dbl_expected.l;
740 0000FFF6 0d effffff9b0 effffff9a7 movl _dbl_expected+4,_sgl_value_4
741 00010001 # sgl_value_5 = dbl_value_2.m;
742 00010001 0d effffff9a1 effffff99c movl _dbl_value_2,_sgl_value_5
743 0001000C # sgl_value_6 = dbl_value_2.l;
744 0001000C 0d effffff99a effffff991 movl _dbl_value_2+4,_sgl_value_6
745 00010017 # asm("movl _sgl_value_1,r8"); /* r8 = MSW of final acc. */
746 00010017 0d effffff98b 58 movl _sgl_value_1,r8
747 0001001E # asm("movl _sgl_value_2,r9"); /* r9 = LSW of final acc. */
748 0001001E 0d effffff984 59 movl _sgl_value_2,r9
749 00010025 # asm("movl _sgl_value_3,r10"); /* r10 = MSW of expected */
750 00010025 0d effffff97d 5a movl _sgl_value_3,r10
751 0001002C # asm("movl _sgl_value_4,r11"); /* r11 = LSW of expected */
752 0001002C 0d effffff976 5b movl _sgl_value_4,r11
753 00010033 # asm("movl _sgl_value_5,r12"); /* r12 = MSW of operand 3 */
754 00010033 0d effffff96f 5c movl _sgl_value_5,r12
755 0001003A # asm("movl _sgl_value_6,r13"); /* r13 = LSW of operand 3 */
756 0001003A 0d effffff968 5d movl _sgl_value_6,r13
757 00010041 # asm("movl _index,r14"); /* r14 = data index */
758 00010041 0d effffff961 5e movl _index,r14
759 00010048 # }
760 00010048 L469:
761 00010048 # asm("halt"); /* HALT ... */
762 00010048 00 halt
763 00010049 # }
764 00010049 40 ret#2
765 0001004A .set L464,0x0
766 0001004A L466:
767 0001004A 13 ff0c jbr L467
768 0001004D .data
768 0001F9F5 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.