![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe13.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 pipe13.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 00000468 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe13
6: 6 00000000 _pipe13:
7: 7 00013404 0000 .word L381
8: 8 00013406 #
9: 9 00013406 # #include "evt_defs.h"
10: 10 00013406 #
11: 11 00013406 # /*
12: 12 00013406 # *********************************************************************
13: 13 00013406 # * FPP PIPELINED EVENTS TEST #13
14: 14 00013406 # *
15: 15 00013406 # * This test will execute the following code: "LDF CVFL NEGF"
16: 16 00013406 # * with an integer overflow fault on the CVFL. We will make sure that:
17: 17 00013406 # * 1. The fault is detected, and
18: 18 00013406 # * 2. the NEGF instruction is not executed.
19: 19 00013406 # *********************************************************************
20: 20 00013406 # */
21: 21 00013406 # pipe13()
22: 22 00013406 # {
23: 23 00013406 13 0135 jbr L383
24: 24 00013409 L384:
25: 25 00013409 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
26: 26 00013409 ed 6d effffffff4 moval (r13),_pre_event_fp
27: 27 00013410 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
28: 28 00013410 ed 6e efffffffed moval (r14),_pre_event_sp
29: 29 00013417 # precision = SGL;
30: 30 00013417 0d 01 efffffffe6 movl $1,_precision
31: 31 0001341E # test_event = ARITH_CODE; /* expect an arithmetic fault */
32: 32 0001341E 0d 34 efffffffdf movl $52,_test_event
33: 33 00013425 # exp_code = INT_OVFL_CODE; /* - specificly underflow */
34: 34 00013425 0d 01 efffffffd8 movl $1,_exp_code
35: 35 0001342C # exp_event = FALSE; /* ... but not yet */
36: 36 0001342C 4d efffffffd2 clrl _exp_event
37: 37 00013432 # asm("movab _pipe13_ret,_event_return"); /* set event return address */
38: 38 00013432 e9 ef000000ae efffffffc7 movab _pipe13_ret,_event_return
39: 39 0001343D # max_index = cvdl_ov_cnt; /* set max operand index */
40: 40 0001343D 0d efffffffc1 efffffffbc movl _cvdl_ov_cnt,_max_index
41: 41 00013448 # for( index = 0; index < max_index; index++ )
42: 42 00013448 4d efffffffb6 clrl _index
43: 43 0001344E L387:
44: 44 0001344E 1d efffffffb0 efffffffab cmpl _index,_max_index
45: 45 00013459 91 03 13 00df jgeq L386
46: 46 0001345E # {
47: 47 0001345E # dbl_ld_acc = cvfl_ov_dat[index].op_1; /* get the Acc data */
48: 48 0001345E 48 04 efffffff9f 50 shll $4,_index,r0
49: 49 00013466 0c 8f00000000 50 addl2 $_cvfl_ov_dat,r0
50: 50 0001346D 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4
51: 51 00013475 0d 60 efffffff88 movl (r0),_dbl_ld_acc
52: 52 0001347C # if( dbl_ld_acc.m & 0x7f800000 )
53: 53 0001347C 3d 8f7f800000 efffffff7d bitl $2139095040,_dbl_ld_acc
54: 54 00013487 31 0d jeql L388
55: 55 00013489 # dbl_expected.m = dbl_ld_acc.m; /* Acc shouldn't change */
56: 56 00013489 0d efffffff75 efffffff70 movl _dbl_ld_acc,_dbl_expected
57: 57 00013494 # else
58: 58 00013494 11 06 jbr L389
59: 59 00013496 L388:
60: 60 00013496 # dbl_expected.m = 0; /* expect a 'good 0' */
61: 61 00013496 4d efffffff68 clrl _dbl_expected
62: 62 0001349C L389:
63: 63 0001349C # asm("bispsw $0x60"); /* enable ovfl,undfl */
64: 64 0001349C 8b 8860 bispsw $0x60
65: 65 0001349F # asm(".globl _pipe13_lp1");
66: 66 0001349F .globl _pipe13_lp1
67: 67 0001349F # asm("_pipe13_lp1:");
68: 68 0001349F _pipe13_lp1:
69: 69 0001349F # asm("ldf _dbl_ld_acc"); /* load the Acc. */
70: 70 0001349F 06 efffffff5f ldf _dbl_ld_acc
71: 71 000134A5 # exp_event = test_event; /* expect event soon */
72: 72 000134A5 0d efffffff59 efffffff54 movl _test_event,_exp_event
73: 73 000134B0 # asm("cvfl _dbl_value_1"); /* trigger the event */
74: 74 000134B0 86 efffffff4e cvfl _dbl_value_1
75: 75 000134B6 # asm("negf"); /* shouldn't get here*/
76: 76 000134B6 b6 negf
77: 77 000134B7 # /*
78: 78 000134B7 # * If we got to here then there was no event
79: 79 000134B7 # */
80: 80 000134B7 # if( force_loop )
81: 81 000134B7 5d efffffff47 tstl _force_loop
82: 82 000134BD 31 03 jeql L390
83: 83 000134BF # asm("brw _pipe13_lp1");; /* loop on the error */
84: Assemb0002ABC4 # asm("brw _pipe13_lp1");; /* loop on the error */
85: "pipe100013407 e 84: WARNING: brw: destination label is external
86: 84 000134BF 13 ffdd brw _pipe13_lp1
87: 85 000134C2 L390:
88: 86 000134C2 # exp_event = FALSE; /* reset event expected flag */
89: 87 000134C2 4d efffffff3c clrl _exp_event
90: 88 000134C8 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
91: 89 000134C8 9b 8860 bicpsw $0x60
92: 90 000134CB # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
93: 91 000134CB 0d efffffff33 5d movl _pre_event_fp,fp
94: 92 000134D2 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
95: 93 000134D2 0d efffffff2c 5e movl _pre_event_sp,sp
96: 94 000134D9 # asm("stf _dbl_st_acc"); /* save the accumulator */
97: 95 000134D9 26 efffffff25 stf _dbl_st_acc
98: 96 000134DF # no_pipe13_evt();; /* report the error */
99: 97 000134DF fe 04 ef0000005c callf $4,_no_pipe13_evt
100: 98 000134E6 # /*
101: 99 000134E6 # * Come here after the event
102: 100 000134E6 # */
103: 101 000134E6 # asm(".globl _pipe13_ret");
104: 102 000134E6 .globl _pipe13_ret
105: 103 000134E6 # asm("_pipe13_ret:");
106: 104 000134E6 _pipe13_ret:
107: 105 000134E6 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
108: 106 000134E6 0d efffffff18 5d movl _pre_event_fp,fp
109: 107 000134ED # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
110: 108 000134ED 0d efffffff11 5e movl _pre_event_sp,sp
111: 109 000134F4 # if( force_loop )
112: 110 000134F4 5d efffffff0a tstl _force_loop
113: 111 000134FA 31 03 jeql L392
114: 112 000134FC # asm("brw _pipe13_lp1");; /* loop on the error */
115: "pipe100013407 e 113: WARNING: brw: destination label is external
116: 113 000134FC 13 ffa0 brw _pipe13_lp1
117: 114 000134FF L392:
118: 115 000134FF # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
119: 116 000134FF 9b 8860 bicpsw $0x60
120: 117 00013502 # if( post_evt_acc.m == (dbl_ld_acc.m ^ 0x80000000) )
121: 118 00013502 dc 8f80000000 effffffef7 xorl3 $-2147483648,_dbl_ld_acc,r0
122: 50
123: 119 0001350E 1d effffffef0 50 cmpl _post_evt_acc,r0
124: 120 00013515 21 09 jneq L393
125: 121 00013517 # pipe13_queue_er(); /* the NEGF was executed */
126: 122 00013517 fe 04 ef00000174 callf $4,_pipe13_queue_er
127: 123 0001351E # else if( post_evt_acc.m != dbl_expected.m ) /* Acc modified? */
128: 124 0001351E 11 14 jbr L395
129: 125 00013520 L393:
130: 126 00013520 1d effffffede effffffed9 cmpl _post_evt_acc,_dbl_expected
131: 127 0001352B 31 07 jeql L396
132: 128 0001352D # bad_pipe13_result(); /* incorrect result error */
133: 129 0001352D fe 04 ef000000b0 callf $4,_bad_pipe13_result
134: 130 00013534 #
135: 131 00013534 # }
136: 132 00013534 L396:
137: 133 00013534 L395:
138: 134 00013534 L385:
139: 135 00013534 6d effffffeca incl _index
140: 136 0001353A 13 ff11 jbr L387
141: 137 0001353D L386:
142: 138 0001353D # }
143: 139 0001353D 40 ret#2
144: 140 0001353E .set L381,0x0
145: 141 0001353E L383:
146: 142 0001353E 13 fec8 jbr L384
147: 143 00013541 .data
148: 144 00000468 * .text
149: 145 00013541 00 .align 1
150: 146 00013542 .globl _no_pipe13_evt
151: 147 00013542 _no_pipe13_evt:
152: 148 00013542 0000 .word L398
153: 149 00013544 #
154: 150 00013544 #
155: 151 00013544 #
156: 152 00013544 # /****************************************************************************
157: 153 00013544 # * Report an "EVENT NOT DETECTED" error
158: 154 00013544 # *
159: 155 00013544 # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx
160: 156 00013544 # * inst = LDF op1, CVFL op2, NEGF (integer overflow fault on the CVDF)
161: 157 00013544 # * op1 = xxxxxxxx, op2 = xxxxxxxx, final Acc. = xxxxxxxx
162: 158 00013544 # ****************************************************************************/
163: 159 00013544 # no_pipe13_evt()
164: 160 00013544 # {
165: 161 00013544 13 0099 jbr L400
166: 162 00013547 L401:
167: 163 00013547 # errcnt++; /* bump the error count */
168: 164 00013547 6d effffffeb7 incl _errcnt
169: 165 0001354D # if ( prt_error )
170: 166 0001354D 5d effffffeb1 tstl _prt_error
171: 167 00013553 31 64 jeql L402
172: 168 00013555 # {
173: 169 00013555 # print_pipe13_er( ". No overflow fault seen." );
174: 170 00013555 .data 1
175: 171 00000468 * L404:
176: 172 00000468 * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen.\0"
177: 7206661756C74207365656E2E
178: 00
179: 173 00000482 * .text
180: 174 00013555 dd 8f00000468 pushl $L404
181: 175 0001355B fe 08 ef000001fc callf $8,_print_pipe13_er
182: 176 00013562 # writes("op1 = ");
183: 177 00013562 .data 1
184: 178 00000482 * L406:
185: 179 00000482 * 6F7031203D2000 .ascii "op1 = \0"
186: 180 00000489 * .text
187: 181 00013562 dd 8f00000482 pushl $L406
188: 182 00013568 fe 08 effffffe95 callf $8,_writes
189: 183 0001356F # write32h( dbl_ld_acc.m );
190: 184 0001356F dd effffffe8f pushl _dbl_ld_acc
191: 185 00013575 fe 08 effffffe88 callf $8,_write32h
192: 186 0001357C # writes(", op2 = ");
193: 187 0001357C .data 1
194: 188 00000489 * L408:
195: 189 00000489 * 2C2020206F7032203D2000 .ascii ", op2 = \0"
196: 190 00000494 * .text
197: 191 0001357C dd 8f00000489 pushl $L408
198: 192 00013582 fe 08 effffffe7b callf $8,_writes
199: 193 00013589 # write32h( dbl_value_1.m );
200: 194 00013589 dd effffffe75 pushl _dbl_value_1
201: 195 0001358F fe 08 effffffe6e callf $8,_write32h
202: 196 00013596 # writes(", final Acc. = ");
203: 197 00013596 .data 1
204: 198 00000494 * L409:
205: 199 00000494 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
206: 32E203D2000
207: 200 000004a6 * .text
208: 201 00013596 dd 8f00000494 pushl $L409
209: 202 0001359C fe 08 effffffe61 callf $8,_writes
210: 203 000135A3 # write32h( dbl_st_acc.m );
211: 204 000135A3 dd effffffe5b pushl _dbl_st_acc
212: 205 000135A9 fe 08 effffffe54 callf $8,_write32h
213: 206 000135B0 # writec('\n');
214: 207 000135B0 dd 0a pushl $10
215: 208 000135B2 fe 08 effffffe4b callf $8,_writec
216: 209 000135B9 # }
217: 210 000135B9 # if ( halt_flg ) /* halt on error? */
218: 211 000135B9 L402:
219: 212 000135B9 5d effffffe45 tstl _halt_flg
220: 213 000135BF 31 09 jeql L411
221: 214 000135C1 # pipe13_halt( 1 ); /* halt with a code of 1 */
222: 215 000135C1 dd 01 pushl $1
223: 216 000135C3 fe 08 ef00000232 callf $8,_pipe13_halt
224: 217 000135CA # if ( loop_on_err )
225: 218 000135CA L411:
226: 219 000135CA 5d effffffe34 tstl _loop_on_err
227: 220 000135D0 31 0d jeql L413
228: 221 000135D2 # {
229: 222 000135D2 # force_loop = TRUE; /* set the force loop flag */
230: 223 000135D2 0d 01 effffffe2b movl $1,_force_loop
231: 224 000135D9 # asm("jmp _pipe13_lp1"); /* and loop */
232: 225 000135D9 71 effffffec0 jmp _pipe13_lp1
233: 226 000135DF # };
234: 227 000135DF L413:
235: 228 000135DF # }
236: 229 000135DF 40 ret#2
237: 230 000135E0 .set L398,0x0
238: 231 000135E0 L400:
239: 232 000135E0 13 ff64 jbr L401
240: 233 000135E3 .data
241: 234 00000468 * .text
242: 235 000135E3 00 .align 1
243: 236 000135E4 .globl _bad_pipe13_result
244: 237 000135E4 _bad_pipe13_result:
245: 238 000135E4 0000 .word L414
246: 239 000135E6 #
247: 240 000135E6 #
248: 241 000135E6 #
249: 242 000135E6 #
250: 243 000135E6 # /****************************************************************************
251: 244 000135E6 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
252: 245 000135E6 # *
253: 246 000135E6 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
254: 247 000135E6 # * inst = LDF op1, CVFL op2, NEGF (integer overflow fault on the CVDF)
255: 248 000135E6 # * The NEGF instruction should not be executed.
256: 249 000135E6 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx
257: 250 000135E6 # ****************************************************************************/
258: 251 000135E6 # bad_pipe13_result()
259: 252 000135E6 # {
260: 253 000135E6 13 00a6 jbr L416
261: 254 000135E9 L417:
262: 255 000135E9 # errcnt++; /* bump the error count */
263: 256 000135E9 6d effffffe15 incl _errcnt
264: 257 000135EF # if ( prt_error )
265: 258 000135EF 5d effffffe0f tstl _prt_error
266: 259 000135F5 31 71 jeql L418
267: 260 000135F7 # {
268: 261 000135F7 # print_pipe13_er( ". Bad final Accumulator" );
269: 262 000135F7 .data 1
270: 263 000004a6 * L419:
271: 264 000004a6 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
272: 16363756D756C61746F7200
273: 265 000004be * .text
274: 266 000135F7 dd 8f000004a6 pushl $L419
275: 267 000135FD fe 08 ef0000015a callf $8,_print_pipe13_er
276: 268 00013604 # writes(
277: 269 00013604 # "The NEGF instruction should not be executed\n");
278: 270 00013604 .data 1
279: 271 000004be * L420:
280: 272 000004be * 546865204E45474620696E737 .ascii "The NEGF instruction should not be executed\12\0"
281: 472756374696F6E2073686F75
282: 6C64206E6F742062652065786
283: 563757465640A00
284: 273 000004eb * .text
285: 274 00013604 dd 8f000004be pushl $L420
286: 275 0001360A fe 08 effffffdf3 callf $8,_writes
287: 276 00013611 # writes("op1 = ");
288: 277 00013611 .data 1
289: 278 000004eb * L421:
290: 279 000004eb * 6F7031203D2000 .ascii "op1 = \0"
291: 280 000004f2 * .text
292: 281 00013611 dd 8f000004eb pushl $L421
293: 282 00013617 fe 08 effffffde6 callf $8,_writes
294: 283 0001361E # write32h( dbl_ld_acc.m );
295: 284 0001361E dd effffffde0 pushl _dbl_ld_acc
296: 285 00013624 fe 08 effffffdd9 callf $8,_write32h
297: 286 0001362B # writes(", final Acc. = ");
298: 287 0001362B .data 1
299: 288 000004f2 * L422:
300: 289 000004f2 * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
301: E203D2000
302: 290 00000503 * .text
303: 291 0001362B dd 8f000004f2 pushl $L422
304: 292 00013631 fe 08 effffffdcc callf $8,_writes
305: 293 00013638 # write32h( post_evt_acc.m );
306: 294 00013638 dd effffffdc6 pushl _post_evt_acc
307: 295 0001363E fe 08 effffffdbf callf $8,_write32h
308: 296 00013645 # writes(", expected = ");
309: 297 00013645 .data 1
310: 298 00000503 * L423:
311: 299 00000503 * 2C20206578706563746564203 .ascii ", expected = \0"
312: D2000
313: 300 00000512 * .text
314: 301 00013645 dd 8f00000503 pushl $L423
315: 302 0001364B fe 08 effffffdb2 callf $8,_writes
316: 303 00013652 # write32h( dbl_expected.m ); /* expected = initial data */
317: 304 00013652 dd effffffdac pushl _dbl_expected
318: 305 00013658 fe 08 effffffda5 callf $8,_write32h
319: 306 0001365F # writec('\n');
320: 307 0001365F dd 0a pushl $10
321: 308 00013661 fe 08 effffffd9c callf $8,_writec
322: 309 00013668 # }
323: 310 00013668 # if ( halt_flg ) /* halt on error? */
324: 311 00013668 L418:
325: 312 00013668 5d effffffd96 tstl _halt_flg
326: 313 0001366E 31 09 jeql L424
327: 314 00013670 # pipe13_halt( 2 ); /* halt with a code of 2 */
328: 315 00013670 dd 02 pushl $2
329: 316 00013672 fe 08 ef00000183 callf $8,_pipe13_halt
330: 317 00013679 # if ( loop_on_err )
331: 318 00013679 L424:
332: 319 00013679 5d effffffd85 tstl _loop_on_err
333: 320 0001367F 31 0d jeql L425
334: 321 00013681 # {
335: 322 00013681 # force_loop = TRUE; /* set the force loop flag */
336: 323 00013681 0d 01 effffffd7c movl $1,_force_loop
337: 324 00013688 # asm("jmp _pipe13_lp1"); /* and loop */
338: 325 00013688 71 effffffe11 jmp _pipe13_lp1
339: 326 0001368E # };
340: 327 0001368E L425:
341: 328 0001368E # }
342: 329 0001368E 40 ret#2
343: 330 0001368F .set L414,0x0
344: 331 0001368F L416:
345: 332 0001368F 13 ff57 jbr L417
346: 333 00013692 .data
347: 334 00000468 * .text
348: 335 00013692 .align 1
349: 336 00013692 .globl _pipe13_queue_er
350: 337 00013692 _pipe13_queue_er:
351: 338 00013692 0000 .word L426
352: 339 00013694 #
353: 340 00013694 #
354: 341 00013694 #
355: 342 00013694 #
356: 343 00013694 #
357: 344 00013694 # /****************************************************************************
358: 345 00013694 # * Report an "FPP queue not cleared" message
359: 346 00013694 # *
360: 347 00013694 # * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx
361: 348 00013694 # * inst = LDF op1, CVFL op2, NEGF (integer overflow fault on the CVDF)
362: 349 00013694 # * The NEGF instruction was apparently executed.
363: 350 00013694 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx
364: 351 00013694 # * op2 = xxxxxxxx, expected = xxxxxxxx
365: 352 00013694 # ****************************************************************************/
366: 353 00013694 # pipe13_queue_er()
367: 354 00013694 # {
368: 355 00013694 13 00c3 jbr L428
369: 356 00013697 L429:
370: 357 00013697 # errcnt++; /* bump the error count */
371: 358 00013697 6d effffffd67 incl _errcnt
372: 359 0001369D # if ( prt_error )
373: 360 0001369D 5d effffffd61 tstl _prt_error
374: 361 000136A3 21 03 13 008b jeql L430
375: 362 000136A8 # {
376: 363 000136A8 # print_pipe13_er( ". Fpp queue not cleared" );
377: 364 000136A8 .data 1
378: 365 00000512 * L431:
379: 366 00000512 * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0"
380: E6F7420636C656172656400
381: 367 0000052a * .text
382: 368 000136A8 dd 8f00000512 pushl $L431
383: 369 000136AE fe 08 ef000000a9 callf $8,_print_pipe13_er
384: 370 000136B5 # writes(
385: 371 000136B5 # "The NEGF instruction was apparently executed.\n");
386: 372 000136B5 .data 1
387: 373 0000052a * L432:
388: 374 0000052a * 546865204E45474620696E737 .ascii "The NEGF instruction was apparently executed.\12\0"
389: 472756374696F6E2077617320
390: 6170706172656E746C7920657
391: 86563757465642E0A00
392: 375 00000559 * .text
393: 376 000136B5 dd 8f0000052a pushl $L432
394: 377 000136BB fe 08 effffffd42 callf $8,_writes
395: 378 000136C2 # writes("op1 = ");
396: 379 000136C2 .data 1
397: 380 00000559 * L433:
398: 381 00000559 * 6F7031203D2000 .ascii "op1 = \0"
399: 382 00000560 * .text
400: 383 000136C2 dd 8f00000559 pushl $L433
401: 384 000136C8 fe 08 effffffd35 callf $8,_writes
402: 385 000136CF # write32h( dbl_ld_acc.m );
403: 386 000136CF dd effffffd2f pushl _dbl_ld_acc
404: 387 000136D5 fe 08 effffffd28 callf $8,_write32h
405: 388 000136DC # writes(", final Acc. = ");
406: 389 000136DC .data 1
407: 390 00000560 * L434:
408: 391 00000560 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
409: 32E203D2000
410: 392 00000572 * .text
411: 393 000136DC dd 8f00000560 pushl $L434
412: 394 000136E2 fe 08 effffffd1b callf $8,_writes
413: 395 000136E9 # write32h( post_evt_acc.m );
414: 396 000136E9 dd effffffd15 pushl _post_evt_acc
415: 397 000136EF fe 08 effffffd0e callf $8,_write32h
416: 398 000136F6 # writes("\nop2 = ");
417: 399 000136F6 .data 1
418: 400 00000572 * L435:
419: 401 00000572 * 0A6F7032203D2000 .ascii "\12op2 = \0"
420: 402 0000057a * .text
421: 403 000136F6 dd 8f00000572 pushl $L435
422: 404 000136FC fe 08 effffffd01 callf $8,_writes
423: 405 00013703 # write32h( dbl_value_1.m );
424: 406 00013703 dd effffffcfb pushl _dbl_value_1
425: 407 00013709 fe 08 effffffcf4 callf $8,_write32h
426: 408 00013710 # writes(", expected = ");
427: 409 00013710 .data 1
428: 410 0000057a * L436:
429: 411 0000057a * 2C20202020206578706563746 .ascii ", expected = \0"
430: 564203D2000
431: 412 0000058c * .text
432: 413 00013710 dd 8f0000057a pushl $L436
433: 414 00013716 fe 08 effffffce7 callf $8,_writes
434: 415 0001371D # write32h( dbl_expected.m ); /* expected = initial data */
435: 416 0001371D dd effffffce1 pushl _dbl_expected
436: 417 00013723 fe 08 effffffcda callf $8,_write32h
437: 418 0001372A # writec('\n');
438: 419 0001372A dd 0a pushl $10
439: 420 0001372C fe 08 effffffcd1 callf $8,_writec
440: 421 00013733 # }
441: 422 00013733 # if ( halt_flg ) /* halt on error? */
442: 423 00013733 L430:
443: 424 00013733 5d effffffccb tstl _halt_flg
444: 425 00013739 31 09 jeql L437
445: 426 0001373B # pipe13_halt( 3 ); /* halt with a code of 3 */
446: 427 0001373B dd 03 pushl $3
447: 428 0001373D fe 08 ef000000b8 callf $8,_pipe13_halt
448: 429 00013744 # if ( loop_on_err )
449: 430 00013744 L437:
450: 431 00013744 5d effffffcba tstl _loop_on_err
451: 432 0001374A 31 0d jeql L438
452: 433 0001374C # {
453: 434 0001374C # force_loop = TRUE; /* set the force loop flag */
454: 435 0001374C 0d 01 effffffcb1 movl $1,_force_loop
455: 436 00013753 # asm("jmp _pipe13_lp1"); /* and loop */
456: 437 00013753 71 effffffd46 jmp _pipe13_lp1
457: 438 00013759 # };
458: 439 00013759 L438:
459: 440 00013759 # }
460: 441 00013759 40 ret#2
461: 442 0001375A .set L426,0x0
462: 443 0001375A L428:
463: 444 0001375A 13 ff3a jbr L429
464: 445 0001375D .data
465: 446 00000468 * .text
466: 447 0001375D 00 .align 1
467: 448 0001375E .globl _print_pipe13_er
468: 449 0001375E _print_pipe13_er:
469: 450 0001375E 0000 .word L439
470: 451 00013760 #
471: 452 00013760 #
472: 453 00013760 #
473: 454 00013760 #
474: 455 00013760 # /****************************************************************************
475: 456 00013760 # * Report an error message of the form:
476: 457 00013760 # *
477: 458 00013760 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
478: 459 00013760 # * inst = LDF op1, CVFL op2, NEGF (integer overflow fault on the CVDF)
479: 460 00013760 # ****************************************************************************/
480: 461 00013760 # print_pipe13_er( msg )
481: 462 00013760 # char *msg; /* error message to print */
482: 463 00013760 # {
483: 464 00013760 13 0096 jbr L441
484: 465 00013763 L442:
485: 466 00013763 # if( errcnt == 1 ) /* 1st error? */
486: 467 00013763 1d effffffc9b 01 cmpl _errcnt,$1
487: 468 0001376A 21 0d jneq L443
488: 469 0001376C # writes(" \n"); /* start a new print line */
489: 470 0001376C .data 1
490: 471 0000058c * L444:
491: 472 0000058c * 200A00 .ascii " \12\0"
492: 473 0000058f * .text
493: 474 0001376C dd 8f0000058c pushl $L444
494: 475 00013772 fe 08 effffffc8b callf $8,_writes
495: 476 00013779 # writes("Cycle: ");
496: 477 00013779 L443:
497: 478 00013779 .data 1
498: 479 0000058f * L445:
499: 480 0000058f * 4379636C653A2000 .ascii "Cycle: \0"
500: 481 00000597 * .text
501: 482 00013779 dd 8f0000058f pushl $L445
502: 483 0001377F fe 08 effffffc7e callf $8,_writes
503: 484 00013786 # writed( cycle );
504: 485 00013786 dd effffffc78 pushl _cycle
505: 486 0001378C fe 08 effffffc71 callf $8,_writed
506: 487 00013793 # writes(" EVT test ");
507: 488 00013793 .data 1
508: 489 00000597 * L447:
509: 490 00000597 * 202045565420746573742000 .ascii " EVT test \0"
510: 491 000005a3 * .text
511: 492 00013793 dd 8f00000597 pushl $L447
512: 493 00013799 fe 08 effffffc64 callf $8,_writes
513: 494 000137A0 # writed( test_no );
514: 495 000137A0 dd effffffc5e pushl _test_no
515: 496 000137A6 fe 08 effffffc57 callf $8,_writed
516: 497 000137AD # writes(". subtest ");
517: 498 000137AD .data 1
518: 499 000005a3 * L448:
519: 500 000005a3 * 2E20737562746573742000 .ascii ". subtest \0"
520: 501 000005ae * .text
521: 502 000137AD dd 8f000005a3 pushl $L448
522: 503 000137B3 fe 08 effffffc4a callf $8,_writes
523: 504 000137BA # writed( subtest );
524: 505 000137BA dd effffffc44 pushl _subtest
525: 506 000137C0 fe 08 effffffc3d callf $8,_writed
526: 507 000137C7 # writes( msg ); /* print the message */
527: 508 000137C7 dd ad04 pushl 4(fp)
528: 509 000137CA fe 08 effffffc33 callf $8,_writes
529: 510 000137D1 # writes(" index = ");
530: 511 000137D1 .data 1
531: 512 000005ae * L449:
532: 513 000005ae * 20696E646578203D2000 .ascii " index = \0"
533: 514 000005b8 * .text
534: 515 000137D1 dd 8f000005ae pushl $L449
535: 516 000137D7 fe 08 effffffc26 callf $8,_writes
536: 517 000137DE # writed( index );
537: 518 000137DE dd effffffc20 pushl _index
538: 519 000137E4 fe 08 effffffc19 callf $8,_writed
539: 520 000137EB # writes(
540: 521 000137EB # "\ninst = LDF op1, CVFL op2, NEGF (integer overflow fault on the CVDF)\n");
541: 522 000137EB .data 1
542: 523 000005b8 * L450:
543: 524 000005b8 * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1, CVFL op2, NEGF (integer overflow fault on th"
544: F70312C204356464C206F7032
545: 2C204E4547462020202028696
546: E7465676572206F766572666C
547: 6F77206661756C74206F6E207
548: 468
549: 525 000005f8 * 652043564446290A00 .ascii "e CVDF)\12\0"
550: 526 00000601 * .text
551: 527 000137EB dd 8f000005b8 pushl $L450
552: 528 000137F1 fe 08 effffffc0c callf $8,_writes
553: 529 000137F8 # }
554: 530 000137F8 40 ret#2
555: 531 000137F9 .set L439,0x0
556: 532 000137F9 L441:
557: 533 000137F9 13 ff67 jbr L442
558: 534 000137FC .data
559: 535 00000468 * .text
560: 536 000137FC .align 1
561: 537 000137FC .globl _pipe13_halt
562: 538 000137FC _pipe13_halt:
563: 539 000137FC 0000 .word L451
564: 540 000137FE #
565: 541 000137FE #
566: 542 000137FE #
567: 543 000137FE # /****************************************************************************
568: 544 000137FE # * halt on error routine
569: 545 000137FE # ****************************************************************************/
570: 546 000137FE # pipe13_halt( code )
571: 547 000137FE # int code; /* error code to halt with */
572: 548 000137FE # {
573: 549 000137FE 11 6a jbr L453
574: 550 00013800 L454:
575: 551 00013800 # err_code = code;
576: 552 00013800 0d ad04 effffffbfc movl 4(fp),_err_code
577: 553 00013808 # sgl_value_1 = dbl_ld_acc.m;
578: 554 00013808 0d effffffbf6 effffffbf1 movl _dbl_ld_acc,_sgl_value_1
579: 555 00013813 # sgl_value_2 = post_evt_acc.m;
580: 556 00013813 0d effffffbeb effffffbe6 movl _post_evt_acc,_sgl_value_2
581: 557 0001381E # sgl_value_3 = dbl_value_1.m;
582: 558 0001381E 0d effffffbe0 effffffbdb movl _dbl_value_1,_sgl_value_3
583: 559 00013829 # asm("movl _test_no,r0"); /* r0 = test number */
584: 560 00013829 0d effffffbd5 50 movl _test_no,r0
585: 561 00013830 # asm("movl _subtest,r1"); /* r1 = subtest number */
586: 562 00013830 0d effffffbce 51 movl _subtest,r1
587: 563 00013837 # asm("movl _err_code,r2"); /* r2 = error code */
588: 564 00013837 0d effffffbc7 52 movl _err_code,r2
589: 565 0001383E # asm("movl _cycle,r3"); /* r3 = cycle count */
590: 566 0001383E 0d effffffbc0 53 movl _cycle,r3
591: 567 00013845 # asm("movl _sgl_value_1,r4"); /* r4 = initial Acc. */
592: 568 00013845 0d effffffbb9 54 movl _sgl_value_1,r4
593: 569 0001384C # asm("movl _sgl_value_2,r5"); /* r5 = post event Acc. */
594: 570 0001384C 0d effffffbb2 55 movl _sgl_value_2,r5
595: 571 00013853 # asm("movl _sgl_value_3,r6"); /* r6 = integer stored */
596: 572 00013853 0d effffffbab 56 movl _sgl_value_3,r6
597: 573 0001385A # asm("movl _sgl_value_4,r7"); /* r7 = expected Acc. */
598: 574 0001385A 0d effffffba4 57 movl _sgl_value_4,r7
599: 575 00013861 # asm("movl _index,r8"); /* r8 = data index */
600: 576 00013861 0d effffffb9d 58 movl _index,r8
601: 577 00013868 # asm("halt"); /* HALT ... */
602: 578 00013868 00 halt
603: 579 00013869 # }
604: 580 00013869 40 ret#2
605: 581 0001386A .set L451,0x0
606: 582 0001386A L453:
607: 583 0001386A 11 94 jbr L454
608: 584 00000468 * .data
609: 584 00000468 * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.