![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe8.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 pipe8.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 000003d0 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe8
6: 6 00000000 _pipe8:
7: 7 00011CBC 0000 .word L381
8: 8 00011CBE #
9: 9 00011CBE # #include "evt_defs.h"
10: 10 00011CBE #
11: 11 00011CBE # /*
12: 12 00011CBE # *********************************************************************
13: 13 00011CBE # * FPP PIPELINED EVENTS TEST #8
14: 14 00011CBE # *
15: 15 00011CBE # * This test will execute the following code: "LDF EXPF CVLF"
16: 16 00011CBE # * with an underflow fault on the EXPF. We will make sure that:
17: 17 00011CBE # * 1. The fault is detected, and
18: 18 00011CBE # * 2. the convert long to float instruction is not executed.
19: 19 00011CBE # *********************************************************************
20: 20 00011CBE # */
21: 21 00011CBE # pipe8()
22: 22 00011CBE # {
23: 23 00011CBE 13 00fe jbr L383
24: 24 00011CC1 L384:
25: 25 00011CC1 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
26: 26 00011CC1 ed 6d effffffff4 moval (r13),_pre_event_fp
27: 27 00011CC8 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
28: 28 00011CC8 ed 6e efffffffed moval (r14),_pre_event_sp
29: 29 00011CCF # precision = SGL;
30: 30 00011CCF 0d 01 efffffffe6 movl $1,_precision
31: 31 00011CD6 # test_event = ARITH_CODE; /* expect an arithmetic fault */
32: 32 00011CD6 0d 34 efffffffdf movl $52,_test_event
33: 33 00011CDD # exp_code = FLT_UNDFL_CODE; /* - an specificly underflow */
34: 34 00011CDD 0d 05 efffffffd8 movl $5,_exp_code
35: 35 00011CE4 # exp_event = FALSE; /* ... but not yet */
36: 36 00011CE4 4d efffffffd2 clrl _exp_event
37: 37 00011CEA # asm("movab _pipe8_ret,_event_return"); /* set event return address */
38: 38 00011CEA e9 ef00000084 efffffffc7 movab _pipe8_ret,_event_return
39: 39 00011CF5 # max_index = exf_u_cnt; /* set max operand index */
40: 40 00011CF5 0d efffffffc1 efffffffbc movl _exf_u_cnt,_max_index
41: 41 00011D00 # for( index = 0; index < max_index; index++ )
42: 42 00011D00 4d efffffffb6 clrl _index
43: 43 00011D06 L387:
44: 44 00011D06 1d efffffffb0 efffffffab cmpl _index,_max_index
45: 45 00011D11 91 03 13 00a8 jgeq L386
46: 46 00011D16 # {
47: 47 00011D16 # dbl_ld_acc = exf_u_dat[index].op_1; /* get the data */
48: 48 00011D16 48 04 efffffff9f 50 shll $4,_index,r0
49: 49 00011D1E 0c 8f00000000 50 addl2 $_exf_u_dat,r0
50: 50 00011D25 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4
51: 51 00011D2D 0d 60 efffffff88 movl (r0),_dbl_ld_acc
52: 52 00011D34 # asm(".globl _pipe8_lp1");
53: 53 00011D34 .globl _pipe8_lp1
54: 54 00011D34 # asm("_pipe8_lp1:");
55: 55 00011D34 _pipe8_lp1:
56: 56 00011D34 # asm("bispsw $0x60"); /* enable ovfl,undfl */
57: 57 00011D34 8b 8860 bispsw $0x60
58: 58 00011D37 # asm("ldf _dbl_ld_acc"); /* load the Acc. */
59: 59 00011D37 06 efffffff7f ldf _dbl_ld_acc
60: 60 00011D3D # exp_event = test_event; /* expect event soon */
61: 61 00011D3D 0d efffffff79 efffffff74 movl _test_event,_exp_event
62: 62 00011D48 # asm("expf"); /* get undfl. event */
63: 63 00011D48 55 expf
64: 64 00011D49 # asm("cvlf $2"); /* queue the convert */
65: 65 00011D49 76 02 cvlf $2
66: 66 00011D4B # /*
67: 67 00011D4B # * If we got to here then there was no event
68: 68 00011D4B # */
69: 69 00011D4B # if( force_loop )
70: 70 00011D4B 5d efffffff6b tstl _force_loop
71: 71 00011D51 31 03 jeql L388
72: 72 00011D53 # asm("brw _pipe8_lp1");; /* loop on the error */
73: Assemb0002947C # asm("brw _pipe8_lp1");; /* loop on the error */
74: "pipe80002947C 73: WARNING: brw: destination label is external
75: 73 00011D53 13 ffde brw _pipe8_lp1
76: 74 00011D56 L388:
77: 75 00011D56 # exp_event = FALSE; /* reset event expected flag */
78: 76 00011D56 4d efffffff60 clrl _exp_event
79: 77 00011D5C # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
80: 78 00011D5C 0d efffffff5a 5d movl _pre_event_fp,fp
81: 79 00011D63 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
82: 80 00011D63 0d efffffff53 5e movl _pre_event_sp,sp
83: 81 00011D6A # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
84: 82 00011D6A 9b 8860 bicpsw $0x60
85: 83 00011D6D # no_pipe8_evt();; /* report the error */
86: 84 00011D6D fe 04 ef0000004e callf $4,_no_pipe8_evt
87: 85 00011D74 # /*
88: 86 00011D74 # * Come here after the event
89: 87 00011D74 # */
90: 88 00011D74 # asm(".globl _pipe8_ret");
91: 89 00011D74 .globl _pipe8_ret
92: 90 00011D74 # asm("_pipe8_ret:");
93: 91 00011D74 _pipe8_ret:
94: 92 00011D74 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
95: 93 00011D74 0d efffffff42 5d movl _pre_event_fp,fp
96: 94 00011D7B # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
97: 95 00011D7B 0d efffffff3b 5e movl _pre_event_sp,sp
98: 96 00011D82 # if( force_loop )
99: 97 00011D82 5d efffffff34 tstl _force_loop
100: 98 00011D88 31 03 jeql L390
101: 99 00011D8A # asm("brw _pipe8_lp1");; /* loop on the error */
102: "pipe80002947C 100: WARNING: brw: destination label is external
103: 100 00011D8A 13 ffa7 brw _pipe8_lp1
104: 101 00011D8D L390:
105: 102 00011D8D # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
106: 103 00011D8D 9b 8860 bicpsw $0x60
107: 104 00011D90 # if( post_evt_acc.m == 0x41000000 ) /* is the Acc. = floating 2? */
108: 105 00011D90 1d efffffff26 8f41000000 cmpl _post_evt_acc,$1090519040
109: 106 00011D9B 21 09 jneq L391
110: 107 00011D9D # pipe8_queue_er(); /* queue not cleared error */
111: 108 00011D9D fe 04 ef00000134 callf $4,_pipe8_queue_er
112: 109 00011DA4 # else if( post_evt_acc.m ) /* is the Acc. non zero? */
113: 110 00011DA4 11 0f jbr L393
114: 111 00011DA6 L391:
115: 112 00011DA6 5d efffffff10 tstl _post_evt_acc
116: 113 00011DAC 31 07 jeql L394
117: 114 00011DAE # bad_pipe8_result(); /* incorrect result error */
118: 115 00011DAE fe 04 ef00000079 callf $4,_bad_pipe8_result
119: 116 00011DB5 #
120: 117 00011DB5 # }
121: 118 00011DB5 L394:
122: 119 00011DB5 L393:
123: 120 00011DB5 L385:
124: 121 00011DB5 6d efffffff01 incl _index
125: 122 00011DBB 13 ff48 jbr L387
126: 123 00011DBE L386:
127: 124 00011DBE # }
128: 125 00011DBE 40 ret#2
129: 126 00011DBF .set L381,0x0
130: 127 00011DBF L383:
131: 128 00011DBF 13 feff jbr L384
132: 129 00011DC2 .data
133: 130 000003d0 * .text
134: 131 00011DC2 .align 1
135: 132 00011DC2 .globl _no_pipe8_evt
136: 133 00011DC2 _no_pipe8_evt:
137: 134 00011DC2 0000 .word L396
138: 135 00011DC4 #
139: 136 00011DC4 #
140: 137 00011DC4 #
141: 138 00011DC4 # /****************************************************************************
142: 139 00011DC4 # * Report an "EVENT NOT DETECTED" error
143: 140 00011DC4 # *
144: 141 00011DC4 # * Cycle: xx. EVT test xx. subtest xx. No underflow fault detected. index = xx
145: 142 00011DC4 # * inst = LDD op_1, EXPF, CVLF '2' (underflow fault on EXPF)
146: 143 00011DC4 # * op_1 = xxxxxxxx
147: 144 00011DC4 # ****************************************************************************/
148: 145 00011DC4 # no_pipe8_evt()
149: 146 00011DC4 # {
150: 147 00011DC4 11 65 jbr L398
151: 148 00011DC6 L399:
152: 149 00011DC6 # errcnt++; /* bump the error count */
153: 150 00011DC6 6d effffffef0 incl _errcnt
154: 151 00011DCC # if ( prt_error )
155: 152 00011DCC 5d effffffeea tstl _prt_error
156: 153 00011DD2 31 30 jeql L400
157: 154 00011DD4 # {
158: 155 00011DD4 # print_pipe8_er( ". No underflow fault detected." );
159: 156 00011DD4 .data 1
160: 157 000003d0 * L402:
161: 158 000003d0 * 2E204E6F20756E646572666C6 .ascii ". No underflow fault detected.\0"
162: F77206661756C742064657465
163: 637465642E00
164: 159 000003ef * .text
165: 160 00011DD4 dd 8f000003d0 pushl $L402
166: 161 00011DDA fe 08 ef000001a1 callf $8,_print_pipe8_er
167: 162 00011DE1 # writes("op_1 = ");
168: 163 00011DE1 .data 1
169: 164 000003ef * L404:
170: 165 000003ef * 6F705F31203D2000 .ascii "op_1 = \0"
171: 166 000003f7 * .text
172: 167 00011DE1 dd 8f000003ef pushl $L404
173: 168 00011DE7 fe 08 effffffece callf $8,_writes
174: 169 00011DEE # write32h( dbl_ld_acc.m );
175: 170 00011DEE dd effffffec8 pushl _dbl_ld_acc
176: 171 00011DF4 fe 08 effffffec1 callf $8,_write32h
177: 172 00011DFB # writec('\n');
178: 173 00011DFB dd 0a pushl $10
179: 174 00011DFD fe 08 effffffeb8 callf $8,_writec
180: 175 00011E04 # }
181: 176 00011E04 # if ( halt_flg ) /* halt on error? */
182: 177 00011E04 L400:
183: 178 00011E04 5d effffffeb2 tstl _halt_flg
184: 179 00011E0A 31 09 jeql L407
185: 180 00011E0C # pipe8_halt( 1 ); /* halt with a code of 1 */
186: 181 00011E0C dd 01 pushl $1
187: 182 00011E0E fe 08 ef0000020b callf $8,_pipe8_halt
188: 183 00011E15 # if ( loop_on_err )
189: 184 00011E15 L407:
190: 185 00011E15 5d effffffea1 tstl _loop_on_err
191: 186 00011E1B 31 0d jeql L409
192: 187 00011E1D # {
193: 188 00011E1D # force_loop = TRUE; /* set the force loop flag */
194: 189 00011E1D 0d 01 effffffe98 movl $1,_force_loop
195: 190 00011E24 # asm("jmp _pipe8_lp1"); /* and loop */
196: 191 00011E24 71 efffffff0a jmp _pipe8_lp1
197: 192 00011E2A # };
198: 193 00011E2A L409:
199: 194 00011E2A # }
200: 195 00011E2A 40 ret#2
201: 196 00011E2B .set L396,0x0
202: 197 00011E2B L398:
203: 198 00011E2B 11 99 jbr L399
204: 199 00011E2D .data
205: 200 000003d0 * .text
206: 201 00011E2D 00 .align 1
207: 202 00011E2E .globl _bad_pipe8_result
208: 203 00011E2E _bad_pipe8_result:
209: 204 00011E2E 0000 .word L410
210: 205 00011E30 #
211: 206 00011E30 #
212: 207 00011E30 #
213: 208 00011E30 #
214: 209 00011E30 # /****************************************************************************
215: 210 00011E30 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
216: 211 00011E30 # *
217: 212 00011E30 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
218: 213 00011E30 # * inst = LDD op_1, EXPF, CVLF '2' (underflow fault on EXPF)
219: 214 00011E30 # * The 'Convert '2' to Floating Point' should not be executed.
220: 215 00011E30 # * op_1 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx
221: 216 00011E30 # ****************************************************************************/
222: 217 00011E30 # bad_pipe8_result()
223: 218 00011E30 # {
224: 219 00011E30 13 00a2 jbr L412
225: 220 00011E33 L413:
226: 221 00011E33 # errcnt++; /* bump the error count */
227: 222 00011E33 6d effffffe83 incl _errcnt
228: 223 00011E39 # if ( prt_error )
229: 224 00011E39 5d effffffe7d tstl _prt_error
230: 225 00011E3F 31 6d jeql L414
231: 226 00011E41 # {
232: 227 00011E41 # print_pipe8_er( ". Bad final Accumulator" );
233: 228 00011E41 .data 1
234: 229 000003f7 * L415:
235: 230 000003f7 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
236: 16363756D756C61746F7200
237: 231 0000040f * .text
238: 232 00011E41 dd 8f000003f7 pushl $L415
239: 233 00011E47 fe 08 ef00000134 callf $8,_print_pipe8_er
240: 234 00011E4E # writes(
241: 235 00011E4E # "The 'Convert '2' to Floating Point' should not be executed\n");
242: 236 00011E4E .data 1
243: 237 0000040f * L416:
244: 238 0000040f * 5468652027436F6E766572742 .ascii "The 'Convert '2' to Floating Point' should not be executed\12\0"
245: 027322720746F20466C6F6174
246: 696E6720506F696E742720736
247: 86F756C64206E6F7420626520
248: 65786563757465640A00
249: 239 0000044b * .text
250: 240 00011E4E dd 8f0000040f pushl $L416
251: 241 00011E54 fe 08 effffffe61 callf $8,_writes
252: 242 00011E5B # writes("op_1 = ");
253: 243 00011E5B .data 1
254: 244 0000044b * L417:
255: 245 0000044b * 6F705F31203D2000 .ascii "op_1 = \0"
256: 246 00000453 * .text
257: 247 00011E5B dd 8f0000044b pushl $L417
258: 248 00011E61 fe 08 effffffe54 callf $8,_writes
259: 249 00011E68 # write32h( dbl_ld_acc.m );
260: 250 00011E68 dd effffffe4e pushl _dbl_ld_acc
261: 251 00011E6E fe 08 effffffe47 callf $8,_write32h
262: 252 00011E75 # writes(", final Acc. = ");
263: 253 00011E75 .data 1
264: 254 00000453 * L418:
265: 255 00000453 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
266: 32E203D2000
267: 256 00000465 * .text
268: 257 00011E75 dd 8f00000453 pushl $L418
269: 258 00011E7B fe 08 effffffe3a callf $8,_writes
270: 259 00011E82 # write32h( post_evt_acc.m );
271: 260 00011E82 dd effffffe34 pushl _post_evt_acc
272: 261 00011E88 fe 08 effffffe2d callf $8,_write32h
273: 262 00011E8F # writes(", expected = ");
274: 263 00011E8F .data 1
275: 264 00000465 * L419:
276: 265 00000465 * 2C20202065787065637465642 .ascii ", expected = \0"
277: 020203D2000
278: 266 00000477 * .text
279: 267 00011E8F dd 8f00000465 pushl $L419
280: 268 00011E95 fe 08 effffffe20 callf $8,_writes
281: 269 00011E9C # write32h( 0 ); /* the expected result = 0 */
282: 270 00011E9C dd 00 pushl $0
283: 271 00011E9E fe 08 effffffe17 callf $8,_write32h
284: 272 00011EA5 # writec('\n');
285: 273 00011EA5 dd 0a pushl $10
286: 274 00011EA7 fe 08 effffffe0e callf $8,_writec
287: 275 00011EAE # }
288: 276 00011EAE # if ( halt_flg ) /* halt on error? */
289: 277 00011EAE L414:
290: 278 00011EAE 5d effffffe08 tstl _halt_flg
291: 279 00011EB4 31 09 jeql L420
292: 280 00011EB6 # pipe8_halt( 2 ); /* halt with a code of 2 */
293: 281 00011EB6 dd 02 pushl $2
294: 282 00011EB8 fe 08 ef00000161 callf $8,_pipe8_halt
295: 283 00011EBF # if ( loop_on_err )
296: 284 00011EBF L420:
297: 285 00011EBF 5d effffffdf7 tstl _loop_on_err
298: 286 00011EC5 31 0d jeql L421
299: 287 00011EC7 # {
300: 288 00011EC7 # force_loop = TRUE; /* set the force loop flag */
301: 289 00011EC7 0d 01 effffffdee movl $1,_force_loop
302: 290 00011ECE # asm("jmp _pipe8_lp1"); /* and loop */
303: 291 00011ECE 71 effffffe60 jmp _pipe8_lp1
304: 292 00011ED4 # };
305: 293 00011ED4 L421:
306: 294 00011ED4 # }
307: 295 00011ED4 40 ret#2
308: 296 00011ED5 .set L410,0x0
309: 297 00011ED5 L412:
310: 298 00011ED5 13 ff5b jbr L413
311: 299 00011ED8 .data
312: 300 000003d0 * .text
313: 301 00011ED8 .align 1
314: 302 00011ED8 .globl _pipe8_queue_er
315: 303 00011ED8 _pipe8_queue_er:
316: 304 00011ED8 0000 .word L422
317: 305 00011EDA #
318: 306 00011EDA #
319: 307 00011EDA #
320: 308 00011EDA #
321: 309 00011EDA #
322: 310 00011EDA # /****************************************************************************
323: 311 00011EDA # * Report an "FPP queue not cleared" message
324: 312 00011EDA # *
325: 313 00011EDA # * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx
326: 314 00011EDA # * inst = LDD op_1, EXPF, CVLF '2' (underflow fault on EXPF)
327: 315 00011EDA # * The 'Convert '2' to Floating Point' was apparently executed.
328: 316 00011EDA # * op_1 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx
329: 317 00011EDA # ****************************************************************************/
330: 318 00011EDA # pipe8_queue_er()
331: 319 00011EDA # {
332: 320 00011EDA 13 00a2 jbr L424
333: 321 00011EDD L425:
334: 322 00011EDD # errcnt++; /* bump the error count */
335: 323 00011EDD 6d effffffdd9 incl _errcnt
336: 324 00011EE3 # if ( prt_error )
337: 325 00011EE3 5d effffffdd3 tstl _prt_error
338: 326 00011EE9 31 6d jeql L426
339: 327 00011EEB # {
340: 328 00011EEB # print_pipe8_er( ". Fpp queue not cleared" );
341: 329 00011EEB .data 1
342: 330 00000477 * L427:
343: 331 00000477 * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0"
344: E6F7420636C656172656400
345: 332 0000048f * .text
346: 333 00011EEB dd 8f00000477 pushl $L427
347: 334 00011EF1 fe 08 ef0000008a callf $8,_print_pipe8_er
348: 335 00011EF8 # writes(
349: 336 00011EF8 # "The 'Convert '2' to Floating Point' was apparently executed.\n");
350: 337 00011EF8 .data 1
351: 338 0000048f * L428:
352: 339 0000048f * 5468652027436F6E766572742 .ascii "The 'Convert '2' to Floating Point' was apparently executed.\12\0"
353: 027322720746F20466C6F6174
354: 696E6720506F696E742720776
355: 173206170706172656E746C79
356: 2065786563757465642E0A00
357: 340 000004cd * .text
358: 341 00011EF8 dd 8f0000048f pushl $L428
359: 342 00011EFE fe 08 effffffdb7 callf $8,_writes
360: 343 00011F05 # writes("op_1 = ");
361: 344 00011F05 .data 1
362: 345 000004cd * L429:
363: 346 000004cd * 6F705F31203D2000 .ascii "op_1 = \0"
364: 347 000004d5 * .text
365: 348 00011F05 dd 8f000004cd pushl $L429
366: 349 00011F0B fe 08 effffffdaa callf $8,_writes
367: 350 00011F12 # write32h( dbl_ld_acc.m );
368: 351 00011F12 dd effffffda4 pushl _dbl_ld_acc
369: 352 00011F18 fe 08 effffffd9d callf $8,_write32h
370: 353 00011F1F # writes(", final Acc. = ");
371: 354 00011F1F .data 1
372: 355 000004d5 * L430:
373: 356 000004d5 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
374: 32E203D2000
375: 357 000004e7 * .text
376: 358 00011F1F dd 8f000004d5 pushl $L430
377: 359 00011F25 fe 08 effffffd90 callf $8,_writes
378: 360 00011F2C # write32h( post_evt_acc.m );
379: 361 00011F2C dd effffffd8a pushl _post_evt_acc
380: 362 00011F32 fe 08 effffffd83 callf $8,_write32h
381: 363 00011F39 # writes(", expected = ");
382: 364 00011F39 .data 1
383: 365 000004e7 * L431:
384: 366 000004e7 * 2C20202065787065637465642 .ascii ", expected = \0"
385: 020203D2000
386: 367 000004f9 * .text
387: 368 00011F39 dd 8f000004e7 pushl $L431
388: 369 00011F3F fe 08 effffffd76 callf $8,_writes
389: 370 00011F46 # write32h( 0 ); /* expected result = 0 */
390: 371 00011F46 dd 00 pushl $0
391: 372 00011F48 fe 08 effffffd6d callf $8,_write32h
392: 373 00011F4F # writec('\n');
393: 374 00011F4F dd 0a pushl $10
394: 375 00011F51 fe 08 effffffd64 callf $8,_writec
395: 376 00011F58 # }
396: 377 00011F58 # if ( halt_flg ) /* halt on error? */
397: 378 00011F58 L426:
398: 379 00011F58 5d effffffd5e tstl _halt_flg
399: 380 00011F5E 31 09 jeql L432
400: 381 00011F60 # pipe8_halt( 3 ); /* halt with a code of 3 */
401: 382 00011F60 dd 03 pushl $3
402: 383 00011F62 fe 08 ef000000b7 callf $8,_pipe8_halt
403: 384 00011F69 # if ( loop_on_err )
404: 385 00011F69 L432:
405: 386 00011F69 5d effffffd4d tstl _loop_on_err
406: 387 00011F6F 31 0d jeql L433
407: 388 00011F71 # {
408: 389 00011F71 # force_loop = TRUE; /* set the force loop flag */
409: 390 00011F71 0d 01 effffffd44 movl $1,_force_loop
410: 391 00011F78 # asm("jmp _pipe8_lp1"); /* and loop */
411: 392 00011F78 71 effffffdb6 jmp _pipe8_lp1
412: 393 00011F7E # };
413: 394 00011F7E L433:
414: 395 00011F7E # }
415: 396 00011F7E 40 ret#2
416: 397 00011F7F .set L422,0x0
417: 398 00011F7F L424:
418: 399 00011F7F 13 ff5b jbr L425
419: 400 00011F82 .data
420: 401 000003d0 * .text
421: 402 00011F82 .align 1
422: 403 00011F82 .globl _print_pipe8_er
423: 404 00011F82 _print_pipe8_er:
424: 405 00011F82 0000 .word L434
425: 406 00011F84 #
426: 407 00011F84 #
427: 408 00011F84 #
428: 409 00011F84 #
429: 410 00011F84 # /****************************************************************************
430: 411 00011F84 # * Report an error message of the form:
431: 412 00011F84 # *
432: 413 00011F84 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
433: 414 00011F84 # * inst = LDD op_1, EXPF, CVLF '2' (underflow fault on EXPF)
434: 415 00011F84 # ****************************************************************************/
435: 416 00011F84 # print_pipe8_er( msg )
436: 417 00011F84 # char *msg; /* error message to print */
437: 418 00011F84 # {
438: 419 00011F84 13 0096 jbr L436
439: 420 00011F87 L437:
440: 421 00011F87 # if( errcnt == 1 ) /* 1st error? */
441: 422 00011F87 1d effffffd2f 01 cmpl _errcnt,$1
442: 423 00011F8E 21 0d jneq L438
443: 424 00011F90 # writes(" \n"); /* start a new print line */
444: 425 00011F90 .data 1
445: 426 000004f9 * L439:
446: 427 000004f9 * 200A00 .ascii " \12\0"
447: 428 000004fc * .text
448: 429 00011F90 dd 8f000004f9 pushl $L439
449: 430 00011F96 fe 08 effffffd1f callf $8,_writes
450: 431 00011F9D # writes("Cycle: ");
451: 432 00011F9D L438:
452: 433 00011F9D .data 1
453: 434 000004fc * L440:
454: 435 000004fc * 4379636C653A2000 .ascii "Cycle: \0"
455: 436 00000504 * .text
456: 437 00011F9D dd 8f000004fc pushl $L440
457: 438 00011FA3 fe 08 effffffd12 callf $8,_writes
458: 439 00011FAA # writed( cycle );
459: 440 00011FAA dd effffffd0c pushl _cycle
460: 441 00011FB0 fe 08 effffffd05 callf $8,_writed
461: 442 00011FB7 # writes(" EVT test ");
462: 443 00011FB7 .data 1
463: 444 00000504 * L442:
464: 445 00000504 * 202045565420746573742000 .ascii " EVT test \0"
465: 446 00000510 * .text
466: 447 00011FB7 dd 8f00000504 pushl $L442
467: 448 00011FBD fe 08 effffffcf8 callf $8,_writes
468: 449 00011FC4 # writed( test_no );
469: 450 00011FC4 dd effffffcf2 pushl _test_no
470: 451 00011FCA fe 08 effffffceb callf $8,_writed
471: 452 00011FD1 # writes(". subtest ");
472: 453 00011FD1 .data 1
473: 454 00000510 * L443:
474: 455 00000510 * 2E20737562746573742000 .ascii ". subtest \0"
475: 456 0000051b * .text
476: 457 00011FD1 dd 8f00000510 pushl $L443
477: 458 00011FD7 fe 08 effffffcde callf $8,_writes
478: 459 00011FDE # writed( subtest );
479: 460 00011FDE dd effffffcd8 pushl _subtest
480: 461 00011FE4 fe 08 effffffcd1 callf $8,_writed
481: 462 00011FEB # writes( msg ); /* print the message */
482: 463 00011FEB dd ad04 pushl 4(fp)
483: 464 00011FEE fe 08 effffffcc7 callf $8,_writes
484: 465 00011FF5 # writes(" index = ");
485: 466 00011FF5 .data 1
486: 467 0000051b * L444:
487: 468 0000051b * 20696E646578203D2000 .ascii " index = \0"
488: 469 00000525 * .text
489: 470 00011FF5 dd 8f0000051b pushl $L444
490: 471 00011FFB fe 08 effffffcba callf $8,_writes
491: 472 00012002 # writed( index );
492: 473 00012002 dd effffffcb4 pushl _index
493: 474 00012008 fe 08 effffffcad callf $8,_writed
494: 475 0001200F # writes(
495: 476 0001200F # "\ninst = LDD op_1, EXPF, CVLF '2' (underflow fault on EXPF)\n");
496: 477 0001200F .data 1
497: 478 00000525 * L445:
498: 479 00000525 * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op_1, EXPF, CVLF '2' (underflow fault on EXPF)\12\0"
499: F705F312C20455850462C2043
500: 564C462027322720202020287
501: 56E646572666C6F7720666175
502: 6C74206F6E2045585046290A0
503: 0
504: 480 00000564 * .text
505: 481 0001200F dd 8f00000525 pushl $L445
506: 482 00012015 fe 08 effffffca0 callf $8,_writes
507: 483 0001201C # }
508: 484 0001201C 40 ret#2
509: 485 0001201D .set L434,0x0
510: 486 0001201D L436:
511: 487 0001201D 13 ff67 jbr L437
512: 488 00012020 .data
513: 489 000003d0 * .text
514: 490 00012020 .align 1
515: 491 00012020 .globl _pipe8_halt
516: 492 00012020 _pipe8_halt:
517: 493 00012020 0000 .word L446
518: 494 00012022 #
519: 495 00012022 #
520: 496 00012022 #
521: 497 00012022 # /****************************************************************************
522: 498 00012022 # * halt on error routine
523: 499 00012022 # ****************************************************************************/
524: 500 00012022 # pipe8_halt( code )
525: 501 00012022 # int code; /* error code to halt with */
526: 502 00012022 # {
527: 503 00012022 11 63 jbr L448
528: 504 00012024 L449:
529: 505 00012024 # err_code = code;
530: 506 00012024 0d ad04 effffffc90 movl 4(fp),_err_code
531: 507 0001202C # sgl_value_1 = dbl_ld_acc.m;
532: 508 0001202C 0d effffffc8a effffffc85 movl _dbl_ld_acc,_sgl_value_1
533: 509 00012037 # sgl_value_2 = post_evt_acc.m;
534: 510 00012037 0d effffffc7f effffffc7a movl _post_evt_acc,_sgl_value_2
535: 511 00012042 # sgl_value_3 = dbl_expected.m;
536: 512 00012042 0d effffffc74 effffffc6f movl _dbl_expected,_sgl_value_3
537: 513 0001204D # asm("movl _test_no,r0"); /* r0 = test number */
538: 514 0001204D 0d effffffc69 50 movl _test_no,r0
539: 515 00012054 # asm("movl _subtest,r1"); /* r1 = subtest number */
540: 516 00012054 0d effffffc62 51 movl _subtest,r1
541: 517 0001205B # asm("movl _err_code,r2"); /* r2 = error code */
542: 518 0001205B 0d effffffc5b 52 movl _err_code,r2
543: 519 00012062 # asm("movl _cycle,r3"); /* r3 = cycle count */
544: 520 00012062 0d effffffc54 53 movl _cycle,r3
545: 521 00012069 # asm("movl _sgl_value_1,r4"); /* r4 = initial operand */
546: 522 00012069 0d effffffc4d 54 movl _sgl_value_1,r4
547: 523 00012070 # asm("movl _sgl_value_2,r5"); /* r5 = final accumulator */
548: 524 00012070 0d effffffc46 55 movl _sgl_value_2,r5
549: 525 00012077 # asm("movl _sgl_value_3,r6"); /* r6 = expected accumulator */
550: 526 00012077 0d effffffc3f 56 movl _sgl_value_3,r6
551: 527 0001207E # asm("movl _index,r7"); /* r7 = data index */
552: 528 0001207E 0d effffffc38 57 movl _index,r7
553: 529 00012085 # asm("halt"); /* HALT ... */
554: 530 00012085 00 halt
555: 531 00012086 # }
556: 532 00012086 40 ret#2
557: 533 00012087 .set L446,0x0
558: 534 00012087 L448:
559: 535 00012087 11 9b jbr L449
560: 536 00012089 .data
561: 536 00023D45 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.