![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe10.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 pipe10.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 00000560 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe10
6: 6 00000000 _pipe10:
7: 7 00012514 0000 .word L381
8: 8 00012516 #
9: 9 00012516 # #include "evt_defs.h"
10: 10 00012516 #
11: 11 00012516 # /*
12: 12 00012516 # *********************************************************************
13: 13 00012516 # * FPP PIPELINED EVENTS TEST #10
14: 14 00012516 # *
15: 15 00012516 # * This test will execute the following code: "LDD MULD CVLF $2"
16: 16 00012516 # * with an underflow fault on the MULD. We will make sure that:
17: 17 00012516 # * 1. The fault is detected, and
18: 18 00012516 # * 2. the convert instruction is not executed.
19: 19 00012516 # *********************************************************************
20: 20 00012516 # */
21: 21 00012516 # pipe10()
22: 22 00012516 # {
23: 23 00012516 13 0129 jbr L383
24: 24 00012519 L384:
25: 25 00012519 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
26: 26 00012519 ed 6d effffffff4 moval (r13),_pre_event_fp
27: 27 00012520 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
28: 28 00012520 ed 6e efffffffed moval (r14),_pre_event_sp
29: 29 00012527 # precision = DBL;
30: 30 00012527 0d 02 efffffffe6 movl $2,_precision
31: 31 0001252E # test_event = ARITH_CODE; /* expect an arithmetic fault */
32: 32 0001252E 0d 34 efffffffdf movl $52,_test_event
33: 33 00012535 # exp_code = FLT_UNDFL_CODE; /* - specificly underflow */
34: 34 00012535 0d 05 efffffffd8 movl $5,_exp_code
35: 35 0001253C # exp_event = FALSE; /* ... but not yet */
36: 36 0001253C 4d efffffffd2 clrl _exp_event
37: 37 00012542 # asm("movab _pipe10_ret,_event_return"); /* set event return address */
38: 38 00012542 e9 ef000000a7 efffffffc7 movab _pipe10_ret,_event_return
39: 39 0001254D # max_index = mud_u_cnt; /* set max operand index */
40: 40 0001254D 0d efffffffc1 efffffffbc movl _mud_u_cnt,_max_index
41: 41 00012558 # for( index = 0; index < max_index; index++ )
42: 42 00012558 4d efffffffb6 clrl _index
43: 43 0001255E L387:
44: 44 0001255E 1d efffffffb0 efffffffab cmpl _index,_max_index
45: 45 00012569 91 03 13 00d3 jgeq L386
46: 46 0001256E # {
47: 47 0001256E # dbl_ld_acc = mud_u_dat[index].op_1; /* get the Acc data */
48: 48 0001256E 48 04 efffffff9f 50 shll $4,_index,r0
49: 49 00012576 0c 8f00000000 50 addl2 $_mud_u_dat,r0
50: 50 0001257D 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4
51: 51 00012585 0d 60 efffffff88 movl (r0),_dbl_ld_acc
52: 52 0001258C # dbl_value_1 = mud_u_dat[index].op_2; /* get the B operand */
53: 53 0001258C 48 04 efffffff81 50 shll $4,_index,r0
54: 54 00012594 0c 8f00000008 50 addl2 $_mud_u_dat+8,r0
55: 55 0001259B 0d a004 efffffff75 movl 4(r0),_dbl_value_1+4
56: 56 000125A3 0d 60 efffffff6a movl (r0),_dbl_value_1
57: 57 000125AA # asm("bispsw $0x60"); /* enable ovfl&undfl */
58: 58 000125AA 8b 8860 bispsw $0x60
59: 59 000125AD # asm(".globl _pipe10_lp1");
60: 60 000125AD .globl _pipe10_lp1
61: 61 000125AD # asm("_pipe10_lp1:");
62: 62 000125AD _pipe10_lp1:
63: 63 000125AD # asm("ldd _dbl_ld_acc"); /* load the Acc. */
64: 64 000125AD 07 efffffff61 ldd _dbl_ld_acc
65: 65 000125B3 # exp_event = test_event; /* expect event soon */
66: 66 000125B3 0d efffffff5b efffffff56 movl _test_event,_exp_event
67: 67 000125BE # asm("muld _dbl_value_1"); /* trigger the event */
68: 68 000125BE e7 efffffff50 muld _dbl_value_1
69: 69 000125C4 # asm("cvlf $2"); /* shouldn't get here*/
70: 70 000125C4 76 02 cvlf $2
71: 71 000125C6 # /*
72: 72 000125C6 # * If we got to here then there was no event
73: 73 000125C6 # */
74: 74 000125C6 # if( force_loop )
75: 75 000125C6 5d efffffff48 tstl _force_loop
76: 76 000125CC 31 03 jeql L388
77: 77 000125CE # asm("brw _pipe10_lp1");; /* loop on the error */
78: Assemb00029CD4 # asm("brw _pipe10_lp1");; /* loop on the error */
79: "pipe100012514 e 78: WARNING: brw: destination label is external
80: 78 000125CE 13 ffdc brw _pipe10_lp1
81: 79 000125D1 L388:
82: 80 000125D1 # exp_event = FALSE; /* reset event expected flag */
83: 81 000125D1 4d efffffff3d clrl _exp_event
84: 82 000125D7 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
85: 83 000125D7 0d efffffff37 5d movl _pre_event_fp,fp
86: 84 000125DE # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
87: 85 000125DE 0d efffffff30 5e movl _pre_event_sp,sp
88: 86 000125E5 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
89: 87 000125E5 9b 8860 bicpsw $0x60
90: 88 000125E8 # no_pipe10_evt();; /* report the error */
91: 89 000125E8 fe 04 ef00000057 callf $4,_no_pipe10_evt
92: 90 000125EF # /*
93: 91 000125EF # * Come here after the event
94: 92 000125EF # */
95: 93 000125EF # asm(".globl _pipe10_ret");
96: 94 000125EF .globl _pipe10_ret
97: 95 000125EF # asm("_pipe10_ret:");
98: 96 000125EF _pipe10_ret:
99: 97 000125EF # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
100: 98 000125EF 0d efffffff1f 5d movl _pre_event_fp,fp
101: 99 000125F6 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
102: 100 000125F6 0d efffffff18 5e movl _pre_event_sp,sp
103: 101 000125FD # if( force_loop )
104: 102 000125FD 5d efffffff11 tstl _force_loop
105: 103 00012603 31 03 jeql L390
106: 104 00012605 # asm("brw _pipe10_lp1");; /* loop on the error */
107: "pipe100012514 e 105: WARNING: brw: destination label is external
108: 105 00012605 13 ffa5 brw _pipe10_lp1
109: 106 00012608 L390:
110: 107 00012608 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
111: 108 00012608 9b 8860 bicpsw $0x60
112: 109 0001260B # if( post_evt_acc.m == 0x41000000 ) /* is the Acc. = floating 2? */
113: 110 0001260B 1d efffffff03 8f41000000 cmpl _post_evt_acc,$1090519040
114: 111 00012616 21 09 jneq L391
115: 112 00012618 # pipe10_queue_er(); /* queue not cleared error */
116: 113 00012618 fe 04 ef000001f7 callf $4,_pipe10_queue_er
117: 114 0001261F # else if( (post_evt_acc.m) || (post_evt_acc.l) ) /* is Acc = 0? */
118: 115 0001261F 11 17 jbr L393
119: 116 00012621 L391:
120: 117 00012621 5d effffffeed tstl _post_evt_acc
121: 118 00012627 21 08 jneq L9999
122: 119 00012629 5d effffffee9 tstl _post_evt_acc+4
123: 120 0001262F 31 07 jeql L394
124: 121 00012631 L9999:
125: 122 00012631 # bad_pipe10_result(); /* incorrect result error */
126: 123 00012631 fe 04 ef000000c2 callf $4,_bad_pipe10_result
127: 124 00012638 #
128: 125 00012638 # }
129: 126 00012638 L394:
130: 127 00012638 L393:
131: 128 00012638 L385:
132: 129 00012638 6d effffffed6 incl _index
133: 130 0001263E 13 ff1d jbr L387
134: 131 00012641 L386:
135: 132 00012641 # }
136: 133 00012641 40 ret#2
137: 134 00012642 .set L381,0x0
138: 135 00012642 L383:
139: 136 00012642 13 fed4 jbr L384
140: 137 00012645 .data
141: 138 00000560 * .text
142: 139 00012645 00 .align 1
143: 140 00012646 .globl _no_pipe10_evt
144: 141 00012646 _no_pipe10_evt:
145: 142 00012646 0000 .word L396
146: 143 00012648 #
147: 144 00012648 #
148: 145 00012648 #
149: 146 00012648 # /****************************************************************************
150: 147 00012648 # * Report an "EVENT NOT DETECTED" error
151: 148 00012648 # *
152: 149 00012648 # * Cycle: xx. EVT test xx. subtest xx. index = xx. No underflow fault seen.
153: 150 00012648 # * inst = LDD op1, MULD op2, CVLF '2' (underflow fault on the MULD)
154: 151 00012648 # * op1 = xxxxxxxx xxxxxxxx, op2 = xxxxxxxx xxxxxxxx
155: 152 00012648 # ****************************************************************************/
156: 153 00012648 # no_pipe10_evt()
157: 154 00012648 # {
158: 155 00012648 13 00ab jbr L398
159: 156 0001264B L399:
160: 157 0001264B # errcnt++; /* bump the error count */
161: 158 0001264B 6d effffffec3 incl _errcnt
162: 159 00012651 # if ( prt_error )
163: 160 00012651 5d effffffebd tstl _prt_error
164: 161 00012657 31 76 jeql L400
165: 162 00012659 # {
166: 163 00012659 # print_pipe10_er( ". No underflow fault seen." );
167: 164 00012659 .data 1
168: 165 00000560 * L402:
169: 166 00000560 * 2E204E6F20756E646572666C6 .ascii ". No underflow fault seen.\0"
170: F77206661756C74207365656E
171: 2E00
172: 167 0000057b * .text
173: 168 00012659 dd 8f00000560 pushl $L402
174: 169 0001265F fe 08 ef000002cc callf $8,_print_pipe10_er
175: 170 00012666 # writes("op1 = ");
176: 171 00012666 .data 1
177: 172 0000057b * L404:
178: 173 0000057b * 6F7031203D2000 .ascii "op1 = \0"
179: 174 00000582 * .text
180: 175 00012666 dd 8f0000057b pushl $L404
181: 176 0001266C fe 08 effffffea1 callf $8,_writes
182: 177 00012673 # write32h( dbl_ld_acc.m );
183: 178 00012673 dd effffffe9b pushl _dbl_ld_acc
184: 179 00012679 fe 08 effffffe94 callf $8,_write32h
185: 180 00012680 # writec(' ');
186: 181 00012680 dd 20 pushl $32
187: 182 00012682 fe 08 effffffe8b callf $8,_writec
188: 183 00012689 # write32h( dbl_ld_acc.l );
189: 184 00012689 dd effffffe89 pushl _dbl_ld_acc+4
190: 185 0001268F fe 08 effffffe7e callf $8,_write32h
191: 186 00012696 # writes(", op2 = ");
192: 187 00012696 .data 1
193: 188 00000582 * L407:
194: 189 00000582 * 2C2020206F7032203D2000 .ascii ", op2 = \0"
195: 190 0000058d * .text
196: 191 00012696 dd 8f00000582 pushl $L407
197: 192 0001269C fe 08 effffffe71 callf $8,_writes
198: 193 000126A3 # write32h( dbl_value_1.m );
199: 194 000126A3 dd effffffe6b pushl _dbl_value_1
200: 195 000126A9 fe 08 effffffe64 callf $8,_write32h
201: 196 000126B0 # writec(' ');
202: 197 000126B0 dd 20 pushl $32
203: 198 000126B2 fe 08 effffffe5b callf $8,_writec
204: 199 000126B9 # write32h( dbl_value_1.l );
205: 200 000126B9 dd effffffe59 pushl _dbl_value_1+4
206: 201 000126BF fe 08 effffffe4e callf $8,_write32h
207: 202 000126C6 # writec('\n');
208: 203 000126C6 dd 0a pushl $10
209: 204 000126C8 fe 08 effffffe45 callf $8,_writec
210: 205 000126CF # }
211: 206 000126CF # if ( halt_flg ) /* halt on error? */
212: 207 000126CF L400:
213: 208 000126CF 5d effffffe3f tstl _halt_flg
214: 209 000126D5 31 09 jeql L408
215: 210 000126D7 # pipe10_halt( 1 ); /* halt with a code of 1 */
216: 211 000126D7 dd 01 pushl $1
217: 212 000126D9 fe 08 ef000002f0 callf $8,_pipe10_halt
218: 213 000126E0 # if ( loop_on_err )
219: 214 000126E0 L408:
220: 215 000126E0 5d effffffe2e tstl _loop_on_err
221: 216 000126E6 31 0d jeql L410
222: 217 000126E8 # {
223: 218 000126E8 # force_loop = TRUE; /* set the force loop flag */
224: 219 000126E8 0d 01 effffffe25 movl $1,_force_loop
225: 220 000126EF # asm("jmp _pipe10_lp1"); /* and loop */
226: 221 000126EF 71 effffffeb8 jmp _pipe10_lp1
227: 222 000126F5 # };
228: 223 000126F5 L410:
229: 224 000126F5 # }
230: 225 000126F5 40 ret#2
231: 226 000126F6 .set L396,0x0
232: 227 000126F6 L398:
233: 228 000126F6 13 ff52 jbr L399
234: 229 000126F9 .data
235: 230 00000560 * .text
236: 231 000126F9 00 .align 1
237: 232 000126FA .globl _bad_pipe10_result
238: 233 000126FA _bad_pipe10_result:
239: 234 000126FA 0000 .word L411
240: 235 000126FC #
241: 236 000126FC #
242: 237 000126FC #
243: 238 000126FC #
244: 239 000126FC # /****************************************************************************
245: 240 000126FC # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
246: 241 000126FC # *
247: 242 000126FC # * Cycle: xx. EVT test xx. subtest xx. index = xx. Bad final Accumulator.
248: 243 000126FC # * inst = LDD op1, MULD op2, CVLF '2' (underflow fault on the MULD)
249: 244 000126FC # * The 'Convert '2' to Floating Point' should not be executed.
250: 245 000126FC # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
251: 246 000126FC # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
252: 247 000126FC # ****************************************************************************/
253: 248 000126FC # bad_pipe10_result()
254: 249 000126FC # {
255: 250 000126FC 13 0113 jbr L413
256: 251 000126FF L414:
257: 252 000126FF # errcnt++; /* bump the error count */
258: 253 000126FF 6d effffffe0f incl _errcnt
259: 254 00012705 # if ( prt_error )
260: 255 00012705 5d effffffe09 tstl _prt_error
261: 256 0001270B 21 03 13 00db jeql L415
262: 257 00012710 # {
263: 258 00012710 # print_pipe10_er( ". Bad final Accumulator" );
264: 259 00012710 .data 1
265: 260 0000058d * L416:
266: 261 0000058d * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
267: 16363756D756C61746F7200
268: 262 000005a5 * .text
269: 263 00012710 dd 8f0000058d pushl $L416
270: 264 00012716 fe 08 ef00000215 callf $8,_print_pipe10_er
271: 265 0001271D # writes(
272: 266 0001271D # "The 'Convert '2' to Floating Point' should not be executed\n");
273: 267 0001271D .data 1
274: 268 000005a5 * L417:
275: 269 000005a5 * 5468652027436F6E766572742 .ascii "The 'Convert '2' to Floating Point' should not be executed\12\0"
276: 027322720746F20466C6F6174
277: 696E6720506F696E742720736
278: 86F756C64206E6F7420626520
279: 65786563757465640A00
280: 270 000005e1 * .text
281: 271 0001271D dd 8f000005a5 pushl $L417
282: 272 00012723 fe 08 effffffdea callf $8,_writes
283: 273 0001272A # writes("op1 = ");
284: 274 0001272A .data 1
285: 275 000005e1 * L418:
286: 276 000005e1 * 6F7031203D2000 .ascii "op1 = \0"
287: 277 000005e8 * .text
288: 278 0001272A dd 8f000005e1 pushl $L418
289: 279 00012730 fe 08 effffffddd callf $8,_writes
290: 280 00012737 # write32h( dbl_ld_acc.m );
291: 281 00012737 dd effffffdd7 pushl _dbl_ld_acc
292: 282 0001273D fe 08 effffffdd0 callf $8,_write32h
293: 283 00012744 # writec(' ');
294: 284 00012744 dd 20 pushl $32
295: 285 00012746 fe 08 effffffdc7 callf $8,_writec
296: 286 0001274D # write32h( dbl_ld_acc.l );
297: 287 0001274D dd effffffdc5 pushl _dbl_ld_acc+4
298: 288 00012753 fe 08 effffffdba callf $8,_write32h
299: 289 0001275A # writes(", final Acc. = ");
300: 290 0001275A .data 1
301: 291 000005e8 * L419:
302: 292 000005e8 * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0"
303: 03D2000
304: 293 000005f8 * .text
305: 294 0001275A dd 8f000005e8 pushl $L419
306: 295 00012760 fe 08 effffffdad callf $8,_writes
307: 296 00012767 # write32h( post_evt_acc.l );
308: 297 00012767 dd effffffdab pushl _post_evt_acc+4
309: 298 0001276D fe 08 effffffda0 callf $8,_write32h
310: 299 00012774 # writec(' ');
311: 300 00012774 dd 20 pushl $32
312: 301 00012776 fe 08 effffffd97 callf $8,_writec
313: 302 0001277D # write32h( post_evt_acc.l );
314: 303 0001277D dd effffffd95 pushl _post_evt_acc+4
315: 304 00012783 fe 08 effffffd8a callf $8,_write32h
316: 305 0001278A # writes("\nop2 = ");
317: 306 0001278A .data 1
318: 307 000005f8 * L420:
319: 308 000005f8 * 0A6F7032203D2000 .ascii "\12op2 = \0"
320: 309 00000600 * .text
321: 310 0001278A dd 8f000005f8 pushl $L420
322: 311 00012790 fe 08 effffffd7d callf $8,_writes
323: 312 00012797 # write32h( dbl_value_1.m );
324: 313 00012797 dd effffffd77 pushl _dbl_value_1
325: 314 0001279D fe 08 effffffd70 callf $8,_write32h
326: 315 000127A4 # writec(' ');
327: 316 000127A4 dd 20 pushl $32
328: 317 000127A6 fe 08 effffffd67 callf $8,_writec
329: 318 000127AD # write32h( dbl_value_1.l );
330: 319 000127AD dd effffffd65 pushl _dbl_value_1+4
331: 320 000127B3 fe 08 effffffd5a callf $8,_write32h
332: 321 000127BA # writes(", expected = ");
333: 322 000127BA .data 1
334: 323 00000600 * L421:
335: 324 00000600 * 2C20202065787065637465642 .ascii ", expected = \0"
336: 03D2000
337: 325 00000610 * .text
338: 326 000127BA dd 8f00000600 pushl $L421
339: 327 000127C0 fe 08 effffffd4d callf $8,_writes
340: 328 000127C7 # write32h( 0 ); /* the expected result = 0 */
341: 329 000127C7 dd 00 pushl $0
342: 330 000127C9 fe 08 effffffd44 callf $8,_write32h
343: 331 000127D0 # writec(' ');
344: 332 000127D0 dd 20 pushl $32
345: 333 000127D2 fe 08 effffffd3b callf $8,_writec
346: 334 000127D9 # write32h( 0 );
347: 335 000127D9 dd 00 pushl $0
348: 336 000127DB fe 08 effffffd32 callf $8,_write32h
349: 337 000127E2 # writec('\n');
350: 338 000127E2 dd 0a pushl $10
351: 339 000127E4 fe 08 effffffd29 callf $8,_writec
352: 340 000127EB # }
353: 341 000127EB # if ( halt_flg ) /* halt on error? */
354: 342 000127EB L415:
355: 343 000127EB 5d effffffd23 tstl _halt_flg
356: 344 000127F1 31 09 jeql L422
357: 345 000127F3 # pipe10_halt( 2 ); /* halt with a code of 2 */
358: 346 000127F3 dd 02 pushl $2
359: 347 000127F5 fe 08 ef000001d4 callf $8,_pipe10_halt
360: 348 000127FC # if ( loop_on_err )
361: 349 000127FC L422:
362: 350 000127FC 5d effffffd12 tstl _loop_on_err
363: 351 00012802 31 0d jeql L423
364: 352 00012804 # {
365: 353 00012804 # force_loop = TRUE; /* set the force loop flag */
366: 354 00012804 0d 01 effffffd09 movl $1,_force_loop
367: 355 0001280B # asm("jmp _pipe10_lp1"); /* and loop */
368: 356 0001280B 71 effffffd9c jmp _pipe10_lp1
369: 357 00012811 # };
370: 358 00012811 L423:
371: 359 00012811 # }
372: 360 00012811 40 ret#2
373: 361 00012812 .set L411,0x0
374: 362 00012812 L413:
375: 363 00012812 13 feea jbr L414
376: 364 00012815 .data
377: 365 00000560 * .text
378: 366 00012815 00 .align 1
379: 367 00012816 .globl _pipe10_queue_er
380: 368 00012816 _pipe10_queue_er:
381: 369 00012816 0000 .word L424
382: 370 00012818 #
383: 371 00012818 #
384: 372 00012818 #
385: 373 00012818 #
386: 374 00012818 #
387: 375 00012818 # /****************************************************************************
388: 376 00012818 # * Report an "FPP queue not cleared" message
389: 377 00012818 # *
390: 378 00012818 # * Cycle: xx. EVT test xx. subtest xx. index = xx. Fpp queue not cleared.
391: 379 00012818 # * inst = LDD op1, MULD op2, CVLF '2' (underflow fault on the MULD)
392: 380 00012818 # * The 'Convert '2' to Floating Point' was apparently executed.
393: 381 00012818 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
394: 382 00012818 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
395: 383 00012818 # ****************************************************************************/
396: 384 00012818 # pipe10_queue_er()
397: 385 00012818 # {
398: 386 00012818 13 0113 jbr L426
399: 387 0001281B L427:
400: 388 0001281B # errcnt++; /* bump the error count */
401: 389 0001281B 6d effffffcf3 incl _errcnt
402: 390 00012821 # if ( prt_error )
403: 391 00012821 5d effffffced tstl _prt_error
404: 392 00012827 21 03 13 00db jeql L428
405: 393 0001282C # {
406: 394 0001282C # print_pipe10_er( ". Fpp queue not cleared" );
407: 395 0001282C .data 1
408: 396 00000610 * L429:
409: 397 00000610 * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0"
410: E6F7420636C656172656400
411: 398 00000628 * .text
412: 399 0001282C dd 8f00000610 pushl $L429
413: 400 00012832 fe 08 ef000000f9 callf $8,_print_pipe10_er
414: 401 00012839 # writes(
415: 402 00012839 # "The 'Convert '2' to Floating Point' was apparently executed.\n");
416: 403 00012839 .data 1
417: 404 00000628 * L430:
418: 405 00000628 * 5468652027436F6E766572742 .ascii "The 'Convert '2' to Floating Point' was apparently executed.\12\0"
419: 027322720746F20466C6F6174
420: 696E6720506F696E742720776
421: 173206170706172656E746C79
422: 2065786563757465642E0A00
423: 406 00000666 * .text
424: 407 00012839 dd 8f00000628 pushl $L430
425: 408 0001283F fe 08 effffffcce callf $8,_writes
426: 409 00012846 # writes("op1 = ");
427: 410 00012846 .data 1
428: 411 00000666 * L431:
429: 412 00000666 * 6F7031203D2000 .ascii "op1 = \0"
430: 413 0000066d * .text
431: 414 00012846 dd 8f00000666 pushl $L431
432: 415 0001284C fe 08 effffffcc1 callf $8,_writes
433: 416 00012853 # write32h( dbl_ld_acc.m );
434: 417 00012853 dd effffffcbb pushl _dbl_ld_acc
435: 418 00012859 fe 08 effffffcb4 callf $8,_write32h
436: 419 00012860 # writec(' ');
437: 420 00012860 dd 20 pushl $32
438: 421 00012862 fe 08 effffffcab callf $8,_writec
439: 422 00012869 # write32h( dbl_ld_acc.l );
440: 423 00012869 dd effffffca9 pushl _dbl_ld_acc+4
441: 424 0001286F fe 08 effffffc9e callf $8,_write32h
442: 425 00012876 # writes(", final Acc. = ");
443: 426 00012876 .data 1
444: 427 0000066d * L432:
445: 428 0000066d * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0"
446: 03D2000
447: 429 0000067d * .text
448: 430 00012876 dd 8f0000066d pushl $L432
449: 431 0001287C fe 08 effffffc91 callf $8,_writes
450: 432 00012883 # write32h( post_evt_acc.m );
451: 433 00012883 dd effffffc8b pushl _post_evt_acc
452: 434 00012889 fe 08 effffffc84 callf $8,_write32h
453: 435 00012890 # writec(' ');
454: 436 00012890 dd 20 pushl $32
455: 437 00012892 fe 08 effffffc7b callf $8,_writec
456: 438 00012899 # write32h( post_evt_acc.l );
457: 439 00012899 dd effffffc79 pushl _post_evt_acc+4
458: 440 0001289F fe 08 effffffc6e callf $8,_write32h
459: 441 000128A6 # writes("\nop2 = ");
460: 442 000128A6 .data 1
461: 443 0000067d * L433:
462: 444 0000067d * 0A6F7032203D2000 .ascii "\12op2 = \0"
463: 445 00000685 * .text
464: 446 000128A6 dd 8f0000067d pushl $L433
465: 447 000128AC fe 08 effffffc61 callf $8,_writes
466: 448 000128B3 # write32h( dbl_value_1.m );
467: 449 000128B3 dd effffffc5b pushl _dbl_value_1
468: 450 000128B9 fe 08 effffffc54 callf $8,_write32h
469: 451 000128C0 # writec(' ');
470: 452 000128C0 dd 20 pushl $32
471: 453 000128C2 fe 08 effffffc4b callf $8,_writec
472: 454 000128C9 # write32h( dbl_value_1.l );
473: 455 000128C9 dd effffffc49 pushl _dbl_value_1+4
474: 456 000128CF fe 08 effffffc3e callf $8,_write32h
475: 457 000128D6 # writes(", expected = ");
476: 458 000128D6 .data 1
477: 459 00000685 * L434:
478: 460 00000685 * 2C20202065787065637465642 .ascii ", expected = \0"
479: 03D2000
480: 461 00000695 * .text
481: 462 000128D6 dd 8f00000685 pushl $L434
482: 463 000128DC fe 08 effffffc31 callf $8,_writes
483: 464 000128E3 # write32h( 0 ); /* the expected result = 0 */
484: 465 000128E3 dd 00 pushl $0
485: 466 000128E5 fe 08 effffffc28 callf $8,_write32h
486: 467 000128EC # writec(' ');
487: 468 000128EC dd 20 pushl $32
488: 469 000128EE fe 08 effffffc1f callf $8,_writec
489: 470 000128F5 # write32h( 0 );
490: 471 000128F5 dd 00 pushl $0
491: 472 000128F7 fe 08 effffffc16 callf $8,_write32h
492: 473 000128FE # writec('\n');
493: 474 000128FE dd 0a pushl $10
494: 475 00012900 fe 08 effffffc0d callf $8,_writec
495: 476 00012907 # }
496: 477 00012907 # if ( halt_flg ) /* halt on error? */
497: 478 00012907 L428:
498: 479 00012907 5d effffffc07 tstl _halt_flg
499: 480 0001290D 31 09 jeql L435
500: 481 0001290F # pipe10_halt( 3 ); /* halt with a code of 3 */
501: 482 0001290F dd 03 pushl $3
502: 483 00012911 fe 08 ef000000b8 callf $8,_pipe10_halt
503: 484 00012918 # if ( loop_on_err )
504: 485 00012918 L435:
505: 486 00012918 5d effffffbf6 tstl _loop_on_err
506: 487 0001291E 31 0d jeql L436
507: 488 00012920 # {
508: 489 00012920 # force_loop = TRUE; /* set the force loop flag */
509: 490 00012920 0d 01 effffffbed movl $1,_force_loop
510: 491 00012927 # asm("jmp _pipe10_lp1"); /* and loop */
511: 492 00012927 71 effffffc80 jmp _pipe10_lp1
512: 493 0001292D # };
513: 494 0001292D L436:
514: 495 0001292D # }
515: 496 0001292D 40 ret#2
516: 497 0001292E .set L424,0x0
517: 498 0001292E L426:
518: 499 0001292E 13 feea jbr L427
519: 500 00012931 .data
520: 501 00000560 * .text
521: 502 00012931 00 .align 1
522: 503 00012932 .globl _print_pipe10_er
523: 504 00012932 _print_pipe10_er:
524: 505 00012932 0000 .word L437
525: 506 00012934 #
526: 507 00012934 #
527: 508 00012934 #
528: 509 00012934 #
529: 510 00012934 # /****************************************************************************
530: 511 00012934 # * Report an error message of the form:
531: 512 00012934 # *
532: 513 00012934 # * Cycle: xx. EVT test xx. subtest xx. index = xx. <your message here>
533: 514 00012934 # * inst = LDD op1, MULD op2, CVLF '2' (underflow fault on the MULD)
534: 515 00012934 # ****************************************************************************/
535: 516 00012934 # print_pipe10_er( msg )
536: 517 00012934 # char *msg; /* error message to print */
537: 518 00012934 # {
538: 519 00012934 13 0096 jbr L439
539: 520 00012937 L440:
540: 521 00012937 # if( errcnt == 1 ) /* 1st error? */
541: 522 00012937 1d effffffbd7 01 cmpl _errcnt,$1
542: 523 0001293E 21 0d jneq L441
543: 524 00012940 # writes(" \n"); /* start a new print line */
544: 525 00012940 .data 1
545: 526 00000695 * L442:
546: 527 00000695 * 200A00 .ascii " \12\0"
547: 528 00000698 * .text
548: 529 00012940 dd 8f00000695 pushl $L442
549: 530 00012946 fe 08 effffffbc7 callf $8,_writes
550: 531 0001294D # writes("Cycle: ");
551: 532 0001294D L441:
552: 533 0001294D .data 1
553: 534 00000698 * L443:
554: 535 00000698 * 4379636C653A2000 .ascii "Cycle: \0"
555: 536 000006a0 * .text
556: 537 0001294D dd 8f00000698 pushl $L443
557: 538 00012953 fe 08 effffffbba callf $8,_writes
558: 539 0001295A # writed( cycle );
559: 540 0001295A dd effffffbb4 pushl _cycle
560: 541 00012960 fe 08 effffffbad callf $8,_writed
561: 542 00012967 # writes(" EVT test ");
562: 543 00012967 .data 1
563: 544 000006a0 * L445:
564: 545 000006a0 * 202045565420746573742000 .ascii " EVT test \0"
565: 546 000006ac * .text
566: 547 00012967 dd 8f000006a0 pushl $L445
567: 548 0001296D fe 08 effffffba0 callf $8,_writes
568: 549 00012974 # writed( test_no );
569: 550 00012974 dd effffffb9a pushl _test_no
570: 551 0001297A fe 08 effffffb93 callf $8,_writed
571: 552 00012981 # writes(". subtest ");
572: 553 00012981 .data 1
573: 554 000006ac * L446:
574: 555 000006ac * 2E20737562746573742000 .ascii ". subtest \0"
575: 556 000006b7 * .text
576: 557 00012981 dd 8f000006ac pushl $L446
577: 558 00012987 fe 08 effffffb86 callf $8,_writes
578: 559 0001298E # writed( subtest );
579: 560 0001298E dd effffffb80 pushl _subtest
580: 561 00012994 fe 08 effffffb79 callf $8,_writed
581: 562 0001299B # writes(". index = ");
582: 563 0001299B .data 1
583: 564 000006b7 * L447:
584: 565 000006b7 * 2E20696E646578203D2000 .ascii ". index = \0"
585: 566 000006c2 * .text
586: 567 0001299B dd 8f000006b7 pushl $L447
587: 568 000129A1 fe 08 effffffb6c callf $8,_writes
588: 569 000129A8 # writed( index );
589: 570 000129A8 dd effffffb66 pushl _index
590: 571 000129AE fe 08 effffffb5f callf $8,_writed
591: 572 000129B5 # writes( msg ); /* print the message */
592: 573 000129B5 dd ad04 pushl 4(fp)
593: 574 000129B8 fe 08 effffffb55 callf $8,_writes
594: 575 000129BF # writes(
595: 576 000129BF # "\ninst = LDD op1, MULD op2, CVLF '2' (underflow fault on the MULD)\n");
596: 577 000129BF .data 1
597: 578 000006c2 * L448:
598: 579 000006c2 * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1, MULD op2, CVLF '2' (underflow fault on the M"
599: F70312C204D554C44206F7032
600: 2C2043564C462027322720202
601: 02028756E646572666C6F7720
602: 6661756C74206F6E207468652
603: 04D
604: 580 00000702 * 554C44290A00 .ascii "ULD)\12\0"
605: 581 00000708 * .text
606: 582 000129BF dd 8f000006c2 pushl $L448
607: 583 000129C5 fe 08 effffffb48 callf $8,_writes
608: 584 000129CC # }
609: 585 000129CC 40 ret#2
610: 586 000129CD .set L437,0x0
611: 587 000129CD L439:
612: 588 000129CD 13 ff67 jbr L440
613: 589 000129D0 .data
614: 590 00000560 * .text
615: 591 000129D0 .align 1
616: 592 000129D0 .globl _pipe10_halt
617: 593 000129D0 _pipe10_halt:
618: 594 000129D0 0000 .word L449
619: 595 000129D2 #
620: 596 000129D2 #
621: 597 000129D2 #
622: 598 000129D2 # /****************************************************************************
623: 599 000129D2 # * halt on error routine
624: 600 000129D2 # ****************************************************************************/
625: 601 000129D2 # pipe10_halt( code )
626: 602 000129D2 # int code; /* error code to halt with */
627: 603 000129D2 # {
628: 604 000129D2 13 009b jbr L451
629: 605 000129D5 L452:
630: 606 000129D5 # err_code = code;
631: 607 000129D5 0d ad04 effffffb37 movl 4(fp),_err_code
632: 608 000129DD # sgl_value_1 = dbl_ld_acc.m;
633: 609 000129DD 0d effffffb31 effffffb2c movl _dbl_ld_acc,_sgl_value_1
634: 610 000129E8 # sgl_value_2 = dbl_ld_acc.l;
635: 611 000129E8 0d effffffb2a effffffb21 movl _dbl_ld_acc+4,_sgl_value_2
636: 612 000129F3 # sgl_value_3 = dbl_value_1.m;
637: 613 000129F3 0d effffffb1b effffffb16 movl _dbl_value_1,_sgl_value_3
638: 614 000129FE # sgl_value_4 = dbl_value_1.l;
639: 615 000129FE 0d effffffb14 effffffb0b movl _dbl_value_1+4,_sgl_value_4
640: 616 00012A09 # sgl_value_5 = post_evt_acc.m;
641: 617 00012A09 0d effffffb05 effffffb00 movl _post_evt_acc,_sgl_value_5
642: 618 00012A14 # sgl_value_6 = post_evt_acc.l;
643: 619 00012A14 0d effffffafe effffffaf5 movl _post_evt_acc+4,_sgl_value_6
644: 620 00012A1F # asm("movl _test_no,r0"); /* r0 = test number */
645: 621 00012A1F 0d effffffaef 50 movl _test_no,r0
646: 622 00012A26 # asm("movl _subtest,r1"); /* r1 = subtest number */
647: 623 00012A26 0d effffffae8 51 movl _subtest,r1
648: 624 00012A2D # asm("movl _err_code,r2"); /* r2 = error code */
649: 625 00012A2D 0d effffffae1 52 movl _err_code,r2
650: 626 00012A34 # asm("movl _cycle,r3"); /* r3 = cycle count */
651: 627 00012A34 0d effffffada 53 movl _cycle,r3
652: 628 00012A3B # asm("movl _sgl_value_1,r4"); /* r4 = MSW of operand 1 */
653: 629 00012A3B 0d effffffad3 54 movl _sgl_value_1,r4
654: 630 00012A42 # asm("movl _sgl_value_2,r5"); /* r5 = LSW of operand 1 */
655: 631 00012A42 0d effffffacc 55 movl _sgl_value_2,r5
656: 632 00012A49 # asm("movl _sgl_value_3,r6"); /* r6 = MSW of operand 2 */
657: 633 00012A49 0d effffffac5 56 movl _sgl_value_3,r6
658: 634 00012A50 # asm("movl _sgl_value_4,r7"); /* r7 = LSW of operand 2 */
659: 635 00012A50 0d effffffabe 57 movl _sgl_value_4,r7
660: 636 00012A57 # asm("movl _sgl_value_5,r8"); /* r8 = MSW of final Acc. */
661: 637 00012A57 0d effffffab7 58 movl _sgl_value_5,r8
662: 638 00012A5E # asm("movl _sgl_value_6,r9"); /* r9 = LSW of final Acc. */
663: 639 00012A5E 0d effffffab0 59 movl _sgl_value_6,r9
664: 640 00012A65 # asm("clrl r10"); /* r10 = 0 (expected Acc.) */
665: 641 00012A65 4d 5a clrl r10
666: 642 00012A67 # asm("movl _index,r11"); /* r11 = data index */
667: 643 00012A67 0d effffffaa7 5b movl _index,r11
668: 644 00012A6E # asm("halt"); /* HALT ... */
669: 645 00012A6E 00 halt
670: 646 00012A6F # }
671: 647 00012A6F 40 ret#2
672: 648 00012A70 .set L449,0x0
673: 649 00012A70 L451:
674: 650 00012A70 13 ff62 jbr L452
675: 651 00012A73 .data
676: 651 00024F87 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.