![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe3.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 pipe3.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 000003dc * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe3
6: 6 00000000 _pipe3:
7: 7 00010050 0000 .word L381
8: 8 00010052 #
9: 9 00010052 # #include "evt_defs.h"
10: 10 00010052 #
11: 11 00010052 # /*
12: 12 00010052 # *********************************************************************
13: 13 00010052 # * FPP PIPELINED EVENTS TEST #3
14: 14 00010052 # *
15: 15 00010052 # * This test will execute the following code: "LDF LOGF CMPF2 LOGF"
16: 16 00010052 # * with a reserved operand fault on the CMPF2. We will make sure that:
17: 17 00010052 # * 1. The fault is detected,
18: 18 00010052 # * 2. the 1st log operation completes, and
19: 19 00010052 # * 3. the 2nd log instruction is not executed.
20: 20 00010052 # *********************************************************************
21: 21 00010052 # */
22: 22 00010052 # pipe3()
23: 23 00010052 # {
24: 24 00010052 13 013f jbr L383
25: 25 00010055 L384:
26: 26 00010055 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
27: 27 00010055 ed 6d effffffff4 moval (r13),_pre_event_fp
28: 28 0001005C # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
29: 29 0001005C ed 6e efffffffed moval (r14),_pre_event_sp
30: 30 00010063 # precision = SGL;
31: 31 00010063 0d 01 efffffffe6 movl $1,_precision
32: 32 0001006A # test_event = RESOP_CODE; /* reserved op.fault expected */
33: 33 0001006A 0d 2d efffffffdf movl $45,_test_event
34: 34 00010071 # exp_event = FALSE; /* ... but not yet */
35: 35 00010071 4d efffffffd9 clrl _exp_event
36: 36 00010077 # asm("movab _pipe3_ret,_event_return"); /* post event addr */
37: 37 00010077 e9 ef000000dd efffffffce movab _pipe3_ret,_event_return
38: 38 00010082 # for( index = 0; index < max_pipe3_index; index++ ) {
39: 39 00010082 4d efffffffc8 clrl _index
40: 40 00010088 L387:
41: 41 00010088 1d efffffffc2 efffffffbd cmpl _index,_max_pipe3_index
42: 42 00010093 91 03 13 00fb jgeq L386
43: 43 00010098 # dbl_ld_acc = pipe3_data[index].op_1; /* get the data */
44: 44 00010098 5c 18 efffffffb1 50 mull3 $24,_index,r0
45: 45 000100A0 0c 8f00000000 50 addl2 $_pipe3_data,r0
46: 46 000100A7 0d a004 efffffffa5 movl 4(r0),_dbl_ld_acc+4
47: 47 000100AF 0d 60 efffffff9a movl (r0),_dbl_ld_acc
48: 48 000100B6 # dbl_expected = pipe3_data[index].exp;
49: 49 000100B6 5c 18 efffffff93 50 mull3 $24,_index,r0
50: 50 000100BE 0c 8f00000010 50 addl2 $_pipe3_data+16,r0
51: 51 000100C5 0d a004 efffffff87 movl 4(r0),_dbl_expected+4
52: 52 000100CD 0d 60 efffffff7c movl (r0),_dbl_expected
53: 53 000100D4 # dbl_value_1 = cmp2_resops[index].op_1; /* get reserved ops. */
54: 54 000100D4 48 04 efffffff75 50 shll $4,_index,r0
55: 55 000100DC 0c 8f00000000 50 addl2 $_cmp2_resops,r0
56: 56 000100E3 0d a004 efffffff69 movl 4(r0),_dbl_value_1+4
57: 57 000100EB 0d 60 efffffff5e movl (r0),_dbl_value_1
58: 58 000100F2 # dbl_value_2 = cmp2_resops[index].op_2;
59: 59 000100F2 48 04 efffffff57 50 shll $4,_index,r0
60: 60 000100FA 0c 8f00000008 50 addl2 $_cmp2_resops+8,r0
61: 61 00010101 0d a004 efffffff4b movl 4(r0),_dbl_value_2+4
62: 62 00010109 0d 60 efffffff40 movl (r0),_dbl_value_2
63: 63 00010110 # asm(".globl _pipe3_lp1");
64: 64 00010110 .globl _pipe3_lp1
65: 65 00010110 # asm("_pipe3_lp1:");
66: 66 00010110 _pipe3_lp1:
67: 67 00010110 # asm("bispsw $0x60"); /* enable ovfl,undfl */
68: 68 00010110 8b 8860 bispsw $0x60
69: 69 00010113 # asm("ldf _dbl_ld_acc"); /* load the Acc. */
70: 70 00010113 06 efffffff37 ldf _dbl_ld_acc
71: 71 00010119 # exp_event = test_event; /* expect event soon */
72: 72 00010119 0d efffffff31 efffffff2c movl _test_event,_exp_event
73: 73 00010124 # asm("logf"); /* get the log */
74: 74 00010124 35 logf
75: 75 00010125 # asm("cmpf2 _dbl_value_1,_dbl_value_2"); /* cause the event */
76: 76 00010125 46 efffffff25 efffffff20 cmpf2 _dbl_value_1,_dbl_value_2
77: 77 00010130 # asm("logf"); /* shouldn't get here*/
78: 78 00010130 35 logf
79: 79 00010131 # /*
80: 80 00010131 # * If we got to here then there was no event
81: 81 00010131 # */
82: 82 00010131 # if( force_loop )
83: 83 00010131 5d efffffff19 tstl _force_loop
84: 84 00010137 31 03 jeql L388
85: 85 00010139 # asm("brw _pipe3_lp1");; /* loop on the error */
86: Assemb00027810 # asm("brw _pipe3_lp1");; /* loop on the error */
87: "pipe300027810 86: WARNING: brw: destination label is external
88: 86 00010139 13 ffd4 brw _pipe3_lp1
89: 87 0001013C L388:
90: 88 0001013C # exp_event = FALSE; /* reset event expected flag */
91: 89 0001013C 4d efffffff0e clrl _exp_event
92: 90 00010142 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
93: 91 00010142 9b 8860 bicpsw $0x60
94: 92 00010145 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
95: 93 00010145 0d efffffff05 5d movl _pre_event_fp,fp
96: 94 0001014C # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
97: 95 0001014C 0d effffffefe 5e movl _pre_event_sp,sp
98: 96 00010153 # no_pipe3_evt();; /* report the error */
99: 97 00010153 fe 04 ef0000003e callf $4,_no_pipe3_evt
100: 98 0001015A # /*
101: 99 0001015A # * Come here after the event
102: 100 0001015A # */
103: 101 0001015A # asm(".globl _pipe3_ret");
104: 102 0001015A .globl _pipe3_ret
105: 103 0001015A # asm("_pipe3_ret:");
106: 104 0001015A _pipe3_ret:
107: 105 0001015A # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
108: 106 0001015A 0d effffffef0 5d movl _pre_event_fp,fp
109: 107 00010161 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
110: 108 00010161 0d effffffee9 5e movl _pre_event_sp,sp
111: 109 00010168 # if( force_loop )
112: 110 00010168 5d effffffee2 tstl _force_loop
113: 111 0001016E 31 03 jeql L390
114: 112 00010170 # asm("brw _pipe3_lp1");; /* loop on the error */
115: "pipe300027810 113: WARNING: brw: destination label is external
116: 113 00010170 13 ff9d brw _pipe3_lp1
117: 114 00010173 L390:
118: 115 00010173 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
119: 116 00010173 9b 8860 bicpsw $0x60
120: 117 00010176 # if( post_evt_acc.m != dbl_expected.m )
121: 118 00010176 1d effffffed4 effffffecf cmpl _post_evt_acc,_dbl_expected
122: 119 00010181 31 07 jeql L391
123: 120 00010183 # bad_pipe3_result(); /* incorrect result error */
124: 121 00010183 fe 04 ef000000b0 callf $4,_bad_pipe3_result
125: 122 0001018A #
126: 123 0001018A # }
127: 124 0001018A L391:
128: 125 0001018A L385:
129: 126 0001018A 6d effffffec0 incl _index
130: 127 00010190 13 fef5 jbr L387
131: 128 00010193 L386:
132: 129 00010193 # }
133: 130 00010193 40 ret#2
134: 131 00010194 .set L381,0x0
135: 132 00010194 L383:
136: 133 00010194 13 febe jbr L384
137: 134 00010197 .data
138: 135 000003dc * .text
139: 136 00010197 00 .align 1
140: 137 00010198 .globl _no_pipe3_evt
141: 138 00010198 _no_pipe3_evt:
142: 139 00010198 0000 .word L393
143: 140 0001019A #
144: 141 0001019A #
145: 142 0001019A #
146: 143 0001019A # /****************************************************************************
147: 144 0001019A # * Report an "EVENT NOT DETECTED" error
148: 145 0001019A # *
149: 146 0001019A # * Cycle: xx. EVT test xx. subtest xx. No reserved operand fault. index = xx
150: 147 0001019A # * inst = LDF op_1, LOGF, CMPF2 op_2,op_3, LOGF (reserved op. fault on CMPF2)
151: 148 0001019A # * op_1 = xxxxxxxx, op_2 = xxxxxxxx, op_3 = xxxxxxxx
152: 149 0001019A # ****************************************************************************/
153: 150 0001019A # no_pipe3_evt()
154: 151 0001019A # {
155: 152 0001019A 13 0099 jbr L395
156: 153 0001019D L396:
157: 154 0001019D # errcnt++; /* bump the error count */
158: 155 0001019D 6d effffffead incl _errcnt
159: 156 000101A3 # if ( prt_error ) {
160: 157 000101A3 5d effffffea7 tstl _prt_error
161: 158 000101A9 31 64 jeql L397
162: 159 000101AB # print_pipe3_er( ". No reserved operand fault. " );
163: 160 000101AB .data 1
164: 161 000003dc * L399:
165: 162 000003dc * 2E204E6F20726573657276656 .ascii ". No reserved operand fault. \0"
166: 4206F706572616E6420666175
167: 6C742E2000
168: 163 000003fa * .text
169: 164 000101AB dd 8f000003dc pushl $L399
170: 165 000101B1 fe 08 ef00000130 callf $8,_print_pipe3_er
171: 166 000101B8 # writes("op_1 = ");
172: 167 000101B8 .data 1
173: 168 000003fa * L401:
174: 169 000003fa * 6F705F31203D2000 .ascii "op_1 = \0"
175: 170 00000402 * .text
176: 171 000101B8 dd 8f000003fa pushl $L401
177: 172 000101BE fe 08 effffffe8b callf $8,_writes
178: 173 000101C5 # write32h( dbl_ld_acc.m );
179: 174 000101C5 dd effffffe85 pushl _dbl_ld_acc
180: 175 000101CB fe 08 effffffe7e callf $8,_write32h
181: 176 000101D2 # writes(", op_2 = ");
182: 177 000101D2 .data 1
183: 178 00000402 * L403:
184: 179 00000402 * 2C2020206F705F32203D2000 .ascii ", op_2 = \0"
185: 180 0000040e * .text
186: 181 000101D2 dd 8f00000402 pushl $L403
187: 182 000101D8 fe 08 effffffe71 callf $8,_writes
188: 183 000101DF # write32h( dbl_value_1.m );
189: 184 000101DF dd effffffe6b pushl _dbl_value_1
190: 185 000101E5 fe 08 effffffe64 callf $8,_write32h
191: 186 000101EC # writes(", op_3 = ");
192: 187 000101EC .data 1
193: 188 0000040e * L404:
194: 189 0000040e * 2C2020206F705F33203D2000 .ascii ", op_3 = \0"
195: 190 0000041a * .text
196: 191 000101EC dd 8f0000040e pushl $L404
197: 192 000101F2 fe 08 effffffe57 callf $8,_writes
198: 193 000101F9 # write32h( dbl_value_2.m );
199: 194 000101F9 dd effffffe51 pushl _dbl_value_2
200: 195 000101FF fe 08 effffffe4a callf $8,_write32h
201: 196 00010206 # writec('\n');
202: 197 00010206 dd 0a pushl $10
203: 198 00010208 fe 08 effffffe41 callf $8,_writec
204: 199 0001020F # }
205: 200 0001020F # if ( halt_flg ) /* halt on error? */
206: 201 0001020F L397:
207: 202 0001020F 5d effffffe3b tstl _halt_flg
208: 203 00010215 31 09 jeql L406
209: 204 00010217 # pipe3_halt( 1 ); /* halt with a code of 1 */
210: 205 00010217 dd 01 pushl $1
211: 206 00010219 fe 08 ef00000174 callf $8,_pipe3_halt
212: 207 00010220 # if ( loop_on_err ) {
213: 208 00010220 L406:
214: 209 00010220 5d effffffe2a tstl _loop_on_err
215: 210 00010226 31 0d jeql L408
216: 211 00010228 # force_loop = TRUE; /* set the force loop flag */
217: 212 00010228 0d 01 effffffe21 movl $1,_force_loop
218: 213 0001022F # asm("jmp _pipe3_lp1"); /* and loop */
219: 214 0001022F 71 effffffedb jmp _pipe3_lp1
220: 215 00010235 # };
221: 216 00010235 L408:
222: 217 00010235 # }
223: 218 00010235 40 ret#2
224: 219 00010236 .set L393,0x0
225: 220 00010236 L395:
226: 221 00010236 13 ff64 jbr L396
227: 222 00010239 .data
228: 223 000003dc * .text
229: 224 00010239 00 .align 1
230: 225 0001023A .globl _bad_pipe3_result
231: 226 0001023A _bad_pipe3_result:
232: 227 0001023A 0000 .word L409
233: 228 0001023C #
234: 229 0001023C #
235: 230 0001023C #
236: 231 0001023C #
237: 232 0001023C # /****************************************************************************
238: 233 0001023C # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
239: 234 0001023C # *
240: 235 0001023C # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
241: 236 0001023C # * inst = LDF op_1, LOGF, CMPF2 op_2,op_3, LOGF (reserved op. fault on CMPF2)
242: 237 0001023C # * The 2nd LOGF should not be executed.
243: 238 0001023C # * op_1 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx
244: 239 0001023C # ****************************************************************************/
245: 240 0001023C # bad_pipe3_result()
246: 241 0001023C # {
247: 242 0001023C 13 00a6 jbr L411
248: 243 0001023F L412:
249: 244 0001023F # errcnt++; /* bump the error count */
250: 245 0001023F 6d effffffe0b incl _errcnt
251: 246 00010245 # if ( prt_error ) {
252: 247 00010245 5d effffffe05 tstl _prt_error
253: 248 0001024B 31 71 jeql L413
254: 249 0001024D # print_pipe3_er( ". Bad final Accumulator. " );
255: 250 0001024D .data 1
256: 251 0000041a * L414:
257: 252 0000041a * 2E204261642066696E616C204 .ascii ". Bad final Accumulator. \0"
258: 16363756D756C61746F722E20
259: 00
260: 253 00000434 * .text
261: 254 0001024D dd 8f0000041a pushl $L414
262: 255 00010253 fe 08 ef0000008e callf $8,_print_pipe3_er
263: 256 0001025A # writes("The 2nd LOGF should not be executed\n");
264: 257 0001025A .data 1
265: 258 00000434 * L415:
266: 259 00000434 * 54686520326E64204C4F47462 .ascii "The 2nd LOGF should not be executed\12\0"
267: 073686F756C64206E6F742062
268: 652065786563757465640A00
269: 260 00000459 * .text
270: 261 0001025A dd 8f00000434 pushl $L415
271: 262 00010260 fe 08 effffffde9 callf $8,_writes
272: 263 00010267 # writes("op_1 = ");
273: 264 00010267 .data 1
274: 265 00000459 * L416:
275: 266 00000459 * 6F705F31203D2000 .ascii "op_1 = \0"
276: 267 00000461 * .text
277: 268 00010267 dd 8f00000459 pushl $L416
278: 269 0001026D fe 08 effffffddc callf $8,_writes
279: 270 00010274 # write32h( dbl_ld_acc.m );
280: 271 00010274 dd effffffdd6 pushl _dbl_ld_acc
281: 272 0001027A fe 08 effffffdcf callf $8,_write32h
282: 273 00010281 # writes(", final Acc. = ");
283: 274 00010281 .data 1
284: 275 00000461 * L417:
285: 276 00000461 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
286: 32E203D2000
287: 277 00000473 * .text
288: 278 00010281 dd 8f00000461 pushl $L417
289: 279 00010287 fe 08 effffffdc2 callf $8,_writes
290: 280 0001028E # write32h( post_evt_acc.m );
291: 281 0001028E dd effffffdbc pushl _post_evt_acc
292: 282 00010294 fe 08 effffffdb5 callf $8,_write32h
293: 283 0001029B # writes(", expected = ");
294: 284 0001029B .data 1
295: 285 00000473 * L418:
296: 286 00000473 * 2C20202065787065637465642 .ascii ", expected = \0"
297: 020203D2000
298: 287 00000485 * .text
299: 288 0001029B dd 8f00000473 pushl $L418
300: 289 000102A1 fe 08 effffffda8 callf $8,_writes
301: 290 000102A8 # write32h( dbl_expected.m );
302: 291 000102A8 dd effffffda2 pushl _dbl_expected
303: 292 000102AE fe 08 effffffd9b callf $8,_write32h
304: 293 000102B5 # writec('\n');
305: 294 000102B5 dd 0a pushl $10
306: 295 000102B7 fe 08 effffffd92 callf $8,_writec
307: 296 000102BE # }
308: 297 000102BE # if ( halt_flg ) /* halt on error? */
309: 298 000102BE L413:
310: 299 000102BE 5d effffffd8c tstl _halt_flg
311: 300 000102C4 31 09 jeql L419
312: 301 000102C6 # pipe3_halt( 2 ); /* halt with a code of 2 */
313: 302 000102C6 dd 02 pushl $2
314: 303 000102C8 fe 08 ef000000c5 callf $8,_pipe3_halt
315: 304 000102CF # if ( loop_on_err ) {
316: 305 000102CF L419:
317: 306 000102CF 5d effffffd7b tstl _loop_on_err
318: 307 000102D5 31 0d jeql L420
319: 308 000102D7 # force_loop = TRUE; /* set the force loop flag */
320: 309 000102D7 0d 01 effffffd72 movl $1,_force_loop
321: 310 000102DE # asm("jmp _pipe3_lp1"); /* and loop */
322: 311 000102DE 71 effffffe2c jmp _pipe3_lp1
323: 312 000102E4 # };
324: 313 000102E4 L420:
325: 314 000102E4 # }
326: 315 000102E4 40 ret#2
327: 316 000102E5 .set L409,0x0
328: 317 000102E5 L411:
329: 318 000102E5 13 ff57 jbr L412
330: 319 000102E8 .data
331: 320 000003dc * .text
332: 321 000102E8 .align 1
333: 322 000102E8 .globl _print_pipe3_er
334: 323 000102E8 _print_pipe3_er:
335: 324 000102E8 0000 .word L421
336: 325 000102EA #
337: 326 000102EA #
338: 327 000102EA #
339: 328 000102EA #
340: 329 000102EA #
341: 330 000102EA #
342: 331 000102EA # /****************************************************************************
343: 332 000102EA # * Report an error message of the form:
344: 333 000102EA # *
345: 334 000102EA # * Cycle: xx. EVT test xx. subtest xx. <your message here>. index = xx
346: 335 000102EA # * inst = LDF op_1, LOGF, CMPF2 op_2,op_3, LOGF (reserved op. fault on CMPF2)
347: 336 000102EA # ****************************************************************************/
348: 337 000102EA # print_pipe3_er( msg )
349: 338 000102EA # char *msg; /* error message to print */
350: 339 000102EA # {
351: 340 000102EA 13 00a3 jbr L423
352: 341 000102ED L424:
353: 342 000102ED # if( errcnt == 1 ) /* 1st error? */
354: 343 000102ED 1d effffffd5d 01 cmpl _errcnt,$1
355: 344 000102F4 21 0d jneq L425
356: 345 000102F6 # writes(" \n"); /* start a new print line */
357: 346 000102F6 .data 1
358: 347 00000485 * L426:
359: 348 00000485 * 200A00 .ascii " \12\0"
360: 349 00000488 * .text
361: 350 000102F6 dd 8f00000485 pushl $L426
362: 351 000102FC fe 08 effffffd4d callf $8,_writes
363: 352 00010303 # writes("Cycle: ");
364: 353 00010303 L425:
365: 354 00010303 .data 1
366: 355 00000488 * L427:
367: 356 00000488 * 4379636C653A2000 .ascii "Cycle: \0"
368: 357 00000490 * .text
369: 358 00010303 dd 8f00000488 pushl $L427
370: 359 00010309 fe 08 effffffd40 callf $8,_writes
371: 360 00010310 # writed( cycle );
372: 361 00010310 dd effffffd3a pushl _cycle
373: 362 00010316 fe 08 effffffd33 callf $8,_writed
374: 363 0001031D # writes(" EVT test ");
375: 364 0001031D .data 1
376: 365 00000490 * L429:
377: 366 00000490 * 202045565420746573742000 .ascii " EVT test \0"
378: 367 0000049c * .text
379: 368 0001031D dd 8f00000490 pushl $L429
380: 369 00010323 fe 08 effffffd26 callf $8,_writes
381: 370 0001032A # writed( test_no );
382: 371 0001032A dd effffffd20 pushl _test_no
383: 372 00010330 fe 08 effffffd19 callf $8,_writed
384: 373 00010337 # writes(". subtest ");
385: 374 00010337 .data 1
386: 375 0000049c * L430:
387: 376 0000049c * 2E20737562746573742000 .ascii ". subtest \0"
388: 377 000004a7 * .text
389: 378 00010337 dd 8f0000049c pushl $L430
390: 379 0001033D fe 08 effffffd0c callf $8,_writes
391: 380 00010344 # writed( subtest );
392: 381 00010344 dd effffffd06 pushl _subtest
393: 382 0001034A fe 08 effffffcff callf $8,_writed
394: 383 00010351 # writes( msg ); /* print the message */
395: 384 00010351 dd ad04 pushl 4(fp)
396: 385 00010354 fe 08 effffffcf5 callf $8,_writes
397: 386 0001035B # writes(" index = ");
398: 387 0001035B .data 1
399: 388 000004a7 * L431:
400: 389 000004a7 * 20696E646578203D2000 .ascii " index = \0"
401: 390 000004b1 * .text
402: 391 0001035B dd 8f000004a7 pushl $L431
403: 392 00010361 fe 08 effffffce8 callf $8,_writes
404: 393 00010368 # writed( index );
405: 394 00010368 dd effffffce2 pushl _index
406: 395 0001036E fe 08 effffffcdb callf $8,_writed
407: 396 00010375 # writes("\ninst = LDF op_1, LOGF, CMPF2 op_2,op_3, LOGF");
408: 397 00010375 .data 1
409: 398 000004b1 * L432:
410: 399 000004b1 * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op_1, LOGF, CMPF2 op_2,op_3, LOGF\0"
411: F705F312C204C4F47462C2043
412: 4D504632206F705F322C6F705
413: F332C204C4F474600
414: 400 000004df * .text
415: 401 00010375 dd 8f000004b1 pushl $L432
416: 402 0001037B fe 08 effffffcce callf $8,_writes
417: 403 00010382 # writes(" (reserved op. fault on CMPF2)\n");
418: 404 00010382 .data 1
419: 405 000004df * L433:
420: 406 000004df * 20287265736572766564206F7 .ascii " (reserved op. fault on CMPF2)\12\0"
421: 02E206661756C74206F6E2043
422: 4D504632290A00
423: 407 000004ff * .text
424: 408 00010382 dd 8f000004df pushl $L433
425: 409 00010388 fe 08 effffffcc1 callf $8,_writes
426: 410 0001038F # }
427: 411 0001038F 40 ret#2
428: 412 00010390 .set L421,0x0
429: 413 00010390 L423:
430: 414 00010390 13 ff5a jbr L424
431: 415 00010393 .data
432: 416 000003dc * .text
433: 417 00010393 00 .align 1
434: 418 00010394 .globl _pipe3_halt
435: 419 00010394 _pipe3_halt:
436: 420 00010394 0000 .word L434
437: 421 00010396 #
438: 422 00010396 #
439: 423 00010396 #
440: 424 00010396 # /****************************************************************************
441: 425 00010396 # * halt on error routine
442: 426 00010396 # ****************************************************************************/
443: 427 00010396 # pipe3_halt( code )
444: 428 00010396 # int code; /* error code to halt with */
445: 429 00010396 # {
446: 430 00010396 13 008f jbr L436
447: 431 00010399 L437:
448: 432 00010399 # err_code = code;
449: 433 00010399 0d ad04 effffffcaf movl 4(fp),_err_code
450: 434 000103A1 # sgl_value_1 = dbl_ld_acc.m;
451: 435 000103A1 0d effffffca9 effffffca4 movl _dbl_ld_acc,_sgl_value_1
452: 436 000103AC # asm("movl _test_no,r0"); /* r0 = test number */
453: 437 000103AC 0d effffffc9e 50 movl _test_no,r0
454: 438 000103B3 # asm("movl _subtest,r1"); /* r1 = subtest number */
455: 439 000103B3 0d effffffc97 51 movl _subtest,r1
456: 440 000103BA # asm("movl _err_code,r2"); /* r2 = error code */
457: 441 000103BA 0d effffffc90 52 movl _err_code,r2
458: 442 000103C1 # asm("movl _cycle,r3"); /* r3 = cycle count */
459: 443 000103C1 0d effffffc89 53 movl _cycle,r3
460: 444 000103C8 # asm("movl _sgl_value_1,r4"); /* r4 = initial operand */
461: 445 000103C8 0d effffffc82 54 movl _sgl_value_1,r4
462: 446 000103CF # if( code == 1 ) {
463: 447 000103CF 1d ad04 01 cmpl 4(fp),$1
464: 448 000103D3 21 26 jneq L438
465: 449 000103D5 # sgl_value_2 = dbl_value_1.m;
466: 450 000103D5 0d effffffc75 effffffc70 movl _dbl_value_1,_sgl_value_2
467: 451 000103E0 # sgl_value_3 = dbl_value_2.m;
468: 452 000103E0 0d effffffc6a effffffc65 movl _dbl_value_2,_sgl_value_3
469: 453 000103EB # asm("movl _sgl_value_2,r5"); /* r5 = 1st CMPF2 operand */
470: 454 000103EB 0d effffffc5f 55 movl _sgl_value_2,r5
471: 455 000103F2 # asm("movl _sgl_value_3,r6"); /* r6 = 2nd CMPF2 operand */
472: 456 000103F2 0d effffffc58 56 movl _sgl_value_3,r6
473: 457 000103F9 # } else {
474: 458 000103F9 11 24 jbr L439
475: 459 000103FB L438:
476: 460 000103FB # sgl_value_2 = post_evt_acc.m;
477: 461 000103FB 0d effffffc4f effffffc4a movl _post_evt_acc,_sgl_value_2
478: 462 00010406 # sgl_value_3 = dbl_expected.m;
479: 463 00010406 0d effffffc44 effffffc3f movl _dbl_expected,_sgl_value_3
480: 464 00010411 # asm("movl _sgl_value_2,r5"); /* r5 = final accumulator */
481: 465 00010411 0d effffffc39 55 movl _sgl_value_2,r5
482: 466 00010418 # asm("movl _sgl_value_3,r6"); /* r6 = expected accumulator */
483: 467 00010418 0d effffffc32 56 movl _sgl_value_3,r6
484: 468 0001041F # }
485: 469 0001041F L439:
486: 470 0001041F # asm("movl _index,r7"); /* r7 = data index */
487: 471 0001041F 0d effffffc2b 57 movl _index,r7
488: 472 00010426 # asm("halt"); /* HALT ... */
489: 473 00010426 00 halt
490: 474 00010427 # }
491: 475 00010427 40 ret#2
492: 476 00010428 .set L434,0x0
493: 477 00010428 L436:
494: 478 00010428 13 ff6e jbr L437
495: 479 0001042B .data
496: 479 0002047B .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.