![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe5.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 pipe5.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 000005d4 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe5
6: 6 00000000 _pipe5:
7: 7 000109F0 0000 .word L381
8: 8 000109F2 #
9: 9 000109F2 # #include "evt_defs.h"
10: 10 000109F2 #
11: 11 000109F2 # /*
12: 12 000109F2 # *********************************************************************
13: 13 000109F2 # * FPP PIPELINED EVENTS TEST #5
14: 14 000109F2 # *
15: 15 000109F2 # * This test will execute the following code: "LDD MULD LDF"
16: 16 000109F2 # * with an reserved operand fault on the MULD. We will make sure that:
17: 17 000109F2 # * 1. The fault is detected,
18: 18 000109F2 # * 2. the negate instruction is not executed.
19: 19 000109F2 # *********************************************************************
20: 20 000109F2 # */
21: 21 000109F2 # pipe5()
22: 22 000109F2 # {
23: 23 000109F2 13 0129 jbr L383
24: 24 000109F5 L384:
25: 25 000109F5 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
26: 26 000109F5 ed 6d effffffff4 moval (r13),_pre_event_fp
27: 27 000109FC # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
28: 28 000109FC ed 6e efffffffed moval (r14),_pre_event_sp
29: 29 00010A03 # precision = DBL;
30: 30 00010A03 0d 02 efffffffe6 movl $2,_precision
31: 31 00010A0A # test_event = RESOP_CODE; /* reserved op fault expected */
32: 32 00010A0A 0d 2d efffffffdf movl $45,_test_event
33: 33 00010A11 # exp_event = FALSE; /* ... but not yet */
34: 34 00010A11 4d efffffffd9 clrl _exp_event
35: 35 00010A17 # asm("movab _pipe5_ret,_event_return"); /* post event addr */
36: 36 00010A17 e9 ef000000b6 efffffffce movab _pipe5_ret,_event_return
37: 37 00010A22 # for( index = 0; index < flt_resop_cnt; index++ )
38: 38 00010A22 4d efffffffc8 clrl _index
39: 39 00010A28 L387:
40: 40 00010A28 1d efffffffc2 efffffffbd cmpl _index,_flt_resop_cnt
41: 41 00010A33 91 03 13 00e5 jgeq L386
42: 42 00010A38 # {
43: 43 00010A38 # dbl_ld_acc = acc_data[ index ];
44: 44 00010A38 48 03 efffffffb1 50 shll $3,_index,r0
45: 45 00010A40 0c 8f00000000 50 addl2 $_acc_data,r0
46: 46 00010A47 0d a004 efffffffa5 movl 4(r0),_dbl_ld_acc+4
47: 47 00010A4F 0d 60 efffffff9a movl (r0),_dbl_ld_acc
48: 48 00010A56 # dbl_value_1 = flt_resops[ index ].op_1;
49: 49 00010A56 48 04 efffffff93 50 shll $4,_index,r0
50: 50 00010A5E 0c 8f00000000 50 addl2 $_flt_resops,r0
51: 51 00010A65 0d a004 efffffff87 movl 4(r0),_dbl_value_1+4
52: 52 00010A6D 0d 60 efffffff7c movl (r0),_dbl_value_1
53: 53 00010A74 # dbl_value_3.m = 0x12345678; /* get dummy load value */
54: 54 00010A74 0d 8f12345678 efffffff71 movl $305419896,_dbl_value_3
55: 55 00010A7F # dbl_value_3.l = 0xabcdef01; /* get dummy load value */
56: 56 00010A7F 0d 8fabcdef01 efffffff6a movl $-1412567295,_dbl_value_3+4
57: 57 00010A8A # asm(".globl _pipe5_lp1");
58: 58 00010A8A .globl _pipe5_lp1
59: 59 00010A8A # asm("_pipe5_lp1:");
60: 60 00010A8A _pipe5_lp1:
61: 61 00010A8A # asm("bispsw $0x60"); /* enable ovfl & undfl */
62: 62 00010A8A 8b 8860 bispsw $0x60
63: 63 00010A8D # asm("ldd _dbl_ld_acc"); /* load the Acc. */
64: 64 00010A8D 07 efffffff5d ldd _dbl_ld_acc
65: 65 00010A93 # exp_event = test_event; /* expect event soon */
66: 66 00010A93 0d efffffff57 efffffff52 movl _test_event,_exp_event
67: 67 00010A9E # asm("muld _dbl_value_1"); /* cause the event */
68: 68 00010A9E e7 efffffff4c muld _dbl_value_1
69: 69 00010AA4 # asm("ldd _dbl_value_3"); /* we shouldn't get here */
70: 70 00010AA4 07 efffffff46 ldd _dbl_value_3
71: 71 00010AAA # /*
72: 72 00010AAA # * If we got to here then there was no event
73: 73 00010AAA # */
74: 74 00010AAA # if( force_loop )
75: 75 00010AAA 5d efffffff40 tstl _force_loop
76: 76 00010AB0 31 03 jeql L388
77: 77 00010AB2 # asm("brw _pipe5_lp1");; /* loop on the error */
78: Assemb000281B0 # asm("brw _pipe5_lp1");; /* loop on the error */
79: "pipe5000281B0 78: WARNING: brw: destination label is external
80: 78 00010AB2 13 ffd5 brw _pipe5_lp1
81: 79 00010AB5 L388:
82: 80 00010AB5 # exp_event = FALSE; /* reset event expected flag */
83: 81 00010AB5 4d efffffff35 clrl _exp_event
84: 82 00010ABB # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
85: 83 00010ABB 0d efffffff2f 5d movl _pre_event_fp,fp
86: 84 00010AC2 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
87: 85 00010AC2 0d efffffff28 5e movl _pre_event_sp,sp
88: 86 00010AC9 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
89: 87 00010AC9 9b 8860 bicpsw $0x60
90: 88 00010ACC # no_pipe5_evt();; /* report the error */
91: 89 00010ACC fe 04 ef0000004f callf $4,_no_pipe5_evt
92: 90 00010AD3 # /*
93: 91 00010AD3 # * Come here after the event
94: 92 00010AD3 # */
95: 93 00010AD3 # asm(".globl _pipe5_ret");
96: 94 00010AD3 .globl _pipe5_ret
97: 95 00010AD3 # asm("_pipe5_ret:");
98: 96 00010AD3 _pipe5_ret:
99: 97 00010AD3 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
100: 98 00010AD3 0d efffffff17 5d movl _pre_event_fp,fp
101: 99 00010ADA # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
102: 100 00010ADA 0d efffffff10 5e movl _pre_event_sp,sp
103: 101 00010AE1 # if( force_loop )
104: 102 00010AE1 5d efffffff09 tstl _force_loop
105: 103 00010AE7 31 03 jeql L390
106: 104 00010AE9 # asm("brw _pipe5_lp1");; /* loop on the error */
107: "pipe5000281B0 105: WARNING: brw: destination label is external
108: 105 00010AE9 13 ff9e brw _pipe5_lp1
109: 106 00010AEC L390:
110: 107 00010AEC # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
111: 108 00010AEC 9b 8860 bicpsw $0x60
112: 109 00010AEF # if( post_evt_acc.m == dbl_value_3.m )
113: 110 00010AEF 1d effffffefb effffffef6 cmpl _post_evt_acc,_dbl_value_3
114: 111 00010AFA 21 09 jneq L391
115: 112 00010AFC # pipe5_queue(); /* fpp queue not cleared */
116: 113 00010AFC fe 04 ef00000225 callf $4,_pipe5_queue
117: 114 00010B03 # else if( post_evt_acc.m ) /* was the Acc. cleared? */
118: 115 00010B03 11 0f jbr L393
119: 116 00010B05 L391:
120: 117 00010B05 5d effffffee5 tstl _post_evt_acc
121: 118 00010B0B 31 07 jeql L394
122: 119 00010B0D # bad_pipe5_result(); /* incorrect result error */
123: 120 00010B0D fe 04 ef000000de callf $4,_bad_pipe5_result
124: 121 00010B14 # }
125: 122 00010B14 L394:
126: 123 00010B14 L393:
127: 124 00010B14 L385:
128: 125 00010B14 6d effffffed6 incl _index
129: 126 00010B1A 13 ff0b jbr L387
130: 127 00010B1D L386:
131: 128 00010B1D # }
132: 129 00010B1D 40 ret#2
133: 130 00010B1E .set L381,0x0
134: 131 00010B1E L383:
135: 132 00010B1E 13 fed4 jbr L384
136: 133 00010B21 .data
137: 134 000005d4 * .text
138: 135 00010B21 00 .align 1
139: 136 00010B22 .globl _no_pipe5_evt
140: 137 00010B22 _no_pipe5_evt:
141: 138 00010B22 0000 .word L396
142: 139 00010B24 #
143: 140 00010B24 #
144: 141 00010B24 #
145: 142 00010B24 # /****************************************************************************
146: 143 00010B24 # * Report an "EVENT NOT DETECTED" error
147: 144 00010B24 # *
148: 145 00010B24 # * Cycle: xx. EVT test xx. subtest xx. no reserved op fault. index = xx
149: 146 00010B24 # * inst = LDD op1, MULD op2, LDF op3 (reserved operand fault on MULL3)
150: 147 00010B24 # * op1 = xxxxxxxx xxxxxxxx, op2 = xxxxxxxx xxxxxxxx, op3 = xxxxxxxx
151: 148 00010B24 # ****************************************************************************/
152: 149 00010B24 # no_pipe5_evt()
153: 150 00010B24 # {
154: 151 00010B24 13 00c8 jbr L398
155: 152 00010B27 L399:
156: 153 00010B27 # errcnt++; /* bump the error count */
157: 154 00010B27 6d effffffec3 incl _errcnt
158: 155 00010B2D # if ( prt_error )
159: 156 00010B2D 5d effffffebd tstl _prt_error
160: 157 00010B33 21 03 13 0090 jeql L400
161: 158 00010B38 # {
162: 159 00010B38 # print_pipe5_er( ". no reserved op fault.");
163: 160 00010B38 .data 1
164: 161 000005d4 * L402:
165: 162 000005d4 * 2E206E6F20726573657276656 .ascii ". no reserved op fault.\0"
166: 4206F70206661756C742E00
167: 163 000005ec * .text
168: 164 00010B38 dd 8f000005d4 pushl $L402
169: 165 00010B3E fe 08 ef00000319 callf $8,_print_pipe5_er
170: 166 00010B45 # writes("op1 = ");
171: 167 00010B45 .data 1
172: 168 000005ec * L404:
173: 169 000005ec * 6F7031203D2000 .ascii "op1 = \0"
174: 170 000005f3 * .text
175: 171 00010B45 dd 8f000005ec pushl $L404
176: 172 00010B4B fe 08 effffffe9e callf $8,_writes
177: 173 00010B52 # write32h( dbl_ld_acc.m );
178: 174 00010B52 dd effffffe98 pushl _dbl_ld_acc
179: 175 00010B58 fe 08 effffffe91 callf $8,_write32h
180: 176 00010B5F # writec(' ');
181: 177 00010B5F dd 20 pushl $32
182: 178 00010B61 fe 08 effffffe88 callf $8,_writec
183: 179 00010B68 # write32h( dbl_ld_acc.l );
184: 180 00010B68 dd effffffe86 pushl _dbl_ld_acc+4
185: 181 00010B6E fe 08 effffffe7b callf $8,_write32h
186: 182 00010B75 # writes(", op2 = ");
187: 183 00010B75 .data 1
188: 184 000005f3 * L407:
189: 185 000005f3 * 2C20206F7032203D2000 .ascii ", op2 = \0"
190: 186 000005fd * .text
191: 187 00010B75 dd 8f000005f3 pushl $L407
192: 188 00010B7B fe 08 effffffe6e callf $8,_writes
193: 189 00010B82 # write32h( dbl_value_1.m );
194: 190 00010B82 dd effffffe68 pushl _dbl_value_1
195: 191 00010B88 fe 08 effffffe61 callf $8,_write32h
196: 192 00010B8F # writec(' ');
197: 193 00010B8F dd 20 pushl $32
198: 194 00010B91 fe 08 effffffe58 callf $8,_writec
199: 195 00010B98 # write32h( dbl_value_1.l );
200: 196 00010B98 dd effffffe56 pushl _dbl_value_1+4
201: 197 00010B9E fe 08 effffffe4b callf $8,_write32h
202: 198 00010BA5 # writes(", op3 = ");
203: 199 00010BA5 .data 1
204: 200 000005fd * L408:
205: 201 000005fd * 2C20206F7033203D2000 .ascii ", op3 = \0"
206: 202 00000607 * .text
207: 203 00010BA5 dd 8f000005fd pushl $L408
208: 204 00010BAB fe 08 effffffe3e callf $8,_writes
209: 205 00010BB2 # write32h( dbl_value_3.m );
210: 206 00010BB2 dd effffffe38 pushl _dbl_value_3
211: 207 00010BB8 fe 08 effffffe31 callf $8,_write32h
212: 208 00010BBF # writec('\n');
213: 209 00010BBF dd 0a pushl $10
214: 210 00010BC1 fe 08 effffffe28 callf $8,_writec
215: 211 00010BC8 # }
216: 212 00010BC8 # if ( halt_flg ) /* halt on error? */
217: 213 00010BC8 L400:
218: 214 00010BC8 5d effffffe22 tstl _halt_flg
219: 215 00010BCE 31 09 jeql L409
220: 216 00010BD0 # pipe5_halt( 1 );
221: 217 00010BD0 dd 01 pushl $1
222: 218 00010BD2 fe 08 ef00000331 callf $8,_pipe5_halt
223: 219 00010BD9 # if ( loop_on_err )
224: 220 00010BD9 L409:
225: 221 00010BD9 5d effffffe11 tstl _loop_on_err
226: 222 00010BDF 31 0d jeql L411
227: 223 00010BE1 # {
228: 224 00010BE1 # force_loop = TRUE; /* set the force loop flag */
229: 225 00010BE1 0d 01 effffffe08 movl $1,_force_loop
230: 226 00010BE8 # asm("jmp _pipe5_lp1"); /* and loop */
231: 227 00010BE8 71 effffffe9c jmp _pipe5_lp1
232: 228 00010BEE # };
233: 229 00010BEE L411:
234: 230 00010BEE # }
235: 231 00010BEE 40 ret#2
236: 232 00010BEF .set L396,0x0
237: 233 00010BEF L398:
238: 234 00010BEF 13 ff35 jbr L399
239: 235 00010BF2 .data
240: 236 000005d4 * .text
241: 237 00010BF2 .align 1
242: 238 00010BF2 .globl _bad_pipe5_result
243: 239 00010BF2 _bad_pipe5_result:
244: 240 00010BF2 0000 .word L412
245: 241 00010BF4 #
246: 242 00010BF4 #
247: 243 00010BF4 #
248: 244 00010BF4 #
249: 245 00010BF4 # /****************************************************************************
250: 246 00010BF4 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
251: 247 00010BF4 # *
252: 248 00010BF4 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
253: 249 00010BF4 # * inst = LDD op1, MULD op2, LDF op3 (reserved operand fault on MULL3)
254: 250 00010BF4 # * The LDF should not have been executed.
255: 251 00010BF4 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
256: 252 00010BF4 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
257: 253 00010BF4 # * op3 = xxxxxxxx
258: 254 00010BF4 # ****************************************************************************/
259: 255 00010BF4 # bad_pipe5_result()
260: 256 00010BF4 # {
261: 257 00010BF4 13 012d jbr L414
262: 258 00010BF7 L415:
263: 259 00010BF7 # errcnt++; /* bump the error count */
264: 260 00010BF7 6d effffffdf3 incl _errcnt
265: 261 00010BFD # if ( prt_error )
266: 262 00010BFD 5d effffffded tstl _prt_error
267: 263 00010C03 21 03 13 00f5 jeql L416
268: 264 00010C08 # {
269: 265 00010C08 # print_pipe5_er(". Bad final Accumulator.");
270: 266 00010C08 .data 1
271: 267 00000607 * L417:
272: 268 00000607 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator.\0"
273: 16363756D756C61746F722E00
274: 269 00000620 * .text
275: 270 00010C08 dd 8f00000607 pushl $L417
276: 271 00010C0E fe 08 ef00000249 callf $8,_print_pipe5_er
277: 272 00010C15 # writes("The LDF should not have been executed.\n");
278: 273 00010C15 .data 1
279: 274 00000620 * L418:
280: 275 00000620 * 546865204C44462073686F756 .ascii "The LDF should not have been executed.\12\0"
281: C64206E6F7420686176652062
282: 65656E2065786563757465642
283: E0A00
284: 276 00000648 * .text
285: 277 00010C15 dd 8f00000620 pushl $L418
286: 278 00010C1B fe 08 effffffdce callf $8,_writes
287: 279 00010C22 # writes("op1 = ");
288: 280 00010C22 .data 1
289: 281 00000648 * L419:
290: 282 00000648 * 6F7031203D2000 .ascii "op1 = \0"
291: 283 0000064f * .text
292: 284 00010C22 dd 8f00000648 pushl $L419
293: 285 00010C28 fe 08 effffffdc1 callf $8,_writes
294: 286 00010C2F # write32h( dbl_value_1.m );
295: 287 00010C2F dd effffffdbb pushl _dbl_value_1
296: 288 00010C35 fe 08 effffffdb4 callf $8,_write32h
297: 289 00010C3C # writec(' ');
298: 290 00010C3C dd 20 pushl $32
299: 291 00010C3E fe 08 effffffdab callf $8,_writec
300: 292 00010C45 # write32h( dbl_value_1.l );
301: 293 00010C45 dd effffffda9 pushl _dbl_value_1+4
302: 294 00010C4B fe 08 effffffd9e callf $8,_write32h
303: 295 00010C52 # writes(", final Acc. = ");
304: 296 00010C52 .data 1
305: 297 0000064f * L420:
306: 298 0000064f * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
307: E203D2000
308: 299 00000660 * .text
309: 300 00010C52 dd 8f0000064f pushl $L420
310: 301 00010C58 fe 08 effffffd91 callf $8,_writes
311: 302 00010C5F # write32h( post_evt_acc.m );
312: 303 00010C5F dd effffffd8b pushl _post_evt_acc
313: 304 00010C65 fe 08 effffffd84 callf $8,_write32h
314: 305 00010C6C # writec(' ');
315: 306 00010C6C dd 20 pushl $32
316: 307 00010C6E fe 08 effffffd7b callf $8,_writec
317: 308 00010C75 # write32h( post_evt_acc.l );
318: 309 00010C75 dd effffffd79 pushl _post_evt_acc+4
319: 310 00010C7B fe 08 effffffd6e callf $8,_write32h
320: 311 00010C82 # writes("\nop2 = ");
321: 312 00010C82 .data 1
322: 313 00000660 * L421:
323: 314 00000660 * 0A6F7032203D2000 .ascii "\12op2 = \0"
324: 315 00000668 * .text
325: 316 00010C82 dd 8f00000660 pushl $L421
326: 317 00010C88 fe 08 effffffd61 callf $8,_writes
327: 318 00010C8F # write32h( dbl_value_2.m );
328: 319 00010C8F dd effffffd5b pushl _dbl_value_2
329: 320 00010C95 fe 08 effffffd54 callf $8,_write32h
330: 321 00010C9C # writec(' ');
331: 322 00010C9C dd 20 pushl $32
332: 323 00010C9E fe 08 effffffd4b callf $8,_writec
333: 324 00010CA5 # write32h( dbl_value_2.l );
334: 325 00010CA5 dd effffffd49 pushl _dbl_value_2+4
335: 326 00010CAB fe 08 effffffd3e callf $8,_write32h
336: 327 00010CB2 # writes(", expected = ");
337: 328 00010CB2 .data 1
338: 329 00000668 * L422:
339: 330 00000668 * 2C20202020657870656374656 .ascii ", expected = \0"
340: 4203D2000
341: 331 00000679 * .text
342: 332 00010CB2 dd 8f00000668 pushl $L422
343: 333 00010CB8 fe 08 effffffd31 callf $8,_writes
344: 334 00010CBF # write32h( 0 );
345: 335 00010CBF dd 00 pushl $0
346: 336 00010CC1 fe 08 effffffd28 callf $8,_write32h
347: 337 00010CC8 # writec(' ');
348: 338 00010CC8 dd 20 pushl $32
349: 339 00010CCA fe 08 effffffd1f callf $8,_writec
350: 340 00010CD1 # write32h( 0 );
351: 341 00010CD1 dd 00 pushl $0
352: 342 00010CD3 fe 08 effffffd16 callf $8,_write32h
353: 343 00010CDA # writes("\nop_3 = ");
354: 344 00010CDA .data 1
355: 345 00000679 * L423:
356: 346 00000679 * 0A6F705F33203D2000 .ascii "\12op_3 = \0"
357: 347 00000682 * .text
358: 348 00010CDA dd 8f00000679 pushl $L423
359: 349 00010CE0 fe 08 effffffd09 callf $8,_writes
360: 350 00010CE7 # write32h( dbl_value_3.m );
361: 351 00010CE7 dd effffffd03 pushl _dbl_value_3
362: 352 00010CED fe 08 effffffcfc callf $8,_write32h
363: 353 00010CF4 # writec('\n');
364: 354 00010CF4 dd 0a pushl $10
365: 355 00010CF6 fe 08 effffffcf3 callf $8,_writec
366: 356 00010CFD # }
367: 357 00010CFD # if ( halt_flg ) /* halt on error? */
368: 358 00010CFD L416:
369: 359 00010CFD 5d effffffced tstl _halt_flg
370: 360 00010D03 31 09 jeql L424
371: 361 00010D05 # pipe5_halt( 2 );
372: 362 00010D05 dd 02 pushl $2
373: 363 00010D07 fe 08 ef000001fc callf $8,_pipe5_halt
374: 364 00010D0E # if ( loop_on_err )
375: 365 00010D0E L424:
376: 366 00010D0E 5d effffffcdc tstl _loop_on_err
377: 367 00010D14 31 0d jeql L425
378: 368 00010D16 # {
379: 369 00010D16 # force_loop = TRUE; /* set the force loop flag */
380: 370 00010D16 0d 01 effffffcd3 movl $1,_force_loop
381: 371 00010D1D # asm("jmp _pipe5_lp1"); /* and loop */
382: 372 00010D1D 71 effffffd67 jmp _pipe5_lp1
383: 373 00010D23 # };
384: 374 00010D23 L425:
385: 375 00010D23 # }
386: 376 00010D23 40 ret#2
387: 377 00010D24 .set L412,0x0
388: 378 00010D24 L414:
389: 379 00010D24 13 fed0 jbr L415
390: 380 00010D27 .data
391: 381 000005d4 * .text
392: 382 00010D27 00 .align 1
393: 383 00010D28 .globl _pipe5_queue
394: 384 00010D28 _pipe5_queue:
395: 385 00010D28 0000 .word L426
396: 386 00010D2A #
397: 387 00010D2A #
398: 388 00010D2A #
399: 389 00010D2A #
400: 390 00010D2A #
401: 391 00010D2A # /****************************************************************************
402: 392 00010D2A # * Report an "FPP Queue apparently not cleared" error
403: 393 00010D2A # *
404: 394 00010D2A # * Cycle: xx. EVT test xx. subtest xx. Fpp Queue not cleared. index = xx
405: 395 00010D2A # * inst = LDD op1, MULD op2, LDF op3 (reserved operand fault on MULD)
406: 396 00010D2A # * The LDF should not have been executed but apparently was.
407: 397 00010D2A # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
408: 398 00010D2A # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
409: 399 00010D2A # * op3 = xxxxxxxx
410: 400 00010D2A # ****************************************************************************/
411: 401 00010D2A # pipe5_queue()
412: 402 00010D2A # {
413: 403 00010D2A 13 012d jbr L428
414: 404 00010D2D L429:
415: 405 00010D2D # errcnt++; /* bump the error count */
416: 406 00010D2D 6d effffffcbd incl _errcnt
417: 407 00010D33 # if ( prt_error )
418: 408 00010D33 5d effffffcb7 tstl _prt_error
419: 409 00010D39 21 03 13 00f5 jeql L430
420: 410 00010D3E # {
421: 411 00010D3E # print_pipe5_er(". Fpp Queue not cleared.");
422: 412 00010D3E .data 1
423: 413 00000682 * L431:
424: 414 00000682 * 2E20467070205175657565206 .ascii ". Fpp Queue not cleared.\0"
425: E6F7420636C65617265642E00
426: 415 0000069b * .text
427: 416 00010D3E dd 8f00000682 pushl $L431
428: 417 00010D44 fe 08 ef00000113 callf $8,_print_pipe5_er
429: 418 00010D4B # writes(
430: 419 00010D4B # "The NEGF should not have been executed but apparently was.\n");
431: 420 00010D4B .data 1
432: 421 0000069b * L432:
433: 422 0000069b * 546865204E4547462073686F7 .ascii "The NEGF should not have been executed but apparently was.\12\0"
434: 56C64206E6F74206861766520
435: 6265656E20657865637574656
436: 420627574206170706172656E
437: 746C79207761732E0A00
438: 423 000006d7 * .text
439: 424 00010D4B dd 8f0000069b pushl $L432
440: 425 00010D51 fe 08 effffffc98 callf $8,_writes
441: 426 00010D58 # writes("op1 = ");
442: 427 00010D58 .data 1
443: 428 000006d7 * L433:
444: 429 000006d7 * 6F7031203D2000 .ascii "op1 = \0"
445: 430 000006de * .text
446: 431 00010D58 dd 8f000006d7 pushl $L433
447: 432 00010D5E fe 08 effffffc8b callf $8,_writes
448: 433 00010D65 # write32h( dbl_value_1.m );
449: 434 00010D65 dd effffffc85 pushl _dbl_value_1
450: 435 00010D6B fe 08 effffffc7e callf $8,_write32h
451: 436 00010D72 # writec(' ');
452: 437 00010D72 dd 20 pushl $32
453: 438 00010D74 fe 08 effffffc75 callf $8,_writec
454: 439 00010D7B # write32h( dbl_value_1.l );
455: 440 00010D7B dd effffffc73 pushl _dbl_value_1+4
456: 441 00010D81 fe 08 effffffc68 callf $8,_write32h
457: 442 00010D88 # writes(", final Acc. = ");
458: 443 00010D88 .data 1
459: 444 000006de * L434:
460: 445 000006de * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
461: E203D2000
462: 446 000006ef * .text
463: 447 00010D88 dd 8f000006de pushl $L434
464: 448 00010D8E fe 08 effffffc5b callf $8,_writes
465: 449 00010D95 # write32h( post_evt_acc.m );
466: 450 00010D95 dd effffffc55 pushl _post_evt_acc
467: 451 00010D9B fe 08 effffffc4e callf $8,_write32h
468: 452 00010DA2 # writec(' ');
469: 453 00010DA2 dd 20 pushl $32
470: 454 00010DA4 fe 08 effffffc45 callf $8,_writec
471: 455 00010DAB # write32h( post_evt_acc.l );
472: 456 00010DAB dd effffffc43 pushl _post_evt_acc+4
473: 457 00010DB1 fe 08 effffffc38 callf $8,_write32h
474: 458 00010DB8 # writes("\nop2 = ");
475: 459 00010DB8 .data 1
476: 460 000006ef * L435:
477: 461 000006ef * 0A6F7032203D2000 .ascii "\12op2 = \0"
478: 462 000006f7 * .text
479: 463 00010DB8 dd 8f000006ef pushl $L435
480: 464 00010DBE fe 08 effffffc2b callf $8,_writes
481: 465 00010DC5 # write32h( dbl_value_2.m );
482: 466 00010DC5 dd effffffc25 pushl _dbl_value_2
483: 467 00010DCB fe 08 effffffc1e callf $8,_write32h
484: 468 00010DD2 # writec(' ');
485: 469 00010DD2 dd 20 pushl $32
486: 470 00010DD4 fe 08 effffffc15 callf $8,_writec
487: 471 00010DDB # write32h( dbl_value_2.l );
488: 472 00010DDB dd effffffc13 pushl _dbl_value_2+4
489: 473 00010DE1 fe 08 effffffc08 callf $8,_write32h
490: 474 00010DE8 # writes(", expected = ");
491: 475 00010DE8 .data 1
492: 476 000006f7 * L436:
493: 477 000006f7 * 2C20202020657870656374656 .ascii ", expected = \0"
494: 4203D2000
495: 478 00000708 * .text
496: 479 00010DE8 dd 8f000006f7 pushl $L436
497: 480 00010DEE fe 08 effffffbfb callf $8,_writes
498: 481 00010DF5 # write32h( 0 );
499: 482 00010DF5 dd 00 pushl $0
500: 483 00010DF7 fe 08 effffffbf2 callf $8,_write32h
501: 484 00010DFE # writec(' ');
502: 485 00010DFE dd 20 pushl $32
503: 486 00010E00 fe 08 effffffbe9 callf $8,_writec
504: 487 00010E07 # write32h( 0 );
505: 488 00010E07 dd 00 pushl $0
506: 489 00010E09 fe 08 effffffbe0 callf $8,_write32h
507: 490 00010E10 # writes("\nop_3 = ");
508: 491 00010E10 .data 1
509: 492 00000708 * L437:
510: 493 00000708 * 0A6F705F33203D2000 .ascii "\12op_3 = \0"
511: 494 00000711 * .text
512: 495 00010E10 dd 8f00000708 pushl $L437
513: 496 00010E16 fe 08 effffffbd3 callf $8,_writes
514: 497 00010E1D # write32h( dbl_value_3.m );
515: 498 00010E1D dd effffffbcd pushl _dbl_value_3
516: 499 00010E23 fe 08 effffffbc6 callf $8,_write32h
517: 500 00010E2A # writec('\n');
518: 501 00010E2A dd 0a pushl $10
519: 502 00010E2C fe 08 effffffbbd callf $8,_writec
520: 503 00010E33 # }
521: 504 00010E33 # if ( halt_flg ) /* halt on error? */
522: 505 00010E33 L430:
523: 506 00010E33 5d effffffbb7 tstl _halt_flg
524: 507 00010E39 31 09 jeql L438
525: 508 00010E3B # pipe5_halt( 3 );
526: 509 00010E3B dd 03 pushl $3
527: 510 00010E3D fe 08 ef000000c6 callf $8,_pipe5_halt
528: 511 00010E44 # if ( loop_on_err )
529: 512 00010E44 L438:
530: 513 00010E44 5d effffffba6 tstl _loop_on_err
531: 514 00010E4A 31 0d jeql L439
532: 515 00010E4C # {
533: 516 00010E4C # force_loop = TRUE; /* set the force loop flag */
534: 517 00010E4C 0d 01 effffffb9d movl $1,_force_loop
535: 518 00010E53 # asm("jmp _pipe5_lp1"); /* and loop */
536: 519 00010E53 71 effffffc31 jmp _pipe5_lp1
537: 520 00010E59 # };
538: 521 00010E59 L439:
539: 522 00010E59 # }
540: 523 00010E59 40 ret#2
541: 524 00010E5A .set L426,0x0
542: 525 00010E5A L428:
543: 526 00010E5A 13 fed0 jbr L429
544: 527 00010E5D .data
545: 528 000005d4 * .text
546: 529 00010E5D 00 .align 1
547: 530 00010E5E .globl _print_pipe5_er
548: 531 00010E5E _print_pipe5_er:
549: 532 00010E5E 0000 .word L440
550: 533 00010E60 #
551: 534 00010E60 #
552: 535 00010E60 #
553: 536 00010E60 # /****************************************************************************
554: 537 00010E60 # * print an error message of the form:
555: 538 00010E60 # *
556: 539 00010E60 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
557: 540 00010E60 # * inst = LDD op1, MULD op2, LDF op3 (reserved operand fault on MULD)
558: 541 00010E60 # ****************************************************************************/
559: 542 00010E60 # print_pipe5_er( msg )
560: 543 00010E60 # char *msg; /* error message to print */
561: 544 00010E60 # {
562: 545 00010E60 13 00a3 jbr L442
563: 546 00010E63 L443:
564: 547 00010E63 # if( errcnt == 1 ) /* 1st error? */
565: 548 00010E63 1d effffffb87 01 cmpl _errcnt,$1
566: 549 00010E6A 21 0d jneq L444
567: 550 00010E6C # writes(" \n"); /* start a new print line */
568: 551 00010E6C .data 1
569: 552 00000711 * L445:
570: 553 00000711 * 200A00 .ascii " \12\0"
571: 554 00000714 * .text
572: 555 00010E6C dd 8f00000711 pushl $L445
573: 556 00010E72 fe 08 effffffb77 callf $8,_writes
574: 557 00010E79 # writes("Cycle: ");
575: 558 00010E79 L444:
576: 559 00010E79 .data 1
577: 560 00000714 * L446:
578: 561 00000714 * 4379636C653A2000 .ascii "Cycle: \0"
579: 562 0000071c * .text
580: 563 00010E79 dd 8f00000714 pushl $L446
581: 564 00010E7F fe 08 effffffb6a callf $8,_writes
582: 565 00010E86 # writed( cycle );
583: 566 00010E86 dd effffffb64 pushl _cycle
584: 567 00010E8C fe 08 effffffb5d callf $8,_writed
585: 568 00010E93 # writes(" EVT test ");
586: 569 00010E93 .data 1
587: 570 0000071c * L448:
588: 571 0000071c * 202045565420746573742000 .ascii " EVT test \0"
589: 572 00000728 * .text
590: 573 00010E93 dd 8f0000071c pushl $L448
591: 574 00010E99 fe 08 effffffb50 callf $8,_writes
592: 575 00010EA0 # writed( test_no );
593: 576 00010EA0 dd effffffb4a pushl _test_no
594: 577 00010EA6 fe 08 effffffb43 callf $8,_writed
595: 578 00010EAD # writes(". subtest ");
596: 579 00010EAD .data 1
597: 580 00000728 * L449:
598: 581 00000728 * 2E20737562746573742000 .ascii ". subtest \0"
599: 582 00000733 * .text
600: 583 00010EAD dd 8f00000728 pushl $L449
601: 584 00010EB3 fe 08 effffffb36 callf $8,_writes
602: 585 00010EBA # writed( subtest );
603: 586 00010EBA dd effffffb30 pushl _subtest
604: 587 00010EC0 fe 08 effffffb29 callf $8,_writed
605: 588 00010EC7 # writes( msg ); /* print the error message */
606: 589 00010EC7 dd ad04 pushl 4(fp)
607: 590 00010ECA fe 08 effffffb1f callf $8,_writes
608: 591 00010ED1 # writes(" index = ");
609: 592 00010ED1 .data 1
610: 593 00000733 * L450:
611: 594 00000733 * 20696E646578203D2000 .ascii " index = \0"
612: 595 0000073d * .text
613: 596 00010ED1 dd 8f00000733 pushl $L450
614: 597 00010ED7 fe 08 effffffb12 callf $8,_writes
615: 598 00010EDE # writed( index );
616: 599 00010EDE dd effffffb0c pushl _index
617: 600 00010EE4 fe 08 effffffb05 callf $8,_writed
618: 601 00010EEB # writes("\ninst = LDD op1; MULD op2; LDFop3");
619: 602 00010EEB .data 1
620: 603 0000073d * L451:
621: 604 0000073d * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1; MULD op2; LDFop3\0"
622: F70313B204D554C44206F7032
623: 3B204C44466F703300
624: 605 0000075f * .text
625: 606 00010EEB dd 8f0000073d pushl $L451
626: 607 00010EF1 fe 08 effffffaf8 callf $8,_writes
627: 608 00010EF8 # writes(" (reserved operand fault on MULL3)\n");
628: 609 00010EF8 .data 1
629: 610 0000075f * L452:
630: 611 0000075f * 20287265736572766564206F7 .ascii " (reserved operand fault on MULL3)\12\0"
631: 06572616E64206661756C7420
632: 6F6E204D554C4C33290A00
633: 612 00000783 * .text
634: 613 00010EF8 dd 8f0000075f pushl $L452
635: 614 00010EFE fe 08 effffffaeb callf $8,_writes
636: 615 00010F05 # }
637: 616 00010F05 40 ret#2
638: 617 00010F06 .set L440,0x0
639: 618 00010F06 L442:
640: 619 00010F06 13 ff5a jbr L443
641: 620 00010F09 .data
642: 621 000005d4 * .text
643: 622 00010F09 00 .align 1
644: 623 00010F0A .globl _pipe5_halt
645: 624 00010F0A _pipe5_halt:
646: 625 00010F0A 0000 .word L453
647: 626 00010F0C #
648: 627 00010F0C #
649: 628 00010F0C #
650: 629 00010F0C # /****************************************************************************
651: 630 00010F0C # * Halt on Error routine
652: 631 00010F0C # ****************************************************************************/
653: 632 00010F0C # pipe5_halt( code )
654: 633 00010F0C # int code; /* error code to halt with */
655: 634 00010F0C # {
656: 635 00010F0C 13 00af jbr L455
657: 636 00010F0F L456:
658: 637 00010F0F # err_code = code;
659: 638 00010F0F 0d ad04 effffffad9 movl 4(fp),_err_code
660: 639 00010F17 # sgl_value_4 = dbl_ld_acc.m;
661: 640 00010F17 0d effffffad3 efffffface movl _dbl_ld_acc,_sgl_value_4
662: 641 00010F22 # sgl_value_5 = dbl_ld_acc.l;
663: 642 00010F22 0d effffffacc effffffac3 movl _dbl_ld_acc+4,_sgl_value_5
664: 643 00010F2D # sgl_value_6 = dbl_value_1.m;
665: 644 00010F2D 0d effffffabd effffffab8 movl _dbl_value_1,_sgl_value_6
666: 645 00010F38 # sgl_value_7 = dbl_value_1.l;
667: 646 00010F38 0d effffffab6 effffffaad movl _dbl_value_1+4,_sgl_value_7
668: 647 00010F43 # asm("movl _test_no,r0"); /* r0 = test number */
669: 648 00010F43 0d effffffaa7 50 movl _test_no,r0
670: 649 00010F4A # asm("movl _subtest,r1"); /* r1 = subtest number */
671: 650 00010F4A 0d effffffaa0 51 movl _subtest,r1
672: 651 00010F51 # asm("movl _err_code,r2"); /* r2 = error code */
673: 652 00010F51 0d effffffa99 52 movl _err_code,r2
674: 653 00010F58 # asm("movl _cycle,r3"); /* r3 = cycle count */
675: 654 00010F58 0d effffffa92 53 movl _cycle,r3
676: 655 00010F5F # asm("movl _sgl_value_4,r4"); /* r4 = MSW of operand 1 */
677: 656 00010F5F 0d effffffa8b 54 movl _sgl_value_4,r4
678: 657 00010F66 # asm("movl _sgl_value_5,r5"); /* r5 = LSW of operand 1 */
679: 658 00010F66 0d effffffa84 55 movl _sgl_value_5,r5
680: 659 00010F6D # asm("movl _sgl_value_6,r6"); /* r6 = MSW of operand 2 */
681: 660 00010F6D 0d effffffa7d 56 movl _sgl_value_6,r6
682: 661 00010F74 # asm("movl _sgl_value_7,r7"); /* r7 = LSW of operand 2 */
683: 662 00010F74 0d effffffa76 57 movl _sgl_value_7,r7
684: 663 00010F7B # asm("movl _sgl_value_8,r8"); /* r8 = operand 3 */
685: 664 00010F7B 0d effffffa6f 58 movl _sgl_value_8,r8
686: 665 00010F82 # if( code == 1 )
687: 666 00010F82 1d ad04 01 cmpl 4(fp),$1
688: 667 00010F86 21 09 jneq L457
689: 668 00010F88 # asm("movl _index,r9"); /* r9 = data index */
690: 669 00010F88 0d effffffa62 59 movl _index,r9
691: 670 00010F8F # else {
692: 671 00010F8F 11 2b jbr L458
693: 672 00010F91 L457:
694: 673 00010F91 # sgl_value_6 = post_evt_acc.m;
695: 674 00010F91 0d effffffa59 effffffa54 movl _post_evt_acc,_sgl_value_6
696: 675 00010F9C # sgl_value_7 = post_evt_acc.l;
697: 676 00010F9C 0d effffffa52 effffffa49 movl _post_evt_acc+4,_sgl_value_7
698: 677 00010FA7 # asm("movl _sgl_value_6,r9"); /* r9 = MSW of final acc. */
699: 678 00010FA7 0d effffffa43 59 movl _sgl_value_6,r9
700: 679 00010FAE # asm("movl _sgl_value_7,r10"); /* r10 = LSW of final acc. */
701: 680 00010FAE 0d effffffa3c 5a movl _sgl_value_7,r10
702: 681 00010FB5 # asm("movl _index,r11"); /* r11 = data index */
703: 682 00010FB5 0d effffffa35 5b movl _index,r11
704: 683 00010FBC # }
705: 684 00010FBC L458:
706: 685 00010FBC # asm("halt");; /* HALT ... */
707: 686 00010FBC 00 halt
708: 687 00010FBD # }
709: 688 00010FBD 40 ret#2
710: 689 00010FBE .set L453,0x0
711: 690 00010FBE L455:
712: 691 00010FBE 13 ff4e jbr L456
713: 692 00010FC1 .data
714: 692 000219B1 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.