![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe4.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 pipe4.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 000005c4 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe4
6: 6 00000000 _pipe4:
7: 7 0001042C 0000 .word L381
8: 8 0001042E #
9: 9 0001042E # #include "evt_defs.h"
10: 10 0001042E #
11: 11 0001042E # /*
12: 12 0001042E # *********************************************************************
13: 13 0001042E # * FPP PIPELINED EVENTS TEST #4
14: 14 0001042E # *
15: 15 0001042E # * This test will execute the following code: "LDF MULF MULL3 NEGF"
16: 16 0001042E # * with an alignment fault on the MULL3. We will make sure that:
17: 17 0001042E # * 1. The fault is detected,
18: 18 0001042E # * 2. the floating multiply operation completes,
19: 19 0001042E # * 3. the negate instruction is not executed.
20: 20 0001042E # *********************************************************************
21: 21 0001042E # */
22: 22 0001042E # pipe4()
23: 23 0001042E # {
24: 24 0001042E 13 015d jbr L383
25: 25 00010431 L384:
26: 26 00010431 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
27: 27 00010431 ed 6d effffffff4 moval (r13),_pre_event_fp
28: 28 00010438 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
29: 29 00010438 ed 6e efffffffed moval (r14),_pre_event_sp
30: 30 0001043F # precision = SGL;
31: 31 0001043F 0d 01 efffffffe6 movl $1,_precision
32: 32 00010446 # test_event = ALIGN_CODE; /* alignment fault expected */
33: 33 00010446 0d 35 efffffffdf movl $53,_test_event
34: 34 0001044D # exp_event = FALSE; /* ... but not yet */
35: 35 0001044D 4d efffffffd9 clrl _exp_event
36: 36 00010453 # asm("movab _pipe4_ret,_event_return"); /* post event addr */
37: 37 00010453 e9 ef000000dd efffffffce movab _pipe4_ret,_event_return
38: 38 0001045E # for( index = 0; index < max_pipe4_index; index++ )
39: 39 0001045E 4d efffffffc8 clrl _index
40: 40 00010464 L387:
41: 41 00010464 1d efffffffc2 efffffffbd cmpl _index,_max_pipe4_index
42: 42 0001046F 91 03 13 0119 jgeq L386
43: 43 00010474 # {
44: 44 00010474 # dbl_ld_acc = pipe4_data[index].op_1; /* get the data */
45: 45 00010474 5c 18 efffffffb1 50 mull3 $24,_index,r0
46: 46 0001047C 0c 8f00000000 50 addl2 $_pipe4_data,r0
47: 47 00010483 0d a004 efffffffa5 movl 4(r0),_dbl_ld_acc+4
48: 48 0001048B 0d 60 efffffff9a movl (r0),_dbl_ld_acc
49: 49 00010492 # dbl_value_1 = pipe4_data[index].op_2;
50: 50 00010492 5c 18 efffffff93 50 mull3 $24,_index,r0
51: 51 0001049A 0c 8f00000008 50 addl2 $_pipe4_data+8,r0
52: 52 000104A1 0d a004 efffffff87 movl 4(r0),_dbl_value_1+4
53: 53 000104A9 0d 60 efffffff7c movl (r0),_dbl_value_1
54: 54 000104B0 # dbl_expected = pipe4_data[index].exp;
55: 55 000104B0 5c 18 efffffff75 50 mull3 $24,_index,r0
56: 56 000104B8 0c 8f00000010 50 addl2 $_pipe4_data+16,r0
57: 57 000104BF 0d a004 efffffff69 movl 4(r0),_dbl_expected+4
58: 58 000104C7 0d 60 efffffff5e movl (r0),_dbl_expected
59: 59 000104CE # sgl_value_1 = 0x12345;
60: 60 000104CE 0d 8f00012345 efffffff53 movl $74565,_sgl_value_1
61: 61 000104D9 # sgl_value_2 = -12345;
62: 62 000104D9 0d 89cfc7 efffffff4a movl $-12345,_sgl_value_2
63: 63 000104E2 # asm(".globl _pipe4_lp1");
64: 64 000104E2 .globl _pipe4_lp1
65: 65 000104E2 # asm("_pipe4_lp1:");
66: 66 000104E2 _pipe4_lp1:
67: 67 000104E2 # asm("bispsw $0x60"); /* enable ovfl & undfl */
68: 68 000104E2 8b 8860 bispsw $0x60
69: 69 000104E5 # asm("ldf _dbl_ld_acc"); /* load the Acc. */
70: 70 000104E5 06 efffffff41 ldf _dbl_ld_acc
71: 71 000104EB # exp_event = test_event; /* expect event soon */
72: 72 000104EB 0d efffffff3b efffffff36 movl _test_event,_exp_event
73: 73 000104F6 # asm("mulf _dbl_value_1");
74: 74 000104F6 e6 efffffff30 mulf _dbl_value_1
75: 75 000104FC # asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3+3");
76: 76 000104FC 5c efffffff2a efffffff25 mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3+3
77: efffffff23
78: 77 0001050C # asm("negf");
79: 78 0001050C b6 negf
80: 79 0001050D # /*
81: 80 0001050D # * If we got to here then there was no event
82: 81 0001050D # */
83: 82 0001050D # if( force_loop )
84: 83 0001050D 5d efffffff19 tstl _force_loop
85: 84 00010513 31 03 jeql L388
86: 85 00010515 # asm("brw _pipe4_lp1");; /* loop on the error */
87: Assemb00027BEC # asm("brw _pipe4_lp1");; /* loop on the error */
88: "pipe400027BEC 86: WARNING: brw: destination label is external
89: 86 00010515 13 ffca brw _pipe4_lp1
90: 87 00010518 L388:
91: 88 00010518 # exp_event = FALSE; /* reset event expected flag */
92: 89 00010518 4d efffffff0e clrl _exp_event
93: 90 0001051E # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
94: 91 0001051E 0d efffffff08 5d movl _pre_event_fp,fp
95: 92 00010525 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
96: 93 00010525 0d efffffff01 5e movl _pre_event_sp,sp
97: 94 0001052C # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
98: 95 0001052C 9b 8860 bicpsw $0x60
99: 96 0001052F # no_pipe4_evt();; /* report the error */
100: 97 0001052F fe 04 ef0000005c callf $4,_no_pipe4_evt
101: 98 00010536 # /*
102: 99 00010536 # * Come here after the event
103: 100 00010536 # */
104: 101 00010536 # asm(".globl _pipe4_ret");
105: 102 00010536 .globl _pipe4_ret
106: 103 00010536 # asm("_pipe4_ret:");
107: 104 00010536 _pipe4_ret:
108: 105 00010536 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
109: 106 00010536 0d effffffef0 5d movl _pre_event_fp,fp
110: 107 0001053D # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
111: 108 0001053D 0d effffffee9 5e movl _pre_event_sp,sp
112: 109 00010544 # if( force_loop )
113: 110 00010544 5d effffffee2 tstl _force_loop
114: 111 0001054A 31 03 jeql L390
115: 112 0001054C # asm("brw _pipe4_lp1");; /* loop on the error */
116: "pipe400027BEC 113: WARNING: brw: destination label is external
117: 113 0001054C 13 ff93 brw _pipe4_lp1
118: 114 0001054F L390:
119: 115 0001054F # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
120: 116 0001054F 9b 8860 bicpsw $0x60
121: 117 00010552 # if( post_evt_acc.m == (dbl_expected.m ^ 0x80000000) )
122: 118 00010552 dc 8f80000000 effffffecf xorl3 $-2147483648,_dbl_expected,r0
123: 50
124: 119 0001055E 1d effffffec8 50 cmpl _post_evt_acc,r0
125: 120 00010565 21 09 jneq L391
126: 121 00010567 # pipe4_queue_er(); /* fpp queue not cleared */
127: 122 00010567 fe 04 ef00000216 callf $4,_pipe4_queue_er
128: 123 0001056E # else if( post_evt_acc.m != dbl_expected.m )
129: 124 0001056E 11 14 jbr L393
130: 125 00010570 L391:
131: 126 00010570 1d effffffeb6 effffffeb1 cmpl _post_evt_acc,_dbl_expected
132: 127 0001057B 31 07 jeql L394
133: 128 0001057D # bad_pipe4_result(); /* incorrect result error */
134: 129 0001057D fe 04 ef000000e6 callf $4,_bad_pipe4_result
135: 130 00010584 # }
136: 131 00010584 L394:
137: 132 00010584 L393:
138: 133 00010584 L385:
139: 134 00010584 6d effffffea2 incl _index
140: 135 0001058A 13 fed7 jbr L387
141: 136 0001058D L386:
142: 137 0001058D # }
143: 138 0001058D 40 ret#2
144: 139 0001058E .set L381,0x0
145: 140 0001058E L383:
146: 141 0001058E 13 fea0 jbr L384
147: 142 00010591 .data
148: 143 000005c4 * .text
149: 144 00010591 00 .align 1
150: 145 00010592 .globl _no_pipe4_evt
151: 146 00010592 _no_pipe4_evt:
152: 147 00010592 0000 .word L396
153: 148 00010594 #
154: 149 00010594 #
155: 150 00010594 #
156: 151 00010594 # /****************************************************************************
157: 152 00010594 # * Report an "EVENT NOT DETECTED" error
158: 153 00010594 # *
159: 154 00010594 # * Cycle: xx. EVT test xx. subtest xx. no alignment fault. index = xx
160: 155 00010594 # * inst = LDF op1, MULF op2, MULL3 op3,op4,op5 (alignment fault on MULL3)
161: 156 00010594 # * op1 = xxxxxxxx, op2 = xxxxxxxx
162: 157 00010594 # * op3 = xxxxxxxx, op4 = xxxxxxxx, addr op5 = xxxxxxxx
163: 158 00010594 # ****************************************************************************/
164: 159 00010594 # no_pipe4_evt()
165: 160 00010594 # {
166: 161 00010594 13 00d0 jbr L398
167: 162 00010597 L399:
168: 163 00010597 # errcnt++; /* bump the error count */
169: 164 00010597 6d effffffe8f incl _errcnt
170: 165 0001059D # if ( prt_error )
171: 166 0001059D 5d effffffe89 tstl _prt_error
172: 167 000105A3 21 03 13 0098 jeql L400
173: 168 000105A8 # {
174: 169 000105A8 # print_pipe4_er( ". no alignment fault.");
175: 170 000105A8 .data 1
176: 171 000005c4 * L402:
177: 172 000005c4 * 2E206E6F20616C69676E6D656 .ascii ". no alignment fault.\0"
178: E74206661756C742E00
179: 173 000005da * .text
180: 174 000105A8 dd 8f000005c4 pushl $L402
181: 175 000105AE fe 08 ef000002e9 callf $8,_print_pipe4_er
182: 176 000105B5 # writes("op1 = ");
183: 177 000105B5 .data 1
184: 178 000005da * L404:
185: 179 000005da * 6F7031203D2000 .ascii "op1 = \0"
186: 180 000005e1 * .text
187: 181 000105B5 dd 8f000005da pushl $L404
188: 182 000105BB fe 08 effffffe6a callf $8,_writes
189: 183 000105C2 # write32h( dbl_ld_acc.m );
190: 184 000105C2 dd effffffe64 pushl _dbl_ld_acc
191: 185 000105C8 fe 08 effffffe5d callf $8,_write32h
192: 186 000105CF # writes(", op2 = ");
193: 187 000105CF .data 1
194: 188 000005e1 * L406:
195: 189 000005e1 * 2C20206F7032203D2000 .ascii ", op2 = \0"
196: 190 000005eb * .text
197: 191 000105CF dd 8f000005e1 pushl $L406
198: 192 000105D5 fe 08 effffffe50 callf $8,_writes
199: 193 000105DC # write32h( dbl_value_1.m );
200: 194 000105DC dd effffffe4a pushl _dbl_value_1
201: 195 000105E2 fe 08 effffffe43 callf $8,_write32h
202: 196 000105E9 # writes("\nop3 = ");
203: 197 000105E9 .data 1
204: 198 000005eb * L407:
205: 199 000005eb * 0A6F7033203D2000 .ascii "\12op3 = \0"
206: 200 000005f3 * .text
207: 201 000105E9 dd 8f000005eb pushl $L407
208: 202 000105EF fe 08 effffffe36 callf $8,_writes
209: 203 000105F6 # write32h( sgl_value_1 );
210: 204 000105F6 dd effffffe30 pushl _sgl_value_1
211: 205 000105FC fe 08 effffffe29 callf $8,_write32h
212: 206 00010603 # writes(", op4 = ");
213: 207 00010603 .data 1
214: 208 000005f3 * L408:
215: 209 000005f3 * 2C20206F7034203D2000 .ascii ", op4 = \0"
216: 210 000005fd * .text
217: 211 00010603 dd 8f000005f3 pushl $L408
218: 212 00010609 fe 08 effffffe1c callf $8,_writes
219: 213 00010610 # write32h( sgl_value_2 );
220: 214 00010610 dd effffffe16 pushl _sgl_value_2
221: 215 00010616 fe 08 effffffe0f callf $8,_write32h
222: 216 0001061D # writes(", addr of op5 = ");
223: 217 0001061D .data 1
224: 218 000005fd * L409:
225: 219 000005fd * 2C202061646472206F66206F7 .ascii ", addr of op5 = \0"
226: 035203D2000
227: 220 0000060f * .text
228: 221 0001061D dd 8f000005fd pushl $L409
229: 222 00010623 fe 08 effffffe02 callf $8,_writes
230: 223 0001062A # write32h( ( (int)&sgl_value_3 )+1 );
231: 224 0001062A dd 8f00000001 pushl $_sgl_value_3+1
232: 225 00010630 fe 08 effffffdf5 callf $8,_write32h
233: 226 00010637 # writec('\n');
234: 227 00010637 dd 0a pushl $10
235: 228 00010639 fe 08 effffffdec callf $8,_writec
236: 229 00010640 # }
237: 230 00010640 # if ( halt_flg ) /* halt on error? */
238: 231 00010640 L400:
239: 232 00010640 5d effffffde6 tstl _halt_flg
240: 233 00010646 31 09 jeql L411
241: 234 00010648 # pipe4_halt( 1 );
242: 235 00010648 dd 01 pushl $1
243: 236 0001064A fe 08 ef000002f9 callf $8,_pipe4_halt
244: 237 00010651 # if ( loop_on_err )
245: 238 00010651 L411:
246: 239 00010651 5d effffffdd5 tstl _loop_on_err
247: 240 00010657 31 0d jeql L413
248: 241 00010659 # {
249: 242 00010659 # force_loop = TRUE; /* set the force loop flag */
250: 243 00010659 0d 01 effffffdcc movl $1,_force_loop
251: 244 00010660 # asm("jmp _pipe4_lp1"); /* and loop */
252: 245 00010660 71 effffffe7c jmp _pipe4_lp1
253: 246 00010666 # };
254: 247 00010666 L413:
255: 248 00010666 # }
256: 249 00010666 40 ret#2
257: 250 00010667 .set L396,0x0
258: 251 00010667 L398:
259: 252 00010667 13 ff2d jbr L399
260: 253 0001066A .data
261: 254 000005c4 * .text
262: 255 0001066A .align 1
263: 256 0001066A .globl _bad_pipe4_result
264: 257 0001066A _bad_pipe4_result:
265: 258 0001066A 0000 .word L414
266: 259 0001066C #
267: 260 0001066C #
268: 261 0001066C #
269: 262 0001066C #
270: 263 0001066C # /****************************************************************************
271: 264 0001066C # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
272: 265 0001066C # *
273: 266 0001066C # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
274: 267 0001066C # * inst = LDF op1, MULF op2, MULL3 op3,op4,op5 (alignment fault on MULL3)
275: 268 0001066C # * The NEGF should not have been executed.
276: 269 0001066C # * op1 = xxxxxxxx, op2 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx
277: 270 0001066C # * op3 = xxxxxxxx, op4 = xxxxxxxx, addr op5 = xxxxxxxx
278: 271 0001066C # ****************************************************************************/
279: 272 0001066C # bad_pipe4_result()
280: 273 0001066C # {
281: 274 0001066C 13 0111 jbr L416
282: 275 0001066F L417:
283: 276 0001066F # errcnt++; /* bump the error count */
284: 277 0001066F 6d effffffdb7 incl _errcnt
285: 278 00010675 # if ( prt_error )
286: 279 00010675 5d effffffdb1 tstl _prt_error
287: 280 0001067B 21 03 13 00d9 jeql L418
288: 281 00010680 # {
289: 282 00010680 # print_pipe4_er(". Bad final Accumulator.");
290: 283 00010680 .data 1
291: 284 0000060f * L419:
292: 285 0000060f * 2E204261642066696E616C204 .ascii ". Bad final Accumulator.\0"
293: 16363756D756C61746F722E00
294: 286 00000628 * .text
295: 287 00010680 dd 8f0000060f pushl $L419
296: 288 00010686 fe 08 ef00000211 callf $8,_print_pipe4_er
297: 289 0001068D # writes("The NEGF should not have been executed.\n");
298: 290 0001068D .data 1
299: 291 00000628 * L420:
300: 292 00000628 * 546865204E4547462073686F7 .ascii "The NEGF should not have been executed.\12\0"
301: 56C64206E6F74206861766520
302: 6265656E20657865637574656
303: 42E0A00
304: 293 00000651 * .text
305: 294 0001068D dd 8f00000628 pushl $L420
306: 295 00010693 fe 08 effffffd92 callf $8,_writes
307: 296 0001069A # writes("op1 = ");
308: 297 0001069A .data 1
309: 298 00000651 * L421:
310: 299 00000651 * 6F7031203D2000 .ascii "op1 = \0"
311: 300 00000658 * .text
312: 301 0001069A dd 8f00000651 pushl $L421
313: 302 000106A0 fe 08 effffffd85 callf $8,_writes
314: 303 000106A7 # write32h( dbl_value_1.m );
315: 304 000106A7 dd effffffd7f pushl _dbl_value_1
316: 305 000106AD fe 08 effffffd78 callf $8,_write32h
317: 306 000106B4 # writes(", op2 = ");
318: 307 000106B4 .data 1
319: 308 00000658 * L422:
320: 309 00000658 * 2C206F7032203D2000 .ascii ", op2 = \0"
321: 310 00000661 * .text
322: 311 000106B4 dd 8f00000658 pushl $L422
323: 312 000106BA fe 08 effffffd6b callf $8,_writes
324: 313 000106C1 # write32h( dbl_value_2.m );
325: 314 000106C1 dd effffffd65 pushl _dbl_value_2
326: 315 000106C7 fe 08 effffffd5e callf $8,_write32h
327: 316 000106CE # writes(", final Acc. = ");
328: 317 000106CE .data 1
329: 318 00000661 * L423:
330: 319 00000661 * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0"
331: 03D2000
332: 320 00000671 * .text
333: 321 000106CE dd 8f00000661 pushl $L423
334: 322 000106D4 fe 08 effffffd51 callf $8,_writes
335: 323 000106DB # write32h( post_evt_acc.m );
336: 324 000106DB dd effffffd4b pushl _post_evt_acc
337: 325 000106E1 fe 08 effffffd44 callf $8,_write32h
338: 326 000106E8 # writes(", expected = ");
339: 327 000106E8 .data 1
340: 328 00000671 * L424:
341: 329 00000671 * 2C20657870656374656420202 .ascii ", expected = \0"
342: 03D2000
343: 330 00000681 * .text
344: 331 000106E8 dd 8f00000671 pushl $L424
345: 332 000106EE fe 08 effffffd37 callf $8,_writes
346: 333 000106F5 # write32h( dbl_expected.m );
347: 334 000106F5 dd effffffd31 pushl _dbl_expected
348: 335 000106FB fe 08 effffffd2a callf $8,_write32h
349: 336 00010702 # writes("\nop3 = ");
350: 337 00010702 .data 1
351: 338 00000681 * L425:
352: 339 00000681 * 0A6F7033203D2000 .ascii "\12op3 = \0"
353: 340 00000689 * .text
354: 341 00010702 dd 8f00000681 pushl $L425
355: 342 00010708 fe 08 effffffd1d callf $8,_writes
356: 343 0001070F # write32h( sgl_value_1 );
357: 344 0001070F dd effffffd17 pushl _sgl_value_1
358: 345 00010715 fe 08 effffffd10 callf $8,_write32h
359: 346 0001071C # writes(", op4 = ");
360: 347 0001071C .data 1
361: 348 00000689 * L426:
362: 349 00000689 * 2C206F7034203D2000 .ascii ", op4 = \0"
363: 350 00000692 * .text
364: 351 0001071C dd 8f00000689 pushl $L426
365: 352 00010722 fe 08 effffffd03 callf $8,_writes
366: 353 00010729 # write32h( sgl_value_2 );
367: 354 00010729 dd effffffcfd pushl _sgl_value_2
368: 355 0001072F fe 08 effffffcf6 callf $8,_write32h
369: 356 00010736 # writes(", addr of op5 = ");
370: 357 00010736 .data 1
371: 358 00000692 * L427:
372: 359 00000692 * 2C20202061646472206F66206 .ascii ", addr of op5 = \0"
373: F7035203D2000
374: 360 000006a5 * .text
375: 361 00010736 dd 8f00000692 pushl $L427
376: 362 0001073C fe 08 effffffce9 callf $8,_writes
377: 363 00010743 # write32h( ( (int)&sgl_value_3 )+1 );
378: 364 00010743 dd 8f00000001 pushl $_sgl_value_3+1
379: 365 00010749 fe 08 effffffcdc callf $8,_write32h
380: 366 00010750 # writec('\n');
381: 367 00010750 dd 0a pushl $10
382: 368 00010752 fe 08 effffffcd3 callf $8,_writec
383: 369 00010759 # }
384: 370 00010759 # if ( halt_flg ) /* halt on error? */
385: 371 00010759 L418:
386: 372 00010759 5d effffffccd tstl _halt_flg
387: 373 0001075F 31 09 jeql L428
388: 374 00010761 # pipe4_halt( 2 );
389: 375 00010761 dd 02 pushl $2
390: 376 00010763 fe 08 ef000001e0 callf $8,_pipe4_halt
391: 377 0001076A # if ( loop_on_err )
392: 378 0001076A L428:
393: 379 0001076A 5d effffffcbc tstl _loop_on_err
394: 380 00010770 31 0d jeql L429
395: 381 00010772 # {
396: 382 00010772 # force_loop = TRUE; /* set the force loop flag */
397: 383 00010772 0d 01 effffffcb3 movl $1,_force_loop
398: 384 00010779 # asm("jmp _pipe4_lp1"); /* and loop */
399: 385 00010779 71 effffffd63 jmp _pipe4_lp1
400: 386 0001077F # };
401: 387 0001077F L429:
402: 388 0001077F # }
403: 389 0001077F 40 ret#2
404: 390 00010780 .set L414,0x0
405: 391 00010780 L416:
406: 392 00010780 13 feec jbr L417
407: 393 00010783 .data
408: 394 000005c4 * .text
409: 395 00010783 00 .align 1
410: 396 00010784 .globl _pipe4_queue_er
411: 397 00010784 _pipe4_queue_er:
412: 398 00010784 0000 .word L430
413: 399 00010786 #
414: 400 00010786 #
415: 401 00010786 #
416: 402 00010786 #
417: 403 00010786 #
418: 404 00010786 # /****************************************************************************
419: 405 00010786 # * Report an "FPP Queue apparently not cleared" error
420: 406 00010786 # *
421: 407 00010786 # * Cycle: xx. EVT test xx. subtest xx. Fpp Queue not cleared. index = xx
422: 408 00010786 # * inst = LDF op1, MULF op2, MULL3 op3,op4,op5, NEGF (alignment fault on MULL3)
423: 409 00010786 # * The NEGF should not have been executed but apparently was.
424: 410 00010786 # * op1 = xxxxxxxx, op2 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx
425: 411 00010786 # * op3 = xxxxxxxx, op4 = xxxxxxxx, addr op5 = xxxxxxxx
426: 412 00010786 # ****************************************************************************/
427: 413 00010786 # pipe4_queue_er()
428: 414 00010786 # {
429: 415 00010786 13 0111 jbr L432
430: 416 00010789 L433:
431: 417 00010789 # errcnt++; /* bump the error count */
432: 418 00010789 6d effffffc9d incl _errcnt
433: 419 0001078F # if ( prt_error )
434: 420 0001078F 5d effffffc97 tstl _prt_error
435: 421 00010795 21 03 13 00d9 jeql L434
436: 422 0001079A # {
437: 423 0001079A # print_pipe4_er(". Fpp Queue not cleared.");
438: 424 0001079A .data 1
439: 425 000006a5 * L435:
440: 426 000006a5 * 2E20467070205175657565206 .ascii ". Fpp Queue not cleared.\0"
441: E6F7420636C65617265642E00
442: 427 000006be * .text
443: 428 0001079A dd 8f000006a5 pushl $L435
444: 429 000107A0 fe 08 ef000000f7 callf $8,_print_pipe4_er
445: 430 000107A7 # writes(
446: 431 000107A7 # "The NEGF should not have been executed but apparently was.\n");
447: 432 000107A7 .data 1
448: 433 000006be * L436:
449: 434 000006be * 546865204E4547462073686F7 .ascii "The NEGF should not have been executed but apparently was.\12\0"
450: 56C64206E6F74206861766520
451: 6265656E20657865637574656
452: 420627574206170706172656E
453: 746C79207761732E0A00
454: 435 000006fa * .text
455: 436 000107A7 dd 8f000006be pushl $L436
456: 437 000107AD fe 08 effffffc78 callf $8,_writes
457: 438 000107B4 # writes("op1 = ");
458: 439 000107B4 .data 1
459: 440 000006fa * L437:
460: 441 000006fa * 6F7031203D2000 .ascii "op1 = \0"
461: 442 00000701 * .text
462: 443 000107B4 dd 8f000006fa pushl $L437
463: 444 000107BA fe 08 effffffc6b callf $8,_writes
464: 445 000107C1 # write32h( dbl_value_1.m );
465: 446 000107C1 dd effffffc65 pushl _dbl_value_1
466: 447 000107C7 fe 08 effffffc5e callf $8,_write32h
467: 448 000107CE # writes(", op2 = ");
468: 449 000107CE .data 1
469: 450 00000701 * L438:
470: 451 00000701 * 2C206F7032203D2000 .ascii ", op2 = \0"
471: 452 0000070a * .text
472: 453 000107CE dd 8f00000701 pushl $L438
473: 454 000107D4 fe 08 effffffc51 callf $8,_writes
474: 455 000107DB # write32h( dbl_value_2.m );
475: 456 000107DB dd effffffc4b pushl _dbl_value_2
476: 457 000107E1 fe 08 effffffc44 callf $8,_write32h
477: 458 000107E8 # writes(", final Acc. = ");
478: 459 000107E8 .data 1
479: 460 0000070a * L439:
480: 461 0000070a * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0"
481: 03D2000
482: 462 0000071a * .text
483: 463 000107E8 dd 8f0000070a pushl $L439
484: 464 000107EE fe 08 effffffc37 callf $8,_writes
485: 465 000107F5 # write32h( post_evt_acc.m );
486: 466 000107F5 dd effffffc31 pushl _post_evt_acc
487: 467 000107FB fe 08 effffffc2a callf $8,_write32h
488: 468 00010802 # writes(", expected = ");
489: 469 00010802 .data 1
490: 470 0000071a * L440:
491: 471 0000071a * 2C20657870656374656420202 .ascii ", expected = \0"
492: 03D2000
493: 472 0000072a * .text
494: 473 00010802 dd 8f0000071a pushl $L440
495: 474 00010808 fe 08 effffffc1d callf $8,_writes
496: 475 0001080F # write32h( dbl_expected.m );
497: 476 0001080F dd effffffc17 pushl _dbl_expected
498: 477 00010815 fe 08 effffffc10 callf $8,_write32h
499: 478 0001081C # writes("\nop3 = ");
500: 479 0001081C .data 1
501: 480 0000072a * L441:
502: 481 0000072a * 0A6F7033203D2000 .ascii "\12op3 = \0"
503: 482 00000732 * .text
504: 483 0001081C dd 8f0000072a pushl $L441
505: 484 00010822 fe 08 effffffc03 callf $8,_writes
506: 485 00010829 # write32h( sgl_value_1 );
507: 486 00010829 dd effffffbfd pushl _sgl_value_1
508: 487 0001082F fe 08 effffffbf6 callf $8,_write32h
509: 488 00010836 # writes(", op4 = ");
510: 489 00010836 .data 1
511: 490 00000732 * L442:
512: 491 00000732 * 2C206F7034203D2000 .ascii ", op4 = \0"
513: 492 0000073b * .text
514: 493 00010836 dd 8f00000732 pushl $L442
515: 494 0001083C fe 08 effffffbe9 callf $8,_writes
516: 495 00010843 # write32h( sgl_value_2 );
517: 496 00010843 dd effffffbe3 pushl _sgl_value_2
518: 497 00010849 fe 08 effffffbdc callf $8,_write32h
519: 498 00010850 # writes(", addr of op5 = ");
520: 499 00010850 .data 1
521: 500 0000073b * L443:
522: 501 0000073b * 2C20202061646472206F66206 .ascii ", addr of op5 = \0"
523: F7035203D2000
524: 502 0000074e * .text
525: 503 00010850 dd 8f0000073b pushl $L443
526: 504 00010856 fe 08 effffffbcf callf $8,_writes
527: 505 0001085D # write32h( ( (int)&sgl_value_3 )+1 );
528: 506 0001085D dd 8f00000001 pushl $_sgl_value_3+1
529: 507 00010863 fe 08 effffffbc2 callf $8,_write32h
530: 508 0001086A # writec('\n');
531: 509 0001086A dd 0a pushl $10
532: 510 0001086C fe 08 effffffbb9 callf $8,_writec
533: 511 00010873 # }
534: 512 00010873 # if ( halt_flg ) /* halt on error? */
535: 513 00010873 L434:
536: 514 00010873 5d effffffbb3 tstl _halt_flg
537: 515 00010879 31 09 jeql L444
538: 516 0001087B # pipe4_halt( 3 );
539: 517 0001087B dd 03 pushl $3
540: 518 0001087D fe 08 ef000000c6 callf $8,_pipe4_halt
541: 519 00010884 # if ( loop_on_err )
542: 520 00010884 L444:
543: 521 00010884 5d effffffba2 tstl _loop_on_err
544: 522 0001088A 31 0d jeql L445
545: 523 0001088C # {
546: 524 0001088C # force_loop = TRUE; /* set the force loop flag */
547: 525 0001088C 0d 01 effffffb99 movl $1,_force_loop
548: 526 00010893 # asm("jmp _pipe4_lp1"); /* and loop */
549: 527 00010893 71 effffffc49 jmp _pipe4_lp1
550: 528 00010899 # };
551: 529 00010899 L445:
552: 530 00010899 # }
553: 531 00010899 40 ret#2
554: 532 0001089A .set L430,0x0
555: 533 0001089A L432:
556: 534 0001089A 13 feec jbr L433
557: 535 0001089D .data
558: 536 000005c4 * .text
559: 537 0001089D 00 .align 1
560: 538 0001089E .globl _print_pipe4_er
561: 539 0001089E _print_pipe4_er:
562: 540 0001089E 0000 .word L446
563: 541 000108A0 #
564: 542 000108A0 #
565: 543 000108A0 #
566: 544 000108A0 # /****************************************************************************
567: 545 000108A0 # * print an error message of the form:
568: 546 000108A0 # *
569: 547 000108A0 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
570: 548 000108A0 # * inst = LDF op1; MULF op2; MULL3 op3,op4,op5; NEGF; (alignment fault on MULL3)
571: 549 000108A0 # ****************************************************************************/
572: 550 000108A0 # print_pipe4_er( msg )
573: 551 000108A0 # char *msg; /* error message to print */
574: 552 000108A0 # {
575: 553 000108A0 13 00a3 jbr L448
576: 554 000108A3 L449:
577: 555 000108A3 # if( errcnt == 1 ) /* 1st error? */
578: 556 000108A3 1d effffffb83 01 cmpl _errcnt,$1
579: 557 000108AA 21 0d jneq L450
580: 558 000108AC # writes(" \n"); /* start a new print line */
581: 559 000108AC .data 1
582: 560 0000074e * L451:
583: 561 0000074e * 200A00 .ascii " \12\0"
584: 562 00000751 * .text
585: 563 000108AC dd 8f0000074e pushl $L451
586: 564 000108B2 fe 08 effffffb73 callf $8,_writes
587: 565 000108B9 # writes("Cycle: ");
588: 566 000108B9 L450:
589: 567 000108B9 .data 1
590: 568 00000751 * L452:
591: 569 00000751 * 4379636C653A2000 .ascii "Cycle: \0"
592: 570 00000759 * .text
593: 571 000108B9 dd 8f00000751 pushl $L452
594: 572 000108BF fe 08 effffffb66 callf $8,_writes
595: 573 000108C6 # writed( cycle );
596: 574 000108C6 dd effffffb60 pushl _cycle
597: 575 000108CC fe 08 effffffb59 callf $8,_writed
598: 576 000108D3 # writes(" EVT test ");
599: 577 000108D3 .data 1
600: 578 00000759 * L454:
601: 579 00000759 * 202045565420746573742000 .ascii " EVT test \0"
602: 580 00000765 * .text
603: 581 000108D3 dd 8f00000759 pushl $L454
604: 582 000108D9 fe 08 effffffb4c callf $8,_writes
605: 583 000108E0 # writed( test_no );
606: 584 000108E0 dd effffffb46 pushl _test_no
607: 585 000108E6 fe 08 effffffb3f callf $8,_writed
608: 586 000108ED # writes(". subtest ");
609: 587 000108ED .data 1
610: 588 00000765 * L455:
611: 589 00000765 * 2E20737562746573742000 .ascii ". subtest \0"
612: 590 00000770 * .text
613: 591 000108ED dd 8f00000765 pushl $L455
614: 592 000108F3 fe 08 effffffb32 callf $8,_writes
615: 593 000108FA # writed( subtest );
616: 594 000108FA dd effffffb2c pushl _subtest
617: 595 00010900 fe 08 effffffb25 callf $8,_writed
618: 596 00010907 # writes( msg ); /* print the error message */
619: 597 00010907 dd ad04 pushl 4(fp)
620: 598 0001090A fe 08 effffffb1b callf $8,_writes
621: 599 00010911 # writes(" index = ");
622: 600 00010911 .data 1
623: 601 00000770 * L456:
624: 602 00000770 * 20696E646578203D2000 .ascii " index = \0"
625: 603 0000077a * .text
626: 604 00010911 dd 8f00000770 pushl $L456
627: 605 00010917 fe 08 effffffb0e callf $8,_writes
628: 606 0001091E # writed( index );
629: 607 0001091E dd effffffb08 pushl _index
630: 608 00010924 fe 08 effffffb01 callf $8,_writed
631: 609 0001092B # writes("\ninst = LDF op1; MULF op2; MULL3 op3,op4,op5; NEGF");
632: 610 0001092B .data 1
633: 611 0000077a * L457:
634: 612 0000077a * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1; MULF op2; MULL3 op3,op4,op5; NEGF\0"
635: F70313B204D554C46206F7032
636: 3B204D554C4C33206F70332C6
637: F70342C6F70353B204E454746
638: 00
639: 613 000007ad * .text
640: 614 0001092B dd 8f0000077a pushl $L457
641: 615 00010931 fe 08 effffffaf4 callf $8,_writes
642: 616 00010938 # writes(" (alignment fault on MULL3)\n");
643: 617 00010938 .data 1
644: 618 000007ad * L458:
645: 619 000007ad * 2028616C69676E6D656E74206 .ascii " (alignment fault on MULL3)\12\0"
646: 661756C74206F6E204D554C4C
647: 33290A00
648: 620 000007ca * .text
649: 621 00010938 dd 8f000007ad pushl $L458
650: 622 0001093E fe 08 effffffae7 callf $8,_writes
651: 623 00010945 # }
652: 624 00010945 40 ret#2
653: 625 00010946 .set L446,0x0
654: 626 00010946 L448:
655: 627 00010946 13 ff5a jbr L449
656: 628 00010949 .data
657: 629 000005c4 * .text
658: 630 00010949 00 .align 1
659: 631 0001094A .globl _pipe4_halt
660: 632 0001094A _pipe4_halt:
661: 633 0001094A 0000 .word L459
662: 634 0001094C #
663: 635 0001094C #
664: 636 0001094C #
665: 637 0001094C # /****************************************************************************
666: 638 0001094C # * Halt on Error routine
667: 639 0001094C # ****************************************************************************/
668: 640 0001094C # pipe4_halt( code )
669: 641 0001094C # int code; /* error code to halt with */
670: 642 0001094C # {
671: 643 0001094C 13 009b jbr L461
672: 644 0001094F L462:
673: 645 0001094F # err_code = code;
674: 646 0001094F 0d ad04 effffffad5 movl 4(fp),_err_code
675: 647 00010957 # sgl_value_4 = dbl_ld_acc.m;
676: 648 00010957 0d effffffacf effffffaca movl _dbl_ld_acc,_sgl_value_4
677: 649 00010962 # sgl_value_5 = dbl_value_1.m;
678: 650 00010962 0d effffffac4 effffffabf movl _dbl_value_1,_sgl_value_5
679: 651 0001096D # asm("movl _test_no,r0"); /* r0 = test number */
680: 652 0001096D 0d effffffab9 50 movl _test_no,r0
681: 653 00010974 # asm("movl _subtest,r1"); /* r1 = subtest number */
682: 654 00010974 0d effffffab2 51 movl _subtest,r1
683: 655 0001097B # asm("movl _err_code,r2"); /* r2 = error code */
684: 656 0001097B 0d effffffaab 52 movl _err_code,r2
685: 657 00010982 # asm("movl _cycle,r3"); /* r3 = cycle count */
686: 658 00010982 0d effffffaa4 53 movl _cycle,r3
687: 659 00010989 # asm("movl _sgl_value_4,r4"); /* r4 = floating operand 1 */
688: 660 00010989 0d effffffa9d 54 movl _sgl_value_4,r4
689: 661 00010990 # asm("movl _sgl_value_5,r5"); /* r5 = floating operand 2 */
690: 662 00010990 0d effffffa96 55 movl _sgl_value_5,r5
691: 663 00010997 # asm("movl _sgl_value_1,r6"); /* r6 = integer operand 1 */
692: 664 00010997 0d effffffa8f 56 movl _sgl_value_1,r6
693: 665 0001099E # asm("movl _sgl_value_2,r7"); /* r7 = integer operand 2 */
694: 666 0001099E 0d effffffa88 57 movl _sgl_value_2,r7
695: 667 000109A5 # asm("moval _sgl_value_3,r8");
696: 668 000109A5 ed effffffa81 58 moval _sgl_value_3,r8
697: 669 000109AC # asm("incl r8"); /* r8 = addr causing event */
698: 670 000109AC 6d 58 incl r8
699: 671 000109AE # if( code == 1 )
700: 672 000109AE 1d ad04 01 cmpl 4(fp),$1
701: 673 000109B2 21 09 jneq L463
702: 674 000109B4 # asm("movl _index,r9"); /* r9 = data index */
703: 675 000109B4 0d effffffa72 59 movl _index,r9
704: 676 000109BB # else {
705: 677 000109BB 11 2b jbr L464
706: 678 000109BD L463:
707: 679 000109BD # sgl_value_6 = post_evt_acc.m;
708: 680 000109BD 0d effffffa69 effffffa64 movl _post_evt_acc,_sgl_value_6
709: 681 000109C8 # sgl_value_7 = dbl_expected.m;
710: 682 000109C8 0d effffffa5e effffffa59 movl _dbl_expected,_sgl_value_7
711: 683 000109D3 # asm("movl _sgl_value_6,r9"); /* r9 = final accumulator */
712: 684 000109D3 0d effffffa53 59 movl _sgl_value_6,r9
713: 685 000109DA # asm("movl _sgl_value_7,r10"); /* r10 = expected acc. */
714: 686 000109DA 0d effffffa4c 5a movl _sgl_value_7,r10
715: 687 000109E1 # asm("movl _index,r11"); /* r11 = data index */
716: 688 000109E1 0d effffffa45 5b movl _index,r11
717: 689 000109E8 # }
718: 690 000109E8 L464:
719: 691 000109E8 # asm("halt");; /* HALT ... */
720: 692 000109E8 00 halt
721: 693 000109E9 # }
722: 694 000109E9 40 ret#2
723: 695 000109EA .set L459,0x0
724: 696 000109EA L461:
725: 697 000109EA 13 ff62 jbr L462
726: 698 000109ED .data
727: 698 00020E19 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.