![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe14.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 pipe14.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 00000688 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe14
6: 6 00000000 _pipe14:
7: 7 0001386C 0000 .word L381
8: 8 0001386E #
9: 9 0001386E # #include "evt_defs.h"
10: 10 0001386E #
11: 11 0001386E # /*
12: 12 0001386E # *********************************************************************
13: 13 0001386E # * FPP PIPELINED EVENTS TEST #14
14: 14 0001386E # *
15: 15 0001386E # * This test will execute the following code: "LDD DIVD MULL3 NEGD"
16: 16 0001386E # * with an integer overflow fault on the MULL3. We will make sure that:
17: 17 0001386E # * 1. The fault is detected, and
18: 18 0001386E # * 2. the NEGD instruction is not executed.
19: 19 0001386E # *
20: 20 0001386E # * NOTE: This instruction uses the same data as pipe1
21: 21 0001386E # *********************************************************************
22: 22 0001386E # */
23: 23 0001386E # pipe14()
24: 24 0001386E # {
25: 25 0001386E 13 0171 jbr L383
26: 26 00013871 L384:
27: 27 00013871 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
28: 28 00013871 ed 6d effffffff4 moval (r13),_pre_event_fp
29: 29 00013878 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
30: 30 00013878 ed 6e efffffffed moval (r14),_pre_event_sp
31: 31 0001387F # precision = DBL;
32: 32 0001387F 0d 02 efffffffe6 movl $2,_precision
33: 33 00013886 # test_event = ARITH_CODE; /* expect an arithmetic fault */
34: 34 00013886 0d 34 efffffffdf movl $52,_test_event
35: 35 0001388D # exp_code = INT_OVFL_CODE; /* - specificly underflow */
36: 36 0001388D 0d 01 efffffffd8 movl $1,_exp_code
37: 37 00013894 # exp_event = FALSE; /* ... but not yet */
38: 38 00013894 4d efffffffd2 clrl _exp_event
39: 39 0001389A # asm("movab _pipe14_ret,_event_return"); /* set event return address */
40: 40 0001389A e9 ef000000d0 efffffffc7 movab _pipe14_ret,_event_return
41: 41 000138A5 # for( index = 0; index < max_pipe1_index; index++ )
42: 42 000138A5 4d efffffffc1 clrl _index
43: 43 000138AB L387:
44: 44 000138AB 1d efffffffbb efffffffb6 cmpl _index,_max_pipe1_index
45: 45 000138B6 91 03 13 0126 jgeq L386
46: 46 000138BB # {
47: 47 000138BB # dbl_ld_acc = pipe1_data[index].op_1; /* get operand 1 */
48: 48 000138BB 5c 18 efffffffaa 50 mull3 $24,_index,r0
49: 49 000138C3 0c 8f00000000 50 addl2 $_pipe1_data,r0
50: 50 000138CA 0d a004 efffffff9e movl 4(r0),_dbl_ld_acc+4
51: 51 000138D2 0d 60 efffffff93 movl (r0),_dbl_ld_acc
52: 52 000138D9 # dbl_value_1 = pipe1_data[index].op_2; /* get operand 2 */
53: 53 000138D9 5c 18 efffffff8c 50 mull3 $24,_index,r0
54: 54 000138E1 0c 8f00000008 50 addl2 $_pipe1_data+8,r0
55: 55 000138E8 0d a004 efffffff80 movl 4(r0),_dbl_value_1+4
56: 56 000138F0 0d 60 efffffff75 movl (r0),_dbl_value_1
57: 57 000138F7 # dbl_expected = pipe1_data[index].exp; /* get expected Acc. */
58: 58 000138F7 5c 18 efffffff6e 50 mull3 $24,_index,r0
59: 59 000138FF 0c 8f00000010 50 addl2 $_pipe1_data+16,r0
60: 60 00013906 0d a004 efffffff62 movl 4(r0),_dbl_expected+4
61: 61 0001390E 0d 60 efffffff57 movl (r0),_dbl_expected
62: 62 00013915 # asm("bispsw $0x60"); /* enable ovfl,undfl */
63: 63 00013915 8b 8860 bispsw $0x60
64: 64 00013918 # asm(".globl _pipe14_lp1");
65: 65 00013918 .globl _pipe14_lp1
66: 66 00013918 # asm("_pipe14_lp1:");
67: 67 00013918 _pipe14_lp1:
68: 68 00013918 # asm("movl $0x40404040,r0"); /* get the 'mull3' */
69: 69 00013918 0d 8f40404040 50 movl $0x40404040,r0
70: 70 0001391F # asm("movl $0x55005500,r2"); /* data patterns */
71: 71 0001391F 0d 8f55005500 52 movl $0x55005500,r2
72: 72 00013926 # asm("ldd _dbl_ld_acc"); /* load the Acc. */
73: 73 00013926 07 efffffff40 ldd _dbl_ld_acc
74: 74 0001392C # exp_event = test_event; /* expect event soon */
75: 75 0001392C 0d efffffff3a efffffff35 movl _test_event,_exp_event
76: 76 00013937 # asm("divd _dbl_value_1"); /* do the divide */
77: 77 00013937 f7 efffffff2f divd _dbl_value_1
78: 78 0001393D # asm("mull3 r0,r2,_dbl_value_3"); /* trigger the fault */
79: 79 0001393D 5c 50 52 efffffff27 mull3 r0,r2,_dbl_value_3
80: 80 00013945 # asm("nop"); /* shouldn't get here*/
81: 81 00013945 10 nop
82: 82 00013946 # asm("negd"); /* shouldn't get here*/
83: 83 00013946 b7 negd
84: 84 00013947 # /*
85: 85 00013947 # * If we got to here then there was no event
86: 86 00013947 # */
87: 87 00013947 # if( force_loop )
88: 88 00013947 5d efffffff1f tstl _force_loop
89: 89 0001394D 31 03 jeql L388
90: 90 0001394F # asm("brw _pipe14_lp1");; /* loop on the error */
91: Assemb0002B570 # asm("brw _pipe14_lp1");; /* loop on the error */
92: "pipe100013870 e 91: WARNING: brw: destination label is external
93: 91 0001394F 13 ffc6 brw _pipe14_lp1
94: 92 00013952 L388:
95: 93 00013952 # exp_event = FALSE; /* reset event expected flag */
96: 94 00013952 4d efffffff14 clrl _exp_event
97: 95 00013958 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
98: 96 00013958 0d efffffff0e 5d movl _pre_event_fp,fp
99: 97 0001395F # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
100: 98 0001395F 0d efffffff07 5e movl _pre_event_sp,sp
101: 99 00013966 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
102: 100 00013966 9b 8860 bicpsw $0x60
103: 101 00013969 # no_pipe14_evt();; /* report the error */
104: 102 00013969 fe 04 ef00000076 callf $4,_no_pipe14_evt
105: 103 00013970 # /*
106: 104 00013970 # * Come here after the event
107: 105 00013970 # */
108: 106 00013970 # asm(".globl _pipe14_ret");
109: 107 00013970 .globl _pipe14_ret
110: 108 00013970 # asm("_pipe14_ret:");
111: 109 00013970 _pipe14_ret:
112: 110 00013970 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
113: 111 00013970 0d effffffef6 5d movl _pre_event_fp,fp
114: 112 00013977 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
115: 113 00013977 0d effffffeef 5e movl _pre_event_sp,sp
116: 114 0001397E # if( force_loop )
117: 115 0001397E 5d effffffee8 tstl _force_loop
118: 116 00013984 31 03 jeql L390
119: 117 00013986 # asm("brw _pipe14_lp1");; /* loop on the error */
120: "pipe100013870 e 118: WARNING: brw: destination label is external
121: 118 00013986 13 ff8f brw _pipe14_lp1
122: 119 00013989 L390:
123: 120 00013989 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
124: 121 00013989 9b 8860 bicpsw $0x60
125: 122 0001398C # if( (post_evt_acc.m == (dbl_expected.m ^ 0x80000000)) &&
126: 123 0001398C # (post_evt_acc.l == dbl_expected.l) ) /* was Acc. negated? */
127: 124 0001398C dc 8f80000000 effffffed5 xorl3 $-2147483648,_dbl_expected,r0
128: 50
129: 125 00013998 1d effffffece 50 cmpl _post_evt_acc,r0
130: 126 0001399F 21 16 jneq L391
131: 127 000139A1 1d effffffec9 effffffec4 cmpl _post_evt_acc+4,_dbl_expected+4
132: 128 000139AC 21 09 jneq L391
133: 129 000139AE # pipe14_queue_er(); /* queue not cleared error */
134: 130 000139AE fe 04 ef00000273 callf $4,_pipe14_queue_er
135: 131 000139B5 # else if( (post_evt_acc.m != dbl_expected.m) ||
136: 132 000139B5 11 21 jbr L393
137: 133 000139B7 L391:
138: 134 000139B7 # (post_evt_acc.l != dbl_expected.l) ) /* Acc. = exp.? */
139: 135 000139B7 1d effffffeaf effffffeaa cmpl _post_evt_acc,_dbl_expected
140: 136 000139C2 21 0d jneq L9999
141: 137 000139C4 1d effffffea6 effffffea1 cmpl _post_evt_acc+4,_dbl_expected+4
142: 138 000139CF 31 07 jeql L394
143: 139 000139D1 L9999:
144: 140 000139D1 # bad_pipe14_result(); /* incorrect result error */
145: 141 000139D1 fe 04 ef000000f8 callf $4,_bad_pipe14_result
146: 142 000139D8 #
147: 143 000139D8 # }
148: 144 000139D8 L394:
149: 145 000139D8 L393:
150: 146 000139D8 L385:
151: 147 000139D8 6d effffffe8e incl _index
152: 148 000139DE 13 feca jbr L387
153: 149 000139E1 L386:
154: 150 000139E1 # }
155: 151 000139E1 40 ret#2
156: 152 000139E2 .set L381,0x0
157: 153 000139E2 L383:
158: 154 000139E2 13 fe8c jbr L384
159: 155 000139E5 .data
160: 156 00000688 * .text
161: 157 000139E5 00 .align 1
162: 158 000139E6 .globl _no_pipe14_evt
163: 159 000139E6 _no_pipe14_evt:
164: 160 000139E6 0000 .word L396
165: 161 000139E8 #
166: 162 000139E8 #
167: 163 000139E8 #
168: 164 000139E8 # /****************************************************************************
169: 165 000139E8 # * Report an "EVENT NOT DETECTED" error
170: 166 000139E8 # *
171: 167 000139E8 # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx
172: 168 000139E8 # * inst = LDD op1; DIVD op2; MULL3,op3,op4,op5; NEGD (integer overflow on MULL3)
173: 169 000139E8 # * op1 = xxxxxxxx xxxxxxxx, op3 = xxxxxxxx
174: 170 000139E8 # * op2 = xxxxxxxx xxxxxxxx, op4 = xxxxxxxx
175: 171 000139E8 # ****************************************************************************/
176: 172 000139E8 # no_pipe14_evt()
177: 173 000139E8 # {
178: 174 000139E8 13 00e2 jbr L398
179: 175 000139EB L399:
180: 176 000139EB # errcnt++; /* bump the error count */
181: 177 000139EB 6d effffffe7b incl _errcnt
182: 178 000139F1 # if ( prt_error )
183: 179 000139F1 5d effffffe75 tstl _prt_error
184: 180 000139F7 21 03 13 00aa jeql L400
185: 181 000139FC # {
186: 182 000139FC # print_pipe14_er( ". No overflow fault seen." );
187: 183 000139FC .data 1
188: 184 00000688 * L402:
189: 185 00000688 * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen.\0"
190: 7206661756C74207365656E2E
191: 00
192: 186 000006a2 * .text
193: 187 000139FC dd 8f00000688 pushl $L402
194: 188 00013A02 fe 08 ef00000377 callf $8,_print_pipe14_er
195: 189 00013A09 # writes("op1 = ");
196: 190 00013A09 .data 1
197: 191 000006a2 * L404:
198: 192 000006a2 * 6F7031203D2000 .ascii "op1 = \0"
199: 193 000006a9 * .text
200: 194 00013A09 dd 8f000006a2 pushl $L404
201: 195 00013A0F fe 08 effffffe56 callf $8,_writes
202: 196 00013A16 # write32h( dbl_ld_acc.m );
203: 197 00013A16 dd effffffe50 pushl _dbl_ld_acc
204: 198 00013A1C fe 08 effffffe49 callf $8,_write32h
205: 199 00013A23 # writec(' ');
206: 200 00013A23 dd 20 pushl $32
207: 201 00013A25 fe 08 effffffe40 callf $8,_writec
208: 202 00013A2C # write32h( dbl_ld_acc.l );
209: 203 00013A2C dd effffffe3e pushl _dbl_ld_acc+4
210: 204 00013A32 fe 08 effffffe33 callf $8,_write32h
211: 205 00013A39 # writes(", op3 = ");
212: 206 00013A39 .data 1
213: 207 000006a9 * L407:
214: 208 000006a9 * 2C2020206F7033203D2000 .ascii ", op3 = \0"
215: 209 000006b4 * .text
216: 210 00013A39 dd 8f000006a9 pushl $L407
217: 211 00013A3F fe 08 effffffe26 callf $8,_writes
218: 212 00013A46 # write32h( 0x40404040 );
219: 213 00013A46 dd 8f40404040 pushl $1077952576
220: 214 00013A4C fe 08 effffffe19 callf $8,_write32h
221: 215 00013A53 # writes("\nop2 = ");
222: 216 00013A53 .data 1
223: 217 000006b4 * L408:
224: 218 000006b4 * 0A6F7032203D2000 .ascii "\12op2 = \0"
225: 219 000006bc * .text
226: 220 00013A53 dd 8f000006b4 pushl $L408
227: 221 00013A59 fe 08 effffffe0c callf $8,_writes
228: 222 00013A60 # write32h( dbl_value_1.m );
229: 223 00013A60 dd effffffe06 pushl _dbl_value_1
230: 224 00013A66 fe 08 effffffdff callf $8,_write32h
231: 225 00013A6D # writec(' ');
232: 226 00013A6D dd 20 pushl $32
233: 227 00013A6F fe 08 effffffdf6 callf $8,_writec
234: 228 00013A76 # write32h( dbl_value_1.l );
235: 229 00013A76 dd effffffdf4 pushl _dbl_value_1+4
236: 230 00013A7C fe 08 effffffde9 callf $8,_write32h
237: 231 00013A83 # writes(", op4 = ");
238: 232 00013A83 .data 1
239: 233 000006bc * L409:
240: 234 000006bc * 2C2020206F7034203D2000 .ascii ", op4 = \0"
241: 235 000006c7 * .text
242: 236 00013A83 dd 8f000006bc pushl $L409
243: 237 00013A89 fe 08 effffffddc callf $8,_writes
244: 238 00013A90 # write32h( 0x55005500 );
245: 239 00013A90 dd 8f55005500 pushl $1426085120
246: 240 00013A96 fe 08 effffffdcf callf $8,_write32h
247: 241 00013A9D # writec('\n');
248: 242 00013A9D dd 0a pushl $10
249: 243 00013A9F fe 08 effffffdc6 callf $8,_writec
250: 244 00013AA6 # }
251: 245 00013AA6 # if ( halt_flg ) /* halt on error? */
252: 246 00013AA6 L400:
253: 247 00013AA6 5d effffffdc0 tstl _halt_flg
254: 248 00013AAC 31 09 jeql L410
255: 249 00013AAE # pipe14_halt( 1 ); /* halt with a code of 1 */
256: 250 00013AAE dd 01 pushl $1
257: 251 00013AB0 fe 08 ef00000375 callf $8,_pipe14_halt
258: 252 00013AB7 # if ( loop_on_err )
259: 253 00013AB7 L410:
260: 254 00013AB7 5d effffffdaf tstl _loop_on_err
261: 255 00013ABD 31 0d jeql L412
262: 256 00013ABF # {
263: 257 00013ABF # force_loop = TRUE; /* set the force loop flag */
264: 258 00013ABF 0d 01 effffffda6 movl $1,_force_loop
265: 259 00013AC6 # asm("jmp _pipe14_lp1"); /* and loop */
266: 260 00013AC6 71 effffffe4c jmp _pipe14_lp1
267: 261 00013ACC # };
268: 262 00013ACC L412:
269: 263 00013ACC # }
270: 264 00013ACC 40 ret#2
271: 265 00013ACD .set L396,0x0
272: 266 00013ACD L398:
273: 267 00013ACD 13 ff1b jbr L399
274: 268 00013AD0 .data
275: 269 00000688 * .text
276: 270 00013AD0 .align 1
277: 271 00013AD0 .globl _bad_pipe14_result
278: 272 00013AD0 _bad_pipe14_result:
279: 273 00013AD0 0000 .word L413
280: 274 00013AD2 #
281: 275 00013AD2 #
282: 276 00013AD2 #
283: 277 00013AD2 #
284: 278 00013AD2 # /****************************************************************************
285: 279 00013AD2 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
286: 280 00013AD2 # *
287: 281 00013AD2 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. indexd = xx
288: 282 00013AD2 # * inst = LDD op1; DIVD op2; MULL3,op3,op4,op5; NEGD (integer overflow on MULL3)
289: 283 00013AD2 # * The NEGD instruction should not be executed.
290: 284 00013AD2 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx, op3 = xxxxxxxx
291: 285 00013AD2 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx, op4 = xxxxxxxx
292: 286 00013AD2 # ****************************************************************************/
293: 287 00013AD2 # bad_pipe14_result()
294: 288 00013AD2 # {
295: 289 00013AD2 13 014f jbr L415
296: 290 00013AD5 L416:
297: 291 00013AD5 # errcnt++; /* bump the error count */
298: 292 00013AD5 6d effffffd91 incl _errcnt
299: 293 00013ADB # if ( prt_error )
300: 294 00013ADB 5d effffffd8b tstl _prt_error
301: 295 00013AE1 21 03 13 0117 jeql L417
302: 296 00013AE6 # {
303: 297 00013AE6 # print_pipe14_er( ". Bad final Accumulator" );
304: 298 00013AE6 .data 1
305: 299 000006c7 * L418:
306: 300 000006c7 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0"
307: 16363756D756C61746F7200
308: 301 000006df * .text
309: 302 00013AE6 dd 8f000006c7 pushl $L418
310: 303 00013AEC fe 08 ef0000028d callf $8,_print_pipe14_er
311: 304 00013AF3 # writes(
312: 305 00013AF3 # "The NEGD INSTRUCTION should not be executed\n");
313: 306 00013AF3 .data 1
314: 307 000006df * L419:
315: 308 000006df * 546865204E45474420494E535 .ascii "The NEGD INSTRUCTION should not be executed\12\0"
316: 452554354494F4E2073686F75
317: 6C64206E6F742062652065786
318: 563757465640A00
319: 309 0000070c * .text
320: 310 00013AF3 dd 8f000006df pushl $L419
321: 311 00013AF9 fe 08 effffffd6c callf $8,_writes
322: 312 00013B00 # writes("op1 = ");
323: 313 00013B00 .data 1
324: 314 0000070c * L420:
325: 315 0000070c * 6F7031203D2000 .ascii "op1 = \0"
326: 316 00000713 * .text
327: 317 00013B00 dd 8f0000070c pushl $L420
328: 318 00013B06 fe 08 effffffd5f callf $8,_writes
329: 319 00013B0D # write32h( dbl_ld_acc.m );
330: 320 00013B0D dd effffffd59 pushl _dbl_ld_acc
331: 321 00013B13 fe 08 effffffd52 callf $8,_write32h
332: 322 00013B1A # writec(' ');
333: 323 00013B1A dd 20 pushl $32
334: 324 00013B1C fe 08 effffffd49 callf $8,_writec
335: 325 00013B23 # write32h( dbl_ld_acc.l );
336: 326 00013B23 dd effffffd47 pushl _dbl_ld_acc+4
337: 327 00013B29 fe 08 effffffd3c callf $8,_write32h
338: 328 00013B30 # writes(", final Acc. = ");
339: 329 00013B30 .data 1
340: 330 00000713 * L421:
341: 331 00000713 * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
342: E203D2000
343: 332 00000724 * .text
344: 333 00013B30 dd 8f00000713 pushl $L421
345: 334 00013B36 fe 08 effffffd2f callf $8,_writes
346: 335 00013B3D # write32h( post_evt_acc.m );
347: 336 00013B3D dd effffffd29 pushl _post_evt_acc
348: 337 00013B43 fe 08 effffffd22 callf $8,_write32h
349: 338 00013B4A # writec(' ');
350: 339 00013B4A dd 20 pushl $32
351: 340 00013B4C fe 08 effffffd19 callf $8,_writec
352: 341 00013B53 # write32h( post_evt_acc.l );
353: 342 00013B53 dd effffffd17 pushl _post_evt_acc+4
354: 343 00013B59 fe 08 effffffd0c callf $8,_write32h
355: 344 00013B60 # writes(", op3 = ");
356: 345 00013B60 .data 1
357: 346 00000724 * L422:
358: 347 00000724 * 2C20206F7033203D2000 .ascii ", op3 = \0"
359: 348 0000072e * .text
360: 349 00013B60 dd 8f00000724 pushl $L422
361: 350 00013B66 fe 08 effffffcff callf $8,_writes
362: 351 00013B6D # write32h( 0x40404040 );
363: 352 00013B6D dd 8f40404040 pushl $1077952576
364: 353 00013B73 fe 08 effffffcf2 callf $8,_write32h
365: 354 00013B7A # writes("\nop2 = ");
366: 355 00013B7A .data 1
367: 356 0000072e * L423:
368: 357 0000072e * 0A6F7032203D2000 .ascii "\12op2 = \0"
369: 358 00000736 * .text
370: 359 00013B7A dd 8f0000072e pushl $L423
371: 360 00013B80 fe 08 effffffce5 callf $8,_writes
372: 361 00013B87 # write32h( dbl_value_1.m );
373: 362 00013B87 dd effffffcdf pushl _dbl_value_1
374: 363 00013B8D fe 08 effffffcd8 callf $8,_write32h
375: 364 00013B94 # writec(' ');
376: 365 00013B94 dd 20 pushl $32
377: 366 00013B96 fe 08 effffffccf callf $8,_writec
378: 367 00013B9D # write32h( dbl_value_1.l );
379: 368 00013B9D dd effffffccd pushl _dbl_value_1+4
380: 369 00013BA3 fe 08 effffffcc2 callf $8,_write32h
381: 370 00013BAA # writes(", expected = ");
382: 371 00013BAA .data 1
383: 372 00000736 * L424:
384: 373 00000736 * 2C20202020657870656374656 .ascii ", expected = \0"
385: 4203D2000
386: 374 00000747 * .text
387: 375 00013BAA dd 8f00000736 pushl $L424
388: 376 00013BB0 fe 08 effffffcb5 callf $8,_writes
389: 377 00013BB7 # write32h( dbl_expected.m );
390: 378 00013BB7 dd effffffcaf pushl _dbl_expected
391: 379 00013BBD fe 08 effffffca8 callf $8,_write32h
392: 380 00013BC4 # writec(' ');
393: 381 00013BC4 dd 20 pushl $32
394: 382 00013BC6 fe 08 effffffc9f callf $8,_writec
395: 383 00013BCD # write32h( dbl_expected.l );
396: 384 00013BCD dd effffffc9d pushl _dbl_expected+4
397: 385 00013BD3 fe 08 effffffc92 callf $8,_write32h
398: 386 00013BDA # writes(", op4 = ");
399: 387 00013BDA .data 1
400: 388 00000747 * L425:
401: 389 00000747 * 2C20206F7034203D2000 .ascii ", op4 = \0"
402: 390 00000751 * .text
403: 391 00013BDA dd 8f00000747 pushl $L425
404: 392 00013BE0 fe 08 effffffc85 callf $8,_writes
405: 393 00013BE7 # write32h( 0x55005500 );
406: 394 00013BE7 dd 8f55005500 pushl $1426085120
407: 395 00013BED fe 08 effffffc78 callf $8,_write32h
408: 396 00013BF4 # writec('\n');
409: 397 00013BF4 dd 0a pushl $10
410: 398 00013BF6 fe 08 effffffc6f callf $8,_writec
411: 399 00013BFD # }
412: 400 00013BFD # if ( halt_flg ) /* halt on error? */
413: 401 00013BFD L417:
414: 402 00013BFD 5d effffffc69 tstl _halt_flg
415: 403 00013C03 31 09 jeql L426
416: 404 00013C05 # pipe14_halt( 2 ); /* halt with a code of 2 */
417: 405 00013C05 dd 02 pushl $2
418: 406 00013C07 fe 08 ef0000021e callf $8,_pipe14_halt
419: 407 00013C0E # if ( loop_on_err )
420: 408 00013C0E L426:
421: 409 00013C0E 5d effffffc58 tstl _loop_on_err
422: 410 00013C14 31 0d jeql L427
423: 411 00013C16 # {
424: 412 00013C16 # force_loop = TRUE; /* set the force loop flag */
425: 413 00013C16 0d 01 effffffc4f movl $1,_force_loop
426: 414 00013C1D # asm("jmp _pipe14_lp1"); /* and loop */
427: 415 00013C1D 71 effffffcf5 jmp _pipe14_lp1
428: 416 00013C23 # };
429: 417 00013C23 L427:
430: 418 00013C23 # }
431: 419 00013C23 40 ret#2
432: 420 00013C24 .set L413,0x0
433: 421 00013C24 L415:
434: 422 00013C24 13 feae jbr L416
435: 423 00013C27 .data
436: 424 00000688 * .text
437: 425 00013C27 00 .align 1
438: 426 00013C28 .globl _pipe14_queue_er
439: 427 00013C28 _pipe14_queue_er:
440: 428 00013C28 0000 .word L428
441: 429 00013C2A #
442: 430 00013C2A #
443: 431 00013C2A #
444: 432 00013C2A #
445: 433 00013C2A #
446: 434 00013C2A # /****************************************************************************
447: 435 00013C2A # * Report an "FPP queue not cleared" message
448: 436 00013C2A # *
449: 437 00013C2A # * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx
450: 438 00013C2A # * inst = LDD op1; DIVD op2; MULL3,op3,op4,op5; NEGD (integer overflow on MULL3)
451: 439 00013C2A # * The NEGD instruction was apparently executed.
452: 440 00013C2A # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx, op3 = xxxxxxxx
453: 441 00013C2A # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx, op4 = xxxxxxxx
454: 442 00013C2A # ****************************************************************************/
455: 443 00013C2A # pipe14_queue_er()
456: 444 00013C2A # {
457: 445 00013C2A 13 014f jbr L430
458: 446 00013C2D L431:
459: 447 00013C2D # errcnt++; /* bump the error count */
460: 448 00013C2D 6d effffffc39 incl _errcnt
461: 449 00013C33 # if ( prt_error )
462: 450 00013C33 5d effffffc33 tstl _prt_error
463: 451 00013C39 21 03 13 0117 jeql L432
464: 452 00013C3E # {
465: 453 00013C3E # print_pipe14_er( ". Fpp queue not cleared" );
466: 454 00013C3E .data 1
467: 455 00000751 * L433:
468: 456 00000751 * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0"
469: E6F7420636C656172656400
470: 457 00000769 * .text
471: 458 00013C3E dd 8f00000751 pushl $L433
472: 459 00013C44 fe 08 ef00000135 callf $8,_print_pipe14_er
473: 460 00013C4B # writes(
474: 461 00013C4B # "The 2nd load double instruction was apparently executed.\n");
475: 462 00013C4B .data 1
476: 463 00000769 * L434:
477: 464 00000769 * 54686520326E64206C6F61642 .ascii "The 2nd load double instruction was apparently executed.\12\0"
478: 0646F75626C6520696E737472
479: 756374696F6E2077617320617
480: 0706172656E746C7920657865
481: 63757465642E0A00
482: 465 000007a3 * .text
483: 466 00013C4B dd 8f00000769 pushl $L434
484: 467 00013C51 fe 08 effffffc14 callf $8,_writes
485: 468 00013C58 # writes("op1 = ");
486: 469 00013C58 .data 1
487: 470 000007a3 * L435:
488: 471 000007a3 * 6F7031203D2000 .ascii "op1 = \0"
489: 472 000007aa * .text
490: 473 00013C58 dd 8f000007a3 pushl $L435
491: 474 00013C5E fe 08 effffffc07 callf $8,_writes
492: 475 00013C65 # write32h( dbl_ld_acc.m );
493: 476 00013C65 dd effffffc01 pushl _dbl_ld_acc
494: 477 00013C6B fe 08 effffffbfa callf $8,_write32h
495: 478 00013C72 # writec(' ');
496: 479 00013C72 dd 20 pushl $32
497: 480 00013C74 fe 08 effffffbf1 callf $8,_writec
498: 481 00013C7B # write32h( dbl_ld_acc.l );
499: 482 00013C7B dd effffffbef pushl _dbl_ld_acc+4
500: 483 00013C81 fe 08 effffffbe4 callf $8,_write32h
501: 484 00013C88 # writes(", final Acc. = ");
502: 485 00013C88 .data 1
503: 486 000007aa * L436:
504: 487 000007aa * 2C202066696E616C204163632 .ascii ", final Acc. = \0"
505: E203D2000
506: 488 000007bb * .text
507: 489 00013C88 dd 8f000007aa pushl $L436
508: 490 00013C8E fe 08 effffffbd7 callf $8,_writes
509: 491 00013C95 # write32h( post_evt_acc.m );
510: 492 00013C95 dd effffffbd1 pushl _post_evt_acc
511: 493 00013C9B fe 08 effffffbca callf $8,_write32h
512: 494 00013CA2 # writec(' ');
513: 495 00013CA2 dd 20 pushl $32
514: 496 00013CA4 fe 08 effffffbc1 callf $8,_writec
515: 497 00013CAB # write32h( post_evt_acc.l );
516: 498 00013CAB dd effffffbbf pushl _post_evt_acc+4
517: 499 00013CB1 fe 08 effffffbb4 callf $8,_write32h
518: 500 00013CB8 # writes(", op3 = ");
519: 501 00013CB8 .data 1
520: 502 000007bb * L437:
521: 503 000007bb * 2C20206F7033203D2000 .ascii ", op3 = \0"
522: 504 000007c5 * .text
523: 505 00013CB8 dd 8f000007bb pushl $L437
524: 506 00013CBE fe 08 effffffba7 callf $8,_writes
525: 507 00013CC5 # write32h( 0x40404040 );
526: 508 00013CC5 dd 8f40404040 pushl $1077952576
527: 509 00013CCB fe 08 effffffb9a callf $8,_write32h
528: 510 00013CD2 # writes("\nop2 = ");
529: 511 00013CD2 .data 1
530: 512 000007c5 * L438:
531: 513 000007c5 * 0A6F7032203D2000 .ascii "\12op2 = \0"
532: 514 000007cd * .text
533: 515 00013CD2 dd 8f000007c5 pushl $L438
534: 516 00013CD8 fe 08 effffffb8d callf $8,_writes
535: 517 00013CDF # write32h( dbl_value_1.m );
536: 518 00013CDF dd effffffb87 pushl _dbl_value_1
537: 519 00013CE5 fe 08 effffffb80 callf $8,_write32h
538: 520 00013CEC # writec(' ');
539: 521 00013CEC dd 20 pushl $32
540: 522 00013CEE fe 08 effffffb77 callf $8,_writec
541: 523 00013CF5 # write32h( dbl_value_1.l );
542: 524 00013CF5 dd effffffb75 pushl _dbl_value_1+4
543: 525 00013CFB fe 08 effffffb6a callf $8,_write32h
544: 526 00013D02 # writes(", expected = ");
545: 527 00013D02 .data 1
546: 528 000007cd * L439:
547: 529 000007cd * 2C20202020657870656374656 .ascii ", expected = \0"
548: 4203D2000
549: 530 000007de * .text
550: 531 00013D02 dd 8f000007cd pushl $L439
551: 532 00013D08 fe 08 effffffb5d callf $8,_writes
552: 533 00013D0F # write32h( dbl_expected.m );
553: 534 00013D0F dd effffffb57 pushl _dbl_expected
554: 535 00013D15 fe 08 effffffb50 callf $8,_write32h
555: 536 00013D1C # writec(' ');
556: 537 00013D1C dd 20 pushl $32
557: 538 00013D1E fe 08 effffffb47 callf $8,_writec
558: 539 00013D25 # write32h( dbl_expected.l );
559: 540 00013D25 dd effffffb45 pushl _dbl_expected+4
560: 541 00013D2B fe 08 effffffb3a callf $8,_write32h
561: 542 00013D32 # writes(", op4 = ");
562: 543 00013D32 .data 1
563: 544 000007de * L440:
564: 545 000007de * 2C20206F7034203D2000 .ascii ", op4 = \0"
565: 546 000007e8 * .text
566: 547 00013D32 dd 8f000007de pushl $L440
567: 548 00013D38 fe 08 effffffb2d callf $8,_writes
568: 549 00013D3F # write32h( 0x55005500 );
569: 550 00013D3F dd 8f55005500 pushl $1426085120
570: 551 00013D45 fe 08 effffffb20 callf $8,_write32h
571: 552 00013D4C # writec('\n');
572: 553 00013D4C dd 0a pushl $10
573: 554 00013D4E fe 08 effffffb17 callf $8,_writec
574: 555 00013D55 # }
575: 556 00013D55 # if ( halt_flg ) /* halt on error? */
576: 557 00013D55 L432:
577: 558 00013D55 5d effffffb11 tstl _halt_flg
578: 559 00013D5B 31 09 jeql L441
579: 560 00013D5D # pipe14_halt( 3 ); /* halt with a code of 3 */
580: 561 00013D5D dd 03 pushl $3
581: 562 00013D5F fe 08 ef000000c6 callf $8,_pipe14_halt
582: 563 00013D66 # if ( loop_on_err )
583: 564 00013D66 L441:
584: 565 00013D66 5d effffffb00 tstl _loop_on_err
585: 566 00013D6C 31 0d jeql L442
586: 567 00013D6E # {
587: 568 00013D6E # force_loop = TRUE; /* set the force loop flag */
588: 569 00013D6E 0d 01 effffffaf7 movl $1,_force_loop
589: 570 00013D75 # asm("jmp _pipe14_lp1"); /* and loop */
590: 571 00013D75 71 effffffb9d jmp _pipe14_lp1
591: 572 00013D7B # };
592: 573 00013D7B L442:
593: 574 00013D7B # }
594: 575 00013D7B 40 ret#2
595: 576 00013D7C .set L428,0x0
596: 577 00013D7C L430:
597: 578 00013D7C 13 feae jbr L431
598: 579 00013D7F .data
599: 580 00000688 * .text
600: 581 00013D7F 00 .align 1
601: 582 00013D80 .globl _print_pipe14_er
602: 583 00013D80 _print_pipe14_er:
603: 584 00013D80 0000 .word L443
604: 585 00013D82 #
605: 586 00013D82 #
606: 587 00013D82 #
607: 588 00013D82 #
608: 589 00013D82 # /****************************************************************************
609: 590 00013D82 # * Report an error message of the form:
610: 591 00013D82 # *
611: 592 00013D82 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
612: 593 00013D82 # * inst = LDD op1; DIVD op2; MULL3,op3,op4,op5; NEGD (integer overflow on MULL3)
613: 594 00013D82 # ****************************************************************************/
614: 595 00013D82 # print_pipe14_er( msg )
615: 596 00013D82 # char *msg; /* error message to print */
616: 597 00013D82 # {
617: 598 00013D82 13 00a3 jbr L445
618: 599 00013D85 L446:
619: 600 00013D85 # if( errcnt == 1 ) /* 1st error? */
620: 601 00013D85 1d effffffae1 01 cmpl _errcnt,$1
621: 602 00013D8C 21 0d jneq L447
622: 603 00013D8E # writes("\n\n"); /* start a new print line */
623: 604 00013D8E .data 1
624: 605 000007e8 * L448:
625: 606 000007e8 * 0A0A00 .ascii "\12\12\0"
626: 607 000007eb * .text
627: 608 00013D8E dd 8f000007e8 pushl $L448
628: 609 00013D94 fe 08 effffffad1 callf $8,_writes
629: 610 00013D9B # writes("Cycle: ");
630: 611 00013D9B L447:
631: 612 00013D9B .data 1
632: 613 000007eb * L449:
633: 614 000007eb * 4379636C653A2000 .ascii "Cycle: \0"
634: 615 000007f3 * .text
635: 616 00013D9B dd 8f000007eb pushl $L449
636: 617 00013DA1 fe 08 effffffac4 callf $8,_writes
637: 618 00013DA8 # writed( cycle );
638: 619 00013DA8 dd effffffabe pushl _cycle
639: 620 00013DAE fe 08 effffffab7 callf $8,_writed
640: 621 00013DB5 # writes(" EVT test ");
641: 622 00013DB5 .data 1
642: 623 000007f3 * L451:
643: 624 000007f3 * 202045565420746573742000 .ascii " EVT test \0"
644: 625 000007ff * .text
645: 626 00013DB5 dd 8f000007f3 pushl $L451
646: 627 00013DBB fe 08 effffffaaa callf $8,_writes
647: 628 00013DC2 # writed( test_no );
648: 629 00013DC2 dd effffffaa4 pushl _test_no
649: 630 00013DC8 fe 08 effffffa9d callf $8,_writed
650: 631 00013DCF # writes(". subtest ");
651: 632 00013DCF .data 1
652: 633 000007ff * L452:
653: 634 000007ff * 2E20737562746573742000 .ascii ". subtest \0"
654: 635 0000080a * .text
655: 636 00013DCF dd 8f000007ff pushl $L452
656: 637 00013DD5 fe 08 effffffa90 callf $8,_writes
657: 638 00013DDC # writed( subtest );
658: 639 00013DDC dd effffffa8a pushl _subtest
659: 640 00013DE2 fe 08 effffffa83 callf $8,_writed
660: 641 00013DE9 # writes( msg ); /* print the message */
661: 642 00013DE9 dd ad04 pushl 4(fp)
662: 643 00013DEC fe 08 effffffa79 callf $8,_writes
663: 644 00013DF3 # writes(" index = ");
664: 645 00013DF3 .data 1
665: 646 0000080a * L453:
666: 647 0000080a * 20696E646578203D2000 .ascii " index = \0"
667: 648 00000814 * .text
668: 649 00013DF3 dd 8f0000080a pushl $L453
669: 650 00013DF9 fe 08 effffffa6c callf $8,_writes
670: 651 00013E00 # writed( index );
671: 652 00013E00 dd effffffa66 pushl _index
672: 653 00013E06 fe 08 effffffa5f callf $8,_writed
673: 654 00013E0D # writes("\ninst = LDD op1; DIVD op2; MULL3,op3,op4,op5; NEGD");
674: 655 00013E0D .data 1
675: 656 00000814 * L454:
676: 657 00000814 * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1; DIVD op2; MULL3,op3,op4,op5; NEGD\0"
677: F70313B2044495644206F7032
678: 3B204D554C4C332C6F70332C6
679: F70342C6F70353B204E454744
680: 00
681: 658 00000847 * .text
682: 659 00013E0D dd 8f00000814 pushl $L454
683: 660 00013E13 fe 08 effffffa52 callf $8,_writes
684: 661 00013E1A # writes(" (integer overflow on MULL3)\n");
685: 662 00013E1A .data 1
686: 663 00000847 * L455:
687: 664 00000847 * 2028696E7465676572206F766 .ascii " (integer overflow on MULL3)\12\0"
688: 572666C6F77206F6E204D554C
689: 4C33290A00
690: 665 00000865 * .text
691: 666 00013E1A dd 8f00000847 pushl $L455
692: 667 00013E20 fe 08 effffffa45 callf $8,_writes
693: 668 00013E27 # }
694: 669 00013E27 40 ret#2
695: 670 00013E28 .set L443,0x0
696: 671 00013E28 L445:
697: 672 00013E28 13 ff5a jbr L446
698: 673 00013E2B .data
699: 674 00000688 * .text
700: 675 00013E2B 00 .align 1
701: 676 00013E2C .globl _pipe14_halt
702: 677 00013E2C _pipe14_halt:
703: 678 00013E2C 0000 .word L456
704: 679 00013E2E #
705: 680 00013E2E #
706: 681 00013E2E #
707: 682 00013E2E # /****************************************************************************
708: 683 00013E2E # * halt on error routine
709: 684 00013E2E # ****************************************************************************/
710: 685 00013E2E # pipe14_halt( code )
711: 686 00013E2E # int code; /* error code to halt with */
712: 687 00013E2E # {
713: 688 00013E2E 13 00bd jbr L458
714: 689 00013E31 L459:
715: 690 00013E31 # err_code = code;
716: 691 00013E31 0d ad04 effffffa33 movl 4(fp),_err_code
717: 692 00013E39 # sgl_value_1 = dbl_ld_acc.m;
718: 693 00013E39 0d effffffa2d effffffa28 movl _dbl_ld_acc,_sgl_value_1
719: 694 00013E44 # sgl_value_2 = dbl_ld_acc.l;
720: 695 00013E44 0d effffffa26 effffffa1d movl _dbl_ld_acc+4,_sgl_value_2
721: 696 00013E4F # sgl_value_3 = dbl_value_1.m;
722: 697 00013E4F 0d effffffa17 effffffa12 movl _dbl_value_1,_sgl_value_3
723: 698 00013E5A # sgl_value_4 = dbl_value_1.l;
724: 699 00013E5A 0d effffffa10 effffffa07 movl _dbl_value_1+4,_sgl_value_4
725: 700 00013E65 # sgl_value_5 = post_evt_acc.m;
726: 701 00013E65 0d effffffa01 effffff9fc movl _post_evt_acc,_sgl_value_5
727: 702 00013E70 # sgl_value_6 = post_evt_acc.l;
728: 703 00013E70 0d effffff9fa effffff9f1 movl _post_evt_acc+4,_sgl_value_6
729: 704 00013E7B # sgl_value_7 = dbl_expected.m;
730: 705 00013E7B 0d effffff9eb effffff9e6 movl _dbl_expected,_sgl_value_7
731: 706 00013E86 # sgl_value_8 = dbl_expected.l;
732: 707 00013E86 0d effffff9e4 effffff9db movl _dbl_expected+4,_sgl_value_8
733: 708 00013E91 # asm("movl _test_no,r0"); /* r0 = test number */
734: 709 00013E91 0d effffff9d5 50 movl _test_no,r0
735: 710 00013E98 # asm("movl _subtest,r1"); /* r1 = subtest number */
736: 711 00013E98 0d effffff9ce 51 movl _subtest,r1
737: 712 00013E9F # asm("movl _err_code,r2"); /* r2 = error code */
738: 713 00013E9F 0d effffff9c7 52 movl _err_code,r2
739: 714 00013EA6 # asm("movl _cycle,r3"); /* r3 = cycle count */
740: 715 00013EA6 0d effffff9c0 53 movl _cycle,r3
741: 716 00013EAD # asm("movl _sgl_value_1,r4"); /* r4 = MSW of 1st load. */
742: 717 00013EAD 0d effffff9b9 54 movl _sgl_value_1,r4
743: 718 00013EB4 # asm("movl _sgl_value_2,r5"); /* r5 = LSW of 1st load. */
744: 719 00013EB4 0d effffff9b2 55 movl _sgl_value_2,r5
745: 720 00013EBB # asm("movl _sgl_value_3,r6"); /* r6 = MSW of 2nd load. */
746: 721 00013EBB 0d effffff9ab 56 movl _sgl_value_3,r6
747: 722 00013EC2 # asm("movl _sgl_value_4,r7"); /* r7 = LSW of 2nd load. */
748: 723 00013EC2 0d effffff9a4 57 movl _sgl_value_4,r7
749: 724 00013EC9 # asm("movl _sgl_value_5,r8"); /* r8 = MSW of final Acc. */
750: 725 00013EC9 0d effffff99d 58 movl _sgl_value_5,r8
751: 726 00013ED0 # asm("movl _sgl_value_6,r9"); /* r9 = LSW of final Acc. */
752: 727 00013ED0 0d effffff996 59 movl _sgl_value_6,r9
753: 728 00013ED7 # asm("movl _sgl_value_7,r10"); /* r10 = MSW of exp. Acc. */
754: 729 00013ED7 0d effffff98f 5a movl _sgl_value_7,r10
755: 730 00013EDE # asm("movl _sgl_value_8,r11"); /* r11 = LSW of exp. Acc. */
756: 731 00013EDE 0d effffff988 5b movl _sgl_value_8,r11
757: 732 00013EE5 # asm("movl _index,r12"); /* r12 = data index */
758: 733 00013EE5 0d effffff981 5c movl _index,r12
759: 734 00013EEC # asm("halt"); /* HALT ... */
760: 735 00013EEC 00 halt
761: 736 00013EED # }
762: 737 00013EED 40 ret#2
763: 738 00013EEE .set L456,0x0
764: 739 00013EEE L458:
765: 740 00013EEE 13 ff40 jbr L459
766: 741 00013EF1 .data
767: 741 0002775D .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.