![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe15.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 pipe15.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 0000050c * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe15
6: 6 00000000 _pipe15:
7: 7 00013EF4 0000 .word L381
8: 8 00013EF6 #
9: 9 00013EF6 # #include "evt_defs.h"
10: 10 00013EF6 #
11: 11 00013EF6 # /*
12: 12 00013EF6 # *********************************************************************
13: 13 00013EF6 # * FPP PIPELINED EVENTS TEST #15
14: 14 00013EF6 # *
15: 15 00013EF6 # * This test will execute the following code: "LDF MULF STF"
16: 16 00013EF6 # * with an overflow fault on the MULF. We will make sure that:
17: 17 00013EF6 # * 1. The fault is detected,
18: 18 00013EF6 # * 2. the accumulator is cleared, and
19: 19 00013EF6 # * 3. a floating '0' is stored if anything.
20: 20 00013EF6 # *********************************************************************
21: 21 00013EF6 # */
22: 22 00013EF6 # pipe15()
23: 23 00013EF6 # {
24: 24 00013EF6 13 014b jbr L383
25: 25 00013EF9 L384:
26: 26 00013EF9 # #define PIPE15_PAT 0x12341234
27: 27 00013EF9 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
28: 28 00013EF9 ed 6d effffffff4 moval (r13),_pre_event_fp
29: 29 00013F00 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
30: 30 00013F00 ed 6e efffffffed moval (r14),_pre_event_sp
31: 31 00013F07 # precision = SGL;
32: 32 00013F07 0d 01 efffffffe6 movl $1,_precision
33: 33 00013F0E # test_event = ARITH_CODE; /* expect an arithmetic fault */
34: 34 00013F0E 0d 34 efffffffdf movl $52,_test_event
35: 35 00013F15 # exp_code = FLT_OVFL_CODE; /* - specificly overflow */
36: 36 00013F15 0d 04 efffffffd8 movl $4,_exp_code
37: 37 00013F1C # exp_event = FALSE; /* ... but not yet */
38: 38 00013F1C 4d efffffffd2 clrl _exp_event
39: 39 00013F22 # asm("movab _pipe15_ret,_event_return"); /* set event return address */
40: 40 00013F22 e9 ef000000b9 efffffffc7 movab _pipe15_ret,_event_return
41: 41 00013F2D # max_index = muf_ov_cnt; /* set max operand index */
42: 42 00013F2D 0d efffffffc1 efffffffbc movl _muf_ov_cnt,_max_index
43: 43 00013F38 # for( index = 0; index < max_index; index++ ) {
44: 44 00013F38 4d efffffffb6 clrl _index
45: 45 00013F3E L387:
46: 46 00013F3E 1d efffffffb0 efffffffab cmpl _index,_max_index
47: 47 00013F49 91 03 13 00f5 jgeq L386
48: 48 00013F4E # dbl_ld_acc = muf_ov_dat[index].op_1; /* get the Acc data */
49: 49 00013F4E 48 04 efffffff9f 50 shll $4,_index,r0
50: 50 00013F56 0c 8f00000000 50 addl2 $_muf_ov_dat,r0
51: 51 00013F5D 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4
52: 52 00013F65 0d 60 efffffff88 movl (r0),_dbl_ld_acc
53: 53 00013F6C # dbl_value_1 = muf_ov_dat[index].op_2; /* get the '0' data */
54: 54 00013F6C 48 04 efffffff81 50 shll $4,_index,r0
55: 55 00013F74 0c 8f00000008 50 addl2 $_muf_ov_dat+8,r0
56: 56 00013F7B 0d a004 efffffff75 movl 4(r0),_dbl_value_1+4
57: 57 00013F83 0d 60 efffffff6a movl (r0),_dbl_value_1
58: 58 00013F8A # dbl_value_2.m = PIPE15_PAT; /* background for STF*/
59: 59 00013F8A 0d 8f12341234 efffffff5f movl $305402420,_dbl_value_2
60: 60 00013F95 # asm(".globl _pipe15_lp1");
61: 61 00013F95 .globl _pipe15_lp1
62: 62 00013F95 # asm("_pipe15_lp1:");
63: 63 00013F95 _pipe15_lp1:
64: 64 00013F95 # asm("bispsw $0x60"); /* enable ovfl & undfl events*/
65: 65 00013F95 8b 8860 bispsw $0x60
66: 66 00013F98 # asm("ldf _dbl_ld_acc"); /* load the Acc. */
67: 67 00013F98 06 efffffff56 ldf _dbl_ld_acc
68: 68 00013F9E # exp_event = test_event; /* set the expect event flag */
69: 69 00013F9E 0d efffffff50 efffffff4b movl _test_event,_exp_event
70: 70 00013FA9 # asm("mulf _dbl_value_1"); /* trigger the event */
71: 71 00013FA9 e6 efffffff45 mulf _dbl_value_1
72: 72 00013FAF # asm("stf _dbl_value_2"); /* FPP stores before the evt.*/
73: 73 00013FAF 26 efffffff3f stf _dbl_value_2
74: 74 00013FB5 # /*
75: 75 00013FB5 # * If we got to here then there was no event
76: 76 00013FB5 # */
77: 77 00013FB5 # if( force_loop )
78: 78 00013FB5 5d efffffff39 tstl _force_loop
79: 79 00013FBB 31 06 jeql L388
80: 80 00013FBD # asm("jmp _pipe15_lp1");; /* loop on the error */
81: 81 00013FBD 71 efffffffd2 jmp _pipe15_lp1
82: 82 00013FC3 L388:
83: 83 00013FC3 # exp_event = FALSE; /* reset event expected flag */
84: 84 00013FC3 4d efffffff2b clrl _exp_event
85: 85 00013FC9 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
86: 86 00013FC9 0d efffffff25 5d movl _pre_event_fp,fp
87: 87 00013FD0 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
88: 88 00013FD0 0d efffffff1e 5e movl _pre_event_sp,sp
89: 89 00013FD7 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
90: 90 00013FD7 9b 8860 bicpsw $0x60
91: 91 00013FDA # no_pipe15_evt();; /* report the error */
92: 92 00013FDA fe 04 ef00000067 callf $4,_no_pipe15_evt
93: 93 00013FE1 # /*
94: 94 00013FE1 # * Come here after the event
95: 95 00013FE1 # */
96: 96 00013FE1 # asm(".globl _pipe15_ret");
97: 97 00013FE1 .globl _pipe15_ret
98: 98 00013FE1 # asm("_pipe15_ret:");
99: 99 00013FE1 _pipe15_ret:
100: 100 00013FE1 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
101: 101 00013FE1 0d efffffff0d 5d movl _pre_event_fp,fp
102: 102 00013FE8 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
103: 103 00013FE8 0d efffffff06 5e movl _pre_event_sp,sp
104: 104 00013FEF # if( force_loop )
105: 105 00013FEF 5d effffffeff tstl _force_loop
106: 106 00013FF5 31 06 jeql L390
107: 107 00013FF7 # asm("jmp _pipe15_lp1");; /* loop on the error */
108: 108 00013FF7 71 efffffff98 jmp _pipe15_lp1
109: 109 00013FFD L390:
110: 110 00013FFD # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
111: 111 00013FFD 9b 8860 bicpsw $0x60
112: 112 00014000 # if( post_evt_acc.m ) /* was the Acc cleared? */
113: 113 00014000 5d effffffeee tstl _post_evt_acc
114: 114 00014006 31 09 jeql L391
115: 115 00014008 # bad_pipe15_result(); /* incorrect result error */
116: 116 00014008 fe 04 ef000000f5 callf $4,_bad_pipe15_result
117: 117 0001400F # else if( (dbl_value_2.m ) && /* either a ZERO s/b stored, */
118: 118 0001400F 11 29 jbr L393
119: 119 00014011 L391:
120: 120 00014011 # (dbl_value_2.m != 0x80000000) && /* or a RESERVED OP, */
121: 121 00014011 # (dbl_value_2.m != PIPE15_PAT) ) /* or no store at all */
122: 122 00014011 5d effffffedd tstl _dbl_value_2
123: 123 00014017 31 21 jeql L394
124: 124 00014019 1d effffffed5 8f80000000 cmpl _dbl_value_2,$-2147483648
125: 125 00014024 31 14 jeql L394
126: 126 00014026 1d effffffec8 8f12341234 cmpl _dbl_value_2,$305402420
127: 127 00014031 31 07 jeql L394
128: 128 00014033 # bad_pipe15_store(); /* incorrect store error */
129: 129 00014033 fe 04 ef000001b8 callf $4,_bad_pipe15_store
130: 130 0001403A # }
131: 131 0001403A L394:
132: 132 0001403A L393:
133: 133 0001403A L385:
134: 134 0001403A 6d effffffeb4 incl _index
135: 135 00014040 13 fefb jbr L387
136: 136 00014043 L386:
137: 137 00014043 # }
138: 138 00014043 40 ret#2
139: 139 00014044 .set L381,0x0
140: 140 00014044 L383:
141: 141 00014044 13 feb2 jbr L384
142: 142 00014047 .data
143: 143 0000050c * .text
144: 144 00014047 00 .align 1
145: 145 00014048 .globl _no_pipe15_evt
146: 146 00014048 _no_pipe15_evt:
147: 147 00014048 0000 .word L396
148: 148 0001404A #
149: 149 0001404A #
150: 150 0001404A #
151: 151 0001404A # /****************************************************************************
152: 152 0001404A # * Report an "EVENT NOT DETECTED" error
153: 153 0001404A # *
154: 154 0001404A # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx
155: 155 0001404A # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF)
156: 156 0001404A # * op1 = xxxxxxxx, op2 = xxxxxxxx, init op3 = xxxxxxxx, final op3 = xxxxxxxx
157: 157 0001404A # ****************************************************************************/
158: 158 0001404A # no_pipe15_evt()
159: 159 0001404A # {
160: 160 0001404A 13 00b3 jbr L398
161: 161 0001404D L399:
162: 162 0001404D # errcnt++; /* bump the error count */
163: 163 0001404D 6d effffffea1 incl _errcnt
164: 164 00014053 # if ( prt_error )
165: 165 00014053 5d effffffe9b tstl _prt_error
166: 166 00014059 31 7e jeql L400
167: 167 0001405B # {
168: 168 0001405B # print_pipe15_er( ". No overflow fault seen" );
169: 169 0001405B .data 1
170: 170 0000050c * L402:
171: 171 0000050c * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen\0"
172: 7206661756C74207365656E00
173: 172 00000525 * .text
174: 173 0001405B dd 8f0000050c pushl $L402
175: 174 00014061 fe 08 ef00000266 callf $8,_print_pipe15_er
176: 175 00014068 # writes("op1 = ");
177: 176 00014068 .data 1
178: 177 00000525 * L404:
179: 178 00000525 * 6F7031203D2000 .ascii "op1 = \0"
180: 179 0000052c * .text
181: 180 00014068 dd 8f00000525 pushl $L404
182: 181 0001406E fe 08 effffffe7f callf $8,_writes
183: 182 00014075 # write32h( dbl_ld_acc.m );
184: 183 00014075 dd effffffe79 pushl _dbl_ld_acc
185: 184 0001407B fe 08 effffffe72 callf $8,_write32h
186: 185 00014082 # writes(", op2 = ");
187: 186 00014082 .data 1
188: 187 0000052c * L406:
189: 188 0000052c * 2C20206F7032203D2000 .ascii ", op2 = \0"
190: 189 00000536 * .text
191: 190 00014082 dd 8f0000052c pushl $L406
192: 191 00014088 fe 08 effffffe65 callf $8,_writes
193: 192 0001408F # write32h( dbl_value_1.m );
194: 193 0001408F dd effffffe5f pushl _dbl_value_1
195: 194 00014095 fe 08 effffffe58 callf $8,_write32h
196: 195 0001409C # writes(", init op3 = ");
197: 196 0001409C .data 1
198: 197 00000536 * L407:
199: 198 00000536 * 2C2020696E6974206F7033203 .ascii ", init op3 = \0"
200: D2000
201: 199 00000545 * .text
202: 200 0001409C dd 8f00000536 pushl $L407
203: 201 000140A2 fe 08 effffffe4b callf $8,_writes
204: 202 000140A9 # write32h( PIPE15_PAT );
205: 203 000140A9 dd 8f12341234 pushl $305402420
206: 204 000140AF fe 08 effffffe3e callf $8,_write32h
207: 205 000140B6 # writes(", final op3 = ");
208: 206 000140B6 .data 1
209: 207 00000545 * L408:
210: 208 00000545 * 2C202066696E616C206F70332 .ascii ", final op3 = \0"
211: 03D2000
212: 209 00000555 * .text
213: 210 000140B6 dd 8f00000545 pushl $L408
214: 211 000140BC fe 08 effffffe31 callf $8,_writes
215: 212 000140C3 # write32h( dbl_value_2.m );
216: 213 000140C3 dd effffffe2b pushl _dbl_value_2
217: 214 000140C9 fe 08 effffffe24 callf $8,_write32h
218: 215 000140D0 # writec('\n');
219: 216 000140D0 dd 0a pushl $10
220: 217 000140D2 fe 08 effffffe1b callf $8,_writec
221: 218 000140D9 # }
222: 219 000140D9 # if ( halt_flg ) /* halt on error? */
223: 220 000140D9 L400:
224: 221 000140D9 5d effffffe15 tstl _halt_flg
225: 222 000140DF 31 09 jeql L410
226: 223 000140E1 # pipe15_halt( 1 ); /* halt with a code of 1 */
227: 224 000140E1 dd 01 pushl $1
228: 225 000140E3 fe 08 ef00000282 callf $8,_pipe15_halt
229: 226 000140EA # if ( loop_on_err )
230: 227 000140EA L410:
231: 228 000140EA 5d effffffe04 tstl _loop_on_err
232: 229 000140F0 31 0d jeql L412
233: 230 000140F2 # {
234: 231 000140F2 # force_loop = TRUE; /* set the force loop flag */
235: 232 000140F2 0d 01 effffffdfb movl $1,_force_loop
236: 233 000140F9 # asm("jmp _pipe15_lp1"); /* and loop */
237: 234 000140F9 71 effffffe96 jmp _pipe15_lp1
238: 235 000140FF # };
239: 236 000140FF L412:
240: 237 000140FF # }
241: 238 000140FF 40 ret#2
242: 239 00014100 .set L396,0x0
243: 240 00014100 L398:
244: 241 00014100 13 ff4a jbr L399
245: 242 00014103 .data
246: 243 0000050c * .text
247: 244 00014103 00 .align 1
248: 245 00014104 .globl _bad_pipe15_result
249: 246 00014104 _bad_pipe15_result:
250: 247 00014104 0000 .word L413
251: 248 00014106 #
252: 249 00014106 #
253: 250 00014106 #
254: 251 00014106 #
255: 252 00014106 # /****************************************************************************
256: 253 00014106 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
257: 254 00014106 # *
258: 255 00014106 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
259: 256 00014106 # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF)
260: 257 00014106 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, initial op3 = xxxxxxxx
261: 258 00014106 # * op2 = xxxxxxxx, expected = xxxxxxxx, final op3 = xxxxxxxx
262: 259 00014106 # ****************************************************************************/
263: 260 00014106 # bad_pipe15_result()
264: 261 00014106 # {
265: 262 00014106 13 00e6 jbr L415
266: 263 00014109 L416:
267: 264 00014109 # errcnt++; /* bump the error count */
268: 265 00014109 6d effffffde5 incl _errcnt
269: 266 0001410F # if ( prt_error )
270: 267 0001410F 5d effffffddf tstl _prt_error
271: 268 00014115 21 03 13 00ae jeql L417
272: 269 0001411A # {
273: 270 0001411A # print_pipe15_er( ". Bad final Accumulator" );
274: 271 0001411A .data 1
275: 272 00000555 * L418:
276: 273 00000555 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
277: 16363756D756C61746F7200
278: 274 0000056d * .text
279: 275 0001411A dd 8f00000555 pushl $L418
280: 276 00014120 fe 08 ef000001a7 callf $8,_print_pipe15_er
281: 277 00014127 # writes("op1 = ");
282: 278 00014127 .data 1
283: 279 0000056d * L419:
284: 280 0000056d * 6F7031203D2000 .ascii "op1 = \0"
285: 281 00000574 * .text
286: 282 00014127 dd 8f0000056d pushl $L419
287: 283 0001412D fe 08 effffffdc0 callf $8,_writes
288: 284 00014134 # write32h( dbl_ld_acc.m );
289: 285 00014134 dd effffffdba pushl _dbl_ld_acc
290: 286 0001413A fe 08 effffffdb3 callf $8,_write32h
291: 287 00014141 # writes(", final Acc. = ");
292: 288 00014141 .data 1
293: 289 00000574 * L420:
294: 290 00000574 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
295: 32E203D2000
296: 291 00000586 * .text
297: 292 00014141 dd 8f00000574 pushl $L420
298: 293 00014147 fe 08 effffffda6 callf $8,_writes
299: 294 0001414E # write32h( post_evt_acc.m );
300: 295 0001414E dd effffffda0 pushl _post_evt_acc
301: 296 00014154 fe 08 effffffd99 callf $8,_write32h
302: 297 0001415B # writes(", initial op3 = ");
303: 298 0001415B .data 1
304: 299 00000586 * L421:
305: 300 00000586 * 2C202020696E697469616C206 .ascii ", initial op3 = \0"
306: F703320203D2000
307: 301 0000059a * .text
308: 302 0001415B dd 8f00000586 pushl $L421
309: 303 00014161 fe 08 effffffd8c callf $8,_writes
310: 304 00014168 # write32h( PIPE15_PAT );
311: 305 00014168 dd 8f12341234 pushl $305402420
312: 306 0001416E fe 08 effffffd7f callf $8,_write32h
313: 307 00014175 # writes("\nop2 = ");
314: 308 00014175 .data 1
315: 309 0000059a * L422:
316: 310 0000059a * 0A6F7032203D2000 .ascii "\12op2 = \0"
317: 311 000005a2 * .text
318: 312 00014175 dd 8f0000059a pushl $L422
319: 313 0001417B fe 08 effffffd72 callf $8,_writes
320: 314 00014182 # write32h( dbl_value_1.m );
321: 315 00014182 dd effffffd6c pushl _dbl_value_1
322: 316 00014188 fe 08 effffffd65 callf $8,_write32h
323: 317 0001418F # writes(", expected = ");
324: 318 0001418F .data 1
325: 319 000005a2 * L423:
326: 320 000005a2 * 2C20202020206578706563746 .ascii ", expected = \0"
327: 564203D2000
328: 321 000005b4 * .text
329: 322 0001418F dd 8f000005a2 pushl $L423
330: 323 00014195 fe 08 effffffd58 callf $8,_writes
331: 324 0001419C # write32h( 0 ); /* the expected result = 0 */
332: 325 0001419C dd 00 pushl $0
333: 326 0001419E fe 08 effffffd4f callf $8,_write32h
334: 327 000141A5 # writes(", final op3 = ");
335: 328 000141A5 .data 1
336: 329 000005b4 * L424:
337: 330 000005b4 * 2C202020202066696E616C206 .ascii ", final op3 = \0"
338: F703320203D2000
339: 331 000005c8 * .text
340: 332 000141A5 dd 8f000005b4 pushl $L424
341: 333 000141AB fe 08 effffffd42 callf $8,_writes
342: 334 000141B2 # write32h( dbl_value_2.m );
343: 335 000141B2 dd effffffd3c pushl _dbl_value_2
344: 336 000141B8 fe 08 effffffd35 callf $8,_write32h
345: 337 000141BF # writec('\n');
346: 338 000141BF dd 0a pushl $10
347: 339 000141C1 fe 08 effffffd2c callf $8,_writec
348: 340 000141C8 # }
349: 341 000141C8 # if ( halt_flg ) /* halt on error? */
350: 342 000141C8 L417:
351: 343 000141C8 5d effffffd26 tstl _halt_flg
352: 344 000141CE 31 09 jeql L425
353: 345 000141D0 # pipe15_halt( 2 ); /* halt with a code of 2 */
354: 346 000141D0 dd 02 pushl $2
355: 347 000141D2 fe 08 ef00000193 callf $8,_pipe15_halt
356: 348 000141D9 # if ( loop_on_err )
357: 349 000141D9 L425:
358: 350 000141D9 5d effffffd15 tstl _loop_on_err
359: 351 000141DF 31 0d jeql L426
360: 352 000141E1 # {
361: 353 000141E1 # force_loop = TRUE; /* set the force loop flag */
362: 354 000141E1 0d 01 effffffd0c movl $1,_force_loop
363: 355 000141E8 # asm("jmp _pipe15_lp1"); /* and loop */
364: 356 000141E8 71 effffffda7 jmp _pipe15_lp1
365: 357 000141EE # };
366: 358 000141EE L426:
367: 359 000141EE # }
368: 360 000141EE 40 ret#2
369: 361 000141EF .set L413,0x0
370: 362 000141EF L415:
371: 363 000141EF 13 ff17 jbr L416
372: 364 000141F2 .data
373: 365 0000050c * .text
374: 366 000141F2 .align 1
375: 367 000141F2 .globl _bad_pipe15_store
376: 368 000141F2 _bad_pipe15_store:
377: 369 000141F2 0000 .word L427
378: 370 000141F4 #
379: 371 000141F4 #
380: 372 000141F4 #
381: 373 000141F4 #
382: 374 000141F4 # /****************************************************************************
383: 375 000141F4 # * Report a "BAD RESULT STORED AFTER THE EVENT" error
384: 376 000141F4 # *
385: 377 000141F4 # * Cycle: xx. EVT test xx. subtest xx. Bad STF OP3 result. index = xx
386: 378 000141F4 # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF)
387: 379 000141F4 # * op1 = xxxxxxxx, initial op3 = xxxxxxxx, final Acc. = xxxxxxxx
388: 380 000141F4 # * op2 = xxxxxxxx, final op3 = xxxxxxxx, op3 expected = xxxxxxxx
389: 381 000141F4 # ****************************************************************************/
390: 382 000141F4 # bad_pipe15_store()
391: 383 000141F4 # {
392: 384 000141F4 13 00d4 jbr L429
393: 385 000141F7 L430:
394: 386 000141F7 # errcnt++; /* bump the error count */
395: 387 000141F7 6d effffffcf7 incl _errcnt
396: 388 000141FD # if ( prt_error )
397: 389 000141FD 5d effffffcf1 tstl _prt_error
398: 390 00014203 21 03 13 009c jeql L431
399: 391 00014208 # {
400: 392 00014208 # print_pipe15_er( ". Bad STF OP3 result" );
401: 393 00014208 .data 1
402: 394 000005c8 * L432:
403: 395 000005c8 * 2E2042616420535446204F503 .ascii ". Bad STF OP3 result\0"
404: 320726573756C7400
405: 396 000005dd * .text
406: 397 00014208 dd 8f000005c8 pushl $L432
407: 398 0001420E fe 08 ef000000b9 callf $8,_print_pipe15_er
408: 399 00014215 # writes("op1 = ");
409: 400 00014215 .data 1
410: 401 000005dd * L433:
411: 402 000005dd * 6F7031203D2000 .ascii "op1 = \0"
412: 403 000005e4 * .text
413: 404 00014215 dd 8f000005dd pushl $L433
414: 405 0001421B fe 08 effffffcd2 callf $8,_writes
415: 406 00014222 # write32h( dbl_ld_acc.m );
416: 407 00014222 dd effffffccc pushl _dbl_ld_acc
417: 408 00014228 fe 08 effffffcc5 callf $8,_write32h
418: 409 0001422F # writes(", initial op3 = ");
419: 410 0001422F .data 1
420: 411 000005e4 * L434:
421: 412 000005e4 * 2C2020696E697469616C206F7 .ascii ", initial op3 = \0"
422: 03320203D2000
423: 413 000005f7 * .text
424: 414 0001422F dd 8f000005e4 pushl $L434
425: 415 00014235 fe 08 effffffcb8 callf $8,_writes
426: 416 0001423C # write32h( PIPE15_PAT );
427: 417 0001423C dd 8f12341234 pushl $305402420
428: 418 00014242 fe 08 effffffcab callf $8,_write32h
429: 419 00014249 # writes(", final Acc. = ");
430: 420 00014249 .data 1
431: 421 000005f7 * L435:
432: 422 000005f7 * 2C2020202066696E616C20416 .ascii ", final Acc. = \0"
433: 3632E203D2000
434: 423 0000060a * .text
435: 424 00014249 dd 8f000005f7 pushl $L435
436: 425 0001424F fe 08 effffffc9e callf $8,_writes
437: 426 00014256 # write32h( post_evt_acc.m );
438: 427 00014256 dd effffffc98 pushl _post_evt_acc
439: 428 0001425C fe 08 effffffc91 callf $8,_write32h
440: 429 00014263 # writes("\nop2 = ");
441: 430 00014263 .data 1
442: 431 0000060a * L436:
443: 432 0000060a * 0A6F7032203D2000 .ascii "\12op2 = \0"
444: 433 00000612 * .text
445: 434 00014263 dd 8f0000060a pushl $L436
446: 435 00014269 fe 08 effffffc84 callf $8,_writes
447: 436 00014270 # write32h( dbl_value_1.m );
448: 437 00014270 dd effffffc7e pushl _dbl_value_1
449: 438 00014276 fe 08 effffffc77 callf $8,_write32h
450: 439 0001427D # writes(", final op3 = ");
451: 440 0001427D .data 1
452: 441 00000612 * L437:
453: 442 00000612 * 2C2020202066696E616C206F7 .ascii ", final op3 = \0"
454: 03320203D2000
455: 443 00000625 * .text
456: 444 0001427D dd 8f00000612 pushl $L437
457: 445 00014283 fe 08 effffffc6a callf $8,_writes
458: 446 0001428A # write32h( dbl_value_2.m );
459: 447 0001428A dd effffffc64 pushl _dbl_value_2
460: 448 00014290 fe 08 effffffc5d callf $8,_write32h
461: 449 00014297 # writes(", op3 expected = 80000000\n"); /* exp = Reserved Op */
462: 450 00014297 .data 1
463: 451 00000625 * L438:
464: 452 00000625 * 2C20206F70332065787065637 .ascii ", op3 expected = 80000000\12\0"
465: 46564203D2038303030303030
466: 300A00
467: 453 00000641 * .text
468: 454 00014297 dd 8f00000625 pushl $L438
469: 455 0001429D fe 08 effffffc50 callf $8,_writes
470: 456 000142A4 # }
471: 457 000142A4 # if ( halt_flg ) /* halt on error? */
472: 458 000142A4 L431:
473: 459 000142A4 5d effffffc4a tstl _halt_flg
474: 460 000142AA 31 09 jeql L439
475: 461 000142AC # pipe15_halt( 3 ); /* halt with a code of 2 */
476: 462 000142AC dd 03 pushl $3
477: 463 000142AE fe 08 ef000000b7 callf $8,_pipe15_halt
478: 464 000142B5 # if ( loop_on_err )
479: 465 000142B5 L439:
480: 466 000142B5 5d effffffc39 tstl _loop_on_err
481: 467 000142BB 31 0d jeql L440
482: 468 000142BD # {
483: 469 000142BD # force_loop = TRUE; /* set the force loop flag */
484: 470 000142BD 0d 01 effffffc30 movl $1,_force_loop
485: 471 000142C4 # asm("jmp _pipe15_lp1"); /* and loop */
486: 472 000142C4 71 effffffccb jmp _pipe15_lp1
487: 473 000142CA # };
488: 474 000142CA L440:
489: 475 000142CA # }
490: 476 000142CA 40 ret#2
491: 477 000142CB .set L427,0x0
492: 478 000142CB L429:
493: 479 000142CB 13 ff29 jbr L430
494: 480 000142CE .data
495: 481 0000050c * .text
496: 482 000142CE .align 1
497: 483 000142CE .globl _print_pipe15_er
498: 484 000142CE _print_pipe15_er:
499: 485 000142CE 0000 .word L441
500: 486 000142D0 #
501: 487 000142D0 #
502: 488 000142D0 #
503: 489 000142D0 #
504: 490 000142D0 #
505: 491 000142D0 #
506: 492 000142D0 # /****************************************************************************
507: 493 000142D0 # * Report an error message of the form:
508: 494 000142D0 # *
509: 495 000142D0 # * Cycle: xx. EVT test xx. subtest xx. <your message here>. index = xx
510: 496 000142D0 # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF)
511: 497 000142D0 # ****************************************************************************/
512: 498 000142D0 # print_pipe15_er( msg )
513: 499 000142D0 # char *msg; /* error message to print */
514: 500 000142D0 # {
515: 501 000142D0 13 0096 jbr L443
516: 502 000142D3 L444:
517: 503 000142D3 # if( errcnt == 1 ) /* 1st error? */
518: 504 000142D3 1d effffffc1b 01 cmpl _errcnt,$1
519: 505 000142DA 21 0d jneq L445
520: 506 000142DC # writes(" \n"); /* start a new print line */
521: 507 000142DC .data 1
522: 508 00000641 * L446:
523: 509 00000641 * 200A00 .ascii " \12\0"
524: 510 00000644 * .text
525: 511 000142DC dd 8f00000641 pushl $L446
526: 512 000142E2 fe 08 effffffc0b callf $8,_writes
527: 513 000142E9 # writes("Cycle: ");
528: 514 000142E9 L445:
529: 515 000142E9 .data 1
530: 516 00000644 * L447:
531: 517 00000644 * 4379636C653A2000 .ascii "Cycle: \0"
532: 518 0000064c * .text
533: 519 000142E9 dd 8f00000644 pushl $L447
534: 520 000142EF fe 08 effffffbfe callf $8,_writes
535: 521 000142F6 # writed( cycle );
536: 522 000142F6 dd effffffbf8 pushl _cycle
537: 523 000142FC fe 08 effffffbf1 callf $8,_writed
538: 524 00014303 # writes(" EVT test ");
539: 525 00014303 .data 1
540: 526 0000064c * L449:
541: 527 0000064c * 202045565420746573742000 .ascii " EVT test \0"
542: 528 00000658 * .text
543: 529 00014303 dd 8f0000064c pushl $L449
544: 530 00014309 fe 08 effffffbe4 callf $8,_writes
545: 531 00014310 # writed( test_no );
546: 532 00014310 dd effffffbde pushl _test_no
547: 533 00014316 fe 08 effffffbd7 callf $8,_writed
548: 534 0001431D # writes(". subtest ");
549: 535 0001431D .data 1
550: 536 00000658 * L450:
551: 537 00000658 * 2E20737562746573742000 .ascii ". subtest \0"
552: 538 00000663 * .text
553: 539 0001431D dd 8f00000658 pushl $L450
554: 540 00014323 fe 08 effffffbca callf $8,_writes
555: 541 0001432A # writed( subtest );
556: 542 0001432A dd effffffbc4 pushl _subtest
557: 543 00014330 fe 08 effffffbbd callf $8,_writed
558: 544 00014337 # writes( msg ); /* print the message */
559: 545 00014337 dd ad04 pushl 4(fp)
560: 546 0001433A fe 08 effffffbb3 callf $8,_writes
561: 547 00014341 # writes(". index = ");
562: 548 00014341 .data 1
563: 549 00000663 * L451:
564: 550 00000663 * 2E20696E646578203D2000 .ascii ". index = \0"
565: 551 0000066e * .text
566: 552 00014341 dd 8f00000663 pushl $L451
567: 553 00014347 fe 08 effffffba6 callf $8,_writes
568: 554 0001434E # writed( index );
569: 555 0001434E dd effffffba0 pushl _index
570: 556 00014354 fe 08 effffffb99 callf $8,_writed
571: 557 0001435B # writes(
572: 558 0001435B # "\ninst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF)\n");
573: 559 0001435B .data 1
574: 560 0000066e * L452:
575: 561 0000066e * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1, MULF op2, STF op3 (overflow fault on the MUL"
576: F70312C204D554C46206F7032
577: 2C20535446206F70332020202
578: 0286F766572666C6F77206661
579: 756C74206F6E20746865204D5
580: 54C
581: 562 000006ae * 46290A00 .ascii "F)\12\0"
582: 563 000006b2 * .text
583: 564 0001435B dd 8f0000066e pushl $L452
584: 565 00014361 fe 08 effffffb8c callf $8,_writes
585: 566 00014368 # }
586: 567 00014368 40 ret#2
587: 568 00014369 .set L441,0x0
588: 569 00014369 L443:
589: 570 00014369 13 ff67 jbr L444
590: 571 0001436C .data
591: 572 0000050c * .text
592: 573 0001436C .align 1
593: 574 0001436C .globl _pipe15_halt
594: 575 0001436C _pipe15_halt:
595: 576 0001436C 0000 .word L453
596: 577 0001436E #
597: 578 0001436E #
598: 579 0001436E #
599: 580 0001436E # /****************************************************************************
600: 581 0001436E # * halt on error routine
601: 582 0001436E # ****************************************************************************/
602: 583 0001436E # pipe15_halt( code )
603: 584 0001436E # int code; /* error code to halt with */
604: 585 0001436E # {
605: 586 0001436E 13 008b jbr L455
606: 587 00014371 L456:
607: 588 00014371 # err_code = code;
608: 589 00014371 0d ad04 effffffb7b movl 4(fp),_err_code
609: 590 00014379 # sgl_value_1 = dbl_ld_acc.m;
610: 591 00014379 0d effffffb75 effffffb70 movl _dbl_ld_acc,_sgl_value_1
611: 592 00014384 # sgl_value_2 = dbl_value_1.m;
612: 593 00014384 0d effffffb6a effffffb65 movl _dbl_value_1,_sgl_value_2
613: 594 0001438F # sgl_value_3 = post_evt_acc.m;
614: 595 0001438F 0d effffffb5f effffffb5a movl _post_evt_acc,_sgl_value_3
615: 596 0001439A # sgl_value_4 = PIPE15_PAT;
616: 597 0001439A 0d 8f12341234 effffffb4f movl $305402420,_sgl_value_4
617: 598 000143A5 # sgl_value_5 = dbl_value_2.m;
618: 599 000143A5 0d effffffb49 effffffb44 movl _dbl_value_2,_sgl_value_5
619: 600 000143B0 # asm("movl _test_no,r0"); /* r0 = test number */
620: 601 000143B0 0d effffffb3e 50 movl _test_no,r0
621: 602 000143B7 # asm("movl _subtest,r1"); /* r1 = subtest number */
622: 603 000143B7 0d effffffb37 51 movl _subtest,r1
623: 604 000143BE # asm("movl _err_code,r2"); /* r2 = error code */
624: 605 000143BE 0d effffffb30 52 movl _err_code,r2
625: 606 000143C5 # asm("movl _cycle,r3"); /* r3 = cycle count */
626: 607 000143C5 0d effffffb29 53 movl _cycle,r3
627: 608 000143CC # asm("movl _sgl_value_1,r4"); /* r4 = initial acc. */
628: 609 000143CC 0d effffffb22 54 movl _sgl_value_1,r4
629: 610 000143D3 # asm("movl _sgl_value_2,r5"); /* r5 = MULF operand */
630: 611 000143D3 0d effffffb1b 55 movl _sgl_value_2,r5
631: 612 000143DA # asm("movl _sgl_value_3,r6"); /* r6 = final acc. */
632: 613 000143DA 0d effffffb14 56 movl _sgl_value_3,r6
633: 614 000143E1 # asm("clrl r7"); /* r7 = expected acc. */
634: 615 000143E1 4d 57 clrl r7
635: 616 000143E3 # asm("movl _sgl_value_4,r8"); /* r8 = initial op3 value */
636: 617 000143E3 0d effffffb0b 58 movl _sgl_value_4,r8
637: 618 000143EA # asm("movl _sgl_value_5,r9"); /* r9 = final op3 value */
638: 619 000143EA 0d effffffb04 59 movl _sgl_value_5,r9
639: 620 000143F1 # asm("clrl r10"); /* r10 = expected op3 value */
640: 621 000143F1 4d 5a clrl r10
641: 622 000143F3 # asm("movl _index,r11"); /* r11 = data index */
642: 623 000143F3 0d effffffafb 5b movl _index,r11
643: 624 000143FA # asm("halt"); /* HALT ... */
644: 625 000143FA 00 halt
645: 626 000143FB # }
646: 627 000143FB 40 ret#2
647: 628 000143FC .set L453,0x0
648: 629 000143FC L455:
649: 630 000143FC 13 ff72 jbr L456
650: 631 000143FF .data
651: 631 000282F3 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.