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