![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe12.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 pipe12.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 00000504 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe12
6: 6 00000000 _pipe12:
7: 7 00012F00 0000 .word L381
8: 8 00012F02 #
9: 9 00012F02 #
10: 10 00012F02 # #include "evt_defs.h"
11: 11 00012F02 #
12: 12 00012F02 # /*
13: 13 00012F02 # *********************************************************************
14: 14 00012F02 # * FPP PIPELINED EVENTS TEST #12
15: 15 00012F02 # *
16: 16 00012F02 # * This test will execute the following code: "LDD CVDF LDD"
17: 17 00012F02 # * with an overflow fault on the CVDF. We will make sure that:
18: 18 00012F02 # * 1. The fault is detected, and
19: 19 00012F02 # * 2. the 2nd load instruction is not executed.
20: 20 00012F02 # *********************************************************************
21: 21 00012F02 # */
22: 22 00012F02 # pipe12()
23: 23 00012F02 # {
24: 24 00012F02 13 0125 jbr L383
25: 25 00012F05 L384:
26: 26 00012F05 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
27: 27 00012F05 ed 6d effffffff4 moval (r13),_pre_event_fp
28: 28 00012F0C # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
29: 29 00012F0C ed 6e efffffffed moval (r14),_pre_event_sp
30: 30 00012F13 # precision = DBL;
31: 31 00012F13 0d 02 efffffffe6 movl $2,_precision
32: 32 00012F1A # test_event = ARITH_CODE; /* expect an arithmetic fault */
33: 33 00012F1A 0d 34 efffffffdf movl $52,_test_event
34: 34 00012F21 # exp_code = FLT_OVFL_CODE; /* - specificly underflow */
35: 35 00012F21 0d 04 efffffffd8 movl $4,_exp_code
36: 36 00012F28 # exp_event = FALSE; /* ... but not yet */
37: 37 00012F28 4d efffffffd2 clrl _exp_event
38: 38 00012F2E # asm("movab _pipe12_ret,_event_return"); /* set event return address */
39: 39 00012F2E e9 ef0000009e efffffffc7 movab _pipe12_ret,_event_return
40: 40 00012F39 # max_index = cvdf_ov_cnt; /* set max operand index */
41: 41 00012F39 0d efffffffc1 efffffffbc movl _cvdf_ov_cnt,_max_index
42: 42 00012F44 # for( index = 0; index < max_index; index++ )
43: 43 00012F44 4d efffffffb6 clrl _index
44: 44 00012F4A L387:
45: 45 00012F4A 1d efffffffb0 efffffffab cmpl _index,_max_index
46: 46 00012F55 91 03 13 00cf jgeq L386
47: 47 00012F5A # {
48: 48 00012F5A # dbl_ld_acc = cvdf_ov_dat[index].op_1; /* get the Acc data */
49: 49 00012F5A 48 04 efffffff9f 50 shll $4,_index,r0
50: 50 00012F62 0c 8f00000000 50 addl2 $_cvdf_ov_dat,r0
51: 51 00012F69 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4
52: 52 00012F71 0d 60 efffffff88 movl (r0),_dbl_ld_acc
53: 53 00012F78 # dbl_value_1.m = 0x12345678; /* dummy load data */
54: 54 00012F78 0d 8f12345678 efffffff7d movl $305419896,_dbl_value_1
55: 55 00012F83 # dbl_value_1.l = 0xfedcba98;
56: 56 00012F83 0d 8ffedcba98 efffffff76 movl $-19088744,_dbl_value_1+4
57: 57 00012F8E # asm(".globl _pipe12_lp1");
58: 58 00012F8E .globl _pipe12_lp1
59: 59 00012F8E # asm("_pipe12_lp1:");
60: 60 00012F8E _pipe12_lp1:
61: 61 00012F8E # asm("bispsw $0x60"); /* enable ovfl&undfl */
62: 62 00012F8E 8b 8860 bispsw $0x60
63: 63 00012F91 # asm("ldd _dbl_ld_acc"); /* load the Acc. */
64: 64 00012F91 07 efffffff69 ldd _dbl_ld_acc
65: 65 00012F97 # exp_event = test_event; /* expect event soon */
66: 66 00012F97 0d efffffff63 efffffff5e movl _test_event,_exp_event
67: 67 00012FA2 # asm("cvdf"); /* trigger the event */
68: 68 00012FA2 a6 cvdf
69: 69 00012FA3 # asm("ldd _dbl_value_1"); /* we shouldn't get to here */
70: 70 00012FA3 07 efffffff57 ldd _dbl_value_1
71: 71 00012FA9 # /*
72: 72 00012FA9 # * If we got to here then there was no event
73: 73 00012FA9 # */
74: 74 00012FA9 # if( force_loop )
75: 75 00012FA9 5d efffffff51 tstl _force_loop
76: 76 00012FAF 31 03 jeql L388
77: 77 00012FB1 # asm("brw _pipe12_lp1");; /* loop on the error */
78: Assemb0002A6C0 # asm("brw _pipe12_lp1");; /* loop on the error */
79: "pipe100012F02 e 78: WARNING: brw: destination label is external
80: 78 00012FB1 13 ffda brw _pipe12_lp1
81: 79 00012FB4 L388:
82: 80 00012FB4 # exp_event = FALSE; /* reset event expected flag */
83: 81 00012FB4 4d efffffff46 clrl _exp_event
84: 82 00012FBA # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
85: 83 00012FBA 9b 8860 bicpsw $0x60
86: 84 00012FBD # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
87: 85 00012FBD 0d efffffff3d 5d movl _pre_event_fp,fp
88: 86 00012FC4 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
89: 87 00012FC4 0d efffffff36 5e movl _pre_event_sp,sp
90: 88 00012FCB # no_pipe12_evt();; /* report the error */
91: 89 00012FCB fe 04 ef0000005c callf $4,_no_pipe12_evt
92: 90 00012FD2 # /*
93: 91 00012FD2 # * Come here after the event
94: 92 00012FD2 # */
95: 93 00012FD2 # asm(".globl _pipe12_ret");
96: 94 00012FD2 .globl _pipe12_ret
97: 95 00012FD2 # asm("_pipe12_ret:");
98: 96 00012FD2 _pipe12_ret:
99: 97 00012FD2 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
100: 98 00012FD2 0d efffffff28 5d movl _pre_event_fp,fp
101: 99 00012FD9 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
102: 100 00012FD9 0d efffffff21 5e movl _pre_event_sp,sp
103: 101 00012FE0 # if( force_loop )
104: 102 00012FE0 5d efffffff1a tstl _force_loop
105: 103 00012FE6 31 03 jeql L390
106: 104 00012FE8 # asm("brw _pipe12_lp1");; /* loop on the error */
107: "pipe100012F02 e 105: WARNING: brw: destination label is external
108: 105 00012FE8 13 ffa3 brw _pipe12_lp1
109: 106 00012FEB L390:
110: 107 00012FEB # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
111: 108 00012FEB 9b 8860 bicpsw $0x60
112: 109 00012FEE # if( (post_evt_acc.m == dbl_value_1.m) && /* was the 2nd 'LDD' */
113: 110 00012FEE # (post_evt_acc.l == dbl_value_1.l) ) /* executed? */
114: 111 00012FEE 1d efffffff0c efffffff07 cmpl _post_evt_acc,_dbl_value_1
115: 112 00012FF9 21 16 jneq L391
116: 113 00012FFB 1d efffffff03 effffffefe cmpl _post_evt_acc+4,_dbl_value_1+4
117: 114 00013006 21 09 jneq L391
118: 115 00013008 # pipe12_queue_er(); /* queue not cleared error */
119: 116 00013008 fe 04 ef00000195 callf $4,_pipe12_queue_er
120: 117 0001300F # else if( post_evt_acc.m ) /* was the Acc. cleared? */
121: 118 0001300F 11 0f jbr L393
122: 119 00013011 L391:
123: 120 00013011 5d effffffee9 tstl _post_evt_acc
124: 121 00013017 31 07 jeql L394
125: 122 00013019 # bad_pipe12_result(); /* incorrect result error */
126: 123 00013019 fe 04 ef00000090 callf $4,_bad_pipe12_result
127: 124 00013020 #
128: 125 00013020 # }
129: 126 00013020 L394:
130: 127 00013020 L393:
131: 128 00013020 L385:
132: 129 00013020 6d effffffeda incl _index
133: 130 00013026 13 ff21 jbr L387
134: 131 00013029 L386:
135: 132 00013029 # }
136: 133 00013029 40 ret#2
137: 134 0001302A .set L381,0x0
138: 135 0001302A L383:
139: 136 0001302A 13 fed8 jbr L384
140: 137 0001302D .data
141: 138 00000504 * .text
142: 139 0001302D 00 .align 1
143: 140 0001302E .globl _no_pipe12_evt
144: 141 0001302E _no_pipe12_evt:
145: 142 0001302E 0000 .word L396
146: 143 00013030 #
147: 144 00013030 #
148: 145 00013030 #
149: 146 00013030 # /****************************************************************************
150: 147 00013030 # * Report an "EVENT NOT DETECTED" error
151: 148 00013030 # *
152: 149 00013030 # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx
153: 150 00013030 # * inst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF)
154: 151 00013030 # * op1 = xxxxxxxx xxxxxxxx
155: 152 00013030 # ****************************************************************************/
156: 153 00013030 # no_pipe12_evt()
157: 154 00013030 # {
158: 155 00013030 11 7b jbr L398
159: 156 00013032 L399:
160: 157 00013032 # errcnt++; /* bump the error count */
161: 158 00013032 6d effffffec8 incl _errcnt
162: 159 00013038 # if ( prt_error )
163: 160 00013038 5d effffffec2 tstl _prt_error
164: 161 0001303E 31 46 jeql L400
165: 162 00013040 # {
166: 163 00013040 # print_pipe12_er( ". No overflow fault seen." );
167: 164 00013040 .data 1
168: 165 00000504 * L402:
169: 166 00000504 * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen.\0"
170: 7206661756C74207365656E2E
171: 00
172: 167 0000051e * .text
173: 168 00013040 dd 8f00000504 pushl $L402
174: 169 00013046 fe 08 ef00000273 callf $8,_print_pipe12_er
175: 170 0001304D # writes("op1 = ");
176: 171 0001304D .data 1
177: 172 0000051e * L404:
178: 173 0000051e * 6F7031203D2000 .ascii "op1 = \0"
179: 174 00000525 * .text
180: 175 0001304D dd 8f0000051e pushl $L404
181: 176 00013053 fe 08 effffffea6 callf $8,_writes
182: 177 0001305A # write32h( dbl_ld_acc.m );
183: 178 0001305A dd effffffea0 pushl _dbl_ld_acc
184: 179 00013060 fe 08 effffffe99 callf $8,_write32h
185: 180 00013067 # writec(' ');
186: 181 00013067 dd 20 pushl $32
187: 182 00013069 fe 08 effffffe90 callf $8,_writec
188: 183 00013070 # write32h( dbl_ld_acc.l );
189: 184 00013070 dd effffffe8e pushl _dbl_ld_acc+4
190: 185 00013076 fe 08 effffffe83 callf $8,_write32h
191: 186 0001307D # writec('\n');
192: 187 0001307D dd 0a pushl $10
193: 188 0001307F fe 08 effffffe7a callf $8,_writec
194: 189 00013086 # }
195: 190 00013086 # if ( halt_flg ) /* halt on error? */
196: 191 00013086 L400:
197: 192 00013086 5d effffffe74 tstl _halt_flg
198: 193 0001308C 31 09 jeql L407
199: 194 0001308E # pipe12_halt( 1 ); /* halt with a code of 1 */
200: 195 0001308E dd 01 pushl $1
201: 196 00013090 fe 08 ef000002c7 callf $8,_pipe12_halt
202: 197 00013097 # if ( loop_on_err )
203: 198 00013097 L407:
204: 199 00013097 5d effffffe63 tstl _loop_on_err
205: 200 0001309D 31 0d jeql L409
206: 201 0001309F # {
207: 202 0001309F # force_loop = TRUE; /* set the force loop flag */
208: 203 0001309F 0d 01 effffffe5a movl $1,_force_loop
209: 204 000130A6 # asm("jmp _pipe12_lp1"); /* and loop */
210: 205 000130A6 71 effffffee2 jmp _pipe12_lp1
211: 206 000130AC # };
212: 207 000130AC L409:
213: 208 000130AC # }
214: 209 000130AC 40 ret#2
215: 210 000130AD .set L396,0x0
216: 211 000130AD L398:
217: 212 000130AD 11 83 jbr L399
218: 213 000130AF .data
219: 214 00000504 * .text
220: 215 000130AF 00 .align 1
221: 216 000130B0 .globl _bad_pipe12_result
222: 217 000130B0 _bad_pipe12_result:
223: 218 000130B0 0000 .word L410
224: 219 000130B2 #
225: 220 000130B2 #
226: 221 000130B2 #
227: 222 000130B2 #
228: 223 000130B2 # /****************************************************************************
229: 224 000130B2 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
230: 225 000130B2 # *
231: 226 000130B2 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
232: 227 000130B2 # * inst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF)
233: 228 000130B2 # * The 2nd LOAD DOUBLE instruction should not be executed.
234: 229 000130B2 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx
235: 230 000130B2 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx
236: 231 000130B2 # ****************************************************************************/
237: 232 000130B2 # bad_pipe12_result()
238: 233 000130B2 # {
239: 234 000130B2 13 00eb jbr L412
240: 235 000130B5 L413:
241: 236 000130B5 # errcnt++; /* bump the error count */
242: 237 000130B5 6d effffffe45 incl _errcnt
243: 238 000130BB # if ( prt_error )
244: 239 000130BB 5d effffffe3f tstl _prt_error
245: 240 000130C1 21 03 13 00b3 jeql L414
246: 241 000130C6 # {
247: 242 000130C6 # print_pipe12_er( ". Bad final Accumulator" );
248: 243 000130C6 .data 1
249: 244 00000525 * L415:
250: 245 00000525 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
251: 16363756D756C61746F7200
252: 246 0000053d * .text
253: 247 000130C6 dd 8f00000525 pushl $L415
254: 248 000130CC fe 08 ef000001ed callf $8,_print_pipe12_er
255: 249 000130D3 # writes(
256: 250 000130D3 # "The 2nd LOAD DOUBLE INSTRUCTION should not be executed\n");
257: 251 000130D3 .data 1
258: 252 0000053d * L416:
259: 253 0000053d * 54686520326E64204C4F41442 .ascii "The 2nd LOAD DOUBLE INSTRUCTION should not be executed\12\0"
260: 0444F55424C4520494E535452
261: 554354494F4E2073686F756C6
262: 4206E6F742062652065786563
263: 757465640A00
264: 254 00000575 * .text
265: 255 000130D3 dd 8f0000053d pushl $L416
266: 256 000130D9 fe 08 effffffe20 callf $8,_writes
267: 257 000130E0 # writes("op1 = ");
268: 258 000130E0 .data 1
269: 259 00000575 * L417:
270: 260 00000575 * 6F7031203D2000 .ascii "op1 = \0"
271: 261 0000057c * .text
272: 262 000130E0 dd 8f00000575 pushl $L417
273: 263 000130E6 fe 08 effffffe13 callf $8,_writes
274: 264 000130ED # write32h( dbl_ld_acc.m );
275: 265 000130ED dd effffffe0d pushl _dbl_ld_acc
276: 266 000130F3 fe 08 effffffe06 callf $8,_write32h
277: 267 000130FA # writec(' ');
278: 268 000130FA dd 20 pushl $32
279: 269 000130FC fe 08 effffffdfd callf $8,_writec
280: 270 00013103 # write32h( dbl_ld_acc.l );
281: 271 00013103 dd effffffdfb pushl _dbl_ld_acc+4
282: 272 00013109 fe 08 effffffdf0 callf $8,_write32h
283: 273 00013110 # writes(", final Acc. = ");
284: 274 00013110 .data 1
285: 275 0000057c * L418:
286: 276 0000057c * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0"
287: 03D2000
288: 277 0000058c * .text
289: 278 00013110 dd 8f0000057c pushl $L418
290: 279 00013116 fe 08 effffffde3 callf $8,_writes
291: 280 0001311D # write32h( post_evt_acc.m );
292: 281 0001311D dd effffffddd pushl _post_evt_acc
293: 282 00013123 fe 08 effffffdd6 callf $8,_write32h
294: 283 0001312A # writes("op2 = ");
295: 284 0001312A .data 1
296: 285 0000058c * L419:
297: 286 0000058c * 6F7032203D2000 .ascii "op2 = \0"
298: 287 00000593 * .text
299: 288 0001312A dd 8f0000058c pushl $L419
300: 289 00013130 fe 08 effffffdc9 callf $8,_writes
301: 290 00013137 # write32h( dbl_value_1.m );
302: 291 00013137 dd effffffdc3 pushl _dbl_value_1
303: 292 0001313D fe 08 effffffdbc callf $8,_write32h
304: 293 00013144 # writec(' ');
305: 294 00013144 dd 20 pushl $32
306: 295 00013146 fe 08 effffffdb3 callf $8,_writec
307: 296 0001314D # write32h( dbl_value_1.l );
308: 297 0001314D dd effffffdb1 pushl _dbl_value_1+4
309: 298 00013153 fe 08 effffffda6 callf $8,_write32h
310: 299 0001315A # writes(", expected = ");
311: 300 0001315A .data 1
312: 301 00000593 * L420:
313: 302 00000593 * 2C20202065787065637465642 .ascii ", expected = \0"
314: 03D2000
315: 303 000005a3 * .text
316: 304 0001315A dd 8f00000593 pushl $L420
317: 305 00013160 fe 08 effffffd99 callf $8,_writes
318: 306 00013167 # write32h( 0 ); /* expected = floating '0.0' */
319: 307 00013167 dd 00 pushl $0
320: 308 00013169 fe 08 effffffd90 callf $8,_write32h
321: 309 00013170 # writec('\n');
322: 310 00013170 dd 0a pushl $10
323: 311 00013172 fe 08 effffffd87 callf $8,_writec
324: 312 00013179 # }
325: 313 00013179 # if ( halt_flg ) /* halt on error? */
326: 314 00013179 L414:
327: 315 00013179 5d effffffd81 tstl _halt_flg
328: 316 0001317F 31 09 jeql L421
329: 317 00013181 # pipe12_halt( 2 ); /* halt with a code of 2 */
330: 318 00013181 dd 02 pushl $2
331: 319 00013183 fe 08 ef000001d4 callf $8,_pipe12_halt
332: 320 0001318A # if ( loop_on_err )
333: 321 0001318A L421:
334: 322 0001318A 5d effffffd70 tstl _loop_on_err
335: 323 00013190 31 0d jeql L422
336: 324 00013192 # {
337: 325 00013192 # force_loop = TRUE; /* set the force loop flag */
338: 326 00013192 0d 01 effffffd67 movl $1,_force_loop
339: 327 00013199 # asm("jmp _pipe12_lp1"); /* and loop */
340: 328 00013199 71 effffffdef jmp _pipe12_lp1
341: 329 0001319F # };
342: 330 0001319F L422:
343: 331 0001319F # }
344: 332 0001319F 40 ret#2
345: 333 000131A0 .set L410,0x0
346: 334 000131A0 L412:
347: 335 000131A0 13 ff12 jbr L413
348: 336 000131A3 .data
349: 337 00000504 * .text
350: 338 000131A3 00 .align 1
351: 339 000131A4 .globl _pipe12_queue_er
352: 340 000131A4 _pipe12_queue_er:
353: 341 000131A4 0000 .word L423
354: 342 000131A6 #
355: 343 000131A6 #
356: 344 000131A6 #
357: 345 000131A6 #
358: 346 000131A6 #
359: 347 000131A6 # /****************************************************************************
360: 348 000131A6 # * Report an "FPP queue not cleared" message
361: 349 000131A6 # *
362: 350 000131A6 # * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx
363: 351 000131A6 # * inst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF)
364: 352 000131A6 # * The 2nd load double instruction was apparently executed.
365: 353 000131A6 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
366: 354 000131A6 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
367: 355 000131A6 # ****************************************************************************/
368: 356 000131A6 # pipe12_queue_er()
369: 357 000131A6 # {
370: 358 000131A6 13 0113 jbr L425
371: 359 000131A9 L426:
372: 360 000131A9 # errcnt++; /* bump the error count */
373: 361 000131A9 6d effffffd51 incl _errcnt
374: 362 000131AF # if ( prt_error )
375: 363 000131AF 5d effffffd4b tstl _prt_error
376: 364 000131B5 21 03 13 00db jeql L427
377: 365 000131BA # {
378: 366 000131BA # print_pipe12_er( ". Fpp queue not cleared" );
379: 367 000131BA .data 1
380: 368 000005a3 * L428:
381: 369 000005a3 * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0"
382: E6F7420636C656172656400
383: 370 000005bb * .text
384: 371 000131BA dd 8f000005a3 pushl $L428
385: 372 000131C0 fe 08 ef000000f9 callf $8,_print_pipe12_er
386: 373 000131C7 # writes(
387: 374 000131C7 # "The 2nd load double instruction was apparently executed.\n");
388: 375 000131C7 .data 1
389: 376 000005bb * L429:
390: 377 000005bb * 54686520326E64206C6F61642 .ascii "The 2nd load double instruction was apparently executed.\12\0"
391: 0646F75626C6520696E737472
392: 756374696F6E2077617320617
393: 0706172656E746C7920657865
394: 63757465642E0A00
395: 378 000005f5 * .text
396: 379 000131C7 dd 8f000005bb pushl $L429
397: 380 000131CD fe 08 effffffd2c callf $8,_writes
398: 381 000131D4 # writes("op1 = ");
399: 382 000131D4 .data 1
400: 383 000005f5 * L430:
401: 384 000005f5 * 6F7031203D2000 .ascii "op1 = \0"
402: 385 000005fc * .text
403: 386 000131D4 dd 8f000005f5 pushl $L430
404: 387 000131DA fe 08 effffffd1f callf $8,_writes
405: 388 000131E1 # write32h( dbl_ld_acc.m );
406: 389 000131E1 dd effffffd19 pushl _dbl_ld_acc
407: 390 000131E7 fe 08 effffffd12 callf $8,_write32h
408: 391 000131EE # writec(' ');
409: 392 000131EE dd 20 pushl $32
410: 393 000131F0 fe 08 effffffd09 callf $8,_writec
411: 394 000131F7 # write32h( dbl_ld_acc.l );
412: 395 000131F7 dd effffffd07 pushl _dbl_ld_acc+4
413: 396 000131FD fe 08 effffffcfc callf $8,_write32h
414: 397 00013204 # writes(", final Acc. = ");
415: 398 00013204 .data 1
416: 399 000005fc * L431:
417: 400 000005fc * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0"
418: 03D2000
419: 401 0000060c * .text
420: 402 00013204 dd 8f000005fc pushl $L431
421: 403 0001320A fe 08 effffffcef callf $8,_writes
422: 404 00013211 # write32h( post_evt_acc.m );
423: 405 00013211 dd effffffce9 pushl _post_evt_acc
424: 406 00013217 fe 08 effffffce2 callf $8,_write32h
425: 407 0001321E # writec(' ');
426: 408 0001321E dd 20 pushl $32
427: 409 00013220 fe 08 effffffcd9 callf $8,_writec
428: 410 00013227 # write32h( post_evt_acc.l );
429: 411 00013227 dd effffffcd7 pushl _post_evt_acc+4
430: 412 0001322D fe 08 effffffccc callf $8,_write32h
431: 413 00013234 # writes("\nop2 = ");
432: 414 00013234 .data 1
433: 415 0000060c * L432:
434: 416 0000060c * 0A6F7032203D2000 .ascii "\12op2 = \0"
435: 417 00000614 * .text
436: 418 00013234 dd 8f0000060c pushl $L432
437: 419 0001323A fe 08 effffffcbf callf $8,_writes
438: 420 00013241 # write32h( dbl_value_1.m );
439: 421 00013241 dd effffffcb9 pushl _dbl_value_1
440: 422 00013247 fe 08 effffffcb2 callf $8,_write32h
441: 423 0001324E # writec(' ');
442: 424 0001324E dd 20 pushl $32
443: 425 00013250 fe 08 effffffca9 callf $8,_writec
444: 426 00013257 # write32h( dbl_value_1.l );
445: 427 00013257 dd effffffca7 pushl _dbl_value_1+4
446: 428 0001325D fe 08 effffffc9c callf $8,_write32h
447: 429 00013264 # writes(", expected = ");
448: 430 00013264 .data 1
449: 431 00000614 * L433:
450: 432 00000614 * 2C20202065787065637465642 .ascii ", expected = \0"
451: 03D2000
452: 433 00000624 * .text
453: 434 00013264 dd 8f00000614 pushl $L433
454: 435 0001326A fe 08 effffffc8f callf $8,_writes
455: 436 00013271 # write32h( 0x ); /* expected = floating '0' */
456: 437 00013271 dd 00 pushl $0
457: 438 00013273 fe 08 effffffc86 callf $8,_write32h
458: 439 0001327A # writec(' ');
459: 440 0001327A dd 20 pushl $32
460: 441 0001327C fe 08 effffffc7d callf $8,_writec
461: 442 00013283 # write32h( 0 );
462: 443 00013283 dd 00 pushl $0
463: 444 00013285 fe 08 effffffc74 callf $8,_write32h
464: 445 0001328C # writec('\n');
465: 446 0001328C dd 0a pushl $10
466: 447 0001328E fe 08 effffffc6b callf $8,_writec
467: 448 00013295 # }
468: 449 00013295 # if ( halt_flg ) /* halt on error? */
469: 450 00013295 L427:
470: 451 00013295 5d effffffc65 tstl _halt_flg
471: 452 0001329B 31 09 jeql L434
472: 453 0001329D # pipe12_halt( 3 ); /* halt with a code of 3 */
473: 454 0001329D dd 03 pushl $3
474: 455 0001329F fe 08 ef000000b8 callf $8,_pipe12_halt
475: 456 000132A6 # if ( loop_on_err )
476: 457 000132A6 L434:
477: 458 000132A6 5d effffffc54 tstl _loop_on_err
478: 459 000132AC 31 0d jeql L435
479: 460 000132AE # {
480: 461 000132AE # force_loop = TRUE; /* set the force loop flag */
481: 462 000132AE 0d 01 effffffc4b movl $1,_force_loop
482: 463 000132B5 # asm("jmp _pipe12_lp1"); /* and loop */
483: 464 000132B5 71 effffffcd3 jmp _pipe12_lp1
484: 465 000132BB # };
485: 466 000132BB L435:
486: 467 000132BB # }
487: 468 000132BB 40 ret#2
488: 469 000132BC .set L423,0x0
489: 470 000132BC L425:
490: 471 000132BC 13 feea jbr L426
491: 472 000132BF .data
492: 473 00000504 * .text
493: 474 000132BF 00 .align 1
494: 475 000132C0 .globl _print_pipe12_er
495: 476 000132C0 _print_pipe12_er:
496: 477 000132C0 0000 .word L436
497: 478 000132C2 #
498: 479 000132C2 #
499: 480 000132C2 #
500: 481 000132C2 #
501: 482 000132C2 # /****************************************************************************
502: 483 000132C2 # * Report an error message of the form:
503: 484 000132C2 # *
504: 485 000132C2 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
505: 486 000132C2 # * inst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF)
506: 487 000132C2 # ****************************************************************************/
507: 488 000132C2 # print_pipe12_er( msg )
508: 489 000132C2 # char *msg; /* error message to print */
509: 490 000132C2 # {
510: 491 000132C2 13 0096 jbr L438
511: 492 000132C5 L439:
512: 493 000132C5 # if( errcnt == 1 ) /* 1st error? */
513: 494 000132C5 1d effffffc35 01 cmpl _errcnt,$1
514: 495 000132CC 21 0d jneq L440
515: 496 000132CE # writes(" \n"); /* start a new print line */
516: 497 000132CE .data 1
517: 498 00000624 * L441:
518: 499 00000624 * 200A00 .ascii " \12\0"
519: 500 00000627 * .text
520: 501 000132CE dd 8f00000624 pushl $L441
521: 502 000132D4 fe 08 effffffc25 callf $8,_writes
522: 503 000132DB # writes("Cycle: ");
523: 504 000132DB L440:
524: 505 000132DB .data 1
525: 506 00000627 * L442:
526: 507 00000627 * 4379636C653A2000 .ascii "Cycle: \0"
527: 508 0000062f * .text
528: 509 000132DB dd 8f00000627 pushl $L442
529: 510 000132E1 fe 08 effffffc18 callf $8,_writes
530: 511 000132E8 # writed( cycle );
531: 512 000132E8 dd effffffc12 pushl _cycle
532: 513 000132EE fe 08 effffffc0b callf $8,_writed
533: 514 000132F5 # writes(" EVT test ");
534: 515 000132F5 .data 1
535: 516 0000062f * L444:
536: 517 0000062f * 202045565420746573742000 .ascii " EVT test \0"
537: 518 0000063b * .text
538: 519 000132F5 dd 8f0000062f pushl $L444
539: 520 000132FB fe 08 effffffbfe callf $8,_writes
540: 521 00013302 # writed( test_no );
541: 522 00013302 dd effffffbf8 pushl _test_no
542: 523 00013308 fe 08 effffffbf1 callf $8,_writed
543: 524 0001330F # writes(". subtest ");
544: 525 0001330F .data 1
545: 526 0000063b * L445:
546: 527 0000063b * 2E20737562746573742000 .ascii ". subtest \0"
547: 528 00000646 * .text
548: 529 0001330F dd 8f0000063b pushl $L445
549: 530 00013315 fe 08 effffffbe4 callf $8,_writes
550: 531 0001331C # writed( subtest );
551: 532 0001331C dd effffffbde pushl _subtest
552: 533 00013322 fe 08 effffffbd7 callf $8,_writed
553: 534 00013329 # writes( msg ); /* print the message */
554: 535 00013329 dd ad04 pushl 4(fp)
555: 536 0001332C fe 08 effffffbcd callf $8,_writes
556: 537 00013333 # writes(" index = ");
557: 538 00013333 .data 1
558: 539 00000646 * L446:
559: 540 00000646 * 20696E646578203D2000 .ascii " index = \0"
560: 541 00000650 * .text
561: 542 00013333 dd 8f00000646 pushl $L446
562: 543 00013339 fe 08 effffffbc0 callf $8,_writes
563: 544 00013340 # writed( index );
564: 545 00013340 dd effffffbba pushl _index
565: 546 00013346 fe 08 effffffbb3 callf $8,_writed
566: 547 0001334D # writes(
567: 548 0001334D # "\ninst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF)\n");
568: 549 0001334D .data 1
569: 550 00000650 * L447:
570: 551 00000650 * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF)\12\0"
571: F70312C20435644462C204C44
572: 44206F703220202020286F766
573: 572666C6F77206661756C7420
574: 6F6E207468652043564446290
575: A00
576: 552 00000690 * .text
577: 553 0001334D dd 8f00000650 pushl $L447
578: 554 00013353 fe 08 effffffba6 callf $8,_writes
579: 555 0001335A # }
580: 556 0001335A 40 ret#2
581: 557 0001335B .set L436,0x0
582: 558 0001335B L438:
583: 559 0001335B 13 ff67 jbr L439
584: 560 0001335E .data
585: 561 00000504 * .text
586: 562 0001335E .align 1
587: 563 0001335E .globl _pipe12_halt
588: 564 0001335E _pipe12_halt:
589: 565 0001335E 0000 .word L448
590: 566 00013360 #
591: 567 00013360 #
592: 568 00013360 #
593: 569 00013360 # /****************************************************************************
594: 570 00013360 # * halt on error routine
595: 571 00013360 # ****************************************************************************/
596: 572 00013360 # pipe12_halt( code )
597: 573 00013360 # int code; /* error code to halt with */
598: 574 00013360 # {
599: 575 00013360 13 009b jbr L450
600: 576 00013363 L451:
601: 577 00013363 # err_code = code;
602: 578 00013363 0d ad04 effffffb95 movl 4(fp),_err_code
603: 579 0001336B # sgl_value_1 = dbl_ld_acc.m;
604: 580 0001336B 0d effffffb8f effffffb8a movl _dbl_ld_acc,_sgl_value_1
605: 581 00013376 # sgl_value_2 = dbl_ld_acc.l;
606: 582 00013376 0d effffffb88 effffffb7f movl _dbl_ld_acc+4,_sgl_value_2
607: 583 00013381 # sgl_value_3 = dbl_value_1.m;
608: 584 00013381 0d effffffb79 effffffb74 movl _dbl_value_1,_sgl_value_3
609: 585 0001338C # sgl_value_4 = dbl_value_1.l;
610: 586 0001338C 0d effffffb72 effffffb69 movl _dbl_value_1+4,_sgl_value_4
611: 587 00013397 # sgl_value_5 = post_evt_acc.m;
612: 588 00013397 0d effffffb63 effffffb5e movl _post_evt_acc,_sgl_value_5
613: 589 000133A2 # sgl_value_6 = post_evt_acc.l;
614: 590 000133A2 0d effffffb5c effffffb53 movl _post_evt_acc+4,_sgl_value_6
615: 591 000133AD # asm("movl _test_no,r0"); /* r0 = test number */
616: 592 000133AD 0d effffffb4d 50 movl _test_no,r0
617: 593 000133B4 # asm("movl _subtest,r1"); /* r1 = subtest number */
618: 594 000133B4 0d effffffb46 51 movl _subtest,r1
619: 595 000133BB # asm("movl _err_code,r2"); /* r2 = error code */
620: 596 000133BB 0d effffffb3f 52 movl _err_code,r2
621: 597 000133C2 # asm("movl _cycle,r3"); /* r3 = cycle count */
622: 598 000133C2 0d effffffb38 53 movl _cycle,r3
623: 599 000133C9 # asm("movl _sgl_value_1,r4"); /* r4 = MSW of 1st load. */
624: 600 000133C9 0d effffffb31 54 movl _sgl_value_1,r4
625: 601 000133D0 # asm("movl _sgl_value_2,r5"); /* r5 = LSW of 1st load. */
626: 602 000133D0 0d effffffb2a 55 movl _sgl_value_2,r5
627: 603 000133D7 # asm("movl _sgl_value_3,r6"); /* r6 = MSW of 2nd load. */
628: 604 000133D7 0d effffffb23 56 movl _sgl_value_3,r6
629: 605 000133DE # asm("movl _sgl_value_4,r7"); /* r7 = LSW of 2nd load. */
630: 606 000133DE 0d effffffb1c 57 movl _sgl_value_4,r7
631: 607 000133E5 # asm("movl _sgl_value_5,r8"); /* r8 = MSW of final Acc. */
632: 608 000133E5 0d effffffb15 58 movl _sgl_value_5,r8
633: 609 000133EC # asm("movl _sgl_value_6,r9"); /* r9 = LSW of final Acc. */
634: 610 000133EC 0d effffffb0e 59 movl _sgl_value_6,r9
635: 611 000133F3 # asm("clrl r10"); /* r10 = expected ( '0' ) */
636: 612 000133F3 4d 5a clrl r10
637: 613 000133F5 # asm("movl _index,r11"); /* r11 = data index */
638: 614 000133F5 0d effffffb05 5b movl _index,r11
639: 615 000133FC # asm("halt"); /* HALT ... */
640: 616 000133FC 00 halt
641: 617 000133FD # }
642: 618 000133FD 40 ret#2
643: 619 000133FE .set L448,0x0
644: 620 000133FE L450:
645: 621 000133FE 13 ff62 jbr L451
646: 622 00013401 .data
647: 622 00026301 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.