![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe11.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 pipe11.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 0000048c * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe11
6: 6 00000000 _pipe11:
7: 7 00012A74 0000 .word L381
8: 8 00012A76 #
9: 9 00012A76 #
10: 10 00012A76 # #include "evt_defs.h"
11: 11 00012A76 #
12: 12 00012A76 # /*
13: 13 00012A76 # *********************************************************************
14: 14 00012A76 # * FPP PIPELINED EVENTS TEST #11
15: 15 00012A76 # *
16: 16 00012A76 # * This test will execute the following code: "LDF ADDF CVLF"
17: 17 00012A76 # * with an overflow fault on the ADDF. We will make sure that:
18: 18 00012A76 # * 1. The fault is detected, and
19: 19 00012A76 # * 2. the Convert Longword Intger to SGL Floating instruction is not executed.
20: 20 00012A76 # *********************************************************************
21: 21 00012A76 # */
22: 22 00012A76 # pipe11()
23: 23 00012A76 # {
24: 24 00012A76 13 012f jbr L383
25: 25 00012A79 L384:
26: 26 00012A79 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
27: 27 00012A79 ed 6d effffffff4 moval (r13),_pre_event_fp
28: 28 00012A80 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
29: 29 00012A80 ed 6e efffffffed moval (r14),_pre_event_sp
30: 30 00012A87 # precision = SGL;
31: 31 00012A87 0d 01 efffffffe6 movl $1,_precision
32: 32 00012A8E # test_event = ARITH_CODE; /* expect an arithmetic fault */
33: 33 00012A8E 0d 34 efffffffdf movl $52,_test_event
34: 34 00012A95 # exp_code = FLT_OVFL_CODE; /* - specificly overflow */
35: 35 00012A95 0d 04 efffffffd8 movl $4,_exp_code
36: 36 00012A9C # exp_event = FALSE; /* ... but not yet */
37: 37 00012A9C 4d efffffffd2 clrl _exp_event
38: 38 00012AA2 # asm("movab _pipe11_ret,_event_return"); /* set event return address */
39: 39 00012AA2 e9 ef000000b5 efffffffc7 movab _pipe11_ret,_event_return
40: 40 00012AAD # dbl_value_2.m = 24; /* set the CVLF data */
41: 41 00012AAD 0d 18 efffffffc0 movl $24,_dbl_value_2
42: 42 00012AB4 # max_index = adf_ov_cnt; /* set max operand index */
43: 43 00012AB4 0d efffffffba efffffffb5 movl _adf_ov_cnt,_max_index
44: 44 00012ABF # for( index = 0; index < max_index; index++ )
45: 45 00012ABF 4d efffffffaf clrl _index
46: 46 00012AC5 L387:
47: 47 00012AC5 1d efffffffa9 efffffffa4 cmpl _index,_max_index
48: 48 00012AD0 91 03 13 00d2 jgeq L386
49: 49 00012AD5 # {
50: 50 00012AD5 # dbl_ld_acc = adf_ov_dat[index].op_1; /* get the Acc data */
51: 51 00012AD5 48 04 efffffff98 50 shll $4,_index,r0
52: 52 00012ADD 0c 8f00000000 50 addl2 $_adf_ov_dat,r0
53: 53 00012AE4 0d a004 efffffff8c movl 4(r0),_dbl_ld_acc+4
54: 54 00012AEC 0d 60 efffffff81 movl (r0),_dbl_ld_acc
55: 55 00012AF3 # dbl_value_1 = adf_ov_dat[index].op_2; /* get the '0' data */
56: 56 00012AF3 48 04 efffffff7a 50 shll $4,_index,r0
57: 57 00012AFB 0c 8f00000008 50 addl2 $_adf_ov_dat+8,r0
58: 58 00012B02 0d a004 efffffff6e movl 4(r0),_dbl_value_1+4
59: 59 00012B0A 0d 60 efffffff63 movl (r0),_dbl_value_1
60: 60 00012B11 # asm(".globl _pipe11_lp1");
61: 61 00012B11 .globl _pipe11_lp1
62: 62 00012B11 # asm("_pipe11_lp1:");
63: 63 00012B11 _pipe11_lp1:
64: 64 00012B11 # asm("bispsw $0x60"); /* enable ovfl & undfl events*/
65: 65 00012B11 8b 8860 bispsw $0x60
66: 66 00012B14 # asm("movl _dbl_value_2,r4"); /* set the dummy load data */
67: 67 00012B14 0d efffffff5a 54 movl _dbl_value_2,r4
68: 68 00012B1B # asm("ldf _dbl_ld_acc"); /* load the Acc. */
69: 69 00012B1B 06 efffffff53 ldf _dbl_ld_acc
70: 70 00012B21 # exp_event = test_event; /* set the expect event flag */
71: 71 00012B21 0d efffffff4d efffffff48 movl _test_event,_exp_event
72: 72 00012B2C # asm("addf _dbl_value_1"); /* trigger the event */
73: 73 00012B2C c6 efffffff42 addf _dbl_value_1
74: 74 00012B32 # asm("cvlf r4"); /* we shouldn't get to here */
75: 75 00012B32 76 54 cvlf r4
76: 76 00012B34 # /*
77: 77 00012B34 # * If we got to here then there was no event
78: 78 00012B34 # */
79: 79 00012B34 # if( force_loop )
80: 80 00012B34 5d efffffff3a tstl _force_loop
81: 81 00012B3A 31 03 jeql L388
82: 82 00012B3C # asm("brw _pipe11_lp1");; /* loop on the error */
83: Assemb0002A234 # asm("brw _pipe11_lp1");; /* loop on the error */
84: "pipe100012A75 e 83: WARNING: brw: destination label is external
85: 83 00012B3C 13 ffd2 brw _pipe11_lp1
86: 84 00012B3F L388:
87: 85 00012B3F # exp_event = FALSE; /* reset event expected flag */
88: 86 00012B3F 4d efffffff2f clrl _exp_event
89: 87 00012B45 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
90: 88 00012B45 9b 8860 bicpsw $0x60
91: 89 00012B48 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
92: 90 00012B48 0d efffffff26 5d movl _pre_event_fp,fp
93: 91 00012B4F # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
94: 92 00012B4F 0d efffffff1f 5e movl _pre_event_sp,sp
95: 93 00012B56 # no_pipe11_evt();; /* report the error */
96: 94 00012B56 fe 04 ef0000004f callf $4,_no_pipe11_evt
97: 95 00012B5D # /*
98: 96 00012B5D # * Come here after the event
99: 97 00012B5D # */
100: 98 00012B5D # asm(".globl _pipe11_ret");
101: 99 00012B5D .globl _pipe11_ret
102: 100 00012B5D # asm("_pipe11_ret:");
103: 101 00012B5D _pipe11_ret:
104: 102 00012B5D # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
105: 103 00012B5D 0d efffffff11 5d movl _pre_event_fp,fp
106: 104 00012B64 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
107: 105 00012B64 0d efffffff0a 5e movl _pre_event_sp,sp
108: 106 00012B6B # if( force_loop )
109: 107 00012B6B 5d efffffff03 tstl _force_loop
110: 108 00012B71 31 03 jeql L390
111: 109 00012B73 # asm("brw _pipe11_lp1");; /* loop on the error */
112: "pipe100012A75 e 110: WARNING: brw: destination label is external
113: 110 00012B73 13 ff9b brw _pipe11_lp1
114: 111 00012B76 L390:
115: 112 00012B76 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
116: 113 00012B76 9b 8860 bicpsw $0x60
117: 114 00012B79 # if( post_evt_acc.m == 0x42c00000 ) /* Acc = CVLF data? ( 24.0 ) */
118: 115 00012B79 1d effffffef5 8f42c00000 cmpl _post_evt_acc,$1119879168
119: 116 00012B84 21 09 jneq L391
120: 117 00012B86 # pipe11_queue_er(); /* yes it was -error! error! */
121: 118 00012B86 fe 04 ef00000187 callf $4,_pipe11_queue_er
122: 119 00012B8D # else if( post_evt_acc.m ) /* was the Acc cleared? */
123: 120 00012B8D 11 0f jbr L393
124: 121 00012B8F L391:
125: 122 00012B8F 5d effffffedf tstl _post_evt_acc
126: 123 00012B95 31 07 jeql L394
127: 124 00012B97 # bad_pipe11_result(); /* incorrect result error */
128: 125 00012B97 fe 04 ef00000094 callf $4,_bad_pipe11_result
129: 126 00012B9E #
130: 127 00012B9E # }
131: 128 00012B9E L394:
132: 129 00012B9E L393:
133: 130 00012B9E L385:
134: 131 00012B9E 6d effffffed0 incl _index
135: 132 00012BA4 13 ff1e jbr L387
136: 133 00012BA7 L386:
137: 134 00012BA7 # }
138: 135 00012BA7 40 ret#2
139: 136 00012BA8 .set L381,0x0
140: 137 00012BA8 L383:
141: 138 00012BA8 13 fece jbr L384
142: 139 00012BAB .data
143: 140 0000048c * .text
144: 141 00012BAB 00 .align 1
145: 142 00012BAC .globl _no_pipe11_evt
146: 143 00012BAC _no_pipe11_evt:
147: 144 00012BAC 0000 .word L396
148: 145 00012BAE #
149: 146 00012BAE #
150: 147 00012BAE #
151: 148 00012BAE # /****************************************************************************
152: 149 00012BAE # * Report an "EVENT NOT DETECTED" error
153: 150 00012BAE # *
154: 151 00012BAE # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx
155: 152 00012BAE # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF)
156: 153 00012BAE # * op1 = xxxxxxxx, op2 = xxxxxxxx
157: 154 00012BAE # ****************************************************************************/
158: 155 00012BAE # no_pipe11_evt()
159: 156 00012BAE # {
160: 157 00012BAE 11 7f jbr L398
161: 158 00012BB0 L399:
162: 159 00012BB0 # errcnt++; /* bump the error count */
163: 160 00012BB0 6d effffffebe incl _errcnt
164: 161 00012BB6 # if ( prt_error )
165: 162 00012BB6 5d effffffeb8 tstl _prt_error
166: 163 00012BBC 31 4a jeql L400
167: 164 00012BBE # {
168: 165 00012BBE # print_pipe11_er( ". No overflow fault seen" );
169: 166 00012BBE .data 1
170: 167 0000048c * L402:
171: 168 0000048c * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen\0"
172: 7206661756C74207365656E00
173: 169 000004a5 * .text
174: 170 00012BBE dd 8f0000048c pushl $L402
175: 171 00012BC4 fe 08 ef0000022b callf $8,_print_pipe11_er
176: 172 00012BCB # writes("op1 = ");
177: 173 00012BCB .data 1
178: 174 000004a5 * L404:
179: 175 000004a5 * 6F7031203D2000 .ascii "op1 = \0"
180: 176 000004ac * .text
181: 177 00012BCB dd 8f000004a5 pushl $L404
182: 178 00012BD1 fe 08 effffffe9c callf $8,_writes
183: 179 00012BD8 # write32h( dbl_ld_acc.m );
184: 180 00012BD8 dd effffffe96 pushl _dbl_ld_acc
185: 181 00012BDE fe 08 effffffe8f callf $8,_write32h
186: 182 00012BE5 # writes(", op2 = ");
187: 183 00012BE5 .data 1
188: 184 000004ac * L406:
189: 185 000004ac * 2C2020206F7032203D2000 .ascii ", op2 = \0"
190: 186 000004b7 * .text
191: 187 00012BE5 dd 8f000004ac pushl $L406
192: 188 00012BEB fe 08 effffffe82 callf $8,_writes
193: 189 00012BF2 # write32h( dbl_value_1.m );
194: 190 00012BF2 dd effffffe7c pushl _dbl_value_1
195: 191 00012BF8 fe 08 effffffe75 callf $8,_write32h
196: 192 00012BFF # writec('\n');
197: 193 00012BFF dd 0a pushl $10
198: 194 00012C01 fe 08 effffffe6c callf $8,_writec
199: 195 00012C08 # }
200: 196 00012C08 # if ( halt_flg ) /* halt on error? */
201: 197 00012C08 L400:
202: 198 00012C08 5d effffffe66 tstl _halt_flg
203: 199 00012C0E 31 09 jeql L408
204: 200 00012C10 # pipe11_halt( 1 ); /* halt with a code of 1 */
205: 201 00012C10 dd 01 pushl $1
206: 202 00012C12 fe 08 ef0000027b callf $8,_pipe11_halt
207: 203 00012C19 # if ( loop_on_err )
208: 204 00012C19 L408:
209: 205 00012C19 5d effffffe55 tstl _loop_on_err
210: 206 00012C1F 31 0d jeql L410
211: 207 00012C21 # {
212: 208 00012C21 # force_loop = TRUE; /* set the force loop flag */
213: 209 00012C21 0d 01 effffffe4c movl $1,_force_loop
214: 210 00012C28 # asm("jmp _pipe11_lp1"); /* and loop */
215: 211 00012C28 71 effffffee3 jmp _pipe11_lp1
216: 212 00012C2E # };
217: 213 00012C2E L410:
218: 214 00012C2E # }
219: 215 00012C2E 40 ret#2
220: 216 00012C2F .set L396,0x0
221: 217 00012C2F L398:
222: 218 00012C2F 13 ff7e jbr L399
223: 219 00012C32 .data
224: 220 0000048c * .text
225: 221 00012C32 .align 1
226: 222 00012C32 .globl _bad_pipe11_result
227: 223 00012C32 _bad_pipe11_result:
228: 224 00012C32 0000 .word L411
229: 225 00012C34 #
230: 226 00012C34 #
231: 227 00012C34 #
232: 228 00012C34 #
233: 229 00012C34 # /****************************************************************************
234: 230 00012C34 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
235: 231 00012C34 # *
236: 232 00012C34 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
237: 233 00012C34 # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF)
238: 234 00012C34 # * The CVLF should not be executed.
239: 235 00012C34 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, op3 = xxxxxxxx
240: 236 00012C34 # * op2 = xxxxxxxx, expected = xxxxxxxx
241: 237 00012C34 # ****************************************************************************/
242: 238 00012C34 # bad_pipe11_result()
243: 239 00012C34 # {
244: 240 00012C34 13 00d9 jbr L413
245: 241 00012C37 L414:
246: 242 00012C37 # errcnt++; /* bump the error count */
247: 243 00012C37 6d effffffe37 incl _errcnt
248: 244 00012C3D # if ( prt_error )
249: 245 00012C3D 5d effffffe31 tstl _prt_error
250: 246 00012C43 21 03 13 00a1 jeql L415
251: 247 00012C48 # {
252: 248 00012C48 # print_pipe11_er( ". Bad final Accumulator" );
253: 249 00012C48 .data 1
254: 250 000004b7 * L416:
255: 251 000004b7 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
256: 16363756D756C61746F7200
257: 252 000004cf * .text
258: 253 00012C48 dd 8f000004b7 pushl $L416
259: 254 00012C4E fe 08 ef000001a1 callf $8,_print_pipe11_er
260: 255 00012C55 # writes(
261: 256 00012C55 # "The CVLF should not be executed\n");
262: 257 00012C55 .data 1
263: 258 000004cf * L417:
264: 259 000004cf * 5468652043564C462073686F7 .ascii "The CVLF should not be executed\12\0"
265: 56C64206E6F74206265206578
266: 6563757465640A00
267: 260 000004f0 * .text
268: 261 00012C55 dd 8f000004cf pushl $L417
269: 262 00012C5B fe 08 effffffe12 callf $8,_writes
270: 263 00012C62 # writes("op1 = ");
271: 264 00012C62 .data 1
272: 265 000004f0 * L418:
273: 266 000004f0 * 6F7031203D2000 .ascii "op1 = \0"
274: 267 000004f7 * .text
275: 268 00012C62 dd 8f000004f0 pushl $L418
276: 269 00012C68 fe 08 effffffe05 callf $8,_writes
277: 270 00012C6F # write32h( dbl_ld_acc.m );
278: 271 00012C6F dd effffffdff pushl _dbl_ld_acc
279: 272 00012C75 fe 08 effffffdf8 callf $8,_write32h
280: 273 00012C7C # writes(", final Acc. = ");
281: 274 00012C7C .data 1
282: 275 000004f7 * L419:
283: 276 000004f7 * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
284: E203D2000
285: 277 00000508 * .text
286: 278 00012C7C dd 8f000004f7 pushl $L419
287: 279 00012C82 fe 08 effffffdeb callf $8,_writes
288: 280 00012C89 # write32h( post_evt_acc.m );
289: 281 00012C89 dd effffffde5 pushl _post_evt_acc
290: 282 00012C8F fe 08 effffffdde callf $8,_write32h
291: 283 00012C96 # writes(", op3 = ");
292: 284 00012C96 .data 1
293: 285 00000508 * L420:
294: 286 00000508 * 2C2020206F7033203D2000 .ascii ", op3 = \0"
295: 287 00000513 * .text
296: 288 00012C96 dd 8f00000508 pushl $L420
297: 289 00012C9C fe 08 effffffdd1 callf $8,_writes
298: 290 00012CA3 # write32h( dbl_value_2.m );
299: 291 00012CA3 dd effffffdcb pushl _dbl_value_2
300: 292 00012CA9 fe 08 effffffdc4 callf $8,_write32h
301: 293 00012CB0 # writes("\nop2 = ");
302: 294 00012CB0 .data 1
303: 295 00000513 * L421:
304: 296 00000513 * 0A6F7032203D2000 .ascii "\12op2 = \0"
305: 297 0000051b * .text
306: 298 00012CB0 dd 8f00000513 pushl $L421
307: 299 00012CB6 fe 08 effffffdb7 callf $8,_writes
308: 300 00012CBD # write32h( dbl_value_1.m );
309: 301 00012CBD dd effffffdb1 pushl _dbl_value_1
310: 302 00012CC3 fe 08 effffffdaa callf $8,_write32h
311: 303 00012CCA # writes(", expected = ");
312: 304 00012CCA .data 1
313: 305 0000051b * L422:
314: 306 0000051b * 2C20202020657870656374656 .ascii ", expected = \0"
315: 4203D2000
316: 307 0000052c * .text
317: 308 00012CCA dd 8f0000051b pushl $L422
318: 309 00012CD0 fe 08 effffffd9d callf $8,_writes
319: 310 00012CD7 # write32h( 0 ); /* the expected result = 0 */
320: 311 00012CD7 dd 00 pushl $0
321: 312 00012CD9 fe 08 effffffd94 callf $8,_write32h
322: 313 00012CE0 # writec('\n');
323: 314 00012CE0 dd 0a pushl $10
324: 315 00012CE2 fe 08 effffffd8b callf $8,_writec
325: 316 00012CE9 # }
326: 317 00012CE9 # if ( halt_flg ) /* halt on error? */
327: 318 00012CE9 L415:
328: 319 00012CE9 5d effffffd85 tstl _halt_flg
329: 320 00012CEF 31 09 jeql L423
330: 321 00012CF1 # pipe11_halt( 2 ); /* halt with a code of 2 */
331: 322 00012CF1 dd 02 pushl $2
332: 323 00012CF3 fe 08 ef0000019a callf $8,_pipe11_halt
333: 324 00012CFA # if ( loop_on_err )
334: 325 00012CFA L423:
335: 326 00012CFA 5d effffffd74 tstl _loop_on_err
336: 327 00012D00 31 0d jeql L424
337: 328 00012D02 # {
338: 329 00012D02 # force_loop = TRUE; /* set the force loop flag */
339: 330 00012D02 0d 01 effffffd6b movl $1,_force_loop
340: 331 00012D09 # asm("jmp _pipe11_lp1"); /* and loop */
341: 332 00012D09 71 effffffe02 jmp _pipe11_lp1
342: 333 00012D0F # };
343: 334 00012D0F L424:
344: 335 00012D0F # }
345: 336 00012D0F 40 ret#2
346: 337 00012D10 .set L411,0x0
347: 338 00012D10 L413:
348: 339 00012D10 13 ff24 jbr L414
349: 340 00012D13 .data
350: 341 0000048c * .text
351: 342 00012D13 00 .align 1
352: 343 00012D14 .globl _pipe11_queue_er
353: 344 00012D14 _pipe11_queue_er:
354: 345 00012D14 0000 .word L425
355: 346 00012D16 #
356: 347 00012D16 #
357: 348 00012D16 #
358: 349 00012D16 #
359: 350 00012D16 #
360: 351 00012D16 # /****************************************************************************
361: 352 00012D16 # * Report an "FPP queue not cleared" message
362: 353 00012D16 # *
363: 354 00012D16 # * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx
364: 355 00012D16 # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF)
365: 356 00012D16 # * The CVLF should not have been executed but apparently was.
366: 357 00012D16 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, op3 = xxxxxxxx
367: 358 00012D16 # * op2 = xxxxxxxx, expected = xxxxxxxx
368: 359 00012D16 # ****************************************************************************/
369: 360 00012D16 # pipe11_queue_er()
370: 361 00012D16 # {
371: 362 00012D16 13 00d9 jbr L427
372: 363 00012D19 L428:
373: 364 00012D19 # errcnt++; /* bump the error count */
374: 365 00012D19 6d effffffd55 incl _errcnt
375: 366 00012D1F # if ( prt_error )
376: 367 00012D1F 5d effffffd4f tstl _prt_error
377: 368 00012D25 21 03 13 00a1 jeql L429
378: 369 00012D2A # {
379: 370 00012D2A # print_pipe11_er( ". Fpp queue not cleared" );
380: 371 00012D2A .data 1
381: 372 0000052c * L430:
382: 373 0000052c * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0"
383: E6F7420636C656172656400
384: 374 00000544 * .text
385: 375 00012D2A dd 8f0000052c pushl $L430
386: 376 00012D30 fe 08 ef000000bf callf $8,_print_pipe11_er
387: 377 00012D37 # writes(
388: 378 00012D37 # "The CVLF should not have been executed but apparently was.\n");
389: 379 00012D37 .data 1
390: 380 00000544 * L431:
391: 381 00000544 * 5468652043564C462073686F7 .ascii "The CVLF should not have been executed but apparently was.\12\0"
392: 56C64206E6F74206861766520
393: 6265656E20657865637574656
394: 420627574206170706172656E
395: 746C79207761732E0A00
396: 382 00000580 * .text
397: 383 00012D37 dd 8f00000544 pushl $L431
398: 384 00012D3D fe 08 effffffd30 callf $8,_writes
399: 385 00012D44 # writes("op1 = ");
400: 386 00012D44 .data 1
401: 387 00000580 * L432:
402: 388 00000580 * 6F7031203D2000 .ascii "op1 = \0"
403: 389 00000587 * .text
404: 390 00012D44 dd 8f00000580 pushl $L432
405: 391 00012D4A fe 08 effffffd23 callf $8,_writes
406: 392 00012D51 # write32h( dbl_ld_acc.m );
407: 393 00012D51 dd effffffd1d pushl _dbl_ld_acc
408: 394 00012D57 fe 08 effffffd16 callf $8,_write32h
409: 395 00012D5E # writes(", final Acc. = ");
410: 396 00012D5E .data 1
411: 397 00000587 * L433:
412: 398 00000587 * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
413: E203D2000
414: 399 00000598 * .text
415: 400 00012D5E dd 8f00000587 pushl $L433
416: 401 00012D64 fe 08 effffffd09 callf $8,_writes
417: 402 00012D6B # write32h( post_evt_acc.m );
418: 403 00012D6B dd effffffd03 pushl _post_evt_acc
419: 404 00012D71 fe 08 effffffcfc callf $8,_write32h
420: 405 00012D78 # writes(", op3 = ");
421: 406 00012D78 .data 1
422: 407 00000598 * L434:
423: 408 00000598 * 2C20206F7033203D2000 .ascii ", op3 = \0"
424: 409 000005a2 * .text
425: 410 00012D78 dd 8f00000598 pushl $L434
426: 411 00012D7E fe 08 effffffcef callf $8,_writes
427: 412 00012D85 # write32h( dbl_value_2.m );
428: 413 00012D85 dd effffffce9 pushl _dbl_value_2
429: 414 00012D8B fe 08 effffffce2 callf $8,_write32h
430: 415 00012D92 # writes("\nop2 = ");
431: 416 00012D92 .data 1
432: 417 000005a2 * L435:
433: 418 000005a2 * 0A6F7032203D2000 .ascii "\12op2 = \0"
434: 419 000005aa * .text
435: 420 00012D92 dd 8f000005a2 pushl $L435
436: 421 00012D98 fe 08 effffffcd5 callf $8,_writes
437: 422 00012D9F # write32h( dbl_value_1.m );
438: 423 00012D9F dd effffffccf pushl _dbl_value_1
439: 424 00012DA5 fe 08 effffffcc8 callf $8,_write32h
440: 425 00012DAC # writes(", expected = ");
441: 426 00012DAC .data 1
442: 427 000005aa * L436:
443: 428 000005aa * 2C20202020657870656374656 .ascii ", expected = \0"
444: 4203D2000
445: 429 000005bb * .text
446: 430 00012DAC dd 8f000005aa pushl $L436
447: 431 00012DB2 fe 08 effffffcbb callf $8,_writes
448: 432 00012DB9 # write32h( 0 ); /* the expected result = 0 */
449: 433 00012DB9 dd 00 pushl $0
450: 434 00012DBB fe 08 effffffcb2 callf $8,_write32h
451: 435 00012DC2 # writec('\n');
452: 436 00012DC2 dd 0a pushl $10
453: 437 00012DC4 fe 08 effffffca9 callf $8,_writec
454: 438 00012DCB # }
455: 439 00012DCB # if ( halt_flg ) /* halt on error? */
456: 440 00012DCB L429:
457: 441 00012DCB 5d effffffca3 tstl _halt_flg
458: 442 00012DD1 31 09 jeql L437
459: 443 00012DD3 # pipe11_halt( 3 ); /* halt with a code of 3 */
460: 444 00012DD3 dd 03 pushl $3
461: 445 00012DD5 fe 08 ef000000b8 callf $8,_pipe11_halt
462: 446 00012DDC # if ( loop_on_err )
463: 447 00012DDC L437:
464: 448 00012DDC 5d effffffc92 tstl _loop_on_err
465: 449 00012DE2 31 0d jeql L438
466: 450 00012DE4 # {
467: 451 00012DE4 # force_loop = TRUE; /* set the force loop flag */
468: 452 00012DE4 0d 01 effffffc89 movl $1,_force_loop
469: 453 00012DEB # asm("jmp _pipe11_lp1"); /* and loop */
470: 454 00012DEB 71 effffffd20 jmp _pipe11_lp1
471: 455 00012DF1 # };
472: 456 00012DF1 L438:
473: 457 00012DF1 # }
474: 458 00012DF1 40 ret#2
475: 459 00012DF2 .set L425,0x0
476: 460 00012DF2 L427:
477: 461 00012DF2 13 ff24 jbr L428
478: 462 00012DF5 .data
479: 463 0000048c * .text
480: 464 00012DF5 00 .align 1
481: 465 00012DF6 .globl _print_pipe11_er
482: 466 00012DF6 _print_pipe11_er:
483: 467 00012DF6 0000 .word L439
484: 468 00012DF8 #
485: 469 00012DF8 #
486: 470 00012DF8 #
487: 471 00012DF8 #
488: 472 00012DF8 # /****************************************************************************
489: 473 00012DF8 # * Report an error message of the form:
490: 474 00012DF8 # *
491: 475 00012DF8 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
492: 476 00012DF8 # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF)
493: 477 00012DF8 # ****************************************************************************/
494: 478 00012DF8 # print_pipe11_er( msg )
495: 479 00012DF8 # char *msg; /* error message to print */
496: 480 00012DF8 # {
497: 481 00012DF8 13 0096 jbr L441
498: 482 00012DFB L442:
499: 483 00012DFB # if( errcnt == 1 ) /* 1st error? */
500: 484 00012DFB 1d effffffc73 01 cmpl _errcnt,$1
501: 485 00012E02 21 0d jneq L443
502: 486 00012E04 # writes(" \n"); /* start a new print line */
503: 487 00012E04 .data 1
504: 488 000005bb * L444:
505: 489 000005bb * 200A00 .ascii " \12\0"
506: 490 000005be * .text
507: 491 00012E04 dd 8f000005bb pushl $L444
508: 492 00012E0A fe 08 effffffc63 callf $8,_writes
509: 493 00012E11 # writes("Cycle: ");
510: 494 00012E11 L443:
511: 495 00012E11 .data 1
512: 496 000005be * L445:
513: 497 000005be * 4379636C653A2000 .ascii "Cycle: \0"
514: 498 000005c6 * .text
515: 499 00012E11 dd 8f000005be pushl $L445
516: 500 00012E17 fe 08 effffffc56 callf $8,_writes
517: 501 00012E1E # writed( cycle );
518: 502 00012E1E dd effffffc50 pushl _cycle
519: 503 00012E24 fe 08 effffffc49 callf $8,_writed
520: 504 00012E2B # writes(" EVT test ");
521: 505 00012E2B .data 1
522: 506 000005c6 * L447:
523: 507 000005c6 * 202045565420746573742000 .ascii " EVT test \0"
524: 508 000005d2 * .text
525: 509 00012E2B dd 8f000005c6 pushl $L447
526: 510 00012E31 fe 08 effffffc3c callf $8,_writes
527: 511 00012E38 # writed( test_no );
528: 512 00012E38 dd effffffc36 pushl _test_no
529: 513 00012E3E fe 08 effffffc2f callf $8,_writed
530: 514 00012E45 # writes(". subtest ");
531: 515 00012E45 .data 1
532: 516 000005d2 * L448:
533: 517 000005d2 * 2E20737562746573742000 .ascii ". subtest \0"
534: 518 000005dd * .text
535: 519 00012E45 dd 8f000005d2 pushl $L448
536: 520 00012E4B fe 08 effffffc22 callf $8,_writes
537: 521 00012E52 # writed( subtest );
538: 522 00012E52 dd effffffc1c pushl _subtest
539: 523 00012E58 fe 08 effffffc15 callf $8,_writed
540: 524 00012E5F # writes( msg ); /* print the message */
541: 525 00012E5F dd ad04 pushl 4(fp)
542: 526 00012E62 fe 08 effffffc0b callf $8,_writes
543: 527 00012E69 # writes(". index = ");
544: 528 00012E69 .data 1
545: 529 000005dd * L449:
546: 530 000005dd * 2E20696E646578203D2000 .ascii ". index = \0"
547: 531 000005e8 * .text
548: 532 00012E69 dd 8f000005dd pushl $L449
549: 533 00012E6F fe 08 effffffbfe callf $8,_writes
550: 534 00012E76 # writed( index );
551: 535 00012E76 dd effffffbf8 pushl _index
552: 536 00012E7C fe 08 effffffbf1 callf $8,_writed
553: 537 00012E83 # writes(
554: 538 00012E83 # "\ninst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF)\n");
555: 539 00012E83 .data 1
556: 540 000005e8 * L450:
557: 541 000005e8 * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the AD"
558: F70312C2041444446206F7032
559: 2C2043564C46206F703320202
560: 020286F766572666C6F772066
561: 61756C74206F6E20746865204
562: 144
563: 542 00000628 * 4446290A00 .ascii "DF)\12\0"
564: 543 0000062d * .text
565: 544 00012E83 dd 8f000005e8 pushl $L450
566: 545 00012E89 fe 08 effffffbe4 callf $8,_writes
567: 546 00012E90 # }
568: 547 00012E90 40 ret#2
569: 548 00012E91 .set L439,0x0
570: 549 00012E91 L441:
571: 550 00012E91 13 ff67 jbr L442
572: 551 00012E94 .data
573: 552 0000048c * .text
574: 553 00012E94 .align 1
575: 554 00012E94 .globl _pipe11_halt
576: 555 00012E94 _pipe11_halt:
577: 556 00012E94 0000 .word L451
578: 557 00012E96 #
579: 558 00012E96 #
580: 559 00012E96 #
581: 560 00012E96 # /****************************************************************************
582: 561 00012E96 # * halt on error routine
583: 562 00012E96 # ****************************************************************************/
584: 563 00012E96 # pipe11_halt( code )
585: 564 00012E96 # int code; /* error code to halt with */
586: 565 00012E96 # {
587: 566 00012E96 11 65 jbr L453
588: 567 00012E98 L454:
589: 568 00012E98 # err_code = code;
590: 569 00012E98 0d ad04 effffffbd4 movl 4(fp),_err_code
591: 570 00012EA0 # sgl_value_1 = dbl_ld_acc.m;
592: 571 00012EA0 0d effffffbce effffffbc9 movl _dbl_ld_acc,_sgl_value_1
593: 572 00012EAB # sgl_value_2 = dbl_value_1.m;
594: 573 00012EAB 0d effffffbc3 effffffbbe movl _dbl_value_1,_sgl_value_2
595: 574 00012EB6 # sgl_value_3 = post_evt_acc.m;
596: 575 00012EB6 0d effffffbb8 effffffbb3 movl _post_evt_acc,_sgl_value_3
597: 576 00012EC1 # asm("movl _test_no,r0"); /* r0 = test number */
598: 577 00012EC1 0d effffffbad 50 movl _test_no,r0
599: 578 00012EC8 # asm("movl _subtest,r1"); /* r1 = subtest number */
600: 579 00012EC8 0d effffffba6 51 movl _subtest,r1
601: 580 00012ECF # asm("movl _err_code,r2"); /* r2 = error code */
602: 581 00012ECF 0d effffffb9f 52 movl _err_code,r2
603: 582 00012ED6 # asm("movl _cycle,r3"); /* r3 = cycle count */
604: 583 00012ED6 0d effffffb98 53 movl _cycle,r3
605: 584 00012EDD # asm("movl _sgl_value_1,r4"); /* r4 = initial accumulator */
606: 585 00012EDD 0d effffffb91 54 movl _sgl_value_1,r4
607: 586 00012EE4 # asm("movl _sgl_value_2,r5"); /* r5 = ADDF operand */
608: 587 00012EE4 0d effffffb8a 55 movl _sgl_value_2,r5
609: 588 00012EEB # asm("movl _sgl_value_3,r6"); /* r6 = final accumulator */
610: 589 00012EEB 0d effffffb83 56 movl _sgl_value_3,r6
611: 590 00012EF2 # asm("clrl r7"); /* r7 = expected accumulator */
612: 591 00012EF2 4d 57 clrl r7
613: 592 00012EF4 # asm("movl _index,r8"); /* r8 = data index */
614: 593 00012EF4 0d effffffb7a 58 movl _index,r8
615: 594 00012EFB # asm("halt"); /* HALT ... */
616: 595 00012EFB 00 halt
617: 596 00012EFC # }
618: 597 00012EFC 40 ret#2
619: 598 00012EFD .set L451,0x0
620: 599 00012EFD L453:
621: 600 00012EFD 11 99 jbr L454
622: 601 00012EFF .data
623: 601 00025973 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.