![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe7.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 pipe7.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 000005c8 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe7
6: 6 00000000 _pipe7:
7: 7 000116F4 0000 .word L381
8: 8 000116F6 #
9: 9 000116F6 # #include "evt_defs.h"
10: 10 000116F6 # #define MAX_POS 0x7fffffff;
11: 11 000116F6 #
12: 12 000116F6 # /*
13: 13 000116F6 # *********************************************************************
14: 14 000116F6 # * FPP PIPELINED EVENTS TEST #7
15: 15 000116F6 # *
16: 16 000116F6 # * This test will execute the following code: "LDF DIVF MULL3 NEGF"
17: 17 000116F6 # * with an integer overflow fault on the MULL3. We will make sure that:
18: 18 000116F6 # * 1. The fault is detected,
19: 19 000116F6 # * 2. the floating divide operation completes,
20: 20 000116F6 # * 3. and that the negate doesn't complete
21: 21 000116F6 # *********************************************************************
22: 22 000116F6 # */
23: 23 000116F6 # pipe7()
24: 24 000116F6 # {
25: 25 000116F6 13 0166 jbr L383
26: 26 000116F9 L384:
27: 27 000116F9 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
28: 28 000116F9 ed 6d effffffff4 moval (r13),_pre_event_fp
29: 29 00011700 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
30: 30 00011700 ed 6e efffffffed moval (r14),_pre_event_sp
31: 31 00011707 # precision = SGL;
32: 32 00011707 0d 01 efffffffe6 movl $1,_precision
33: 33 0001170E # test_event = ARITH_CODE; /* expect an arithmetic fault */
34: 34 0001170E 0d 34 efffffffdf movl $52,_test_event
35: 35 00011715 # exp_code = INT_OVFL_CODE; /* -specificly int overflow */
36: 36 00011715 0d 01 efffffffd8 movl $1,_exp_code
37: 37 0001171C # exp_event = FALSE; /* ... but not yet */
38: 38 0001171C 4d efffffffd2 clrl _exp_event
39: 39 00011722 # asm("movab _pipe7_ret,_event_return"); /* post event addr */
40: 40 00011722 e9 ef000000df efffffffc7 movab _pipe7_ret,_event_return
41: 41 0001172D # for( index = 0; index < max_pipe7_index; index++ )
42: 42 0001172D 4d efffffffc1 clrl _index
43: 43 00011733 L387:
44: 44 00011733 1d efffffffbb efffffffb6 cmpl _index,_max_pipe7_index
45: 45 0001173E 91 03 13 011b jgeq L386
46: 46 00011743 # {
47: 47 00011743 # dbl_ld_acc = pipe7_data[index].op_1; /* get the data */
48: 48 00011743 5c 18 efffffffaa 50 mull3 $24,_index,r0
49: 49 0001174B 0c 8f00000000 50 addl2 $_pipe7_data,r0
50: 50 00011752 0d a004 efffffff9e movl 4(r0),_dbl_ld_acc+4
51: 51 0001175A 0d 60 efffffff93 movl (r0),_dbl_ld_acc
52: 52 00011761 # dbl_value_1 = pipe7_data[index].op_2;
53: 53 00011761 5c 18 efffffff8c 50 mull3 $24,_index,r0
54: 54 00011769 0c 8f00000008 50 addl2 $_pipe7_data+8,r0
55: 55 00011770 0d a004 efffffff80 movl 4(r0),_dbl_value_1+4
56: 56 00011778 0d 60 efffffff75 movl (r0),_dbl_value_1
57: 57 0001177F # dbl_expected = pipe7_data[index].exp;
58: 58 0001177F 5c 18 efffffff6e 50 mull3 $24,_index,r0
59: 59 00011787 0c 8f00000010 50 addl2 $_pipe7_data+16,r0
60: 60 0001178E 0d a004 efffffff62 movl 4(r0),_dbl_expected+4
61: 61 00011796 0d 60 efffffff57 movl (r0),_dbl_expected
62: 62 0001179D # sgl_value_1 = 0x12345; /* get overflow data */
63: 63 0001179D 0d 8f00012345 efffffff4c movl $74565,_sgl_value_1
64: 64 000117A8 # sgl_value_2 = MAX_POS;
65: 65 000117A8 0d 8f7fffffff efffffff41 movl $2147483647,_sgl_value_2
66: 66 000117B3 # asm("bispsw $0x60"); /* enable ovfl,undfl */
67: 67 000117B3 8b 8860 bispsw $0x60
68: 68 000117B6 # asm(".globl _pipe7_lp1");
69: 69 000117B6 .globl _pipe7_lp1
70: 70 000117B6 # asm("_pipe7_lp1:");
71: 71 000117B6 _pipe7_lp1:
72: 72 000117B6 # asm("ldf _dbl_ld_acc"); /* load the Acc. */
73: 73 000117B6 06 efffffff38 ldf _dbl_ld_acc
74: 74 000117BC # exp_event = test_event; /* expect event soon */
75: 75 000117BC 0d efffffff32 efffffff2d movl _test_event,_exp_event
76: 76 000117C7 # asm("divf _dbl_value_1"); /* divide by op.#2 */
77: 77 000117C7 f6 efffffff27 divf _dbl_value_1
78: 78 000117CD # asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3");
79: 79 000117CD 5c efffffff21 efffffff1c mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3
80: efffffff17
81: 80 000117DD # asm("negf");
82: 81 000117DD b6 negf
83: 82 000117DE # /*
84: 83 000117DE # * If we got to here then there was no event
85: 84 000117DE # */
86: 85 000117DE # if( force_loop )
87: 86 000117DE 5d efffffff10 tstl _force_loop
88: 87 000117E4 31 03 jeql L388
89: 88 000117E6 # asm("brw _pipe7_lp1");; /* loop on the error */
90: Assemb00028EB4 # asm("brw _pipe7_lp1");; /* loop on the error */
91: "pipe700028EB4 89: WARNING: brw: destination label is external
92: 89 000117E6 13 ffcd brw _pipe7_lp1
93: 90 000117E9 L388:
94: 91 000117E9 # exp_event = FALSE; /* reset event expected flag */
95: 92 000117E9 4d efffffff05 clrl _exp_event
96: 93 000117EF # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
97: 94 000117EF 0d effffffeff 5d movl _pre_event_fp,fp
98: 95 000117F6 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
99: 96 000117F6 0d effffffef8 5e movl _pre_event_sp,sp
100: 97 000117FD # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
101: 98 000117FD 9b 8860 bicpsw $0x60
102: 99 00011800 # no_pipe7_evt();; /* report the error */
103: 100 00011800 fe 04 ef0000005b callf $4,_no_pipe7_evt
104: 101 00011807 # /*
105: 102 00011807 # * Come here after the event
106: 103 00011807 # */
107: 104 00011807 # asm(".globl _pipe7_ret");
108: 105 00011807 .globl _pipe7_ret
109: 106 00011807 # asm("_pipe7_ret:");
110: 107 00011807 _pipe7_ret:
111: 108 00011807 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
112: 109 00011807 0d effffffee7 5d movl _pre_event_fp,fp
113: 110 0001180E # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
114: 111 0001180E 0d effffffee0 5e movl _pre_event_sp,sp
115: 112 00011815 # if( force_loop )
116: 113 00011815 5d effffffed9 tstl _force_loop
117: 114 0001181B 31 03 jeql L390
118: 115 0001181D # asm("brw _pipe7_lp1");; /* loop on the error */
119: "pipe700028EB4 116: WARNING: brw: destination label is external
120: 116 0001181D 13 ff96 brw _pipe7_lp1
121: 117 00011820 L390:
122: 118 00011820 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
123: 119 00011820 9b 8860 bicpsw $0x60
124: 120 00011823 # if( post_evt_acc.m == (dbl_expected.m ^ 0x80000000) )
125: 121 00011823 dc 8f80000000 effffffec6 xorl3 $-2147483648,_dbl_expected,r0
126: 50
127: 122 0001182F 1d effffffebf 50 cmpl _post_evt_acc,r0
128: 123 00011836 21 09 jneq L391
129: 124 00011838 # pipe7_queue_er(); /* fpp queue not cleared */
130: 125 00011838 fe 04 ef00000215 callf $4,_pipe7_queue_er
131: 126 0001183F # else if( post_evt_acc.m != dbl_expected.m )
132: 127 0001183F 11 14 jbr L393
133: 128 00011841 L391:
134: 129 00011841 1d effffffead effffffea8 cmpl _post_evt_acc,_dbl_expected
135: 130 0001184C 31 07 jeql L394
136: 131 0001184E # bad_pipe7_result(); /* incorrect result error */
137: 132 0001184E fe 04 ef000000e5 callf $4,_bad_pipe7_result
138: 133 00011855 # }
139: 134 00011855 L394:
140: 135 00011855 L393:
141: 136 00011855 L385:
142: 137 00011855 6d effffffe99 incl _index
143: 138 0001185B 13 fed5 jbr L387
144: 139 0001185E L386:
145: 140 0001185E # }
146: 141 0001185E 40 ret#2
147: 142 0001185F .set L381,0x0
148: 143 0001185F L383:
149: 144 0001185F 13 fe97 jbr L384
150: 145 00011862 .data
151: 146 000005c8 * .text
152: 147 00011862 .align 1
153: 148 00011862 .globl _no_pipe7_evt
154: 149 00011862 _no_pipe7_evt:
155: 150 00011862 0000 .word L396
156: 151 00011864 #
157: 152 00011864 #
158: 153 00011864 #
159: 154 00011864 # /****************************************************************************
160: 155 00011864 # * Report an "EVENT NOT DETECTED" error
161: 156 00011864 # *
162: 157 00011864 # * Cycle: xx. EVT test xx. subtest xx. no integer overflow fault. index = xx
163: 158 00011864 # * inst = LDF op1, DIVF op2, MULL3 op3,op4,op5, NEGF (int. overflow on MULL3)
164: 159 00011864 # * op1 = xxxxxxxx, op2 = xxxxxxxx
165: 160 00011864 # * op3 = xxxxxxxx, op4 = xxxxxxxx, op5 = xxxxxxxx
166: 161 00011864 # ****************************************************************************/
167: 162 00011864 # no_pipe7_evt()
168: 163 00011864 # {
169: 164 00011864 13 00d0 jbr L398
170: 165 00011867 L399:
171: 166 00011867 # errcnt++; /* bump the error count */
172: 167 00011867 6d effffffe87 incl _errcnt
173: 168 0001186D # if ( prt_error )
174: 169 0001186D 5d effffffe81 tstl _prt_error
175: 170 00011873 21 03 13 0098 jeql L400
176: 171 00011878 # {
177: 172 00011878 # print_pipe7_er( ". no integer overflow fault.");
178: 173 00011878 .data 1
179: 174 000005c8 * L402:
180: 175 000005c8 * 2E206E6F20696E74656765722 .ascii ". no integer overflow fault.\0"
181: 06F766572666C6F7720666175
182: 6C742E00
183: 176 000005e5 * .text
184: 177 00011878 dd 8f000005c8 pushl $L402
185: 178 0001187E fe 08 ef000002e9 callf $8,_print_pipe7_er
186: 179 00011885 # writes("op1 = ");
187: 180 00011885 .data 1
188: 181 000005e5 * L404:
189: 182 000005e5 * 6F7031203D2000 .ascii "op1 = \0"
190: 183 000005ec * .text
191: 184 00011885 dd 8f000005e5 pushl $L404
192: 185 0001188B fe 08 effffffe62 callf $8,_writes
193: 186 00011892 # write32h( dbl_ld_acc.m );
194: 187 00011892 dd effffffe5c pushl _dbl_ld_acc
195: 188 00011898 fe 08 effffffe55 callf $8,_write32h
196: 189 0001189F # writes(", op2 = ");
197: 190 0001189F .data 1
198: 191 000005ec * L406:
199: 192 000005ec * 2C20206F7032203D2000 .ascii ", op2 = \0"
200: 193 000005f6 * .text
201: 194 0001189F dd 8f000005ec pushl $L406
202: 195 000118A5 fe 08 effffffe48 callf $8,_writes
203: 196 000118AC # write32h( dbl_value_1.m );
204: 197 000118AC dd effffffe42 pushl _dbl_value_1
205: 198 000118B2 fe 08 effffffe3b callf $8,_write32h
206: 199 000118B9 # writes("\nop3 = ");
207: 200 000118B9 .data 1
208: 201 000005f6 * L407:
209: 202 000005f6 * 0A6F7033203D2000 .ascii "\12op3 = \0"
210: 203 000005fe * .text
211: 204 000118B9 dd 8f000005f6 pushl $L407
212: 205 000118BF fe 08 effffffe2e callf $8,_writes
213: 206 000118C6 # write32h( sgl_value_1 );
214: 207 000118C6 dd effffffe28 pushl _sgl_value_1
215: 208 000118CC fe 08 effffffe21 callf $8,_write32h
216: 209 000118D3 # writes(", op4 = ");
217: 210 000118D3 .data 1
218: 211 000005fe * L408:
219: 212 000005fe * 2C20206F7034203D2000 .ascii ", op4 = \0"
220: 213 00000608 * .text
221: 214 000118D3 dd 8f000005fe pushl $L408
222: 215 000118D9 fe 08 effffffe14 callf $8,_writes
223: 216 000118E0 # write32h( sgl_value_2 );
224: 217 000118E0 dd effffffe0e pushl _sgl_value_2
225: 218 000118E6 fe 08 effffffe07 callf $8,_write32h
226: 219 000118ED # writes(", op5 = ");
227: 220 000118ED .data 1
228: 221 00000608 * L409:
229: 222 00000608 * 2C20206F7035203D2000 .ascii ", op5 = \0"
230: 223 00000612 * .text
231: 224 000118ED dd 8f00000608 pushl $L409
232: 225 000118F3 fe 08 effffffdfa callf $8,_writes
233: 226 000118FA # write32h( sgl_value_3 );
234: 227 000118FA dd effffffdf4 pushl _sgl_value_3
235: 228 00011900 fe 08 effffffded callf $8,_write32h
236: 229 00011907 # writec('\n');
237: 230 00011907 dd 0a pushl $10
238: 231 00011909 fe 08 effffffde4 callf $8,_writec
239: 232 00011910 # }
240: 233 00011910 # if ( halt_flg ) /* halt on error? */
241: 234 00011910 L400:
242: 235 00011910 5d effffffdde tstl _halt_flg
243: 236 00011916 31 09 jeql L411
244: 237 00011918 # pipe7_halt( 1 );
245: 238 00011918 dd 01 pushl $1
246: 239 0001191A fe 08 ef000002f9 callf $8,_pipe7_halt
247: 240 00011921 # if ( loop_on_err )
248: 241 00011921 L411:
249: 242 00011921 5d effffffdcd tstl _loop_on_err
250: 243 00011927 31 0d jeql L413
251: 244 00011929 # {
252: 245 00011929 # force_loop = TRUE; /* set the force loop flag */
253: 246 00011929 0d 01 effffffdc4 movl $1,_force_loop
254: 247 00011930 # asm("jmp _pipe7_lp1"); /* and loop */
255: 248 00011930 71 effffffe80 jmp _pipe7_lp1
256: 249 00011936 # };
257: 250 00011936 L413:
258: 251 00011936 # }
259: 252 00011936 40 ret#2
260: 253 00011937 .set L396,0x0
261: 254 00011937 L398:
262: 255 00011937 13 ff2d jbr L399
263: 256 0001193A .data
264: 257 000005c8 * .text
265: 258 0001193A .align 1
266: 259 0001193A .globl _bad_pipe7_result
267: 260 0001193A _bad_pipe7_result:
268: 261 0001193A 0000 .word L414
269: 262 0001193C #
270: 263 0001193C #
271: 264 0001193C #
272: 265 0001193C #
273: 266 0001193C # /****************************************************************************
274: 267 0001193C # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
275: 268 0001193C # *
276: 269 0001193C # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
277: 270 0001193C # * inst = LDF op1, DIVF op2, MULL3 op3,op4,op5, NEGF (int. overflow on MULL3)
278: 271 0001193C # * The NEGF should not have been executed.
279: 272 0001193C # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, op3 = xxxxxxxx
280: 273 0001193C # * op2 = xxxxxxxx, expected = xxxxxxxx, op4 = xxxxxxxx, op5 = xxxxxxxx
281: 274 0001193C # ****************************************************************************/
282: 275 0001193C # bad_pipe7_result()
283: 276 0001193C # {
284: 277 0001193C 13 0111 jbr L416
285: 278 0001193F L417:
286: 279 0001193F # errcnt++; /* bump the error count */
287: 280 0001193F 6d effffffdaf incl _errcnt
288: 281 00011945 # if ( prt_error )
289: 282 00011945 5d effffffda9 tstl _prt_error
290: 283 0001194B 21 03 13 00d9 jeql L418
291: 284 00011950 # {
292: 285 00011950 # print_pipe7_er(". Bad final Accumulator.");
293: 286 00011950 .data 1
294: 287 00000612 * L419:
295: 288 00000612 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator.\0"
296: 16363756D756C61746F722E00
297: 289 0000062b * .text
298: 290 00011950 dd 8f00000612 pushl $L419
299: 291 00011956 fe 08 ef00000211 callf $8,_print_pipe7_er
300: 292 0001195D # writes("The NEGF should not have been executed.\n");
301: 293 0001195D .data 1
302: 294 0000062b * L420:
303: 295 0000062b * 546865204E4547462073686F7 .ascii "The NEGF should not have been executed.\12\0"
304: 56C64206E6F74206861766520
305: 6265656E20657865637574656
306: 42E0A00
307: 296 00000654 * .text
308: 297 0001195D dd 8f0000062b pushl $L420
309: 298 00011963 fe 08 effffffd8a callf $8,_writes
310: 299 0001196A # writes("op1 = ");
311: 300 0001196A .data 1
312: 301 00000654 * L421:
313: 302 00000654 * 6F7031203D2000 .ascii "op1 = \0"
314: 303 0000065b * .text
315: 304 0001196A dd 8f00000654 pushl $L421
316: 305 00011970 fe 08 effffffd7d callf $8,_writes
317: 306 00011977 # write32h( dbl_value_1.m );
318: 307 00011977 dd effffffd77 pushl _dbl_value_1
319: 308 0001197D fe 08 effffffd70 callf $8,_write32h
320: 309 00011984 # writes(", final Acc. = ");
321: 310 00011984 .data 1
322: 311 0000065b * L422:
323: 312 0000065b * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
324: E203D2000
325: 313 0000066c * .text
326: 314 00011984 dd 8f0000065b pushl $L422
327: 315 0001198A fe 08 effffffd63 callf $8,_writes
328: 316 00011991 # write32h( post_evt_acc.m );
329: 317 00011991 dd effffffd5d pushl _post_evt_acc
330: 318 00011997 fe 08 effffffd56 callf $8,_write32h
331: 319 0001199E # writes(", op3 = ");
332: 320 0001199E .data 1
333: 321 0000066c * L423:
334: 322 0000066c * 2C20206F7033203D2000 .ascii ", op3 = \0"
335: 323 00000676 * .text
336: 324 0001199E dd 8f0000066c pushl $L423
337: 325 000119A4 fe 08 effffffd49 callf $8,_writes
338: 326 000119AB # write32h( sgl_value_1 );
339: 327 000119AB dd effffffd43 pushl _sgl_value_1
340: 328 000119B1 fe 08 effffffd3c callf $8,_write32h
341: 329 000119B8 # writes("\nop2 = ");
342: 330 000119B8 .data 1
343: 331 00000676 * L424:
344: 332 00000676 * 0A6F7032203D2000 .ascii "\12op2 = \0"
345: 333 0000067e * .text
346: 334 000119B8 dd 8f00000676 pushl $L424
347: 335 000119BE fe 08 effffffd2f callf $8,_writes
348: 336 000119C5 # write32h( dbl_value_2.m );
349: 337 000119C5 dd effffffd29 pushl _dbl_value_2
350: 338 000119CB fe 08 effffffd22 callf $8,_write32h
351: 339 000119D2 # writes(", expected = ");
352: 340 000119D2 .data 1
353: 341 0000067e * L425:
354: 342 0000067e * 2C20202020657870656374656 .ascii ", expected = \0"
355: 4203D2000
356: 343 0000068f * .text
357: 344 000119D2 dd 8f0000067e pushl $L425
358: 345 000119D8 fe 08 effffffd15 callf $8,_writes
359: 346 000119DF # write32h( dbl_expected.m );
360: 347 000119DF dd effffffd0f pushl _dbl_expected
361: 348 000119E5 fe 08 effffffd08 callf $8,_write32h
362: 349 000119EC # writes(", op4 = ");
363: 350 000119EC .data 1
364: 351 0000068f * L426:
365: 352 0000068f * 2C20206F7034203D2000 .ascii ", op4 = \0"
366: 353 00000699 * .text
367: 354 000119EC dd 8f0000068f pushl $L426
368: 355 000119F2 fe 08 effffffcfb callf $8,_writes
369: 356 000119F9 # write32h( sgl_value_2 );
370: 357 000119F9 dd effffffcf5 pushl _sgl_value_2
371: 358 000119FF fe 08 effffffcee callf $8,_write32h
372: 359 00011A06 # writes(", op5 = ");
373: 360 00011A06 .data 1
374: 361 00000699 * L427:
375: 362 00000699 * 2C20206F7035203D2000 .ascii ", op5 = \0"
376: 363 000006a3 * .text
377: 364 00011A06 dd 8f00000699 pushl $L427
378: 365 00011A0C fe 08 effffffce1 callf $8,_writes
379: 366 00011A13 # write32h( sgl_value_3 );
380: 367 00011A13 dd effffffcdb pushl _sgl_value_3
381: 368 00011A19 fe 08 effffffcd4 callf $8,_write32h
382: 369 00011A20 # writec('\n');
383: 370 00011A20 dd 0a pushl $10
384: 371 00011A22 fe 08 effffffccb callf $8,_writec
385: 372 00011A29 # }
386: 373 00011A29 # if ( halt_flg ) /* halt on error? */
387: 374 00011A29 L418:
388: 375 00011A29 5d effffffcc5 tstl _halt_flg
389: 376 00011A2F 31 09 jeql L428
390: 377 00011A31 # pipe7_halt( 2 );
391: 378 00011A31 dd 02 pushl $2
392: 379 00011A33 fe 08 ef000001e0 callf $8,_pipe7_halt
393: 380 00011A3A # if ( loop_on_err )
394: 381 00011A3A L428:
395: 382 00011A3A 5d effffffcb4 tstl _loop_on_err
396: 383 00011A40 31 0d jeql L429
397: 384 00011A42 # {
398: 385 00011A42 # force_loop = TRUE; /* set the force loop flag */
399: 386 00011A42 0d 01 effffffcab movl $1,_force_loop
400: 387 00011A49 # asm("jmp _pipe7_lp1"); /* and loop */
401: 388 00011A49 71 effffffd67 jmp _pipe7_lp1
402: 389 00011A4F # };
403: 390 00011A4F L429:
404: 391 00011A4F # }
405: 392 00011A4F 40 ret#2
406: 393 00011A50 .set L414,0x0
407: 394 00011A50 L416:
408: 395 00011A50 13 feec jbr L417
409: 396 00011A53 .data
410: 397 000005c8 * .text
411: 398 00011A53 00 .align 1
412: 399 00011A54 .globl _pipe7_queue_er
413: 400 00011A54 _pipe7_queue_er:
414: 401 00011A54 0000 .word L430
415: 402 00011A56 #
416: 403 00011A56 #
417: 404 00011A56 #
418: 405 00011A56 #
419: 406 00011A56 #
420: 407 00011A56 # /****************************************************************************
421: 408 00011A56 # * Report an "FPP Queue apparently not cleared" error
422: 409 00011A56 # *
423: 410 00011A56 # * Cycle: xx. EVT test xx. subtest xx. too many instructions run. index = xx
424: 411 00011A56 # * inst = LDF op1, DIVF op2, MULL3 op3,op4,op5, NEGF (int. overflow on MULL3)
425: 412 00011A56 # * The NEGF should not have been executed but apparently was.
426: 413 00011A56 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, op3 = xxxxxxxx
427: 414 00011A56 # * op2 = xxxxxxxx, expected = xxxxxxxx, op4 = xxxxxxxx, op5 = xxxxxxxx
428: 415 00011A56 # ****************************************************************************/
429: 416 00011A56 # pipe7_queue_er()
430: 417 00011A56 # {
431: 418 00011A56 13 0111 jbr L432
432: 419 00011A59 L433:
433: 420 00011A59 # errcnt++; /* bump the error count */
434: 421 00011A59 6d effffffc95 incl _errcnt
435: 422 00011A5F # if ( prt_error )
436: 423 00011A5F 5d effffffc8f tstl _prt_error
437: 424 00011A65 21 03 13 00d9 jeql L434
438: 425 00011A6A # {
439: 426 00011A6A # print_pipe7_er(". Fpp Queue not cleared.");
440: 427 00011A6A .data 1
441: 428 000006a3 * L435:
442: 429 000006a3 * 2E20467070205175657565206 .ascii ". Fpp Queue not cleared.\0"
443: E6F7420636C65617265642E00
444: 430 000006bc * .text
445: 431 00011A6A dd 8f000006a3 pushl $L435
446: 432 00011A70 fe 08 ef000000f7 callf $8,_print_pipe7_er
447: 433 00011A77 # writes(
448: 434 00011A77 # "The NEGF should not have been executed but apparently was.\n");
449: 435 00011A77 .data 1
450: 436 000006bc * L436:
451: 437 000006bc * 546865204E4547462073686F7 .ascii "The NEGF should not have been executed but apparently was.\12\0"
452: 56C64206E6F74206861766520
453: 6265656E20657865637574656
454: 420627574206170706172656E
455: 746C79207761732E0A00
456: 438 000006f8 * .text
457: 439 00011A77 dd 8f000006bc pushl $L436
458: 440 00011A7D fe 08 effffffc70 callf $8,_writes
459: 441 00011A84 # writes("op1 = ");
460: 442 00011A84 .data 1
461: 443 000006f8 * L437:
462: 444 000006f8 * 6F7031203D2000 .ascii "op1 = \0"
463: 445 000006ff * .text
464: 446 00011A84 dd 8f000006f8 pushl $L437
465: 447 00011A8A fe 08 effffffc63 callf $8,_writes
466: 448 00011A91 # write32h( dbl_value_1.m );
467: 449 00011A91 dd effffffc5d pushl _dbl_value_1
468: 450 00011A97 fe 08 effffffc56 callf $8,_write32h
469: 451 00011A9E # writes(", final Acc. = ");
470: 452 00011A9E .data 1
471: 453 000006ff * L438:
472: 454 000006ff * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
473: E203D2000
474: 455 00000710 * .text
475: 456 00011A9E dd 8f000006ff pushl $L438
476: 457 00011AA4 fe 08 effffffc49 callf $8,_writes
477: 458 00011AAB # write32h( post_evt_acc.m );
478: 459 00011AAB dd effffffc43 pushl _post_evt_acc
479: 460 00011AB1 fe 08 effffffc3c callf $8,_write32h
480: 461 00011AB8 # writes(", op3 = ");
481: 462 00011AB8 .data 1
482: 463 00000710 * L439:
483: 464 00000710 * 2C20206F7033203D2000 .ascii ", op3 = \0"
484: 465 0000071a * .text
485: 466 00011AB8 dd 8f00000710 pushl $L439
486: 467 00011ABE fe 08 effffffc2f callf $8,_writes
487: 468 00011AC5 # write32h( sgl_value_1 );
488: 469 00011AC5 dd effffffc29 pushl _sgl_value_1
489: 470 00011ACB fe 08 effffffc22 callf $8,_write32h
490: 471 00011AD2 # writes("\nop2 = ");
491: 472 00011AD2 .data 1
492: 473 0000071a * L440:
493: 474 0000071a * 0A6F7032203D2000 .ascii "\12op2 = \0"
494: 475 00000722 * .text
495: 476 00011AD2 dd 8f0000071a pushl $L440
496: 477 00011AD8 fe 08 effffffc15 callf $8,_writes
497: 478 00011ADF # write32h( dbl_value_2.m );
498: 479 00011ADF dd effffffc0f pushl _dbl_value_2
499: 480 00011AE5 fe 08 effffffc08 callf $8,_write32h
500: 481 00011AEC # writes(", expected = ");
501: 482 00011AEC .data 1
502: 483 00000722 * L441:
503: 484 00000722 * 2C20202020657870656374656 .ascii ", expected = \0"
504: 4203D2000
505: 485 00000733 * .text
506: 486 00011AEC dd 8f00000722 pushl $L441
507: 487 00011AF2 fe 08 effffffbfb callf $8,_writes
508: 488 00011AF9 # write32h( dbl_expected.m );
509: 489 00011AF9 dd effffffbf5 pushl _dbl_expected
510: 490 00011AFF fe 08 effffffbee callf $8,_write32h
511: 491 00011B06 # writes(", op4 = ");
512: 492 00011B06 .data 1
513: 493 00000733 * L442:
514: 494 00000733 * 2C20206F7034203D2000 .ascii ", op4 = \0"
515: 495 0000073d * .text
516: 496 00011B06 dd 8f00000733 pushl $L442
517: 497 00011B0C fe 08 effffffbe1 callf $8,_writes
518: 498 00011B13 # write32h( sgl_value_2 );
519: 499 00011B13 dd effffffbdb pushl _sgl_value_2
520: 500 00011B19 fe 08 effffffbd4 callf $8,_write32h
521: 501 00011B20 # writes(", op5 = ");
522: 502 00011B20 .data 1
523: 503 0000073d * L443:
524: 504 0000073d * 2C20206F7035203D2000 .ascii ", op5 = \0"
525: 505 00000747 * .text
526: 506 00011B20 dd 8f0000073d pushl $L443
527: 507 00011B26 fe 08 effffffbc7 callf $8,_writes
528: 508 00011B2D # write32h( sgl_value_3 );
529: 509 00011B2D dd effffffbc1 pushl _sgl_value_3
530: 510 00011B33 fe 08 effffffbba callf $8,_write32h
531: 511 00011B3A # writec('\n');
532: 512 00011B3A dd 0a pushl $10
533: 513 00011B3C fe 08 effffffbb1 callf $8,_writec
534: 514 00011B43 # }
535: 515 00011B43 # if ( halt_flg ) /* halt on error? */
536: 516 00011B43 L434:
537: 517 00011B43 5d effffffbab tstl _halt_flg
538: 518 00011B49 31 09 jeql L444
539: 519 00011B4B # pipe7_halt( 3 );
540: 520 00011B4B dd 03 pushl $3
541: 521 00011B4D fe 08 ef000000c6 callf $8,_pipe7_halt
542: 522 00011B54 # if ( loop_on_err )
543: 523 00011B54 L444:
544: 524 00011B54 5d effffffb9a tstl _loop_on_err
545: 525 00011B5A 31 0d jeql L445
546: 526 00011B5C # {
547: 527 00011B5C # force_loop = TRUE; /* set the force loop flag */
548: 528 00011B5C 0d 01 effffffb91 movl $1,_force_loop
549: 529 00011B63 # asm("jmp _pipe7_lp1"); /* and loop */
550: 530 00011B63 71 effffffc4d jmp _pipe7_lp1
551: 531 00011B69 # };
552: 532 00011B69 L445:
553: 533 00011B69 # }
554: 534 00011B69 40 ret#2
555: 535 00011B6A .set L430,0x0
556: 536 00011B6A L432:
557: 537 00011B6A 13 feec jbr L433
558: 538 00011B6D .data
559: 539 000005c8 * .text
560: 540 00011B6D 00 .align 1
561: 541 00011B6E .globl _print_pipe7_er
562: 542 00011B6E _print_pipe7_er:
563: 543 00011B6E 0000 .word L446
564: 544 00011B70 #
565: 545 00011B70 #
566: 546 00011B70 #
567: 547 00011B70 # /****************************************************************************
568: 548 00011B70 # * print an error message of the form:
569: 549 00011B70 # *
570: 550 00011B70 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
571: 551 00011B70 # * inst = LDF op1, DIVF op2, MULL3 op3,op4,op5, NEGF (int. overflow on MULL3)
572: 552 00011B70 # ****************************************************************************/
573: 553 00011B70 # print_pipe7_er( msg )
574: 554 00011B70 # char *msg; /* error message to print */
575: 555 00011B70 # {
576: 556 00011B70 13 00a3 jbr L448
577: 557 00011B73 L449:
578: 558 00011B73 # if( errcnt == 1 ) /* 1st error? */
579: 559 00011B73 1d effffffb7b 01 cmpl _errcnt,$1
580: 560 00011B7A 21 0d jneq L450
581: 561 00011B7C # writes(" \n"); /* start a new print line */
582: 562 00011B7C .data 1
583: 563 00000747 * L451:
584: 564 00000747 * 200A00 .ascii " \12\0"
585: 565 0000074a * .text
586: 566 00011B7C dd 8f00000747 pushl $L451
587: 567 00011B82 fe 08 effffffb6b callf $8,_writes
588: 568 00011B89 # writes("Cycle: ");
589: 569 00011B89 L450:
590: 570 00011B89 .data 1
591: 571 0000074a * L452:
592: 572 0000074a * 4379636C653A2000 .ascii "Cycle: \0"
593: 573 00000752 * .text
594: 574 00011B89 dd 8f0000074a pushl $L452
595: 575 00011B8F fe 08 effffffb5e callf $8,_writes
596: 576 00011B96 # writed( cycle );
597: 577 00011B96 dd effffffb58 pushl _cycle
598: 578 00011B9C fe 08 effffffb51 callf $8,_writed
599: 579 00011BA3 # writes(" EVT test ");
600: 580 00011BA3 .data 1
601: 581 00000752 * L454:
602: 582 00000752 * 202045565420746573742000 .ascii " EVT test \0"
603: 583 0000075e * .text
604: 584 00011BA3 dd 8f00000752 pushl $L454
605: 585 00011BA9 fe 08 effffffb44 callf $8,_writes
606: 586 00011BB0 # writed( test_no );
607: 587 00011BB0 dd effffffb3e pushl _test_no
608: 588 00011BB6 fe 08 effffffb37 callf $8,_writed
609: 589 00011BBD # writes(". subtest ");
610: 590 00011BBD .data 1
611: 591 0000075e * L455:
612: 592 0000075e * 2E20737562746573742000 .ascii ". subtest \0"
613: 593 00000769 * .text
614: 594 00011BBD dd 8f0000075e pushl $L455
615: 595 00011BC3 fe 08 effffffb2a callf $8,_writes
616: 596 00011BCA # writed( subtest );
617: 597 00011BCA dd effffffb24 pushl _subtest
618: 598 00011BD0 fe 08 effffffb1d callf $8,_writed
619: 599 00011BD7 # writes( msg ); /* print the error message */
620: 600 00011BD7 dd ad04 pushl 4(fp)
621: 601 00011BDA fe 08 effffffb13 callf $8,_writes
622: 602 00011BE1 # writes(" index = ");
623: 603 00011BE1 .data 1
624: 604 00000769 * L456:
625: 605 00000769 * 20696E646578203D2000 .ascii " index = \0"
626: 606 00000773 * .text
627: 607 00011BE1 dd 8f00000769 pushl $L456
628: 608 00011BE7 fe 08 effffffb06 callf $8,_writes
629: 609 00011BEE # writed( index );
630: 610 00011BEE dd effffffb00 pushl _index
631: 611 00011BF4 fe 08 effffffaf9 callf $8,_writed
632: 612 00011BFB # writes("\ninst = LDF op1, DIVF op2, MULL3 op3,op4,op5, NEGF");
633: 613 00011BFB .data 1
634: 614 00000773 * L457:
635: 615 00000773 * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1, DIVF op2, MULL3 op3,op4,op5, NEGF\0"
636: F70312C2044495646206F7032
637: 2C204D554C4C33206F70332C6
638: F70342C6F70352C204E454746
639: 00
640: 616 000007a6 * .text
641: 617 00011BFB dd 8f00000773 pushl $L457
642: 618 00011C01 fe 08 effffffaec callf $8,_writes
643: 619 00011C08 # writes(" (int. overflow on MULL3)\n");
644: 620 00011C08 .data 1
645: 621 000007a6 * L458:
646: 622 000007a6 * 202028696E742E206F7665726 .ascii " (int. overflow on MULL3)\12\0"
647: 66C6F77206F6E204D554C4C33
648: 290A00
649: 623 000007c2 * .text
650: 624 00011C08 dd 8f000007a6 pushl $L458
651: 625 00011C0E fe 08 effffffadf callf $8,_writes
652: 626 00011C15 # }
653: 627 00011C15 40 ret#2
654: 628 00011C16 .set L446,0x0
655: 629 00011C16 L448:
656: 630 00011C16 13 ff5a jbr L449
657: 631 00011C19 .data
658: 632 000005c8 * .text
659: 633 00011C19 00 .align 1
660: 634 00011C1A .globl _pipe7_halt
661: 635 00011C1A _pipe7_halt:
662: 636 00011C1A 0000 .word L459
663: 637 00011C1C #
664: 638 00011C1C #
665: 639 00011C1C #
666: 640 00011C1C # /****************************************************************************
667: 641 00011C1C # * Halt on Error routine
668: 642 00011C1C # ****************************************************************************/
669: 643 00011C1C # pipe7_halt( code )
670: 644 00011C1C # int code; /* error code to halt with */
671: 645 00011C1C # {
672: 646 00011C1C 13 0099 jbr L461
673: 647 00011C1F L462:
674: 648 00011C1F # err_code = code;
675: 649 00011C1F 0d ad04 effffffacd movl 4(fp),_err_code
676: 650 00011C27 # sgl_value_4 = dbl_ld_acc.m;
677: 651 00011C27 0d effffffac7 effffffac2 movl _dbl_ld_acc,_sgl_value_4
678: 652 00011C32 # sgl_value_5 = dbl_value_1.m;
679: 653 00011C32 0d effffffabc effffffab7 movl _dbl_value_1,_sgl_value_5
680: 654 00011C3D # asm("movl _test_no,r0"); /* r0 = test number */
681: 655 00011C3D 0d effffffab1 50 movl _test_no,r0
682: 656 00011C44 # asm("movl _subtest,r1"); /* r1 = subtest number */
683: 657 00011C44 0d effffffaaa 51 movl _subtest,r1
684: 658 00011C4B # asm("movl _err_code,r2"); /* r2 = error code */
685: 659 00011C4B 0d effffffaa3 52 movl _err_code,r2
686: 660 00011C52 # asm("movl _cycle,r3"); /* r3 = cycle count */
687: 661 00011C52 0d effffffa9c 53 movl _cycle,r3
688: 662 00011C59 # asm("movl _sgl_value_4,r4"); /* r4 = floating operand 1 */
689: 663 00011C59 0d effffffa95 54 movl _sgl_value_4,r4
690: 664 00011C60 # asm("movl _sgl_value_5,r5"); /* r5 = floating operand 2 */
691: 665 00011C60 0d effffffa8e 55 movl _sgl_value_5,r5
692: 666 00011C67 # asm("movl _sgl_value_1,r6"); /* r6 = integer operand 1 */
693: 667 00011C67 0d effffffa87 56 movl _sgl_value_1,r6
694: 668 00011C6E # asm("movl _sgl_value_2,r7"); /* r7 = integer operand 2 */
695: 669 00011C6E 0d effffffa80 57 movl _sgl_value_2,r7
696: 670 00011C75 # asm("movl _sgl_value_3,r8"); /* r8 = final int. value */
697: 671 00011C75 0d effffffa79 58 movl _sgl_value_3,r8
698: 672 00011C7C # if( code == 1 )
699: 673 00011C7C 1d ad04 01 cmpl 4(fp),$1
700: 674 00011C80 21 09 jneq L463
701: 675 00011C82 # asm("movl _index,r9"); /* r9 = data index */
702: 676 00011C82 0d effffffa6c 59 movl _index,r9
703: 677 00011C89 # else {
704: 678 00011C89 11 2b jbr L464
705: 679 00011C8B L463:
706: 680 00011C8B # sgl_value_6 = post_evt_acc.m;
707: 681 00011C8B 0d effffffa63 effffffa5e movl _post_evt_acc,_sgl_value_6
708: 682 00011C96 # sgl_value_7 = dbl_expected.m;
709: 683 00011C96 0d effffffa58 effffffa53 movl _dbl_expected,_sgl_value_7
710: 684 00011CA1 # asm("movl _sgl_value_6,r9"); /* r9 = final accumulator */
711: 685 00011CA1 0d effffffa4d 59 movl _sgl_value_6,r9
712: 686 00011CA8 # asm("movl _sgl_value_7,r10"); /* r10 = expected acc. */
713: 687 00011CA8 0d effffffa46 5a movl _sgl_value_7,r10
714: 688 00011CAF # asm("movl _index,r11"); /* r11 = data index */
715: 689 00011CAF 0d effffffa3f 5b movl _index,r11
716: 690 00011CB6 # }
717: 691 00011CB6 L464:
718: 692 00011CB6 # asm("halt");; /* HALT ... */
719: 693 00011CB6 00 halt
720: 694 00011CB7 # }
721: 695 00011CB7 40 ret#2
722: 696 00011CB8 .set L459,0x0
723: 697 00011CB8 L461:
724: 698 00011CB8 13 ff64 jbr L462
725: 699 00011CBB .data
726: 699 000233AF .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.