![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe6.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 pipe6.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 00000730 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe6
6: 6 00000000 _pipe6:
7: 7 00010FC4 0000 .word L381
8: 8 00010FC6 #
9: 9 00010FC6 # #include "evt_defs.h"
10: 10 00010FC6 # #define MAX_POS 0x7fffffff;
11: 11 00010FC6 # /*
12: 12 00010FC6 # *********************************************************************
13: 13 00010FC6 # * FPP PIPELINED EVENTS TEST #6
14: 14 00010FC6 # *
15: 15 00010FC6 # * This test will execute the following code: "LDD MULD ADDL2 MULD 0"
16: 16 00010FC6 # * with an integer overflow fault on the ADDL2. We will make sure that:
17: 17 00010FC6 # * 1. The fault is detected,
18: 18 00010FC6 # * 2. the 1st multiply operation completes, and
19: 19 00010FC6 # * 3. the 2nd multiply instruction is not executed.
20: 20 00010FC6 # *
21: 21 00010FC6 # * NOTE: this instruction uses the same data as pipe2
22: 22 00010FC6 # *********************************************************************
23: 23 00010FC6 # */
24: 24 00010FC6 # pipe6()
25: 25 00010FC6 # {
26: 26 00010FC6 13 0182 jbr L383
27: 27 00010FC9 L384:
28: 28 00010FC9 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
29: 29 00010FC9 ed 6d effffffff4 moval (r13),_pre_event_fp
30: 30 00010FD0 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
31: 31 00010FD0 ed 6e efffffffed moval (r14),_pre_event_sp
32: 32 00010FD7 # precision = DBL;
33: 33 00010FD7 0d 02 efffffffe6 movl $2,_precision
34: 34 00010FDE # test_event = ARITH_CODE; /* expect an arithmetic fault */
35: 35 00010FDE 0d 34 efffffffdf movl $52,_test_event
36: 36 00010FE5 # exp_code = INT_OVFL_CODE; /* -specificly int overflow */
37: 37 00010FE5 0d 01 efffffffd8 movl $1,_exp_code
38: 38 00010FEC # exp_event = FALSE; /* ... but not yet */
39: 39 00010FEC 4d efffffffd2 clrl _exp_event
40: 40 00010FF2 # asm("movab _pipe6_ret,_event_return"); /* set post event return addr */
41: 41 00010FF2 e9 ef000000f3 efffffffc7 movab _pipe6_ret,_event_return
42: 42 00010FFD # dbl_value_2.m = dbl_value_2.l = 0; /* clear the 2nd MULD operand */
43: 43 00010FFD 4d efffffffc5 clrl _dbl_value_2+4
44: 44 00011003 0d efffffffbf 50 movl _dbl_value_2+4,r0
45: 45 0001100A 0d 50 efffffffb3 movl r0,_dbl_value_2
46: 46 00011011 # for( index = 0; index < max_pipe2_index; index++ )
47: 47 00011011 4d efffffffad clrl _index
48: 48 00011017 L387:
49: 49 00011017 1d efffffffa7 efffffffa2 cmpl _index,_max_pipe2_index
50: 50 00011022 91 03 13 0123 jgeq L386
51: 51 00011027 # {
52: 52 00011027 # sgl_value_1 = 0x789abcde; /* get the integer ovfl data */
53: 53 00011027 0d 8f789abcde efffffff92 movl $2023406814,_sgl_value_1
54: 54 00011032 # sgl_value_2 = MAX_POS; /* max integer (7fffffff) */
55: 55 00011032 0d 8f7fffffff efffffff87 movl $2147483647,_sgl_value_2
56: 56 0001103D # dbl_ld_acc = pipe2_data[index].op_1; /* get the data */
57: 57 0001103D 5c 18 efffffff80 50 mull3 $24,_index,r0
58: 58 00011045 0c 8f00000000 50 addl2 $_pipe2_data,r0
59: 59 0001104C 0d a004 efffffff74 movl 4(r0),_dbl_ld_acc+4
60: 60 00011054 0d 60 efffffff69 movl (r0),_dbl_ld_acc
61: 61 0001105B # dbl_value_1 = pipe2_data[index].op_2;
62: 62 0001105B 5c 18 efffffff62 50 mull3 $24,_index,r0
63: 63 00011063 0c 8f00000008 50 addl2 $_pipe2_data+8,r0
64: 64 0001106A 0d a004 efffffff56 movl 4(r0),_dbl_value_1+4
65: 65 00011072 0d 60 efffffff4b movl (r0),_dbl_value_1
66: 66 00011079 # dbl_expected = pipe2_data[index].exp;
67: 67 00011079 5c 18 efffffff44 50 mull3 $24,_index,r0
68: 68 00011081 0c 8f00000010 50 addl2 $_pipe2_data+16,r0
69: 69 00011088 0d a004 efffffff38 movl 4(r0),_dbl_expected+4
70: 70 00011090 0d 60 efffffff2d movl (r0),_dbl_expected
71: 71 00011097 # asm(".globl _pipe6_lp1");
72: 72 00011097 .globl _pipe6_lp1
73: 73 00011097 # asm("_pipe6_lp1:");
74: 74 00011097 _pipe6_lp1:
75: 75 00011097 # asm("bispsw $0x60"); /* enable ovfl,undfl */
76: 76 00011097 8b 8860 bispsw $0x60
77: 77 0001109A # asm("ldd _dbl_ld_acc"); /* load the Acc. */
78: 78 0001109A 07 efffffff24 ldd _dbl_ld_acc
79: 79 000110A0 # exp_event = test_event; /* expect event soon */
80: 80 000110A0 0d efffffff1e efffffff19 movl _test_event,_exp_event
81: 81 000110AB # asm("muld _dbl_value_1"); /* start the multiply*/
82: 82 000110AB e7 efffffff13 muld _dbl_value_1
83: 83 000110B1 # asm("addl2 _sgl_value_1,_sgl_value_2"); /* trigger the fault */
84: 84 000110B1 0c efffffff0d efffffff08 addl2 _sgl_value_1,_sgl_value_2
85: 85 000110BC # asm("muld _dbl_value_2"); /* shouldn't get here*/
86: 86 000110BC e7 efffffff02 muld _dbl_value_2
87: 87 000110C2 # /*
88: 88 000110C2 # * If we got to here then there was no event
89: 89 000110C2 # */
90: 90 000110C2 # if( force_loop )
91: 91 000110C2 5d effffffefc tstl _force_loop
92: 92 000110C8 31 03 jeql L388
93: 93 000110CA # asm("brw _pipe6_lp1");; /* loop on the error */
94: Assemb00028784 # asm("brw _pipe6_lp1");; /* loop on the error */
95: "pipe600028784 94: WARNING: brw: destination label is external
96: 94 000110CA 13 ffca brw _pipe6_lp1
97: 95 000110CD L388:
98: 96 000110CD # exp_event = FALSE; /* reset event expected flag */
99: 97 000110CD 4d effffffef1 clrl _exp_event
100: 98 000110D3 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
101: 99 000110D3 0d effffffeeb 5d movl _pre_event_fp,fp
102: 100 000110DA # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
103: 101 000110DA 0d effffffee4 5e movl _pre_event_sp,sp
104: 102 000110E1 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
105: 103 000110E1 9b 8860 bicpsw $0x60
106: 104 000110E4 # no_pipe6_evt();; /* report the error */
107: 105 000110E4 fe 04 ef00000063 callf $4,_no_pipe6_evt
108: 106 000110EB # /*
109: 107 000110EB # * Come here after the event
110: 108 000110EB # */
111: 109 000110EB # asm(".globl _pipe6_ret");
112: 110 000110EB .globl _pipe6_ret
113: 111 000110EB # asm("_pipe6_ret:");
114: 112 000110EB _pipe6_ret:
115: 113 000110EB # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
116: 114 000110EB 0d effffffed3 5d movl _pre_event_fp,fp
117: 115 000110F2 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
118: 116 000110F2 0d effffffecc 5e movl _pre_event_sp,sp
119: 117 000110F9 # if( force_loop )
120: 118 000110F9 5d effffffec5 tstl _force_loop
121: 119 000110FF 31 03 jeql L390
122: 120 00011101 # asm("brw _pipe6_lp1");; /* loop on the error */
123: "pipe600028784 121: WARNING: brw: destination label is external
124: 121 00011101 13 ff93 brw _pipe6_lp1
125: 122 00011104 L390:
126: 123 00011104 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
127: 124 00011104 9b 8860 bicpsw $0x60
128: 125 00011107 # if( (post_evt_acc.m != dbl_expected.m) ||
129: 126 00011107 # (post_evt_acc.l != dbl_expected.l) )
130: 127 00011107 1d effffffeb7 effffffeb2 cmpl _post_evt_acc,_dbl_expected
131: 128 00011112 21 0d jneq L9999
132: 129 00011114 1d effffffeae effffffea9 cmpl _post_evt_acc+4,_dbl_expected+4
133: 130 0001111F 31 20 jeql L391
134: 131 00011121 L9999:
135: 132 00011121 # {
136: 133 00011121 # if( (!post_evt_acc.m) && (!post_evt_acc.l) )
137: 134 00011121 5d effffffe9d tstl _post_evt_acc
138: 135 00011127 21 11 jneq L392
139: 136 00011129 5d effffffe99 tstl _post_evt_acc+4
140: 137 0001112F 21 09 jneq L392
141: 138 00011131 # pipe6_queue_er(); /* queue not cleared error */
142: 139 00011131 fe 04 ef00000292 callf $4,_pipe6_queue_er
143: 140 00011138 # else
144: 141 00011138 11 07 jbr L394
145: 142 0001113A L392:
146: 143 0001113A # bad_pipe6_result(); /* incorrect result error */
147: 144 0001113A fe 04 ef00000125 callf $4,_bad_pipe6_result
148: 145 00011141 L394:
149: 146 00011141 # }
150: 147 00011141 # }
151: 148 00011141 L391:
152: 149 00011141 L385:
153: 150 00011141 6d effffffe7d incl _index
154: 151 00011147 13 fecd jbr L387
155: 152 0001114A L386:
156: 153 0001114A # }
157: 154 0001114A 40 ret#2
158: 155 0001114B .set L381,0x0
159: 156 0001114B L383:
160: 157 0001114B 13 fe7b jbr L384
161: 158 0001114E .data
162: 159 00000730 * .text
163: 160 0001114E .align 1
164: 161 0001114E .globl _no_pipe6_evt
165: 162 0001114E _no_pipe6_evt:
166: 163 0001114E 0000 .word L396
167: 164 00011150 #
168: 165 00011150 #
169: 166 00011150 #
170: 167 00011150 # /****************************************************************************
171: 168 00011150 # * Report an "EVENT NOT DETECTED" error
172: 169 00011150 # *
173: 170 00011150 # * Cycle: xx. EVT test xx. subtest xx. No Integer Overflow fault. index = xx
174: 171 00011150 # * inst = LDD op1, MULD op2, ADDL2 op3,op4, MULD op5 (Int. Overflow on ADDL2)
175: 172 00011150 # * op1 = xxxxxxxx xxxxxxxx, op3 = xxxxxxxx
176: 173 00011150 # * op2 = xxxxxxxx xxxxxxxx, initial op4 = xxxxxxxx, final op4 = xxxxxxxx
177: 174 00011150 # ****************************************************************************/
178: 175 00011150 # no_pipe6_evt()
179: 176 00011150 # {
180: 177 00011150 13 010f jbr L398
181: 178 00011153 L399:
182: 179 00011153 # errcnt++; /* bump the error count */
183: 180 00011153 6d effffffe6b incl _errcnt
184: 181 00011159 # if ( prt_error )
185: 182 00011159 5d effffffe65 tstl _prt_error
186: 183 0001115F 21 03 13 00d7 jeql L400
187: 184 00011164 # {
188: 185 00011164 # print_pipe6_err( " No Integer Overflow fault." );
189: 186 00011164 .data 1
190: 187 00000730 * L402:
191: 188 00000730 * 20204E6F20496E74656765722 .ascii " No Integer Overflow fault.\0"
192: 04F766572666C6F7720666175
193: 6C742E00
194: 189 0000074d * .text
195: 190 00011164 dd 8f00000730 pushl $L402
196: 191 0001116A fe 08 ef000003bd callf $8,_print_pipe6_err
197: 192 00011171 # writes("op1 = ");
198: 193 00011171 .data 1
199: 194 0000074d * L404:
200: 195 0000074d * 6F7031203D2000 .ascii "op1 = \0"
201: 196 00000754 * .text
202: 197 00011171 dd 8f0000074d pushl $L404
203: 198 00011177 fe 08 effffffe46 callf $8,_writes
204: 199 0001117E # write32h( dbl_ld_acc.m );
205: 200 0001117E dd effffffe40 pushl _dbl_ld_acc
206: 201 00011184 fe 08 effffffe39 callf $8,_write32h
207: 202 0001118B # writes(" ");
208: 203 0001118B .data 1
209: 204 00000754 * L406:
210: 205 00000754 * 2000 .ascii " \0"
211: 206 00000756 * .text
212: 207 0001118B dd 8f00000754 pushl $L406
213: 208 00011191 fe 08 effffffe2c callf $8,_writes
214: 209 00011198 # write32h( dbl_ld_acc.l );
215: 210 00011198 dd effffffe2a pushl _dbl_ld_acc+4
216: 211 0001119E fe 08 effffffe1f callf $8,_write32h
217: 212 000111A5 # writes(", op3 = ");
218: 213 000111A5 .data 1
219: 214 00000756 * L407:
220: 215 00000756 * 2C202020202020202020206F7 .ascii ", op3 = \0"
221: 033203D2000
222: 216 00000768 * .text
223: 217 000111A5 dd 8f00000756 pushl $L407
224: 218 000111AB fe 08 effffffe12 callf $8,_writes
225: 219 000111B2 # write32h( sgl_value_1 );
226: 220 000111B2 dd effffffe0c pushl _sgl_value_1
227: 221 000111B8 fe 08 effffffe05 callf $8,_write32h
228: 222 000111BF # writes("\nop2 = ");
229: 223 000111BF .data 1
230: 224 00000768 * L408:
231: 225 00000768 * 0A6F7032203D2000 .ascii "\12op2 = \0"
232: 226 00000770 * .text
233: 227 000111BF dd 8f00000768 pushl $L408
234: 228 000111C5 fe 08 effffffdf8 callf $8,_writes
235: 229 000111CC # write32h( dbl_value_1.m );
236: 230 000111CC dd effffffdf2 pushl _dbl_value_1
237: 231 000111D2 fe 08 effffffdeb callf $8,_write32h
238: 232 000111D9 # writes(" ");
239: 233 000111D9 .data 1
240: 234 00000770 * L409:
241: 235 00000770 * 2000 .ascii " \0"
242: 236 00000772 * .text
243: 237 000111D9 dd 8f00000770 pushl $L409
244: 238 000111DF fe 08 effffffdde callf $8,_writes
245: 239 000111E6 # write32h( dbl_value_1.l );
246: 240 000111E6 dd effffffddc pushl _dbl_value_1+4
247: 241 000111EC fe 08 effffffdd1 callf $8,_write32h
248: 242 000111F3 # writes(", initial op4 = ");
249: 243 000111F3 .data 1
250: 244 00000772 * L410:
251: 245 00000772 * 2C2020696E697469616C206F7 .ascii ", initial op4 = \0"
252: 034203D2000
253: 246 00000784 * .text
254: 247 000111F3 dd 8f00000772 pushl $L410
255: 248 000111F9 fe 08 effffffdc4 callf $8,_writes
256: 249 00011200 # sgl_dummy1 = MAX_POS;
257: 250 00011200 0d 8f7fffffff effffffdb9 movl $2147483647,_sgl_dummy1
258: 251 0001120B # write32h( sgl_dummy1 );
259: 252 0001120B dd effffffdb3 pushl _sgl_dummy1
260: 253 00011211 fe 08 effffffdac callf $8,_write32h
261: 254 00011218 # writes(", final op4 = ");
262: 255 00011218 .data 1
263: 256 00000784 * L411:
264: 257 00000784 * 2C202066696E616C206F70342 .ascii ", final op4 = \0"
265: 03D2000
266: 258 00000794 * .text
267: 259 00011218 dd 8f00000784 pushl $L411
268: 260 0001121E fe 08 effffffd9f callf $8,_writes
269: 261 00011225 # write32h( sgl_value_2 );
270: 262 00011225 dd effffffd99 pushl _sgl_value_2
271: 263 0001122B fe 08 effffffd92 callf $8,_write32h
272: 264 00011232 # writec('\n');
273: 265 00011232 dd 0a pushl $10
274: 266 00011234 fe 08 effffffd89 callf $8,_writec
275: 267 0001123B # }
276: 268 0001123B # if ( halt_flg ) /* halt on error? */
277: 269 0001123B L400:
278: 270 0001123B 5d effffffd83 tstl _halt_flg
279: 271 00011241 31 09 jeql L413
280: 272 00011243 # pipe6_halt( 1 ); /* halt with a code of 1 */
281: 273 00011243 dd 01 pushl $1
282: 274 00011245 fe 08 ef0000038e callf $8,_pipe6_halt
283: 275 0001124C # if ( loop_on_err )
284: 276 0001124C L413:
285: 277 0001124C 5d effffffd72 tstl _loop_on_err
286: 278 00011252 31 0d jeql L415
287: 279 00011254 # {
288: 280 00011254 # force_loop = TRUE; /* set the force loop flag */
289: 281 00011254 0d 01 effffffd69 movl $1,_force_loop
290: 282 0001125B # asm("jmp _pipe6_lp1"); /* and loop */
291: 283 0001125B 71 effffffe36 jmp _pipe6_lp1
292: 284 00011261 # };
293: 285 00011261 L415:
294: 286 00011261 # }
295: 287 00011261 40 ret#2
296: 288 00011262 .set L396,0x0
297: 289 00011262 L398:
298: 290 00011262 13 feee jbr L399
299: 291 00011265 .data
300: 292 00000730 * .text
301: 293 00011265 00 .align 1
302: 294 00011266 .globl _bad_pipe6_result
303: 295 00011266 _bad_pipe6_result:
304: 296 00011266 0000 .word L416
305: 297 00011268 #
306: 298 00011268 #
307: 299 00011268 #
308: 300 00011268 #
309: 301 00011268 # /****************************************************************************
310: 302 00011268 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
311: 303 00011268 # *
312: 304 00011268 # * Cycle: xx. EVT test xx. subtest xx. . Bad final Accumulator. index = xx
313: 305 00011268 # * inst = LDD op1, MULD op2, ADDL2 op3,op4, MULD op5 (Int. Overflow on ADDL2)
314: 306 00011268 # * The 2nd MULD should not be executed.
315: 307 00011268 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
316: 308 00011268 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
317: 309 00011268 # * op5 = xxxxxxxx xxxxxxxx
318: 310 00011268 # ****************************************************************************/
319: 311 00011268 # bad_pipe6_result()
320: 312 00011268 # {
321: 313 00011268 13 015b jbr L418
322: 314 0001126B L419:
323: 315 0001126B # errcnt++; /* bump the error count */
324: 316 0001126B 6d effffffd53 incl _errcnt
325: 317 00011271 # if ( prt_error )
326: 318 00011271 5d effffffd4d tstl _prt_error
327: 319 00011277 21 03 13 0123 jeql L420
328: 320 0001127C # {
329: 321 0001127C # print_pipe6_err( ". Bad final Accumulator." );
330: 322 0001127C .data 1
331: 323 00000794 * L421:
332: 324 00000794 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator.\0"
333: 16363756D756C61746F722E00
334: 325 000007ad * .text
335: 326 0001127C dd 8f00000794 pushl $L421
336: 327 00011282 fe 08 ef000002a5 callf $8,_print_pipe6_err
337: 328 00011289 # writes("The 2nd MULD should not be executed\n");
338: 329 00011289 .data 1
339: 330 000007ad * L422:
340: 331 000007ad * 54686520326E64204D554C442 .ascii "The 2nd MULD should not be executed\12\0"
341: 073686F756C64206E6F742062
342: 652065786563757465640A00
343: 332 000007d2 * .text
344: 333 00011289 dd 8f000007ad pushl $L422
345: 334 0001128F fe 08 effffffd2e callf $8,_writes
346: 335 00011296 # writes("op1 = ");
347: 336 00011296 .data 1
348: 337 000007d2 * L423:
349: 338 000007d2 * 6F7031203D2000 .ascii "op1 = \0"
350: 339 000007d9 * .text
351: 340 00011296 dd 8f000007d2 pushl $L423
352: 341 0001129C fe 08 effffffd21 callf $8,_writes
353: 342 000112A3 # write32h( dbl_ld_acc.m );
354: 343 000112A3 dd effffffd1b pushl _dbl_ld_acc
355: 344 000112A9 fe 08 effffffd14 callf $8,_write32h
356: 345 000112B0 # writes(" ");
357: 346 000112B0 .data 1
358: 347 000007d9 * L424:
359: 348 000007d9 * 2000 .ascii " \0"
360: 349 000007db * .text
361: 350 000112B0 dd 8f000007d9 pushl $L424
362: 351 000112B6 fe 08 effffffd07 callf $8,_writes
363: 352 000112BD # write32h( dbl_ld_acc.l );
364: 353 000112BD dd effffffd05 pushl _dbl_ld_acc+4
365: 354 000112C3 fe 08 effffffcfa callf $8,_write32h
366: 355 000112CA # writes(", final Acc. = ");
367: 356 000112CA .data 1
368: 357 000007db * L425:
369: 358 000007db * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
370: 32E203D2000
371: 359 000007ed * .text
372: 360 000112CA dd 8f000007db pushl $L425
373: 361 000112D0 fe 08 effffffced callf $8,_writes
374: 362 000112D7 # write32h( post_evt_acc.m );
375: 363 000112D7 dd effffffce7 pushl _post_evt_acc
376: 364 000112DD fe 08 effffffce0 callf $8,_write32h
377: 365 000112E4 # writec(' ');
378: 366 000112E4 dd 20 pushl $32
379: 367 000112E6 fe 08 effffffcd7 callf $8,_writec
380: 368 000112ED # write32h( post_evt_acc.l );
381: 369 000112ED dd effffffcd5 pushl _post_evt_acc+4
382: 370 000112F3 fe 08 effffffcca callf $8,_write32h
383: 371 000112FA # writes("\nop2 = ");
384: 372 000112FA .data 1
385: 373 000007ed * L426:
386: 374 000007ed * 0A6F7032203D2000 .ascii "\12op2 = \0"
387: 375 000007f5 * .text
388: 376 000112FA dd 8f000007ed pushl $L426
389: 377 00011300 fe 08 effffffcbd callf $8,_writes
390: 378 00011307 # write32h( dbl_value_1.m );
391: 379 00011307 dd effffffcb7 pushl _dbl_value_1
392: 380 0001130D fe 08 effffffcb0 callf $8,_write32h
393: 381 00011314 # writes(" ");
394: 382 00011314 .data 1
395: 383 000007f5 * L427:
396: 384 000007f5 * 2000 .ascii " \0"
397: 385 000007f7 * .text
398: 386 00011314 dd 8f000007f5 pushl $L427
399: 387 0001131A fe 08 effffffca3 callf $8,_writes
400: 388 00011321 # write32h( dbl_value_1.l );
401: 389 00011321 dd effffffca1 pushl _dbl_value_1+4
402: 390 00011327 fe 08 effffffc96 callf $8,_write32h
403: 391 0001132E # writes(", expected = ");
404: 392 0001132E .data 1
405: 393 000007f7 * L428:
406: 394 000007f7 * 2C20202065787065637465642 .ascii ", expected = \0"
407: 020203D2000
408: 395 00000809 * .text
409: 396 0001132E dd 8f000007f7 pushl $L428
410: 397 00011334 fe 08 effffffc89 callf $8,_writes
411: 398 0001133B # write32h( dbl_expected.m );
412: 399 0001133B dd effffffc83 pushl _dbl_expected
413: 400 00011341 fe 08 effffffc7c callf $8,_write32h
414: 401 00011348 # writes(" ");
415: 402 00011348 .data 1
416: 403 00000809 * L429:
417: 404 00000809 * 2000 .ascii " \0"
418: 405 0000080b * .text
419: 406 00011348 dd 8f00000809 pushl $L429
420: 407 0001134E fe 08 effffffc6f callf $8,_writes
421: 408 00011355 # write32h( dbl_expected.l );
422: 409 00011355 dd effffffc6d pushl _dbl_expected+4
423: 410 0001135B fe 08 effffffc62 callf $8,_write32h
424: 411 00011362 # writes("\nop5 = ");
425: 412 00011362 .data 1
426: 413 0000080b * L430:
427: 414 0000080b * 0A6F7035203D2000 .ascii "\12op5 = \0"
428: 415 00000813 * .text
429: 416 00011362 dd 8f0000080b pushl $L430
430: 417 00011368 fe 08 effffffc55 callf $8,_writes
431: 418 0001136F # write32h( dbl_value_2.m );
432: 419 0001136F dd effffffc4f pushl _dbl_value_2
433: 420 00011375 fe 08 effffffc48 callf $8,_write32h
434: 421 0001137C # writes(" ");
435: 422 0001137C .data 1
436: 423 00000813 * L431:
437: 424 00000813 * 2000 .ascii " \0"
438: 425 00000815 * .text
439: 426 0001137C dd 8f00000813 pushl $L431
440: 427 00011382 fe 08 effffffc3b callf $8,_writes
441: 428 00011389 # write32h( dbl_value_2.l );
442: 429 00011389 dd effffffc39 pushl _dbl_value_2+4
443: 430 0001138F fe 08 effffffc2e callf $8,_write32h
444: 431 00011396 # writec('\n');
445: 432 00011396 dd 0a pushl $10
446: 433 00011398 fe 08 effffffc25 callf $8,_writec
447: 434 0001139F # }
448: 435 0001139F # if ( halt_flg ) /* halt on error? */
449: 436 0001139F L420:
450: 437 0001139F 5d effffffc1f tstl _halt_flg
451: 438 000113A5 31 09 jeql L432
452: 439 000113A7 # pipe6_halt( 2 ); /* halt with a code of 2 */
453: 440 000113A7 dd 02 pushl $2
454: 441 000113A9 fe 08 ef0000022a callf $8,_pipe6_halt
455: 442 000113B0 # if ( loop_on_err )
456: 443 000113B0 L432:
457: 444 000113B0 5d effffffc0e tstl _loop_on_err
458: 445 000113B6 31 0d jeql L433
459: 446 000113B8 # {
460: 447 000113B8 # force_loop = TRUE; /* set the force loop flag */
461: 448 000113B8 0d 01 effffffc05 movl $1,_force_loop
462: 449 000113BF # asm("jmp _pipe6_lp1"); /* and loop */
463: 450 000113BF 71 effffffcd2 jmp _pipe6_lp1
464: 451 000113C5 # };
465: 452 000113C5 L433:
466: 453 000113C5 # }
467: 454 000113C5 40 ret#2
468: 455 000113C6 .set L416,0x0
469: 456 000113C6 L418:
470: 457 000113C6 13 fea2 jbr L419
471: 458 000113C9 .data
472: 459 00000730 * .text
473: 460 000113C9 00 .align 1
474: 461 000113CA .globl _pipe6_queue_er
475: 462 000113CA _pipe6_queue_er:
476: 463 000113CA 0000 .word L434
477: 464 000113CC #
478: 465 000113CC #
479: 466 000113CC #
480: 467 000113CC #
481: 468 000113CC # /****************************************************************************
482: 469 000113CC # * Report an "FPP Queue not cleared" error
483: 470 000113CC # *
484: 471 000113CC # * Cycle: xx. EVT test xx. subtest xx. . FPP queue not cleared. index = xx
485: 472 000113CC # * inst = LDD op1, MULD op2, ADDL2 op3,op4, MULD op5 (Int. Overflow on ADDL2)
486: 473 000113CC # * The 2nd MULD should not have been executed but apparently was.
487: 474 000113CC # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
488: 475 000113CC # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
489: 476 000113CC # * op5 = xxxxxxxx xxxxxxxx
490: 477 000113CC # ****************************************************************************/
491: 478 000113CC # pipe6_queue_er()
492: 479 000113CC # {
493: 480 000113CC 13 015b jbr L436
494: 481 000113CF L437:
495: 482 000113CF # errcnt++; /* bump the error count */
496: 483 000113CF 6d effffffbef incl _errcnt
497: 484 000113D5 # if ( prt_error )
498: 485 000113D5 5d effffffbe9 tstl _prt_error
499: 486 000113DB 21 03 13 0123 jeql L438
500: 487 000113E0 # {
501: 488 000113E0 # print_pipe6_err( ". FPP queue not cleared." );
502: 489 000113E0 .data 1
503: 490 00000815 * L439:
504: 491 00000815 * 2E20465050207175657565206 .ascii ". FPP queue not cleared.\0"
505: E6F7420636C65617265642E00
506: 492 0000082e * .text
507: 493 000113E0 dd 8f00000815 pushl $L439
508: 494 000113E6 fe 08 ef00000141 callf $8,_print_pipe6_err
509: 495 000113ED # writes(
510: 496 000113ED # "The 2nd MULD should not have been executed but apparently was.\n");
511: 497 000113ED .data 1
512: 498 0000082e * L440:
513: 499 0000082e * 54686520326E64204D554C442 .ascii "The 2nd MULD should not have been executed but apparently was.\12\0"
514: 073686F756C64206E6F742068
515: 617665206265656E206578656
516: 3757465642062757420617070
517: 6172656E746C79207761732E0
518: A00
519: 500 0000086e * .text
520: 501 000113ED dd 8f0000082e pushl $L440
521: 502 000113F3 fe 08 effffffbca callf $8,_writes
522: 503 000113FA # writes("op1 = ");
523: 504 000113FA .data 1
524: 505 0000086e * L441:
525: 506 0000086e * 6F7031203D2000 .ascii "op1 = \0"
526: 507 00000875 * .text
527: 508 000113FA dd 8f0000086e pushl $L441
528: 509 00011400 fe 08 effffffbbd callf $8,_writes
529: 510 00011407 # write32h( dbl_ld_acc.m );
530: 511 00011407 dd effffffbb7 pushl _dbl_ld_acc
531: 512 0001140D fe 08 effffffbb0 callf $8,_write32h
532: 513 00011414 # writes(" ");
533: 514 00011414 .data 1
534: 515 00000875 * L442:
535: 516 00000875 * 2000 .ascii " \0"
536: 517 00000877 * .text
537: 518 00011414 dd 8f00000875 pushl $L442
538: 519 0001141A fe 08 effffffba3 callf $8,_writes
539: 520 00011421 # write32h( dbl_ld_acc.l );
540: 521 00011421 dd effffffba1 pushl _dbl_ld_acc+4
541: 522 00011427 fe 08 effffffb96 callf $8,_write32h
542: 523 0001142E # writes(", final Acc. = ");
543: 524 0001142E .data 1
544: 525 00000877 * L443:
545: 526 00000877 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
546: 32E203D2000
547: 527 00000889 * .text
548: 528 0001142E dd 8f00000877 pushl $L443
549: 529 00011434 fe 08 effffffb89 callf $8,_writes
550: 530 0001143B # write32h( post_evt_acc.m );
551: 531 0001143B dd effffffb83 pushl _post_evt_acc
552: 532 00011441 fe 08 effffffb7c callf $8,_write32h
553: 533 00011448 # writec(' ');
554: 534 00011448 dd 20 pushl $32
555: 535 0001144A fe 08 effffffb73 callf $8,_writec
556: 536 00011451 # write32h( post_evt_acc.l );
557: 537 00011451 dd effffffb71 pushl _post_evt_acc+4
558: 538 00011457 fe 08 effffffb66 callf $8,_write32h
559: 539 0001145E # writes("\nop2 = ");
560: 540 0001145E .data 1
561: 541 00000889 * L444:
562: 542 00000889 * 0A6F7032203D2000 .ascii "\12op2 = \0"
563: 543 00000891 * .text
564: 544 0001145E dd 8f00000889 pushl $L444
565: 545 00011464 fe 08 effffffb59 callf $8,_writes
566: 546 0001146B # write32h( dbl_value_1.m );
567: 547 0001146B dd effffffb53 pushl _dbl_value_1
568: 548 00011471 fe 08 effffffb4c callf $8,_write32h
569: 549 00011478 # writes(" ");
570: 550 00011478 .data 1
571: 551 00000891 * L445:
572: 552 00000891 * 2000 .ascii " \0"
573: 553 00000893 * .text
574: 554 00011478 dd 8f00000891 pushl $L445
575: 555 0001147E fe 08 effffffb3f callf $8,_writes
576: 556 00011485 # write32h( dbl_value_1.l );
577: 557 00011485 dd effffffb3d pushl _dbl_value_1+4
578: 558 0001148B fe 08 effffffb32 callf $8,_write32h
579: 559 00011492 # writes(", expected = ");
580: 560 00011492 .data 1
581: 561 00000893 * L446:
582: 562 00000893 * 2C20202065787065637465642 .ascii ", expected = \0"
583: 020203D2000
584: 563 000008a5 * .text
585: 564 00011492 dd 8f00000893 pushl $L446
586: 565 00011498 fe 08 effffffb25 callf $8,_writes
587: 566 0001149F # write32h( dbl_expected.m );
588: 567 0001149F dd effffffb1f pushl _dbl_expected
589: 568 000114A5 fe 08 effffffb18 callf $8,_write32h
590: 569 000114AC # writes(" ");
591: 570 000114AC .data 1
592: 571 000008a5 * L447:
593: 572 000008a5 * 2000 .ascii " \0"
594: 573 000008a7 * .text
595: 574 000114AC dd 8f000008a5 pushl $L447
596: 575 000114B2 fe 08 effffffb0b callf $8,_writes
597: 576 000114B9 # write32h( dbl_expected.l );
598: 577 000114B9 dd effffffb09 pushl _dbl_expected+4
599: 578 000114BF fe 08 effffffafe callf $8,_write32h
600: 579 000114C6 # writes("\nop5 = ");
601: 580 000114C6 .data 1
602: 581 000008a7 * L448:
603: 582 000008a7 * 0A6F7035203D2000 .ascii "\12op5 = \0"
604: 583 000008af * .text
605: 584 000114C6 dd 8f000008a7 pushl $L448
606: 585 000114CC fe 08 effffffaf1 callf $8,_writes
607: 586 000114D3 # write32h( dbl_value_2.m );
608: 587 000114D3 dd effffffaeb pushl _dbl_value_2
609: 588 000114D9 fe 08 effffffae4 callf $8,_write32h
610: 589 000114E0 # writes(" ");
611: 590 000114E0 .data 1
612: 591 000008af * L449:
613: 592 000008af * 2000 .ascii " \0"
614: 593 000008b1 * .text
615: 594 000114E0 dd 8f000008af pushl $L449
616: 595 000114E6 fe 08 effffffad7 callf $8,_writes
617: 596 000114ED # write32h( dbl_value_2.l );
618: 597 000114ED dd effffffad5 pushl _dbl_value_2+4
619: 598 000114F3 fe 08 effffffaca callf $8,_write32h
620: 599 000114FA # writec('\n');
621: 600 000114FA dd 0a pushl $10
622: 601 000114FC fe 08 effffffac1 callf $8,_writec
623: 602 00011503 # }
624: 603 00011503 # if ( halt_flg ) /* halt on error? */
625: 604 00011503 L438:
626: 605 00011503 5d effffffabb tstl _halt_flg
627: 606 00011509 31 09 jeql L450
628: 607 0001150B # pipe6_halt( 3 ); /* halt with a code of 3 */
629: 608 0001150B dd 03 pushl $3
630: 609 0001150D fe 08 ef000000c6 callf $8,_pipe6_halt
631: 610 00011514 # if ( loop_on_err )
632: 611 00011514 L450:
633: 612 00011514 5d effffffaaa tstl _loop_on_err
634: 613 0001151A 31 0d jeql L451
635: 614 0001151C # {
636: 615 0001151C # force_loop = TRUE; /* set the force loop flag */
637: 616 0001151C 0d 01 effffffaa1 movl $1,_force_loop
638: 617 00011523 # asm("jmp _pipe6_lp1"); /* and loop */
639: 618 00011523 71 effffffb6e jmp _pipe6_lp1
640: 619 00011529 # };
641: 620 00011529 L451:
642: 621 00011529 # }
643: 622 00011529 40 ret#2
644: 623 0001152A .set L434,0x0
645: 624 0001152A L436:
646: 625 0001152A 13 fea2 jbr L437
647: 626 0001152D .data
648: 627 00000730 * .text
649: 628 0001152D 00 .align 1
650: 629 0001152E .globl _print_pipe6_err
651: 630 0001152E _print_pipe6_err:
652: 631 0001152E 0000 .word L452
653: 632 00011530 #
654: 633 00011530 #
655: 634 00011530 #
656: 635 00011530 #
657: 636 00011530 #
658: 637 00011530 # /****************************************************************************
659: 638 00011530 # * Report an error message of the form
660: 639 00011530 # *
661: 640 00011530 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx
662: 641 00011530 # * inst = LDD op1, MULD op2, ADDL2 op3,op4, MULD op5 (Int. Overflow on ADDL2)
663: 642 00011530 # ****************************************************************************/
664: 643 00011530 # print_pipe6_err( msg )
665: 644 00011530 # char *msg; /* pointer to error message */
666: 645 00011530 # {
667: 646 00011530 13 00a3 jbr L454
668: 647 00011533 L455:
669: 648 00011533 # if( errcnt == 1 ) /* 1st error? */
670: 649 00011533 1d effffffa8b 01 cmpl _errcnt,$1
671: 650 0001153A 21 0d jneq L456
672: 651 0001153C # writes(" \n"); /* start a new print line */
673: 652 0001153C .data 1
674: 653 000008b1 * L457:
675: 654 000008b1 * 200A00 .ascii " \12\0"
676: 655 000008b4 * .text
677: 656 0001153C dd 8f000008b1 pushl $L457
678: 657 00011542 fe 08 effffffa7b callf $8,_writes
679: 658 00011549 # writes("Cycle: ");
680: 659 00011549 L456:
681: 660 00011549 .data 1
682: 661 000008b4 * L458:
683: 662 000008b4 * 4379636C653A2000 .ascii "Cycle: \0"
684: 663 000008bc * .text
685: 664 00011549 dd 8f000008b4 pushl $L458
686: 665 0001154F fe 08 effffffa6e callf $8,_writes
687: 666 00011556 # writed( cycle );
688: 667 00011556 dd effffffa68 pushl _cycle
689: 668 0001155C fe 08 effffffa61 callf $8,_writed
690: 669 00011563 # writes(" EVT test ");
691: 670 00011563 .data 1
692: 671 000008bc * L460:
693: 672 000008bc * 202045565420746573742000 .ascii " EVT test \0"
694: 673 000008c8 * .text
695: 674 00011563 dd 8f000008bc pushl $L460
696: 675 00011569 fe 08 effffffa54 callf $8,_writes
697: 676 00011570 # writed( test_no );
698: 677 00011570 dd effffffa4e pushl _test_no
699: 678 00011576 fe 08 effffffa47 callf $8,_writed
700: 679 0001157D # writes(". subtest ");
701: 680 0001157D .data 1
702: 681 000008c8 * L461:
703: 682 000008c8 * 2E20737562746573742000 .ascii ". subtest \0"
704: 683 000008d3 * .text
705: 684 0001157D dd 8f000008c8 pushl $L461
706: 685 00011583 fe 08 effffffa3a callf $8,_writes
707: 686 0001158A # writed( subtest );
708: 687 0001158A dd effffffa34 pushl _subtest
709: 688 00011590 fe 08 effffffa2d callf $8,_writed
710: 689 00011597 # writes( msg ); /* print the error message */
711: 690 00011597 dd ad04 pushl 4(fp)
712: 691 0001159A fe 08 effffffa23 callf $8,_writes
713: 692 000115A1 # writes(" index = ");
714: 693 000115A1 .data 1
715: 694 000008d3 * L462:
716: 695 000008d3 * 20696E646578203D2000 .ascii " index = \0"
717: 696 000008dd * .text
718: 697 000115A1 dd 8f000008d3 pushl $L462
719: 698 000115A7 fe 08 effffffa16 callf $8,_writes
720: 699 000115AE # writed( index );
721: 700 000115AE dd effffffa10 pushl _index
722: 701 000115B4 fe 08 effffffa09 callf $8,_writed
723: 702 000115BB # writes("\ninst = LDD op1, MULD op2, ADDL2 op3,op4, MULD op5");
724: 703 000115BB .data 1
725: 704 000008dd * L463:
726: 705 000008dd * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1, MULD op2, ADDL2 op3,op4, MULD op5\0"
727: F70312C204D554C44206F7032
728: 2C204144444C32206F70332C6
729: F70342C204D554C44206F7035
730: 00
731: 706 00000910 * .text
732: 707 000115BB dd 8f000008dd pushl $L463
733: 708 000115C1 fe 08 effffff9fc callf $8,_writes
734: 709 000115C8 # writes(" (Integer Overflow on ADDL2)\n");
735: 710 000115C8 .data 1
736: 711 00000910 * L464:
737: 712 00000910 * 202028496E7465676572204F7 .ascii " (Integer Overflow on ADDL2)\12\0"
738: 66572666C6F77206F6E204144
739: 444C32290A00
740: 713 0000092f * .text
741: 714 000115C8 dd 8f00000910 pushl $L464
742: 715 000115CE fe 08 effffff9ef callf $8,_writes
743: 716 000115D5 # }
744: 717 000115D5 40 ret#2
745: 718 000115D6 .set L452,0x0
746: 719 000115D6 L454:
747: 720 000115D6 13 ff5a jbr L455
748: 721 000115D9 .data
749: 722 00000730 * .text
750: 723 000115D9 00 .align 1
751: 724 000115DA .globl _pipe6_halt
752: 725 000115DA _pipe6_halt:
753: 726 000115DA 0000 .word L465
754: 727 000115DC #
755: 728 000115DC #
756: 729 000115DC # /****************************************************************************
757: 730 000115DC # * Error Halt Routine
758: 731 000115DC # ****************************************************************************/
759: 732 000115DC # pipe6_halt( code )
760: 733 000115DC # int code; /* halt code to use */
761: 734 000115DC # {
762: 735 000115DC 13 0111 jbr L467
763: 736 000115DF L468:
764: 737 000115DF # err_code = code;
765: 738 000115DF 0d ad04 effffff9dd movl 4(fp),_err_code
766: 739 000115E7 # sgl_value_3 = MAX_POS; /* initial op4 data */
767: 740 000115E7 0d 8f7fffffff effffff9d2 movl $2147483647,_sgl_value_3
768: 741 000115F2 # sgl_value_4 = dbl_ld_acc.m;
769: 742 000115F2 0d effffff9cc effffff9c7 movl _dbl_ld_acc,_sgl_value_4
770: 743 000115FD # sgl_value_5 = dbl_ld_acc.l;
771: 744 000115FD 0d effffff9c5 effffff9bc movl _dbl_ld_acc+4,_sgl_value_5
772: 745 00011608 # sgl_value_6 = dbl_value_1.m;
773: 746 00011608 0d effffff9b6 effffff9b1 movl _dbl_value_1,_sgl_value_6
774: 747 00011613 # sgl_value_7 = dbl_value_1.l;
775: 748 00011613 0d effffff9af effffff9a6 movl _dbl_value_1+4,_sgl_value_7
776: 749 0001161E # asm("movl _test_no,r0"); /* r0 = test number */
777: 750 0001161E 0d effffff9a0 50 movl _test_no,r0
778: 751 00011625 # asm("movl _subtest,r1"); /* r1 = subtest number */
779: 752 00011625 0d effffff999 51 movl _subtest,r1
780: 753 0001162C # asm("movl _err_code,r2"); /* r2 = error code */
781: 754 0001162C 0d effffff992 52 movl _err_code,r2
782: 755 00011633 # asm("movl _cycle,r3"); /* r3 = cycle count */
783: 756 00011633 0d effffff98b 53 movl _cycle,r3
784: 757 0001163A # asm("movl _sgl_value_4,r4"); /* r4 = MSW of operand 1 */
785: 758 0001163A 0d effffff984 54 movl _sgl_value_4,r4
786: 759 00011641 # asm("movl _sgl_value_5,r5"); /* r5 = LSW of operand 1 */
787: 760 00011641 0d effffff97d 55 movl _sgl_value_5,r5
788: 761 00011648 # asm("movl _sgl_value_6,r6"); /* r6 = MSW of operand 2 */
789: 762 00011648 0d effffff976 56 movl _sgl_value_6,r6
790: 763 0001164F # asm("movl _sgl_value_7,r7"); /* r7 = LSW of operand 2 */
791: 764 0001164F 0d effffff96f 57 movl _sgl_value_7,r7
792: 765 00011656 # if( code == 1 ) {
793: 766 00011656 1d ad04 01 cmpl 4(fp),$1
794: 767 0001165A 21 1f jneq L469
795: 768 0001165C # asm("movl _sgl_value_1,r8"); /* r8 = operand 3 */
796: 769 0001165C 0d effffff962 58 movl _sgl_value_1,r8
797: 770 00011663 # asm("movl _sgl_value_3,r9"); /* r9 = operand 2, initial */
798: 771 00011663 0d effffff95b 59 movl _sgl_value_3,r9
799: 772 0001166A # asm("movl _sgl_value_2,r10"); /* r10 = operand 2, final */
800: 773 0001166A 0d effffff954 5a movl _sgl_value_2,r10
801: 774 00011671 # asm("movl _index,r11"); /* r11 = data index */
802: 775 00011671 0d effffff94d 5b movl _index,r11
803: 776 00011678 # asm("halt"); /* HALT ... */
804: 777 00011678 00 halt
805: 778 00011679 # } else {
806: 779 00011679 11 73 jbr L470
807: 780 0001167B L469:
808: 781 0001167B # sgl_value_1 = post_evt_acc.m;
809: 782 0001167B 0d effffff943 effffff93e movl _post_evt_acc,_sgl_value_1
810: 783 00011686 # sgl_value_2 = post_evt_acc.l;
811: 784 00011686 0d effffff93c effffff933 movl _post_evt_acc+4,_sgl_value_2
812: 785 00011691 # sgl_value_3 = dbl_expected.m;
813: 786 00011691 0d effffff92d effffff928 movl _dbl_expected,_sgl_value_3
814: 787 0001169C # sgl_value_4 = dbl_expected.l;
815: 788 0001169C 0d effffff926 effffff91d movl _dbl_expected+4,_sgl_value_4
816: 789 000116A7 # sgl_value_5 = dbl_value_2.m;
817: 790 000116A7 0d effffff917 effffff912 movl _dbl_value_2,_sgl_value_5
818: 791 000116B2 # sgl_value_6 = dbl_value_2.l;
819: 792 000116B2 0d effffff910 effffff907 movl _dbl_value_2+4,_sgl_value_6
820: 793 000116BD # asm("movl _sgl_value_1,r8"); /* r8 = MSW of final acc. */
821: 794 000116BD 0d effffff901 58 movl _sgl_value_1,r8
822: 795 000116C4 # asm("movl _sgl_value_2,r9"); /* r9 = LSW of final acc. */
823: 796 000116C4 0d effffff8fa 59 movl _sgl_value_2,r9
824: 797 000116CB # asm("movl _sgl_value_3,r10"); /* r10 = MSW of expected */
825: 798 000116CB 0d effffff8f3 5a movl _sgl_value_3,r10
826: 799 000116D2 # asm("movl _sgl_value_4,r11"); /* r11 = LSW of expected */
827: 800 000116D2 0d effffff8ec 5b movl _sgl_value_4,r11
828: 801 000116D9 # asm("movl _sgl_value_5,r12"); /* r12 = MSW of 2nd MULD op */
829: 802 000116D9 0d effffff8e5 5c movl _sgl_value_5,r12
830: 803 000116E0 # asm("movl _sgl_value_6,r13"); /* r13 = LSW of 2nd MULD op */
831: 804 000116E0 0d effffff8de 5d movl _sgl_value_6,r13
832: 805 000116E7 # asm("movl _index,r14"); /* r14 = data index */
833: 806 000116E7 0d effffff8d7 5e movl _index,r14
834: 807 000116EE # }
835: 808 000116EE L470:
836: 809 000116EE # asm("halt"); /* HALT ... */
837: 810 000116EE 00 halt
838: 811 000116EF # }
839: 812 000116EF 40 ret#2
840: 813 000116F0 .set L465,0x0
841: 814 000116F0 L467:
842: 815 000116F0 13 feec jbr L468
843: 816 000116F3 .data
844: 816 000226B7 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.