![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe16.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 pipe16.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 00000714 * .text
4 00000000 .align 1
5 00000000 .globl _pipe16
6 00000000 _pipe16:
7 00014400 0000 .word L381
8 00014402 #
9 00014402 # #include "evt_defs.h"
10 00014402 #
11 00014402 # /*
12 00014402 # *********************************************************************
13 00014402 # * FPP PIPELINED EVENTS TEST #16
14 00014402 # *
15 00014402 # * This test will execute the following code: "LDD ADDD STD"
16 00014402 # * with an overflow fault on the ADDD. We will make sure that:
17 00014402 # * 1. The fault is detected,
18 00014402 # * 2. the accumulator is cleared, and
19 00014402 # * 3. that a floating '0' is stored by the STD or that there is no store.
20 00014402 # *********************************************************************
21 00014402 # */
22 00014402 # pipe16()
23 00014402 # {
24 00014402 13 016d jbr L383
25 00014405 L384:
26 00014405 # #define PIPE16_PAT1 0x11223344
27 00014405 # #define PIPE16_PAT2 0x55667788
28 00014405 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
29 00014405 ed 6d effffffff4 moval (r13),_pre_event_fp
30 0001440C # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
31 0001440C ed 6e efffffffed moval (r14),_pre_event_sp
32 00014413 # precision = DBL;
33 00014413 0d 02 efffffffe6 movl $2,_precision
34 0001441A # test_event = ARITH_CODE; /* expect an arithmetic fault */
35 0001441A 0d 34 efffffffdf movl $52,_test_event
36 00014421 # exp_code = FLT_OVFL_CODE; /* - specificly overflow */
37 00014421 0d 04 efffffffd8 movl $4,_exp_code
38 00014428 # exp_event = FALSE; /* ... but not yet */
39 00014428 4d efffffffd2 clrl _exp_event
40 0001442E # asm("movab _pipe16_ret,_event_return"); /* set event return address */
41 0001442E e9 ef000000c1 efffffffc7 movab _pipe16_ret,_event_return
42 00014439 # max_index = add_ov_cnt; /* set max operand index */
43 00014439 0d efffffffc1 efffffffbc movl _add_ov_cnt,_max_index
44 00014444 # for( index = 0; index < max_index; index++ )
45 00014444 4d efffffffb6 clrl _index
46 0001444A L387:
47 0001444A 1d efffffffb0 efffffffab cmpl _index,_max_index
48 00014455 91 03 13 0117 jgeq L386
49 0001445A # {
50 0001445A # dbl_ld_acc = add_ov_dat[index].op_1; /* get the Acc data */
51 0001445A 48 04 efffffff9f 50 shll $4,_index,r0
52 00014462 0c 8f00000000 50 addl2 $_add_ov_dat,r0
53 00014469 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4
54 00014471 0d 60 efffffff88 movl (r0),_dbl_ld_acc
55 00014478 # dbl_value_1 = add_ov_dat[index].op_2; /* get the B operand */
56 00014478 48 04 efffffff81 50 shll $4,_index,r0
57 00014480 0c 8f00000008 50 addl2 $_add_ov_dat+8,r0
58 00014487 0d a004 efffffff75 movl 4(r0),_dbl_value_1+4
59 0001448F 0d 60 efffffff6a movl (r0),_dbl_value_1
60 00014496 # dbl_value_2.m = PIPE16_PAT1; /* set the initial */
61 00014496 0d 8f11223344 efffffff5f movl $287454020,_dbl_value_2
62 000144A1 # dbl_value_2.l = PIPE16_PAT2; /* STD op's contents */
63 000144A1 0d 8f55667788 efffffff58 movl $1432778632,_dbl_value_2+4
64 000144AC # asm(".globl _pipe16_lp1");
65 000144AC .globl _pipe16_lp1
66 000144AC # asm("_pipe16_lp1:");
67 000144AC _pipe16_lp1:
68 000144AC # asm("bispsw $0x60"); /* enable ovfl,undfl */
69 000144AC 8b 8860 bispsw $0x60
70 000144AF # asm("ldd _dbl_ld_acc"); /* load the Acc. */
71 000144AF 07 efffffff4b ldd _dbl_ld_acc
72 000144B5 # exp_event = test_event; /* expect event soon */
73 000144B5 0d efffffff45 efffffff40 movl _test_event,_exp_event
74 000144C0 # asm("addd _dbl_value_1"); /* trigger the event */
75 000144C0 c7 efffffff3a addd _dbl_value_1
76 000144C6 # asm("std _dbl_value_2"); /* shouldn't get here*/
77 000144C6 27 efffffff34 std _dbl_value_2
78 000144CC # /*
79 000144CC # * If we got to here then there was no event
80 000144CC # */
81 000144CC # if( force_loop )
82 000144CC 5d efffffff2e tstl _force_loop
83 000144D2 31 03 jeql L388
84 000144D4 # asm("brw _pipe16_lp1");; /* loop on the error */
Assemb0002BBC0 # asm("brw _pipe16_lp1");; /* loop on the error */
"pipe100014406 e 85: WARNING: brw: destination label is external
85 000144D4 13 ffd5 brw _pipe16_lp1
86 000144D7 L388:
87 000144D7 # exp_event = FALSE; /* reset event expected flag */
88 000144D7 4d efffffff23 clrl _exp_event
89 000144DD # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
90 000144DD 0d efffffff1d 5d movl _pre_event_fp,fp
91 000144E4 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
92 000144E4 0d efffffff16 5e movl _pre_event_sp,sp
93 000144EB # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
94 000144EB 9b 8860 bicpsw $0x60
95 000144EE # no_pipe16_evt();; /* report the error */
96 000144EE fe 04 ef00000081 callf $4,_no_pipe16_evt
97 000144F5 # /*
98 000144F5 # * Come here after the event
99 000144F5 # */
100 000144F5 # asm(".globl _pipe16_ret");
101 000144F5 .globl _pipe16_ret
102 000144F5 # asm("_pipe16_ret:");
103 000144F5 _pipe16_ret:
104 000144F5 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
105 000144F5 0d efffffff05 5d movl _pre_event_fp,fp
106 000144FC # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
107 000144FC 0d effffffefe 5e movl _pre_event_sp,sp
108 00014503 # if( force_loop )
109 00014503 5d effffffef7 tstl _force_loop
110 00014509 31 03 jeql L390
111 0001450B # asm("brw _pipe16_lp1");; /* loop on the error */
"pipe100014406 e 112: WARNING: brw: destination label is external
112 0001450B 13 ff9e brw _pipe16_lp1
113 0001450E L390:
114 0001450E # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
115 0001450E 9b 8860 bicpsw $0x60
116 00014511 # if( (post_evt_acc.m) || (post_evt_acc.l) ) /* is Acc = 0? */
117 00014511 5d effffffee9 tstl _post_evt_acc
118 00014517 21 08 jneq L9999
119 00014519 5d effffffee5 tstl _post_evt_acc+4
120 0001451F 31 09 jeql L391
121 00014521 L9999:
122 00014521 # bad_pipe16_result(); /* incorrect result error */
123 00014521 fe 04 ef0000017a callf $4,_bad_pipe16_result
124 00014528 # else if( ( (dbl_value_2.m) ||
125 00014528 11 3e jbr L393
126 0001452A L391:
127 0001452A # (dbl_value_2.l) ) /* either a '0' s/b stored, */
128 0001452A # && (dbl_value_2.m != 0x80000000) /* or a RESERVED OP, or */
129 0001452A # && ( (dbl_value_2.m != PIPE16_PAT1) || /* there s/b no */
130 0001452A # (dbl_value_2.l != PIPE16_PAT2) ) ) /* store at all */
131 0001452A 5d effffffed0 tstl _dbl_value_2
132 00014530 21 08 jneq L9998
133 00014532 5d effffffecc tstl _dbl_value_2+4
134 00014538 31 2e jeql L394
135 0001453A L9998:
136 0001453A 1d effffffec0 8f80000000 cmpl _dbl_value_2,$-2147483648
137 00014545 31 21 jeql L394
138 00014547 1d effffffeb3 8f11223344 cmpl _dbl_value_2,$287454020
139 00014552 21 0d jneq L9997
140 00014554 1d effffffeaa 8f55667788 cmpl _dbl_value_2+4,$1432778632
141 0001455F 31 07 jeql L394
142 00014561 L9997:
143 00014561 # bad_pipe16_store(); /* incorrect store error */
144 00014561 fe 04 ef000002be callf $4,_bad_pipe16_store
145 00014568 # }
146 00014568 L394:
147 00014568 L393:
148 00014568 L385:
149 00014568 6d effffffe92 incl _index
150 0001456E 13 fed9 jbr L387
151 00014571 L386:
152 00014571 # }
153 00014571 40 ret#2
154 00014572 .set L381,0x0
155 00014572 L383:
156 00014572 13 fe90 jbr L384
157 00014575 .data
158 00000714 * .text
159 00014575 00 .align 1
160 00014576 .globl _no_pipe16_evt
161 00014576 _no_pipe16_evt:
162 00014576 0000 .word L396
163 00014578 #
164 00014578 #
165 00014578 #
166 00014578 # /****************************************************************************
167 00014578 # * Report an "EVENT NOT DETECTED" error
168 00014578 # *
169 00014578 # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx
170 00014578 # * inst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADDD)
171 00014578 # * op1 = xxxxxxxx xxxxxxxx, initial op3 = xxxxxxxx xxxxxxxx
172 00014578 # * op2 = xxxxxxxx xxxxxxxx, final op3 = xxxxxxxx xxxxxxxx
173 00014578 # ****************************************************************************/
174 00014578 # no_pipe16_evt()
175 00014578 # {
176 00014578 13 0124 jbr L398
177 0001457B L399:
178 0001457B # errcnt++; /* bump the error count */
179 0001457B 6d effffffe7f incl _errcnt
180 00014581 # if ( prt_error )
181 00014581 5d effffffe79 tstl _prt_error
182 00014587 21 03 13 00ec jeql L400
183 0001458C # {
184 0001458C # sgl_value_1 = PIPE16_PAT1;
185 0001458C 0d 8f11223344 effffffe69 movl $287454020,_sgl_value_1
186 00014597 # sgl_value_2 = PIPE16_PAT2;
187 00014597 0d 8f55667788 effffffe5e movl $1432778632,_sgl_value_2
188 000145A2 # print_pipe16_er( ". No overflow fault seen." );
189 000145A2 .data 1
190 00000714 * L402:
191 00000714 * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen.\0"
7206661756C74207365656E2E
00
192 0000072e * .text
193 000145A2 dd 8f00000714 pushl $L402
194 000145A8 fe 08 ef000003ff callf $8,_print_pipe16_er
195 000145AF # writes("op1 = ");
196 000145AF .data 1
197 0000072e * L404:
198 0000072e * 6F7031203D2000 .ascii "op1 = \0"
199 00000735 * .text
200 000145AF dd 8f0000072e pushl $L404
201 000145B5 fe 08 effffffe44 callf $8,_writes
202 000145BC # write32h( dbl_ld_acc.m );
203 000145BC dd effffffe3e pushl _dbl_ld_acc
204 000145C2 fe 08 effffffe37 callf $8,_write32h
205 000145C9 # writec(' ');
206 000145C9 dd 20 pushl $32
207 000145CB fe 08 effffffe2e callf $8,_writec
208 000145D2 # write32h( dbl_ld_acc.l );
209 000145D2 dd effffffe2c pushl _dbl_ld_acc+4
210 000145D8 fe 08 effffffe21 callf $8,_write32h
211 000145DF # writes(", initial op3 = ");
212 000145DF .data 1
213 00000735 * L407:
214 00000735 * 2C202020696E697469616C206 .ascii ", initial op3 = \0"
F7033203D2000
215 00000748 * .text
216 000145DF dd 8f00000735 pushl $L407
217 000145E5 fe 08 effffffe14 callf $8,_writes
218 000145EC # write32h( sgl_value_1 );
219 000145EC dd effffffe0e pushl _sgl_value_1
220 000145F2 fe 08 effffffe07 callf $8,_write32h
221 000145F9 # writec(' ');
222 000145F9 dd 20 pushl $32
223 000145FB fe 08 effffffdfe callf $8,_writec
224 00014602 # write32h( sgl_value_2 );
225 00014602 dd effffffdf8 pushl _sgl_value_2
226 00014608 fe 08 effffffdf1 callf $8,_write32h
227 0001460F # writes("\nop2 = ");
228 0001460F .data 1
229 00000748 * L408:
230 00000748 * 0A6F7032203D2000 .ascii "\12op2 = \0"
231 00000750 * .text
232 0001460F dd 8f00000748 pushl $L408
233 00014615 fe 08 effffffde4 callf $8,_writes
234 0001461C # write32h( dbl_value_1.m );
235 0001461C dd effffffdde pushl _dbl_value_1
236 00014622 fe 08 effffffdd7 callf $8,_write32h
237 00014629 # writec(' ');
238 00014629 dd 20 pushl $32
239 0001462B fe 08 effffffdce callf $8,_writec
240 00014632 # write32h( dbl_value_1.l );
241 00014632 dd effffffdcc pushl _dbl_value_1+4
242 00014638 fe 08 effffffdc1 callf $8,_write32h
243 0001463F # writes(", final op3 = ");
244 0001463F .data 1
245 00000750 * L409:
246 00000750 * 2C202020202066696E616C206 .ascii ", final op3 = \0"
F7033203D2000
247 00000763 * .text
248 0001463F dd 8f00000750 pushl $L409
249 00014645 fe 08 effffffdb4 callf $8,_writes
250 0001464C # write32h( dbl_value_2.m );
251 0001464C dd effffffdae pushl _dbl_value_2
252 00014652 fe 08 effffffda7 callf $8,_write32h
253 00014659 # writec(' ');
254 00014659 dd 20 pushl $32
255 0001465B fe 08 effffffd9e callf $8,_writec
256 00014662 # write32h( dbl_value_2.l );
257 00014662 dd effffffd9c pushl _dbl_value_2+4
258 00014668 fe 08 effffffd91 callf $8,_write32h
259 0001466F # writec('\n');
260 0001466F dd 0a pushl $10
261 00014671 fe 08 effffffd88 callf $8,_writec
262 00014678 # }
263 00014678 # if ( halt_flg ) /* halt on error? */
264 00014678 L400:
265 00014678 5d effffffd82 tstl _halt_flg
266 0001467E 31 09 jeql L410
267 00014680 # pipe16_halt( 1 ); /* halt with a code of 1 */
268 00014680 dd 01 pushl $1
269 00014682 fe 08 ef000003c3 callf $8,_pipe16_halt
270 00014689 # if ( loop_on_err )
271 00014689 L410:
272 00014689 5d effffffd71 tstl _loop_on_err
273 0001468F 31 0d jeql L412
274 00014691 # {
275 00014691 # force_loop = TRUE; /* set the force loop flag */
276 00014691 0d 01 effffffd68 movl $1,_force_loop
277 00014698 # asm("jmp _pipe16_lp1"); /* and loop */
278 00014698 71 effffffe0e jmp _pipe16_lp1
279 0001469E # };
280 0001469E L412:
281 0001469E # }
282 0001469E 40 ret#2
283 0001469F .set L396,0x0
284 0001469F L398:
285 0001469F 13 fed9 jbr L399
286 000146A2 .data
287 00000714 * .text
288 000146A2 .align 1
289 000146A2 .globl _bad_pipe16_result
290 000146A2 _bad_pipe16_result:
291 000146A2 0000 .word L413
292 000146A4 #
293 000146A4 #
294 000146A4 #
295 000146A4 #
296 000146A4 # /****************************************************************************
297 000146A4 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
298 000146A4 # *
299 000146A4 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
300 000146A4 # * inst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADDD)
301 000146A4 # * op1 = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx
302 000146A4 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
303 000146A4 # * init op3 = xxxxxxxx xxxxxxxx, final op3 = xxxxxxxx xxxxxxxx
304 000146A4 # ****************************************************************************/
305 000146A4 # bad_pipe16_result()
306 000146A4 # {
307 000146A4 13 017c jbr L415
308 000146A7 L416:
309 000146A7 # errcnt++; /* bump the error count */
310 000146A7 6d effffffd53 incl _errcnt
311 000146AD # if ( prt_error )
312 000146AD 5d effffffd4d tstl _prt_error
313 000146B3 21 03 13 0144 jeql L417
314 000146B8 # {
315 000146B8 # sgl_value_1 = PIPE16_PAT1;
316 000146B8 0d 8f11223344 effffffd3d movl $287454020,_sgl_value_1
317 000146C3 # sgl_value_2 = PIPE16_PAT2;
318 000146C3 0d 8f55667788 effffffd32 movl $1432778632,_sgl_value_2
319 000146CE # print_pipe16_er( ". Bad final Accumulator" );
320 000146CE .data 1
321 00000763 * L418:
322 00000763 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
16363756D756C61746F7200
323 0000077b * .text
324 000146CE dd 8f00000763 pushl $L418
325 000146D4 fe 08 ef000002d3 callf $8,_print_pipe16_er
326 000146DB # writes("op1 = ");
327 000146DB .data 1
328 0000077b * L419:
329 0000077b * 6F7031203D2000 .ascii "op1 = \0"
330 00000782 * .text
331 000146DB dd 8f0000077b pushl $L419
332 000146E1 fe 08 effffffd18 callf $8,_writes
333 000146E8 # write32h( dbl_ld_acc.m );
334 000146E8 dd effffffd12 pushl _dbl_ld_acc
335 000146EE fe 08 effffffd0b callf $8,_write32h
336 000146F5 # writec(' ');
337 000146F5 dd 20 pushl $32
338 000146F7 fe 08 effffffd02 callf $8,_writec
339 000146FE # write32h( dbl_ld_acc.l );
340 000146FE dd effffffd00 pushl _dbl_ld_acc+4
341 00014704 fe 08 effffffcf5 callf $8,_write32h
342 0001470B # writes(", final Acc. = ");
343 0001470B .data 1
344 00000782 * L420:
345 00000782 * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0"
03D2000
346 00000792 * .text
347 0001470B dd 8f00000782 pushl $L420
348 00014711 fe 08 effffffce8 callf $8,_writes
349 00014718 # write32h( post_evt_acc.l );
350 00014718 dd effffffce6 pushl _post_evt_acc+4
351 0001471E fe 08 effffffcdb callf $8,_write32h
352 00014725 # writec(' ');
353 00014725 dd 20 pushl $32
354 00014727 fe 08 effffffcd2 callf $8,_writec
355 0001472E # write32h( post_evt_acc.l );
356 0001472E dd effffffcd0 pushl _post_evt_acc+4
357 00014734 fe 08 effffffcc5 callf $8,_write32h
358 0001473B # writes("\nop2 = ");
359 0001473B .data 1
360 00000792 * L421:
361 00000792 * 0A6F7032203D2000 .ascii "\12op2 = \0"
362 0000079a * .text
363 0001473B dd 8f00000792 pushl $L421
364 00014741 fe 08 effffffcb8 callf $8,_writes
365 00014748 # write32h( dbl_value_1.m );
366 00014748 dd effffffcb2 pushl _dbl_value_1
367 0001474E fe 08 effffffcab callf $8,_write32h
368 00014755 # writec(' ');
369 00014755 dd 20 pushl $32
370 00014757 fe 08 effffffca2 callf $8,_writec
371 0001475E # write32h( dbl_value_1.l );
372 0001475E dd effffffca0 pushl _dbl_value_1+4
373 00014764 fe 08 effffffc95 callf $8,_write32h
374 0001476B # writes(", expected = ");
375 0001476B .data 1
376 0000079a * L422:
377 0000079a * 2C20202065787065637465642 .ascii ", expected = \0"
03D2000
378 000007aa * .text
379 0001476B dd 8f0000079a pushl $L422
380 00014771 fe 08 effffffc88 callf $8,_writes
381 00014778 # write32h( 0 ); /* the expected result = 0 */
382 00014778 dd 00 pushl $0
383 0001477A fe 08 effffffc7f callf $8,_write32h
384 00014781 # writec(' ');
385 00014781 dd 20 pushl $32
386 00014783 fe 08 effffffc76 callf $8,_writec
387 0001478A # write32h( 0 );
388 0001478A dd 00 pushl $0
389 0001478C fe 08 effffffc6d callf $8,_write32h
390 00014793 # writes("\ninit op3 = ");
391 00014793 .data 1
392 000007aa * L423:
393 000007aa * 0A696E6974206F7033203D200 .ascii "\12init op3 = \0"
0
394 000007b7 * .text
395 00014793 dd 8f000007aa pushl $L423
396 00014799 fe 08 effffffc60 callf $8,_writes
397 000147A0 # write32h( sgl_value_1 );
398 000147A0 dd effffffc5a pushl _sgl_value_1
399 000147A6 fe 08 effffffc53 callf $8,_write32h
400 000147AD # writec(' ');
401 000147AD dd 20 pushl $32
402 000147AF fe 08 effffffc4a callf $8,_writec
403 000147B6 # write32h( sgl_value_2 );
404 000147B6 dd effffffc44 pushl _sgl_value_2
405 000147BC fe 08 effffffc3d callf $8,_write32h
406 000147C3 # writes(", final op3 = ");
407 000147C3 .data 1
408 000007b7 * L424:
409 000007b7 * 2C202066696E616C206F70332 .ascii ", final op3 = \0"
03D2000
410 000007c7 * .text
411 000147C3 dd 8f000007b7 pushl $L424
412 000147C9 fe 08 effffffc30 callf $8,_writes
413 000147D0 # write32h( dbl_value_2.m );
414 000147D0 dd effffffc2a pushl _dbl_value_2
415 000147D6 fe 08 effffffc23 callf $8,_write32h
416 000147DD # writec(' ');
417 000147DD dd 20 pushl $32
418 000147DF fe 08 effffffc1a callf $8,_writec
419 000147E6 # write32h( dbl_value_2.l );
420 000147E6 dd effffffc18 pushl _dbl_value_2+4
421 000147EC fe 08 effffffc0d callf $8,_write32h
422 000147F3 # writec('\n');
423 000147F3 dd 0a pushl $10
424 000147F5 fe 08 effffffc04 callf $8,_writec
425 000147FC # }
426 000147FC # if ( halt_flg ) /* halt on error? */
427 000147FC L417:
428 000147FC 5d effffffbfe tstl _halt_flg
429 00014802 31 09 jeql L425
430 00014804 # pipe16_halt( 2 ); /* halt with a code of 2 */
431 00014804 dd 02 pushl $2
432 00014806 fe 08 ef0000023f callf $8,_pipe16_halt
433 0001480D # if ( loop_on_err )
434 0001480D L425:
435 0001480D 5d effffffbed tstl _loop_on_err
436 00014813 31 0d jeql L426
437 00014815 # {
438 00014815 # force_loop = TRUE; /* set the force loop flag */
439 00014815 0d 01 effffffbe4 movl $1,_force_loop
440 0001481C # asm("jmp _pipe16_lp1"); /* and loop */
441 0001481C 71 effffffc8a jmp _pipe16_lp1
442 00014822 # };
443 00014822 L426:
444 00014822 # }
445 00014822 40 ret#2
446 00014823 .set L413,0x0
447 00014823 L415:
448 00014823 13 fe81 jbr L416
449 00014826 .data
450 00000714 * .text
451 00014826 .align 1
452 00014826 .globl _bad_pipe16_store
453 00014826 _bad_pipe16_store:
454 00014826 0000 .word L427
455 00014828 #
456 00014828 #
457 00014828 #
458 00014828 #
459 00014828 #
460 00014828 # /****************************************************************************
461 00014828 # * Report an "BAD VALUE STORED INTO OPERAND 3" error
462 00014828 # *
463 00014828 # * Cycle: xx. EVT test xx. subtest xx. Bad STD OP3 result. index = xx
464 00014828 # * inst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADDD)
465 00014828 # * op1 = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx
466 00014828 # * op2 = xxxxxxxx xxxxxxxx, expected op3 = xxxxxxxx xxxxxxxx
467 00014828 # * init op3 = xxxxxxxx xxxxxxxx, final op3 = xxxxxxxx xxxxxxxx
468 00014828 # ****************************************************************************/
469 00014828 # bad_pipe16_store()
470 00014828 # {
471 00014828 13 0180 jbr L429
472 0001482B L430:
473 0001482B # errcnt++; /* bump the error count */
474 0001482B 6d effffffbcf incl _errcnt
475 00014831 # if ( prt_error )
476 00014831 5d effffffbc9 tstl _prt_error
477 00014837 21 03 13 0148 jeql L431
478 0001483C # {
479 0001483C # sgl_value_1 = PIPE16_PAT1;
480 0001483C 0d 8f11223344 effffffbb9 movl $287454020,_sgl_value_1
481 00014847 # sgl_value_2 = PIPE16_PAT2;
482 00014847 0d 8f55667788 effffffbae movl $1432778632,_sgl_value_2
483 00014852 # print_pipe16_er( ". Bad STD OP3 result" );
484 00014852 .data 1
485 000007c7 * L432:
486 000007c7 * 2E202042616420535444204F5 .ascii ". Bad STD OP3 result\0"
03320726573756C7400
487 000007dd * .text
488 00014852 dd 8f000007c7 pushl $L432
489 00014858 fe 08 ef0000014f callf $8,_print_pipe16_er
490 0001485F # writes(" op1 = ");
491 0001485F .data 1
492 000007dd * L433:
493 000007dd * 20202020206F7031203D2000 .ascii " op1 = \0"
494 000007e9 * .text
495 0001485F dd 8f000007dd pushl $L433
496 00014865 fe 08 effffffb94 callf $8,_writes
497 0001486C # write32h( dbl_ld_acc.m );
498 0001486C dd effffffb8e pushl _dbl_ld_acc
499 00014872 fe 08 effffffb87 callf $8,_write32h
500 00014879 # writec(' ');
501 00014879 dd 20 pushl $32
502 0001487B fe 08 effffffb7e callf $8,_writec
503 00014882 # write32h( dbl_ld_acc.l );
504 00014882 dd effffffb7c pushl _dbl_ld_acc+4
505 00014888 fe 08 effffffb71 callf $8,_write32h
506 0001488F # writes(", final Acc. = ");
507 0001488F .data 1
508 000007e9 * L434:
509 000007e9 * 2C2020202066696E616C20416 .ascii ", final Acc. = \0"
3632E203D2000
510 000007fc * .text
511 0001488F dd 8f000007e9 pushl $L434
512 00014895 fe 08 effffffb64 callf $8,_writes
513 0001489C # write32h( post_evt_acc.l );
514 0001489C dd effffffb62 pushl _post_evt_acc+4
515 000148A2 fe 08 effffffb57 callf $8,_write32h
516 000148A9 # writec(' ');
517 000148A9 dd 20 pushl $32
518 000148AB fe 08 effffffb4e callf $8,_writec
519 000148B2 # write32h( post_evt_acc.l );
520 000148B2 dd effffffb4c pushl _post_evt_acc+4
521 000148B8 fe 08 effffffb41 callf $8,_write32h
522 000148BF # writes("\n op2 = ");
523 000148BF .data 1
524 000007fc * L435:
525 000007fc * 0A20202020206F7032203D200 .ascii "\12 op2 = \0"
0
526 00000809 * .text
527 000148BF dd 8f000007fc pushl $L435
528 000148C5 fe 08 effffffb34 callf $8,_writes
529 000148CC # write32h( dbl_value_1.m );
530 000148CC dd effffffb2e pushl _dbl_value_1
531 000148D2 fe 08 effffffb27 callf $8,_write32h
532 000148D9 # writec(' ');
533 000148D9 dd 20 pushl $32
534 000148DB fe 08 effffffb1e callf $8,_writec
535 000148E2 # write32h( dbl_value_1.l );
536 000148E2 dd effffffb1c pushl _dbl_value_1+4
537 000148E8 fe 08 effffffb11 callf $8,_write32h
538 000148EF # writes(", expected op3 = ");
539 000148EF .data 1
540 00000809 * L436:
541 00000809 * 2C20206578706563746564206 .ascii ", expected op3 = \0"
F7033203D2000
542 0000081c * .text
543 000148EF dd 8f00000809 pushl $L436
544 000148F5 fe 08 effffffb04 callf $8,_writes
545 000148FC # write32h( 0x80000000 ); /* the expected result = 0 */
546 000148FC dd 8f80000000 pushl $-2147483648
547 00014902 fe 08 effffffaf7 callf $8,_write32h
548 00014909 # writec(' ');
549 00014909 dd 20 pushl $32
550 0001490B fe 08 effffffaee callf $8,_writec
551 00014912 # write32h( 0 );
552 00014912 dd 00 pushl $0
553 00014914 fe 08 effffffae5 callf $8,_write32h
554 0001491B # writes("\ninit op3 = ");
555 0001491B .data 1
556 0000081c * L437:
557 0000081c * 0A696E6974206F7033203D200 .ascii "\12init op3 = \0"
0
558 00000829 * .text
559 0001491B dd 8f0000081c pushl $L437
560 00014921 fe 08 effffffad8 callf $8,_writes
561 00014928 # write32h( sgl_value_1 );
562 00014928 dd effffffad2 pushl _sgl_value_1
563 0001492E fe 08 effffffacb callf $8,_write32h
564 00014935 # writec(' ');
565 00014935 dd 20 pushl $32
566 00014937 fe 08 effffffac2 callf $8,_writec
567 0001493E # write32h( sgl_value_2 );
568 0001493E dd effffffabc pushl _sgl_value_2
569 00014944 fe 08 effffffab5 callf $8,_write32h
570 0001494B # writes(", final op3 = ");
571 0001494B .data 1
572 00000829 * L438:
573 00000829 * 2C202020202066696E616C206 .ascii ", final op3 = \0"
F7033203D2000
574 0000083c * .text
575 0001494B dd 8f00000829 pushl $L438
576 00014951 fe 08 effffffaa8 callf $8,_writes
577 00014958 # write32h( dbl_value_2.m );
578 00014958 dd effffffaa2 pushl _dbl_value_2
579 0001495E fe 08 effffffa9b callf $8,_write32h
580 00014965 # writec(' ');
581 00014965 dd 20 pushl $32
582 00014967 fe 08 effffffa92 callf $8,_writec
583 0001496E # write32h( dbl_value_2.l );
584 0001496E dd effffffa90 pushl _dbl_value_2+4
585 00014974 fe 08 effffffa85 callf $8,_write32h
586 0001497B # writec('\n');
587 0001497B dd 0a pushl $10
588 0001497D fe 08 effffffa7c callf $8,_writec
589 00014984 # }
590 00014984 # if ( halt_flg ) /* halt on error? */
591 00014984 L431:
592 00014984 5d effffffa76 tstl _halt_flg
593 0001498A 31 09 jeql L439
594 0001498C # pipe16_halt( 3 ); /* halt with a code of 2 */
595 0001498C dd 03 pushl $3
596 0001498E fe 08 ef000000b7 callf $8,_pipe16_halt
597 00014995 # if ( loop_on_err )
598 00014995 L439:
599 00014995 5d effffffa65 tstl _loop_on_err
600 0001499B 31 0d jeql L440
601 0001499D # {
602 0001499D # force_loop = TRUE; /* set the force loop flag */
603 0001499D 0d 01 effffffa5c movl $1,_force_loop
604 000149A4 # asm("jmp _pipe16_lp1"); /* and loop */
605 000149A4 71 effffffb02 jmp _pipe16_lp1
606 000149AA # };
607 000149AA L440:
608 000149AA # }
609 000149AA 40 ret#2
610 000149AB .set L427,0x0
611 000149AB L429:
612 000149AB 13 fe7d jbr L430
613 000149AE .data
614 00000714 * .text
615 000149AE .align 1
616 000149AE .globl _print_pipe16_er
617 000149AE _print_pipe16_er:
618 000149AE 0000 .word L441
619 000149B0 #
620 000149B0 #
621 000149B0 #
622 000149B0 #
623 000149B0 #
624 000149B0 #
625 000149B0 # /****************************************************************************
626 000149B0 # * Report an error message of the form:
627 000149B0 # *
628 000149B0 # * Cycle: xx. EVT test xx. subtest xx. <your message here>. index = xx
629 000149B0 # * inst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADDD)
630 000149B0 # ****************************************************************************/
631 000149B0 # print_pipe16_er( msg )
632 000149B0 # char *msg; /* error message to print */
633 000149B0 # {
634 000149B0 13 0096 jbr L443
635 000149B3 L444:
636 000149B3 # if( errcnt == 1 ) /* 1st error? */
637 000149B3 1d effffffa47 01 cmpl _errcnt,$1
638 000149BA 21 0d jneq L445
639 000149BC # writes(" \n"); /* start a new print line */
640 000149BC .data 1
641 0000083c * L446:
642 0000083c * 200A00 .ascii " \12\0"
643 0000083f * .text
644 000149BC dd 8f0000083c pushl $L446
645 000149C2 fe 08 effffffa37 callf $8,_writes
646 000149C9 # writes("Cycle: ");
647 000149C9 L445:
648 000149C9 .data 1
649 0000083f * L447:
650 0000083f * 4379636C653A2000 .ascii "Cycle: \0"
651 00000847 * .text
652 000149C9 dd 8f0000083f pushl $L447
653 000149CF fe 08 effffffa2a callf $8,_writes
654 000149D6 # writed( cycle );
655 000149D6 dd effffffa24 pushl _cycle
656 000149DC fe 08 effffffa1d callf $8,_writed
657 000149E3 # writes(" EVT test ");
658 000149E3 .data 1
659 00000847 * L449:
660 00000847 * 202045565420746573742000 .ascii " EVT test \0"
661 00000853 * .text
662 000149E3 dd 8f00000847 pushl $L449
663 000149E9 fe 08 effffffa10 callf $8,_writes
664 000149F0 # writed( test_no );
665 000149F0 dd effffffa0a pushl _test_no
666 000149F6 fe 08 effffffa03 callf $8,_writed
667 000149FD # writes(". subtest ");
668 000149FD .data 1
669 00000853 * L450:
670 00000853 * 2E20737562746573742000 .ascii ". subtest \0"
671 0000085e * .text
672 000149FD dd 8f00000853 pushl $L450
673 00014A03 fe 08 effffff9f6 callf $8,_writes
674 00014A0A # writed( subtest );
675 00014A0A dd effffff9f0 pushl _subtest
676 00014A10 fe 08 effffff9e9 callf $8,_writed
677 00014A17 # writes( msg ); /* print the message */
678 00014A17 dd ad04 pushl 4(fp)
679 00014A1A fe 08 effffff9df callf $8,_writes
680 00014A21 # writes(". index = ");
681 00014A21 .data 1
682 0000085e * L451:
683 0000085e * 2E20696E646578203D2000 .ascii ". index = \0"
684 00000869 * .text
685 00014A21 dd 8f0000085e pushl $L451
686 00014A27 fe 08 effffff9d2 callf $8,_writes
687 00014A2E # writed( index );
688 00014A2E dd effffff9cc pushl _index
689 00014A34 fe 08 effffff9c5 callf $8,_writed
690 00014A3B # writes(
691 00014A3B # "\ninst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADDD)\n");
692 00014A3B .data 1
693 00000869 * L452:
694 00000869 * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADD"
F70312C2041444444206F7032
2C20535444206F70332020202
0286F766572666C6F77206661
756C74206F6E2074686520414
444
695 000008a9 * 44290A00 .ascii "D)\12\0"
696 000008ad * .text
697 00014A3B dd 8f00000869 pushl $L452
698 00014A41 fe 08 effffff9b8 callf $8,_writes
699 00014A48 # }
700 00014A48 40 ret#2
701 00014A49 .set L441,0x0
702 00014A49 L443:
703 00014A49 13 ff67 jbr L444
704 00014A4C .data
705 00000714 * .text
706 00014A4C .align 1
707 00014A4C .globl _pipe16_halt
708 00014A4C _pipe16_halt:
709 00014A4C 0000 .word L453
710 00014A4E #
711 00014A4E #
712 00014A4E #
713 00014A4E # /****************************************************************************
714 00014A4E # * halt on error routine
715 00014A4E # ****************************************************************************/
716 00014A4E # pipe16_halt( code )
717 00014A4E # int code; /* error code to halt with */
718 00014A4E # {
719 00014A4E 13 00bf jbr L455
720 00014A51 L456:
721 00014A51 # err_code = code;
722 00014A51 0d ad04 effffff9a7 movl 4(fp),_err_code
723 00014A59 # sgl_value_1 = dbl_ld_acc.m;
724 00014A59 0d effffff9a1 effffff99c movl _dbl_ld_acc,_sgl_value_1
725 00014A64 # sgl_value_2 = dbl_ld_acc.l;
726 00014A64 0d effffff99a effffff991 movl _dbl_ld_acc+4,_sgl_value_2
727 00014A6F # sgl_value_3 = dbl_value_1.m;
728 00014A6F 0d effffff98b effffff986 movl _dbl_value_1,_sgl_value_3
729 00014A7A # sgl_value_4 = dbl_value_1.l;
730 00014A7A 0d effffff984 effffff97b movl _dbl_value_1+4,_sgl_value_4
731 00014A85 # sgl_value_5 = post_evt_acc.m;
732 00014A85 0d effffff975 effffff970 movl _post_evt_acc,_sgl_value_5
733 00014A90 # sgl_value_6 = post_evt_acc.l;
734 00014A90 0d effffff96e effffff965 movl _post_evt_acc+4,_sgl_value_6
735 00014A9B # sgl_value_7 = dbl_value_2.m;
736 00014A9B 0d effffff95f effffff95a movl _dbl_value_2,_sgl_value_7
737 00014AA6 # sgl_value_8 = dbl_value_2.l;
738 00014AA6 0d effffff958 effffff94f movl _dbl_value_2+4,_sgl_value_8
739 00014AB1 # asm("movl _test_no,r0"); /* r0 = test number */
740 00014AB1 0d effffff949 50 movl _test_no,r0
741 00014AB8 # asm("movl _subtest,r1"); /* r1 = subtest number */
742 00014AB8 0d effffff942 51 movl _subtest,r1
743 00014ABF # asm("movl _err_code,r2"); /* r2 = error code */
744 00014ABF 0d effffff93b 52 movl _err_code,r2
745 00014AC6 # asm("movl _cycle,r3"); /* r3 = cycle count */
746 00014AC6 0d effffff934 53 movl _cycle,r3
747 00014ACD # asm("movl _sgl_value_1,r4"); /* r4 = MSW of operand 1 */
748 00014ACD 0d effffff92d 54 movl _sgl_value_1,r4
749 00014AD4 # asm("movl _sgl_value_2,r5"); /* r5 = LSW of operand 1 */
750 00014AD4 0d effffff926 55 movl _sgl_value_2,r5
751 00014ADB # asm("movl _sgl_value_3,r6"); /* r6 = MSW of operand 2 */
752 00014ADB 0d effffff91f 56 movl _sgl_value_3,r6
753 00014AE2 # asm("movl _sgl_value_4,r7"); /* r7 = LSW of operand 2 */
754 00014AE2 0d effffff918 57 movl _sgl_value_4,r7
755 00014AE9 # asm("movl _sgl_value_5,r8"); /* r8 = MSW of final Acc. */
756 00014AE9 0d effffff911 58 movl _sgl_value_5,r8
757 00014AF0 # asm("movl _sgl_value_6,r9"); /* r9 = LSW of final Acc. */
758 00014AF0 0d effffff90a 59 movl _sgl_value_6,r9
759 00014AF7 # asm("clrl r10"); /* r10 = 0 (expected Acc.) */
760 00014AF7 4d 5a clrl r10
761 00014AF9 # asm("movl _sgl_value_7,r11"); /* r11 = MSW of store data */
762 00014AF9 0d effffff901 5b movl _sgl_value_7,r11
763 00014B00 # asm("movl _sgl_value_8,r12"); /* r12 = LSW of store data */
764 00014B00 0d effffff8fa 5c movl _sgl_value_8,r12
765 00014B07 # asm("movl _index,r13"); /* r13 = data index */
766 00014B07 0d effffff8f3 5d movl _index,r13
767 00014B0E # asm("halt"); /* HALT ... */
768 00014B0E 00 halt
769 00014B0F # }
770 00014B0F 40 ret#2
771 00014B10 .set L453,0x0
772 00014B10 L455:
773 00014B10 13 ff3e jbr L456
774 00014B13 .data
774 00028F13 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.