![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe2.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 pipe2.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 000006a8 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe2
6: 6 00000000 _pipe2:
7: 7 0000F9A8 0000 .word L381
8: 8 0000F9AA #
9: 9 0000F9AA # #include "evt_defs.h"
10: 10 0000F9AA #
11: 11 0000F9AA # /*
12: 12 0000F9AA # *********************************************************************
13: 13 0000F9AA # * FPP PIPELINED EVENTS TEST #2
14: 14 0000F9AA # *
15: 15 0000F9AA # * This test will execute the following code: "LDD MULD MTPR LDD"
16: 16 0000F9AA # * with a reserved operand fault on the MTPR. We will make sure that:
17: 17 0000F9AA # * 1. The fault is detected,
18: 18 0000F9AA # * 2. the multiply operation completes, and
19: 19 0000F9AA # * 3. the 2nd load instruction is not executed.
20: 20 0000F9AA # *
21: 21 0000F9AA # * NOTE: pipe6 also uses this test's data patterns
22: 22 0000F9AA # *********************************************************************
23: 23 0000F9AA # */
24: 24 0000F9AA # pipe2()
25: 25 0000F9AA # {
26: 26 0000F9AA 13 0173 jbr L383
27: 27 0000F9AD L384:
28: 28 0000F9AD # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
29: 29 0000F9AD ed 6d effffffff4 moval (r13),_pre_event_fp
30: 30 0000F9B4 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
31: 31 0000F9B4 ed 6e efffffffed moval (r14),_pre_event_sp
32: 32 0000F9BB # precision = DBL;
33: 33 0000F9BB 0d 02 efffffffe6 movl $2,_precision
34: 34 0000F9C2 # test_event = RESOP_CODE; /* alignment fault expected */
35: 35 0000F9C2 0d 2d efffffffdf movl $45,_test_event
36: 36 0000F9C9 # exp_event = FALSE; /* ... but not yet */
37: 37 0000F9C9 4d efffffffd9 clrl _exp_event
38: 38 0000F9CF # asm("movab _pipe2_ret,_event_return"); /* set post - event return */
39: 39 0000F9CF e9 ef000000d8 efffffffce movab _pipe2_ret,_event_return
40: 40 0000F9DA # dbl_value_2.m = 0x12345678; /* data pattern for the */
41: 41 0000F9DA 0d 8f12345678 efffffffc3 movl $305419896,_dbl_value_2
42: 42 0000F9E5 # dbl_value_2.l = 0xfedcba98; /* 2nd LDD instruction */
43: 43 0000F9E5 0d 8ffedcba98 efffffffbc movl $-19088744,_dbl_value_2+4
44: 44 0000F9F0 # for( index = 0; index < max_pipe2_index; index++ )
45: 45 0000F9F0 4d efffffffb2 clrl _index
46: 46 0000F9F6 L387:
47: 47 0000F9F6 1d efffffffac efffffffa7 cmpl _index,_max_pipe2_index
48: 48 0000FA01 91 03 13 0119 jgeq L386
49: 49 0000FA06 # {
50: 50 0000FA06 # dbl_ld_acc = pipe2_data[index].op_1; /* get the data */
51: 51 0000FA06 5c 18 efffffff9b 50 mull3 $24,_index,r0
52: 52 0000FA0E 0c 8f00000000 50 addl2 $_pipe2_data,r0
53: 53 0000FA15 0d a004 efffffff8f movl 4(r0),_dbl_ld_acc+4
54: 54 0000FA1D 0d 60 efffffff84 movl (r0),_dbl_ld_acc
55: 55 0000FA24 # dbl_value_1 = pipe2_data[index].op_2;
56: 56 0000FA24 5c 18 efffffff7d 50 mull3 $24,_index,r0
57: 57 0000FA2C 0c 8f00000008 50 addl2 $_pipe2_data+8,r0
58: 58 0000FA33 0d a004 efffffff71 movl 4(r0),_dbl_value_1+4
59: 59 0000FA3B 0d 60 efffffff66 movl (r0),_dbl_value_1
60: 60 0000FA42 # dbl_expected = pipe2_data[index].exp;
61: 61 0000FA42 5c 18 efffffff5f 50 mull3 $24,_index,r0
62: 62 0000FA4A 0c 8f00000010 50 addl2 $_pipe2_data+16,r0
63: 63 0000FA51 0d a004 efffffff53 movl 4(r0),_dbl_expected+4
64: 64 0000FA59 0d 60 efffffff48 movl (r0),_dbl_expected
65: 65 0000FA60 # asm(".globl _pipe2_lp1");
66: 66 0000FA60 .globl _pipe2_lp1
67: 67 0000FA60 # asm("_pipe2_lp1:");
68: 68 0000FA60 _pipe2_lp1:
69: 69 0000FA60 # asm("bispsw $0x60"); /* enable ovfl & undfl */
70: 70 0000FA60 8b 8860 bispsw $0x60
71: 71 0000FA63 # asm("ldd _dbl_ld_acc"); /* load the Acc. */
72: 72 0000FA63 07 efffffff3f ldd _dbl_ld_acc
73: 73 0000FA69 # exp_event = test_event; /* expect event soon */
74: 74 0000FA69 0d efffffff39 efffffff34 movl _test_event,_exp_event
75: 75 0000FA74 # asm("muld _dbl_value_1"); /* start the multiply */
76: 76 0000FA74 e7 efffffff2e muld _dbl_value_1
77: 77 0000FA7A # asm("mtpr $1,$0x40");; /* trigger the fault */
78: 78 0000FA7A ad 01 8840 mtpr $1,$0x40
79: 79 0000FA7E # asm("ldd _dbl_value_2"); /* we shouldn't get to here */
80: 80 0000FA7E 07 efffffff24 ldd _dbl_value_2
81: 81 0000FA84 # /*
82: 82 0000FA84 # * If we got to here then there was no event
83: 83 0000FA84 # */
84: 84 0000FA84 # if( force_loop )
85: 85 0000FA84 5d efffffff1e tstl _force_loop
86: 86 0000FA8A 31 03 jeql L388
87: 87 0000FA8C # asm("brw _pipe2_lp1");; /* loop on the error */
88: Assemb00027168 # asm("brw _pipe2_lp1");; /* loop on the error */
89: "pipe200027168 88: WARNING: brw: destination label is external
90: 88 0000FA8C 13 ffd1 brw _pipe2_lp1
91: 89 0000FA8F L388:
92: 90 0000FA8F # exp_event = FALSE; /* reset event expected flag */
93: 91 0000FA8F 4d efffffff13 clrl _exp_event
94: 92 0000FA95 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
95: 93 0000FA95 0d efffffff0d 5d movl _pre_event_fp,fp
96: 94 0000FA9C # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
97: 95 0000FA9C 0d efffffff06 5e movl _pre_event_sp,sp
98: 96 0000FAA3 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
99: 97 0000FAA3 9b 8860 bicpsw $0x60
100: 98 0000FAA6 # no_pipe2_evt();; /* report the error */
101: 99 0000FAA6 fe 04 ef00000077 callf $4,_no_pipe2_evt
102: 100 0000FAAD # /*
103: 101 0000FAAD # * Come here after the event
104: 102 0000FAAD # */
105: 103 0000FAAD # asm(".globl _pipe2_ret");
106: 104 0000FAAD .globl _pipe2_ret
107: 105 0000FAAD # asm("_pipe2_ret:");
108: 106 0000FAAD _pipe2_ret:
109: 107 0000FAAD # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */
110: 108 0000FAAD 0d effffffef5 5d movl _pre_event_fp,fp
111: 109 0000FAB4 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */
112: 110 0000FAB4 0d effffffeee 5e movl _pre_event_sp,sp
113: 111 0000FABB # if( force_loop )
114: 112 0000FABB 5d effffffee7 tstl _force_loop
115: 113 0000FAC1 31 03 jeql L390
116: 114 0000FAC3 # asm("brw _pipe2_lp1");; /* loop on the error */
117: "pipe200027168 115: WARNING: brw: destination label is external
118: 115 0000FAC3 13 ff9a brw _pipe2_lp1
119: 116 0000FAC6 L390:
120: 117 0000FAC6 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */
121: 118 0000FAC6 9b 8860 bicpsw $0x60
122: 119 0000FAC9 # if( post_evt_acc.l != dbl_expected.l )
123: 120 0000FAC9 1d effffffedd effffffed8 cmpl _post_evt_acc+4,_dbl_expected+4
124: 121 0000FAD4 31 09 jeql L391
125: 122 0000FAD6 # bad_pipe2_result(); /* incorrect result error */
126: 123 0000FAD6 fe 04 ef00000103 callf $4,_bad_pipe2_result
127: 124 0000FADD # else if( post_evt_acc.m != dbl_expected.m )
128: 125 0000FADD 11 37 jbr L393
129: 126 0000FADF L391:
130: 127 0000FADF 1d effffffec3 effffffebe cmpl _post_evt_acc,_dbl_expected
131: 128 0000FAEA 31 2a jeql L394
132: 129 0000FAEC # {
133: 130 0000FAEC # if( (post_evt_acc.m == dbl_value_2.m) &&
134: 131 0000FAEC # (post_evt_acc.l == dbl_value_2.l) )
135: 132 0000FAEC 1d effffffeb6 effffffeb1 cmpl _post_evt_acc,_dbl_value_2
136: 133 0000FAF7 21 16 jneq L395
137: 134 0000FAF9 1d effffffead effffffea8 cmpl _post_evt_acc+4,_dbl_value_2+4
138: 135 0000FB04 21 09 jneq L395
139: 136 0000FB06 # pipe2_queue_er(); /* queue not cleared error */
140: 137 0000FB06 fe 04 ef00000237 callf $4,_pipe2_queue_er
141: 138 0000FB0D # else
142: 139 0000FB0D 11 07 jbr L397
143: 140 0000FB0F L395:
144: 141 0000FB0F # bad_pipe2_result(); /* incorrect result error */
145: 142 0000FB0F fe 04 ef000000ca callf $4,_bad_pipe2_result
146: 143 0000FB16 L397:
147: 144 0000FB16 # }
148: 145 0000FB16 # }
149: 146 0000FB16 L394:
150: 147 0000FB16 L393:
151: 148 0000FB16 L385:
152: 149 0000FB16 6d effffffe8c incl _index
153: 150 0000FB1C 13 fed7 jbr L387
154: 151 0000FB1F L386:
155: 152 0000FB1F # }
156: 153 0000FB1F 40 ret#2
157: 154 0000FB20 .set L381,0x0
158: 155 0000FB20 L383:
159: 156 0000FB20 13 fe8a jbr L384
160: 157 0000FB23 .data
161: 158 000006a8 * .text
162: 159 0000FB23 00 .align 1
163: 160 0000FB24 .globl _no_pipe2_evt
164: 161 0000FB24 _no_pipe2_evt:
165: 162 0000FB24 0000 .word L398
166: 163 0000FB26 #
167: 164 0000FB26 #
168: 165 0000FB26 #
169: 166 0000FB26 # /****************************************************************************
170: 167 0000FB26 # * Report an "EVENT NOT DETECTED" error
171: 168 0000FB26 # *
172: 169 0000FB26 # * Cycle: xx. EVT test xx. subtest xx. No Reserved Operand fault. index = xx
173: 170 0000FB26 # * inst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3 (Reserved Op. fault on MTPR)
174: 171 0000FB26 # * op1 = xxxxxxxx xxxxxxxx, op2 = xxxxxxxx xxxxxxxx
175: 172 0000FB26 # ****************************************************************************/
176: 173 0000FB26 # no_pipe2_evt()
177: 174 0000FB26 # {
178: 175 0000FB26 13 00b3 jbr L400
179: 176 0000FB29 L401:
180: 177 0000FB29 # errcnt++; /* bump the error count */
181: 178 0000FB29 6d effffffe79 incl _errcnt
182: 179 0000FB2F # if ( prt_error ) {
183: 180 0000FB2F 5d effffffe73 tstl _prt_error
184: 181 0000FB35 31 7e jeql L402
185: 182 0000FB37 # print_pipe2_err( " No Reserved Operand fault." );
186: 183 0000FB37 .data 1
187: 184 000006a8 * L404:
188: 185 000006a8 * 20204E6F20526573657276656 .ascii " No Reserved Operand fault.\0"
189: 4204F706572616E6420666175
190: 6C742E00
191: 186 000006c5 * .text
192: 187 0000FB37 dd 8f000006a8 pushl $L404
193: 188 0000FB3D fe 08 ef00000364 callf $8,_print_pipe2_err
194: 189 0000FB44 # writes("op1 = ");
195: 190 0000FB44 .data 1
196: 191 000006c5 * L406:
197: 192 000006c5 * 6F7031203D2000 .ascii "op1 = \0"
198: 193 000006cc * .text
199: 194 0000FB44 dd 8f000006c5 pushl $L406
200: 195 0000FB4A fe 08 effffffe57 callf $8,_writes
201: 196 0000FB51 # write32h( dbl_ld_acc.m );
202: 197 0000FB51 dd effffffe51 pushl _dbl_ld_acc
203: 198 0000FB57 fe 08 effffffe4a callf $8,_write32h
204: 199 0000FB5E # writes(" ");
205: 200 0000FB5E .data 1
206: 201 000006cc * L408:
207: 202 000006cc * 2000 .ascii " \0"
208: 203 000006ce * .text
209: 204 0000FB5E dd 8f000006cc pushl $L408
210: 205 0000FB64 fe 08 effffffe3d callf $8,_writes
211: 206 0000FB6B # write32h( dbl_ld_acc.l );
212: 207 0000FB6B dd effffffe3b pushl _dbl_ld_acc+4
213: 208 0000FB71 fe 08 effffffe30 callf $8,_write32h
214: 209 0000FB78 # writes(", op2 = ");
215: 210 0000FB78 .data 1
216: 211 000006ce * L409:
217: 212 000006ce * 2C2020206F7032203D2000 .ascii ", op2 = \0"
218: 213 000006d9 * .text
219: 214 0000FB78 dd 8f000006ce pushl $L409
220: 215 0000FB7E fe 08 effffffe23 callf $8,_writes
221: 216 0000FB85 # write32h( dbl_value_1.m );
222: 217 0000FB85 dd effffffe1d pushl _dbl_value_1
223: 218 0000FB8B fe 08 effffffe16 callf $8,_write32h
224: 219 0000FB92 # writes(" ");
225: 220 0000FB92 .data 1
226: 221 000006d9 * L410:
227: 222 000006d9 * 2000 .ascii " \0"
228: 223 000006db * .text
229: 224 0000FB92 dd 8f000006d9 pushl $L410
230: 225 0000FB98 fe 08 effffffe09 callf $8,_writes
231: 226 0000FB9F # write32h( dbl_value_1.l );
232: 227 0000FB9F dd effffffe07 pushl _dbl_value_1+4
233: 228 0000FBA5 fe 08 effffffdfc callf $8,_write32h
234: 229 0000FBAC # writec('\n');
235: 230 0000FBAC dd 0a pushl $10
236: 231 0000FBAE fe 08 effffffdf3 callf $8,_writec
237: 232 0000FBB5 # }
238: 233 0000FBB5 # if ( halt_flg ) /* halt on error? */
239: 234 0000FBB5 L402:
240: 235 0000FBB5 5d effffffded tstl _halt_flg
241: 236 0000FBBB 31 09 jeql L412
242: 237 0000FBBD # pipe2_halt( 1 ); /* halt with a code of 1 */
243: 238 0000FBBD dd 01 pushl $1
244: 239 0000FBBF fe 08 ef0000038e callf $8,_pipe2_halt
245: 240 0000FBC6 # if ( loop_on_err ) {
246: 241 0000FBC6 L412:
247: 242 0000FBC6 5d effffffddc tstl _loop_on_err
248: 243 0000FBCC 31 0d jeql L414
249: 244 0000FBCE # force_loop = TRUE; /* set the force loop flag */
250: 245 0000FBCE 0d 01 effffffdd3 movl $1,_force_loop
251: 246 0000FBD5 # asm("jmp _pipe2_lp1"); /* and loop */
252: 247 0000FBD5 71 effffffe85 jmp _pipe2_lp1
253: 248 0000FBDB # };
254: 249 0000FBDB L414:
255: 250 0000FBDB # }
256: 251 0000FBDB 40 ret#2
257: 252 0000FBDC .set L398,0x0
258: 253 0000FBDC L400:
259: 254 0000FBDC 13 ff4a jbr L401
260: 255 0000FBDF .data
261: 256 000006a8 * .text
262: 257 0000FBDF 00 .align 1
263: 258 0000FBE0 .globl _bad_pipe2_result
264: 259 0000FBE0 _bad_pipe2_result:
265: 260 0000FBE0 0000 .word L415
266: 261 0000FBE2 #
267: 262 0000FBE2 #
268: 263 0000FBE2 #
269: 264 0000FBE2 #
270: 265 0000FBE2 # /****************************************************************************
271: 266 0000FBE2 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error
272: 267 0000FBE2 # *
273: 268 0000FBE2 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx
274: 269 0000FBE2 # * inst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3 (Reserved Op. fault on MTPR)
275: 270 0000FBE2 # * The 2nd LDD should not be executed.
276: 271 0000FBE2 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
277: 272 0000FBE2 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
278: 273 0000FBE2 # * op3 = xxxxxxxx xxxxxxxx
279: 274 0000FBE2 # ****************************************************************************/
280: 275 0000FBE2 # bad_pipe2_result()
281: 276 0000FBE2 # {
282: 277 0000FBE2 13 015b jbr L417
283: 278 0000FBE5 L418:
284: 279 0000FBE5 # errcnt++; /* bump the error count */
285: 280 0000FBE5 6d effffffdbd incl _errcnt
286: 281 0000FBEB # if ( prt_error ) {
287: 282 0000FBEB 5d effffffdb7 tstl _prt_error
288: 283 0000FBF1 21 03 13 0123 jeql L419
289: 284 0000FBF6 # print_pipe2_err( ". Bad final Accumulator." );
290: 285 0000FBF6 .data 1
291: 286 000006db * L420:
292: 287 000006db * 2E204261642066696E616C204 .ascii ". Bad final Accumulator.\0"
293: 16363756D756C61746F722E00
294: 288 000006f4 * .text
295: 289 0000FBF6 dd 8f000006db pushl $L420
296: 290 0000FBFC fe 08 ef000002a5 callf $8,_print_pipe2_err
297: 291 0000FC03 # writes("The 2nd LDD should not be executed\n");
298: 292 0000FC03 .data 1
299: 293 000006f4 * L421:
300: 294 000006f4 * 54686520326E64204C4444207 .ascii "The 2nd LDD should not be executed\12\0"
301: 3686F756C64206E6F74206265
302: 2065786563757465640A00
303: 295 00000718 * .text
304: 296 0000FC03 dd 8f000006f4 pushl $L421
305: 297 0000FC09 fe 08 effffffd98 callf $8,_writes
306: 298 0000FC10 # writes("op1 = ");
307: 299 0000FC10 .data 1
308: 300 00000718 * L422:
309: 301 00000718 * 6F7031203D2000 .ascii "op1 = \0"
310: 302 0000071f * .text
311: 303 0000FC10 dd 8f00000718 pushl $L422
312: 304 0000FC16 fe 08 effffffd8b callf $8,_writes
313: 305 0000FC1D # write32h( dbl_ld_acc.m );
314: 306 0000FC1D dd effffffd85 pushl _dbl_ld_acc
315: 307 0000FC23 fe 08 effffffd7e callf $8,_write32h
316: 308 0000FC2A # writes(" ");
317: 309 0000FC2A .data 1
318: 310 0000071f * L423:
319: 311 0000071f * 2000 .ascii " \0"
320: 312 00000721 * .text
321: 313 0000FC2A dd 8f0000071f pushl $L423
322: 314 0000FC30 fe 08 effffffd71 callf $8,_writes
323: 315 0000FC37 # write32h( dbl_ld_acc.l );
324: 316 0000FC37 dd effffffd6f pushl _dbl_ld_acc+4
325: 317 0000FC3D fe 08 effffffd64 callf $8,_write32h
326: 318 0000FC44 # writes(", final Acc. = ");
327: 319 0000FC44 .data 1
328: 320 00000721 * L424:
329: 321 00000721 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
330: 32E203D2000
331: 322 00000733 * .text
332: 323 0000FC44 dd 8f00000721 pushl $L424
333: 324 0000FC4A fe 08 effffffd57 callf $8,_writes
334: 325 0000FC51 # write32h( post_evt_acc.m );
335: 326 0000FC51 dd effffffd51 pushl _post_evt_acc
336: 327 0000FC57 fe 08 effffffd4a callf $8,_write32h
337: 328 0000FC5E # writec(' ');
338: 329 0000FC5E dd 20 pushl $32
339: 330 0000FC60 fe 08 effffffd41 callf $8,_writec
340: 331 0000FC67 # write32h( post_evt_acc.l );
341: 332 0000FC67 dd effffffd3f pushl _post_evt_acc+4
342: 333 0000FC6D fe 08 effffffd34 callf $8,_write32h
343: 334 0000FC74 # writes("\nop2 = ");
344: 335 0000FC74 .data 1
345: 336 00000733 * L425:
346: 337 00000733 * 0A6F7032203D2000 .ascii "\12op2 = \0"
347: 338 0000073b * .text
348: 339 0000FC74 dd 8f00000733 pushl $L425
349: 340 0000FC7A fe 08 effffffd27 callf $8,_writes
350: 341 0000FC81 # write32h( dbl_value_1.m );
351: 342 0000FC81 dd effffffd21 pushl _dbl_value_1
352: 343 0000FC87 fe 08 effffffd1a callf $8,_write32h
353: 344 0000FC8E # writes(" ");
354: 345 0000FC8E .data 1
355: 346 0000073b * L426:
356: 347 0000073b * 2000 .ascii " \0"
357: 348 0000073d * .text
358: 349 0000FC8E dd 8f0000073b pushl $L426
359: 350 0000FC94 fe 08 effffffd0d callf $8,_writes
360: 351 0000FC9B # write32h( dbl_value_1.l );
361: 352 0000FC9B dd effffffd0b pushl _dbl_value_1+4
362: 353 0000FCA1 fe 08 effffffd00 callf $8,_write32h
363: 354 0000FCA8 # writes(", expected = ");
364: 355 0000FCA8 .data 1
365: 356 0000073d * L427:
366: 357 0000073d * 2C20202065787065637465642 .ascii ", expected = \0"
367: 020203D2000
368: 358 0000074f * .text
369: 359 0000FCA8 dd 8f0000073d pushl $L427
370: 360 0000FCAE fe 08 effffffcf3 callf $8,_writes
371: 361 0000FCB5 # write32h( dbl_expected.m );
372: 362 0000FCB5 dd effffffced pushl _dbl_expected
373: 363 0000FCBB fe 08 effffffce6 callf $8,_write32h
374: 364 0000FCC2 # writes(" ");
375: 365 0000FCC2 .data 1
376: 366 0000074f * L428:
377: 367 0000074f * 2000 .ascii " \0"
378: 368 00000751 * .text
379: 369 0000FCC2 dd 8f0000074f pushl $L428
380: 370 0000FCC8 fe 08 effffffcd9 callf $8,_writes
381: 371 0000FCCF # write32h( dbl_expected.l );
382: 372 0000FCCF dd effffffcd7 pushl _dbl_expected+4
383: 373 0000FCD5 fe 08 effffffccc callf $8,_write32h
384: 374 0000FCDC # writes("\nop3 = ");
385: 375 0000FCDC .data 1
386: 376 00000751 * L429:
387: 377 00000751 * 0A6F7033203D2000 .ascii "\12op3 = \0"
388: 378 00000759 * .text
389: 379 0000FCDC dd 8f00000751 pushl $L429
390: 380 0000FCE2 fe 08 effffffcbf callf $8,_writes
391: 381 0000FCE9 # write32h( dbl_value_2.m );
392: 382 0000FCE9 dd effffffcb9 pushl _dbl_value_2
393: 383 0000FCEF fe 08 effffffcb2 callf $8,_write32h
394: 384 0000FCF6 # writes(" ");
395: 385 0000FCF6 .data 1
396: 386 00000759 * L430:
397: 387 00000759 * 2000 .ascii " \0"
398: 388 0000075b * .text
399: 389 0000FCF6 dd 8f00000759 pushl $L430
400: 390 0000FCFC fe 08 effffffca5 callf $8,_writes
401: 391 0000FD03 # write32h( dbl_value_2.l );
402: 392 0000FD03 dd effffffca3 pushl _dbl_value_2+4
403: 393 0000FD09 fe 08 effffffc98 callf $8,_write32h
404: 394 0000FD10 # writec('\n');
405: 395 0000FD10 dd 0a pushl $10
406: 396 0000FD12 fe 08 effffffc8f callf $8,_writec
407: 397 0000FD19 # }
408: 398 0000FD19 # if ( halt_flg ) /* halt on error? */
409: 399 0000FD19 L419:
410: 400 0000FD19 5d effffffc89 tstl _halt_flg
411: 401 0000FD1F 31 09 jeql L431
412: 402 0000FD21 # pipe2_halt( 2 ); /* halt with a code of 2 */
413: 403 0000FD21 dd 02 pushl $2
414: 404 0000FD23 fe 08 ef0000022a callf $8,_pipe2_halt
415: 405 0000FD2A # if ( loop_on_err ) {
416: 406 0000FD2A L431:
417: 407 0000FD2A 5d effffffc78 tstl _loop_on_err
418: 408 0000FD30 31 0d jeql L432
419: 409 0000FD32 # force_loop = TRUE; /* set the force loop flag */
420: 410 0000FD32 0d 01 effffffc6f movl $1,_force_loop
421: 411 0000FD39 # asm("jmp _pipe2_lp1"); /* and loop */
422: 412 0000FD39 71 effffffd21 jmp _pipe2_lp1
423: 413 0000FD3F # };
424: 414 0000FD3F L432:
425: 415 0000FD3F # }
426: 416 0000FD3F 40 ret#2
427: 417 0000FD40 .set L415,0x0
428: 418 0000FD40 L417:
429: 419 0000FD40 13 fea2 jbr L418
430: 420 0000FD43 .data
431: 421 000006a8 * .text
432: 422 0000FD43 00 .align 1
433: 423 0000FD44 .globl _pipe2_queue_er
434: 424 0000FD44 _pipe2_queue_er:
435: 425 0000FD44 0000 .word L433
436: 426 0000FD46 #
437: 427 0000FD46 #
438: 428 0000FD46 #
439: 429 0000FD46 #
440: 430 0000FD46 # /****************************************************************************
441: 431 0000FD46 # * Report an "FPP Queue not cleared" error
442: 432 0000FD46 # *
443: 433 0000FD46 # * Cycle: xx. EVT test xx. subtest xx. FPP queue not cleared. index = xx
444: 434 0000FD46 # * inst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3 (Reserved Op. fault on MTPR)
445: 435 0000FD46 # * The 2nd LDD should not have been executed but apparently was.
446: 436 0000FD46 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx
447: 437 0000FD46 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
448: 438 0000FD46 # * op3 = xxxxxxxx xxxxxxxx
449: 439 0000FD46 # ****************************************************************************/
450: 440 0000FD46 # pipe2_queue_er()
451: 441 0000FD46 # {
452: 442 0000FD46 13 015b jbr L435
453: 443 0000FD49 L436:
454: 444 0000FD49 # errcnt++; /* bump the error count */
455: 445 0000FD49 6d effffffc59 incl _errcnt
456: 446 0000FD4F # if ( prt_error ) {
457: 447 0000FD4F 5d effffffc53 tstl _prt_error
458: 448 0000FD55 21 03 13 0123 jeql L437
459: 449 0000FD5A # print_pipe2_err( ". FPP queue not cleared." );
460: 450 0000FD5A .data 1
461: 451 0000075b * L438:
462: 452 0000075b * 2E20465050207175657565206 .ascii ". FPP queue not cleared.\0"
463: E6F7420636C65617265642E00
464: 453 00000774 * .text
465: 454 0000FD5A dd 8f0000075b pushl $L438
466: 455 0000FD60 fe 08 ef00000141 callf $8,_print_pipe2_err
467: 456 0000FD67 # writes(
468: 457 0000FD67 # "The 2nd LDD should not have been executed but apparently was.\n");
469: 458 0000FD67 .data 1
470: 459 00000774 * L439:
471: 460 00000774 * 54686520326E64204C4444207 .ascii "The 2nd LDD should not have been executed but apparently was.\12\0"
472: 3686F756C64206E6F74206861
473: 7665206265656E20657865637
474: 5746564206275742061707061
475: 72656E746C79207761732E0A0
476: 0
477: 461 000007b3 * .text
478: 462 0000FD67 dd 8f00000774 pushl $L439
479: 463 0000FD6D fe 08 effffffc34 callf $8,_writes
480: 464 0000FD74 # writes("op1 = ");
481: 465 0000FD74 .data 1
482: 466 000007b3 * L440:
483: 467 000007b3 * 6F7031203D2000 .ascii "op1 = \0"
484: 468 000007ba * .text
485: 469 0000FD74 dd 8f000007b3 pushl $L440
486: 470 0000FD7A fe 08 effffffc27 callf $8,_writes
487: 471 0000FD81 # write32h( dbl_ld_acc.m );
488: 472 0000FD81 dd effffffc21 pushl _dbl_ld_acc
489: 473 0000FD87 fe 08 effffffc1a callf $8,_write32h
490: 474 0000FD8E # writes(" ");
491: 475 0000FD8E .data 1
492: 476 000007ba * L441:
493: 477 000007ba * 2000 .ascii " \0"
494: 478 000007bc * .text
495: 479 0000FD8E dd 8f000007ba pushl $L441
496: 480 0000FD94 fe 08 effffffc0d callf $8,_writes
497: 481 0000FD9B # write32h( dbl_ld_acc.l );
498: 482 0000FD9B dd effffffc0b pushl _dbl_ld_acc+4
499: 483 0000FDA1 fe 08 effffffc00 callf $8,_write32h
500: 484 0000FDA8 # writes(", final Acc. = ");
501: 485 0000FDA8 .data 1
502: 486 000007bc * L442:
503: 487 000007bc * 2C20202066696E616C2041636 .ascii ", final Acc. = \0"
504: 32E203D2000
505: 488 000007ce * .text
506: 489 0000FDA8 dd 8f000007bc pushl $L442
507: 490 0000FDAE fe 08 effffffbf3 callf $8,_writes
508: 491 0000FDB5 # write32h( post_evt_acc.m );
509: 492 0000FDB5 dd effffffbed pushl _post_evt_acc
510: 493 0000FDBB fe 08 effffffbe6 callf $8,_write32h
511: 494 0000FDC2 # writec(' ');
512: 495 0000FDC2 dd 20 pushl $32
513: 496 0000FDC4 fe 08 effffffbdd callf $8,_writec
514: 497 0000FDCB # write32h( post_evt_acc.l );
515: 498 0000FDCB dd effffffbdb pushl _post_evt_acc+4
516: 499 0000FDD1 fe 08 effffffbd0 callf $8,_write32h
517: 500 0000FDD8 # writes("\nop2 = ");
518: 501 0000FDD8 .data 1
519: 502 000007ce * L443:
520: 503 000007ce * 0A6F7032203D2000 .ascii "\12op2 = \0"
521: 504 000007d6 * .text
522: 505 0000FDD8 dd 8f000007ce pushl $L443
523: 506 0000FDDE fe 08 effffffbc3 callf $8,_writes
524: 507 0000FDE5 # write32h( dbl_value_1.m );
525: 508 0000FDE5 dd effffffbbd pushl _dbl_value_1
526: 509 0000FDEB fe 08 effffffbb6 callf $8,_write32h
527: 510 0000FDF2 # writes(" ");
528: 511 0000FDF2 .data 1
529: 512 000007d6 * L444:
530: 513 000007d6 * 2000 .ascii " \0"
531: 514 000007d8 * .text
532: 515 0000FDF2 dd 8f000007d6 pushl $L444
533: 516 0000FDF8 fe 08 effffffba9 callf $8,_writes
534: 517 0000FDFF # write32h( dbl_value_1.l );
535: 518 0000FDFF dd effffffba7 pushl _dbl_value_1+4
536: 519 0000FE05 fe 08 effffffb9c callf $8,_write32h
537: 520 0000FE0C # writes(", expected = ");
538: 521 0000FE0C .data 1
539: 522 000007d8 * L445:
540: 523 000007d8 * 2C20202065787065637465642 .ascii ", expected = \0"
541: 020203D2000
542: 524 000007ea * .text
543: 525 0000FE0C dd 8f000007d8 pushl $L445
544: 526 0000FE12 fe 08 effffffb8f callf $8,_writes
545: 527 0000FE19 # write32h( dbl_expected.m );
546: 528 0000FE19 dd effffffb89 pushl _dbl_expected
547: 529 0000FE1F fe 08 effffffb82 callf $8,_write32h
548: 530 0000FE26 # writes(" ");
549: 531 0000FE26 .data 1
550: 532 000007ea * L446:
551: 533 000007ea * 2000 .ascii " \0"
552: 534 000007ec * .text
553: 535 0000FE26 dd 8f000007ea pushl $L446
554: 536 0000FE2C fe 08 effffffb75 callf $8,_writes
555: 537 0000FE33 # write32h( dbl_expected.l );
556: 538 0000FE33 dd effffffb73 pushl _dbl_expected+4
557: 539 0000FE39 fe 08 effffffb68 callf $8,_write32h
558: 540 0000FE40 # writes("\nop3 = ");
559: 541 0000FE40 .data 1
560: 542 000007ec * L447:
561: 543 000007ec * 0A6F7033203D2000 .ascii "\12op3 = \0"
562: 544 000007f4 * .text
563: 545 0000FE40 dd 8f000007ec pushl $L447
564: 546 0000FE46 fe 08 effffffb5b callf $8,_writes
565: 547 0000FE4D # write32h( dbl_value_2.m );
566: 548 0000FE4D dd effffffb55 pushl _dbl_value_2
567: 549 0000FE53 fe 08 effffffb4e callf $8,_write32h
568: 550 0000FE5A # writes(" ");
569: 551 0000FE5A .data 1
570: 552 000007f4 * L448:
571: 553 000007f4 * 2000 .ascii " \0"
572: 554 000007f6 * .text
573: 555 0000FE5A dd 8f000007f4 pushl $L448
574: 556 0000FE60 fe 08 effffffb41 callf $8,_writes
575: 557 0000FE67 # write32h( dbl_value_2.l );
576: 558 0000FE67 dd effffffb3f pushl _dbl_value_2+4
577: 559 0000FE6D fe 08 effffffb34 callf $8,_write32h
578: 560 0000FE74 # writec('\n');
579: 561 0000FE74 dd 0a pushl $10
580: 562 0000FE76 fe 08 effffffb2b callf $8,_writec
581: 563 0000FE7D # }
582: 564 0000FE7D # if ( halt_flg ) /* halt on error? */
583: 565 0000FE7D L437:
584: 566 0000FE7D 5d effffffb25 tstl _halt_flg
585: 567 0000FE83 31 09 jeql L449
586: 568 0000FE85 # pipe2_halt( 3 ); /* halt with a code of 3 */
587: 569 0000FE85 dd 03 pushl $3
588: 570 0000FE87 fe 08 ef000000c6 callf $8,_pipe2_halt
589: 571 0000FE8E # if ( loop_on_err ) {
590: 572 0000FE8E L449:
591: 573 0000FE8E 5d effffffb14 tstl _loop_on_err
592: 574 0000FE94 31 0d jeql L450
593: 575 0000FE96 # force_loop = TRUE; /* set the force loop flag */
594: 576 0000FE96 0d 01 effffffb0b movl $1,_force_loop
595: 577 0000FE9D # asm("jmp _pipe2_lp1"); /* and loop */
596: 578 0000FE9D 71 effffffbbd jmp _pipe2_lp1
597: 579 0000FEA3 # };
598: 580 0000FEA3 L450:
599: 581 0000FEA3 # }
600: 582 0000FEA3 40 ret#2
601: 583 0000FEA4 .set L433,0x0
602: 584 0000FEA4 L435:
603: 585 0000FEA4 13 fea2 jbr L436
604: 586 0000FEA7 .data
605: 587 000006a8 * .text
606: 588 0000FEA7 00 .align 1
607: 589 0000FEA8 .globl _print_pipe2_err
608: 590 0000FEA8 _print_pipe2_err:
609: 591 0000FEA8 0000 .word L451
610: 592 0000FEAA #
611: 593 0000FEAA #
612: 594 0000FEAA #
613: 595 0000FEAA #
614: 596 0000FEAA #
615: 597 0000FEAA # /****************************************************************************
616: 598 0000FEAA # * Report an error message of the form
617: 599 0000FEAA # *
618: 600 0000FEAA # * Cycle: xx. EVT test xx. subtest xx <your message here> index = xx
619: 601 0000FEAA # * inst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3 (fault expected on the MTPR)
620: 602 0000FEAA # ****************************************************************************/
621: 603 0000FEAA # print_pipe2_err( msg )
622: 604 0000FEAA # char *msg; /* pointer to error message */
623: 605 0000FEAA # {
624: 606 0000FEAA 13 00a3 jbr L453
625: 607 0000FEAD L454:
626: 608 0000FEAD # if( errcnt == 1 ) /* 1st error? */
627: 609 0000FEAD 1d effffffaf5 01 cmpl _errcnt,$1
628: 610 0000FEB4 21 0d jneq L455
629: 611 0000FEB6 # writes(" \n"); /* start a new print line */
630: 612 0000FEB6 .data 1
631: 613 000007f6 * L456:
632: 614 000007f6 * 200A00 .ascii " \12\0"
633: 615 000007f9 * .text
634: 616 0000FEB6 dd 8f000007f6 pushl $L456
635: 617 0000FEBC fe 08 effffffae5 callf $8,_writes
636: 618 0000FEC3 # writes("Cycle: ");
637: 619 0000FEC3 L455:
638: 620 0000FEC3 .data 1
639: 621 000007f9 * L457:
640: 622 000007f9 * 4379636C653A2000 .ascii "Cycle: \0"
641: 623 00000801 * .text
642: 624 0000FEC3 dd 8f000007f9 pushl $L457
643: 625 0000FEC9 fe 08 effffffad8 callf $8,_writes
644: 626 0000FED0 # writed( cycle );
645: 627 0000FED0 dd effffffad2 pushl _cycle
646: 628 0000FED6 fe 08 effffffacb callf $8,_writed
647: 629 0000FEDD # writes(" EVT test ");
648: 630 0000FEDD .data 1
649: 631 00000801 * L459:
650: 632 00000801 * 202045565420746573742000 .ascii " EVT test \0"
651: 633 0000080d * .text
652: 634 0000FEDD dd 8f00000801 pushl $L459
653: 635 0000FEE3 fe 08 effffffabe callf $8,_writes
654: 636 0000FEEA # writed( test_no );
655: 637 0000FEEA dd effffffab8 pushl _test_no
656: 638 0000FEF0 fe 08 effffffab1 callf $8,_writed
657: 639 0000FEF7 # writes(". subtest ");
658: 640 0000FEF7 .data 1
659: 641 0000080d * L460:
660: 642 0000080d * 2E20737562746573742000 .ascii ". subtest \0"
661: 643 00000818 * .text
662: 644 0000FEF7 dd 8f0000080d pushl $L460
663: 645 0000FEFD fe 08 effffffaa4 callf $8,_writes
664: 646 0000FF04 # writed( subtest );
665: 647 0000FF04 dd effffffa9e pushl _subtest
666: 648 0000FF0A fe 08 effffffa97 callf $8,_writed
667: 649 0000FF11 # writes( msg ); /* print the error message */
668: 650 0000FF11 dd ad04 pushl 4(fp)
669: 651 0000FF14 fe 08 effffffa8d callf $8,_writes
670: 652 0000FF1B # writes(" index = ");
671: 653 0000FF1B .data 1
672: 654 00000818 * L461:
673: 655 00000818 * 20696E646578203D2000 .ascii " index = \0"
674: 656 00000822 * .text
675: 657 0000FF1B dd 8f00000818 pushl $L461
676: 658 0000FF21 fe 08 effffffa80 callf $8,_writes
677: 659 0000FF28 # writed( index );
678: 660 0000FF28 dd effffffa7a pushl _index
679: 661 0000FF2E fe 08 effffffa73 callf $8,_writed
680: 662 0000FF35 # writes("\ninst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3");
681: 663 0000FF35 .data 1
682: 664 00000822 * L462:
683: 665 00000822 * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1, MULD op2, MTPR 1,0x40, LDD op3\0"
684: F70312C204D554C44206F7032
685: 2C204D54505220312C3078343
686: 02C204C4444206F703300
687: 666 00000852 * .text
688: 667 0000FF35 dd 8f00000822 pushl $L462
689: 668 0000FF3B fe 08 effffffa66 callf $8,_writes
690: 669 0000FF42 # writes(" (Reserved Op. fault on the MTPR)\n");
691: 670 0000FF42 .data 1
692: 671 00000852 * L463:
693: 672 00000852 * 20285265736572766564204F7 .ascii " (Reserved Op. fault on the MTPR)\12\0"
694: 02E206661756C74206F6E2074
695: 6865204D545052290A00
696: 673 00000875 * .text
697: 674 0000FF42 dd 8f00000852 pushl $L463
698: 675 0000FF48 fe 08 effffffa59 callf $8,_writes
699: 676 0000FF4F # }
700: 677 0000FF4F 40 ret#2
701: 678 0000FF50 .set L451,0x0
702: 679 0000FF50 L453:
703: 680 0000FF50 13 ff5a jbr L454
704: 681 0000FF53 .data
705: 682 000006a8 * .text
706: 683 0000FF53 00 .align 1
707: 684 0000FF54 .globl _pipe2_halt
708: 685 0000FF54 _pipe2_halt:
709: 686 0000FF54 0000 .word L464
710: 687 0000FF56 #
711: 688 0000FF56 #
712: 689 0000FF56 # /****************************************************************************
713: 690 0000FF56 # * Error Halt Routine
714: 691 0000FF56 # ****************************************************************************/
715: 692 0000FF56 # pipe2_halt( code )
716: 693 0000FF56 # int code; /* halt code to use */
717: 694 0000FF56 # {
718: 695 0000FF56 13 00f1 jbr L466
719: 696 0000FF59 L467:
720: 697 0000FF59 # err_code = code;
721: 698 0000FF59 0d ad04 effffffa47 movl 4(fp),_err_code
722: 699 0000FF61 # sgl_value_1 = dbl_ld_acc.m;
723: 700 0000FF61 0d effffffa41 effffffa3c movl _dbl_ld_acc,_sgl_value_1
724: 701 0000FF6C # sgl_value_2 = dbl_ld_acc.l;
725: 702 0000FF6C 0d effffffa3a effffffa31 movl _dbl_ld_acc+4,_sgl_value_2
726: 703 0000FF77 # sgl_value_3 = dbl_value_1.m;
727: 704 0000FF77 0d effffffa2b effffffa26 movl _dbl_value_1,_sgl_value_3
728: 705 0000FF82 # sgl_value_4 = dbl_value_1.l;
729: 706 0000FF82 0d effffffa24 effffffa1b movl _dbl_value_1+4,_sgl_value_4
730: 707 0000FF8D # asm("movl _test_no,r0"); /* r0 = test number */
731: 708 0000FF8D 0d effffffa15 50 movl _test_no,r0
732: 709 0000FF94 # asm("movl _subtest,r1"); /* r1 = subtest number */
733: 710 0000FF94 0d effffffa0e 51 movl _subtest,r1
734: 711 0000FF9B # asm("movl _err_code,r2"); /* r2 = error code */
735: 712 0000FF9B 0d effffffa07 52 movl _err_code,r2
736: 713 0000FFA2 # asm("movl _cycle,r3"); /* r3 = cycle count */
737: 714 0000FFA2 0d effffffa00 53 movl _cycle,r3
738: 715 0000FFA9 # asm("movl _sgl_value_1,r4"); /* r4 = MSW of operand 1 */
739: 716 0000FFA9 0d effffff9f9 54 movl _sgl_value_1,r4
740: 717 0000FFB0 # asm("movl _sgl_value_2,r5"); /* r5 = LSW of operand 1 */
741: 718 0000FFB0 0d effffff9f2 55 movl _sgl_value_2,r5
742: 719 0000FFB7 # asm("movl _sgl_value_3,r6"); /* r6 = MSW of operand 2 */
743: 720 0000FFB7 0d effffff9eb 56 movl _sgl_value_3,r6
744: 721 0000FFBE # asm("movl _sgl_value_4,r7"); /* r7 = LSW of operand 2 */
745: 722 0000FFBE 0d effffff9e4 57 movl _sgl_value_4,r7
746: 723 0000FFC5 # if( code == 1 ) {
747: 724 0000FFC5 1d ad04 01 cmpl 4(fp),$1
748: 725 0000FFC9 21 0a jneq L468
749: 726 0000FFCB # asm("movl _index,r8"); /* r8 = data index */
750: 727 0000FFCB 0d effffff9d7 58 movl _index,r8
751: 728 0000FFD2 # asm("halt"); /* HALT ... */
752: 729 0000FFD2 00 halt
753: 730 0000FFD3 # } else {
754: 731 0000FFD3 11 73 jbr L469
755: 732 0000FFD5 L468:
756: 733 0000FFD5 # sgl_value_1 = post_evt_acc.m;
757: 734 0000FFD5 0d effffff9cd effffff9c8 movl _post_evt_acc,_sgl_value_1
758: 735 0000FFE0 # sgl_value_2 = post_evt_acc.l;
759: 736 0000FFE0 0d effffff9c6 effffff9bd movl _post_evt_acc+4,_sgl_value_2
760: 737 0000FFEB # sgl_value_3 = dbl_expected.m;
761: 738 0000FFEB 0d effffff9b7 effffff9b2 movl _dbl_expected,_sgl_value_3
762: 739 0000FFF6 # sgl_value_4 = dbl_expected.l;
763: 740 0000FFF6 0d effffff9b0 effffff9a7 movl _dbl_expected+4,_sgl_value_4
764: 741 00010001 # sgl_value_5 = dbl_value_2.m;
765: 742 00010001 0d effffff9a1 effffff99c movl _dbl_value_2,_sgl_value_5
766: 743 0001000C # sgl_value_6 = dbl_value_2.l;
767: 744 0001000C 0d effffff99a effffff991 movl _dbl_value_2+4,_sgl_value_6
768: 745 00010017 # asm("movl _sgl_value_1,r8"); /* r8 = MSW of final acc. */
769: 746 00010017 0d effffff98b 58 movl _sgl_value_1,r8
770: 747 0001001E # asm("movl _sgl_value_2,r9"); /* r9 = LSW of final acc. */
771: 748 0001001E 0d effffff984 59 movl _sgl_value_2,r9
772: 749 00010025 # asm("movl _sgl_value_3,r10"); /* r10 = MSW of expected */
773: 750 00010025 0d effffff97d 5a movl _sgl_value_3,r10
774: 751 0001002C # asm("movl _sgl_value_4,r11"); /* r11 = LSW of expected */
775: 752 0001002C 0d effffff976 5b movl _sgl_value_4,r11
776: 753 00010033 # asm("movl _sgl_value_5,r12"); /* r12 = MSW of operand 3 */
777: 754 00010033 0d effffff96f 5c movl _sgl_value_5,r12
778: 755 0001003A # asm("movl _sgl_value_6,r13"); /* r13 = LSW of operand 3 */
779: 756 0001003A 0d effffff968 5d movl _sgl_value_6,r13
780: 757 00010041 # asm("movl _index,r14"); /* r14 = data index */
781: 758 00010041 0d effffff961 5e movl _index,r14
782: 759 00010048 # }
783: 760 00010048 L469:
784: 761 00010048 # asm("halt"); /* HALT ... */
785: 762 00010048 00 halt
786: 763 00010049 # }
787: 764 00010049 40 ret#2
788: 765 0001004A .set L464,0x0
789: 766 0001004A L466:
790: 767 0001004A 13 ff0c jbr L467
791: 768 0001004D .data
792: 768 0001F9F5 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.