![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe18.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 / macro4|
Return to pipe18.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
Power 6/32 Unix version 1.21
1 00000000 LL0:
2 00000000 .data
3 00000464 * .text
4 00000000 .align 1
5 00000000 .globl _pipe_18
6 00000000 _pipe_18:
7 00032A84 0000 .word L215
8 00032A86 # #include "fpp_defs.h"
9 00032A86 #
10 00032A86 #
11 00032A86 # /*****************************************************************************
12 00032A86 # *
13 00032A86 # * PIPELINE TEST #18
14 00032A86 # *
15 00032A86 # * LDD(op1), MULD(op2), CVDL r0, SUBD operand[r0], STD
16 00032A86 # *
17 00032A86 # * -where the operands are the fmacro1 MULD data patterns. The SUBD operand's
18 00032A86 # * address is based on the result of the CVDL.
19 00032A86 # * -The load, multiply, and convert will be done twice. The first time will
20 00032A86 # * be to get the index and the data to subtract. The data to subtract will
21 00032A86 # * be the same as the accumulator so we'll expect a reasult of zero. The
22 00032A86 # * data will be stored based on the 1st CVDL result.
23 00032A86 # * -If the 2nd CVDL doesn't get done before the SUBD operand is fetched then
24 00032A86 # * we won't get a final accumulator of zero.
25 00032A86 # * -For size reasons, only the MULD data with a result between -100 and +100
26 00032A86 # * will be used for this test.
27 00032A86 # *****************************************************************************/
28 00032A86 # pipe_18()
29 00032A86 # {
30 00032A86 13 01cc jbr L217
31 00032A89 L218:
32 00032A89 # asm(".globl _pipeline_18_t");
33 00032A89 .globl _pipeline_18_t
34 00032A89 # asm("_pipeline_18_t:");
35 00032A89 _pipeline_18_t:
36 00032A89 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
37 00032A89 1d effffffff5 01 cmpl _cycle,$1
38 00032A90 21 15 jneq L219
39 00032A92 5d efffffffec tstl _prt_hdrs
40 00032A98 31 0d jeql L219
41 00032A9A # writes(" PIPE_18");
42 00032A9A .data 1
43 00000464 * L221:
44 00000464 * 20504950455F313800 .ascii " PIPE_18\0"
45 0000046d * .text
46 00032A9A dd 8f00000464 pushl $L221
47 00032AA0 fe 08 efffffffdd callf $8,_writes
48 00032AA7 # force_loop = FALSE; /* clear force_loop flag */
49 00032AA7 L219:
50 00032AA7 4d efffffffd7 clrl _force_loop
51 00032AAD # for( index = 0; index <= max_muld_1_index; index++ ) {
52 00032AAD 4d efffffffd1 clrl _index
53 00032AB3 L224:
54 00032AB3 1d efffffffcb efffffffc6 cmpl _index,_max_muld_1_index
55 00032ABE 51 03 13 018b jgtr L223
56 00032AC3 # dbl_value_1 = muld_1_data[index].op_1; /* get the data */
57 00032AC3 5c 18 efffffffba 50 mull3 $24,_index,r0
58 00032ACB 0c 8f00000000 50 addl2 $_muld_1_data,r0
59 00032AD2 0d a004 efffffffae movl 4(r0),_dbl_value_1+4
60 00032ADA 0d 60 efffffffa3 movl (r0),_dbl_value_1
61 00032AE1 # dbl_value_2 = muld_1_data[index].op_2; /* operands */
62 00032AE1 5c 18 efffffff9c 50 mull3 $24,_index,r0
63 00032AE9 0c 8f00000008 50 addl2 $_muld_1_data+8,r0
64 00032AF0 0d a004 efffffff90 movl 4(r0),_dbl_value_2+4
65 00032AF8 0d 60 efffffff85 movl (r0),_dbl_value_2
66 00032AFF # dbl_expected.m = dbl_expected.l = 0; /* result s/b 0 */
67 00032AFF 4d efffffff83 clrl _dbl_expected+4
68 00032B05 0d efffffff7d 50 movl _dbl_expected+4,r0
69 00032B0C 0d 50 efffffff71 movl r0,_dbl_expected
70 00032B13 # asm("ldd _dbl_value_1");
71 00032B13 07 efffffff6b ldd _dbl_value_1
72 00032B19 # asm("muld _dbl_value_2");
73 00032B19 e7 efffffff65 muld _dbl_value_2
74 00032B1F # asm("cvdl _index2");
75 00032B1F 87 efffffff5f cvdl _index2
76 00032B25 # asm("nop");
77 00032B25 10 nop
78 00032B26 # if( (index2 >= -99) && (index2 <= 99) ) {
79 00032B26 1d efffffff58 889d cmpl _index2,$-99
80 00032B2E 81 03 13 0112 jlss L225
81 00032B33 1d efffffff4b 8863 cmpl _index2,$99
82 00032B3B 41 f3 jgtr L225
83 00032B3D # if( index2 ) {
84 00032B3D 5d efffffff41 tstl _index2
85 00032B43 31 35 jeql L226
86 00032B45 # sgl_value_5 = 0; /* set a dummy index */
87 00032B45 4d efffffff39 clrl _sgl_value_5
88 00032B4B # adr_dpipe_ops[sgl_value_5].m = 0;
89 00032B4B 0d efffffff33 50 movl _sgl_value_5,r0
90 00032B52 48 03 50 50 shll $3,r0,r0
91 00032B56 1c 50 efffffff27 50 addl3 r0,_adr_dpipe_ops,r0
92 00032B5E 4d 60 clrl (r0)
93 00032B60 # adr_dpipe_ops[sgl_value_5].l = 0xabadface;
94 00032B60 48 03 efffffff1d 50 shll $3,_sgl_value_5,r0
95 00032B68 1c 50 efffffff15 50 addl3 r0,_adr_dpipe_ops,r0
96 00032B70 0d 8fabadface a004 movl $-1414661426,4(r0)
97 00032B78 # } else {
98 00032B78 11 39 jbr L227
99 00032B7A L226:
100 00032B7A # sgl_value_5 = 6; /* set a dummy index */
101 00032B7A 0d 06 efffffff03 movl $6,_sgl_value_5
102 00032B81 # adr_dpipe_ops[sgl_value_5].m = 0xabadbabe;
103 00032B81 0d effffffefd 50 movl _sgl_value_5,r0
104 00032B88 48 03 50 50 shll $3,r0,r0
105 00032B8C 1c 50 effffffef1 50 addl3 r0,_adr_dpipe_ops,r0
106 00032B94 0d 8fabadbabe 60 movl $-1414677826,(r0)
107 00032B9B # adr_dpipe_ops[sgl_value_5].l = 0xabadface;
108 00032B9B 48 03 effffffee2 50 shll $3,_sgl_value_5,r0
109 00032BA3 1c 50 effffffeda 50 addl3 r0,_adr_dpipe_ops,r0
110 00032BAB 0d 8fabadface a004 movl $-1414661426,4(r0)
111 00032BB3 # }
112 00032BB3 L227:
113 00032BB3 # asm("movl _index2,r0"); /* save the index */
114 00032BB3 0d effffffecb 50 movl _index2,r0
115 00032BBA # asm("std _dpipe_ops[r0]"); /* save the Acc's value */
116 00032BBA 27 40effffffec3 std _dpipe_ops[r0]
117 00032BC1 # asm("std _dbl_value_3"); /* save this value */
118 00032BC1 27 effffffebd std _dbl_value_3
119 00032BC7 # /*
120 00032BC7 # * This is the start of the LOOP ON ERROR section
121 00032BC7 # */
122 00032BC7 # asm("_pipe18_1_lp:");
123 00032BC7 _pipe18_1_lp:
124 00032BC7 # asm("movl _sgl_value_5,r0"); /* save the bum index */
125 00032BC7 0d effffffeb7 50 movl _sgl_value_5,r0
126 00032BCE # asm("ldd _dbl_value_1");
127 00032BCE 07 effffffeb0 ldd _dbl_value_1
128 00032BD4 # asm("muld _dbl_value_2");
129 00032BD4 e7 effffffeaa muld _dbl_value_2
130 00032BDA # asm("cvdl r0"); /* set up the index to use */
131 00032BDA 87 50 cvdl r0
132 00032BDC # asm("subd _dpipe_ops[r0]"); /* subtract saved value */
133 00032BDC d7 40effffffea1 subd _dpipe_ops[r0]
134 00032BE3 # asm("std _dbl_st_acc");
135 00032BE3 27 effffffe9b std _dbl_st_acc
136 00032BE9 # asm("movl r0,_sgl_value_6"); /* save the index used */
137 00032BE9 0d 50 effffffe94 movl r0,_sgl_value_6
138 00032BF0 # if( force_loop )
139 00032BF0 5d effffffe8e tstl _force_loop
140 00032BF6 31 02 jeql L228
141 00032BF8 # asm("brb _pipe18_1_lp");; /* loop on the error */
142 00032BF8 11 cd brb _pipe18_1_lp
143 00032BFA L228:
144 00032BFA # /*
145 00032BFA # * Verify the results (the accumulator should be = 0)
146 00032BFA # */
147 00032BFA # if( (dbl_st_acc.m) || (dbl_st_acc.l) ) {
148 00032BFA 5d effffffe84 tstl _dbl_st_acc
149 00032C00 21 08 jneq L9999
150 00032C02 5d effffffe80 tstl _dbl_st_acc+4
151 00032C08 31 3b jeql L229
152 00032C0A L9999:
153 00032C0A # errcnt++; /* bump the error count */
154 00032C0A 6d effffffe74 incl _errcnt
155 00032C10 # if ( prt_error )
156 00032C10 5d effffffe6e tstl _prt_error
157 00032C16 31 07 jeql L230
158 00032C18 # pipe18_print(); /* print the error mesage */
159 00032C18 fe 04 ef00000039 callf $4,_pipe18_print
160 00032C1F # if ( halt_flg )
161 00032C1F L230:
162 00032C1F 5d effffffe5f tstl _halt_flg
163 00032C25 31 09 jeql L232
164 00032C27 # pipe18_halt( 1 ); /* halt on the error */
165 00032C27 dd 01 pushl $1
166 00032C29 fe 08 ef000001dc callf $8,_pipe18_halt
167 00032C30 # if ( loop_on_err ) {
168 00032C30 L232:
169 00032C30 5d effffffe4e tstl _loop_on_err
170 00032C36 31 0d jeql L234
171 00032C38 # force_loop = TRUE;
172 00032C38 0d 01 effffffe45 movl $1,_force_loop
173 00032C3F # asm("jmp _pipe18_1_lp");;
174 00032C3F 71 efffffff82 jmp _pipe18_1_lp
175 00032C45 # }
176 00032C45 # }
177 00032C45 L234:
178 00032C45 # }
179 00032C45 L229:
180 00032C45 # }
181 00032C45 L225:
182 00032C45 L222:
183 00032C45 6d effffffe39 incl _index
184 00032C4B 13 fe65 jbr L224
185 00032C4E L223:
186 00032C4E # asm("jmp *return"); /* return to the test monitor */
187 00032C4E 71 fffffffe30 jmp *return
188 00032C54 # }
189 00032C54 40 ret#2
190 00032C55 .set L215,0x0
191 00032C55 L217:
192 00032C55 13 fe31 jbr L218
193 00032C58 .data
194 00000464 * .text
195 00032C58 .align 1
196 00032C58 .globl _pipe18_print
197 00032C58 _pipe18_print:
198 00032C58 0000 .word L235
199 00032C5A #
200 00032C5A #
201 00032C5A #
202 00032C5A #
203 00032C5A # /*
204 00032C5A # **************************************************************************
205 00032C5A # *
206 00032C5A # * print an error message of the form
207 00032C5A # *
208 00032C5A # * cycle: xx Test xx, Error with subtract data based on CVDL value, index = xx
209 00032C5A # * test sequence = LDD(op1), MULD(op2), CVDL r0, SUBD operand[r0], STD
210 00032C5A # *operand 1 = xxxxxxx xxxxxxx, final Acc = xxxxxxx xxxxxxx, index = xxxxxxx
211 00032C5A # *operand 2 = xxxxxxx xxxxxxx, expected Acc = xxxxxxx xxxxxxx
212 00032C5A # *operand 3 = xxxxxxx xxxxxxx, CVDL result = xxxxxxx
213 00032C5A # * int expected = xxxxxxx
214 00032C5A # **************************************************************************
215 00032C5A # */
216 00032C5A # pipe18_print()
217 00032C5A # {
218 00032C5A 13 01ac jbr L237
219 00032C5D L238:
220 00032C5D # writes(" \n"); /* start a new print line */
221 00032C5D .data 1
222 0000046d * L239:
223 0000046d * 200A00 .ascii " \12\0"
224 00000470 * .text
225 00032C5D dd 8f0000046d pushl $L239
226 00032C63 fe 08 effffffe1a callf $8,_writes
227 00032C6A # writes("cycle: ");
228 00032C6A .data 1
229 00000470 * L240:
230 00000470 * 6379636C653A2000 .ascii "cycle: \0"
231 00000478 * .text
232 00032C6A dd 8f00000470 pushl $L240
233 00032C70 fe 08 effffffe0d callf $8,_writes
234 00032C77 # writed( cycle );
235 00032C77 dd effffffe07 pushl _cycle
236 00032C7D fe 08 effffffe00 callf $8,_writed
237 00032C84 # writes(" Test ");
238 00032C84 .data 1
239 00000478 * L242:
240 00000478 * 2020546573742000 .ascii " Test \0"
241 00000480 * .text
242 00032C84 dd 8f00000478 pushl $L242
243 00032C8A fe 08 effffffdf3 callf $8,_writes
244 00032C91 # writed( test_no );
245 00032C91 dd effffffded pushl _test_no
246 00032C97 fe 08 effffffde6 callf $8,_writed
247 00032C9E # writes(" (Pipe 18), error\n");
248 00032C9E .data 1
249 00000480 * L243:
250 00000480 * 20202850697065203138292C2 .ascii " (Pipe 18), error\12\0"
0206572726F720A00
251 00000495 * .text
252 00032C9E dd 8f00000480 pushl $L243
253 00032CA4 fe 08 effffffdd9 callf $8,_writes
254 00032CAB # writes(" LDD(op1), MULD(op2), CVDL(r0), SUBD(op3), STD\n");
255 00032CAB .data 1
256 00000495 * L244:
257 00000495 * 204C4444286F7031292C204D5 .ascii " LDD(op1), MULD(op2), CVDL(r0), SUBD(op3), STD\12\0"
54C44286F7032292C20435644
4C287230292C2053554244286
F7033292C205354440A00
258 000004c5 * .text
259 00032CAB dd 8f00000495 pushl $L244
260 00032CB1 fe 08 effffffdcc callf $8,_writes
261 00032CB8 # writes("operand 1 = ");
262 00032CB8 .data 1
263 000004c5 * L245:
264 000004c5 * 6F706572616E642031203D200 .ascii "operand 1 = \0"
0
265 000004d2 * .text
266 00032CB8 dd 8f000004c5 pushl $L245
267 00032CBE fe 08 effffffdbf callf $8,_writes
268 00032CC5 # write32h( dbl_value_1.m );
269 00032CC5 dd effffffdb9 pushl _dbl_value_1
270 00032CCB fe 08 effffffdb2 callf $8,_write32h
271 00032CD2 # writec(' ');
272 00032CD2 dd 20 pushl $32
273 00032CD4 fe 08 effffffda9 callf $8,_writec
274 00032CDB # write32h( dbl_value_1.l );
275 00032CDB dd effffffda7 pushl _dbl_value_1+4
276 00032CE1 fe 08 effffffd9c callf $8,_write32h
277 00032CE8 # writes(", final Acc = ");
278 00032CE8 .data 1
279 000004d2 * L248:
280 000004d2 * 2C2020202066696E616C20416 .ascii ", final Acc = \0"
363203D2000
281 000004e4 * .text
282 00032CE8 dd 8f000004d2 pushl $L248
283 00032CEE fe 08 effffffd8f callf $8,_writes
284 00032CF5 # write32h( dbl_st_acc.m );
285 00032CF5 dd effffffd89 pushl _dbl_st_acc
286 00032CFB fe 08 effffffd82 callf $8,_write32h
287 00032D02 # writec(' ');
288 00032D02 dd 20 pushl $32
289 00032D04 fe 08 effffffd79 callf $8,_writec
290 00032D0B # write32h( dbl_st_acc.l );
291 00032D0B dd effffffd77 pushl _dbl_st_acc+4
292 00032D11 fe 08 effffffd6c callf $8,_write32h
293 00032D18 # writes(", index = ");
294 00032D18 .data 1
295 000004e4 * L249:
296 000004e4 * 2C2020696E646578203D2000 .ascii ", index = \0"
297 000004f0 * .text
298 00032D18 dd 8f000004e4 pushl $L249
299 00032D1E fe 08 effffffd5f callf $8,_writes
300 00032D25 # writed( index );
301 00032D25 dd effffffd59 pushl _index
302 00032D2B fe 08 effffffd52 callf $8,_writed
303 00032D32 # writes("\noperand 2 = ");
304 00032D32 .data 1
305 000004f0 * L250:
306 000004f0 * 0A6F706572616E642032203D2 .ascii "\12operand 2 = \0"
000
307 000004fe * .text
308 00032D32 dd 8f000004f0 pushl $L250
309 00032D38 fe 08 effffffd45 callf $8,_writes
310 00032D3F # write32h( dbl_value_2.m );
311 00032D3F dd effffffd3f pushl _dbl_value_2
312 00032D45 fe 08 effffffd38 callf $8,_write32h
313 00032D4C # writec(' ');
314 00032D4C dd 20 pushl $32
315 00032D4E fe 08 effffffd2f callf $8,_writec
316 00032D55 # write32h( dbl_value_2.l );
317 00032D55 dd effffffd2d pushl _dbl_value_2+4
318 00032D5B fe 08 effffffd22 callf $8,_write32h
319 00032D62 # writes(", expected Acc = ");
320 00032D62 .data 1
321 000004fe * L251:
322 000004fe * 2C20657870656374656420416 .ascii ", expected Acc = \0"
363203D2000
323 00000510 * .text
324 00032D62 dd 8f000004fe pushl $L251
325 00032D68 fe 08 effffffd15 callf $8,_writes
326 00032D6F # write32h( dbl_expected.m );
327 00032D6F dd effffffd0f pushl _dbl_expected
328 00032D75 fe 08 effffffd08 callf $8,_write32h
329 00032D7C # writec(' ');
330 00032D7C dd 20 pushl $32
331 00032D7E fe 08 effffffcff callf $8,_writec
332 00032D85 # write32h( dbl_expected.l );
333 00032D85 dd effffffcfd pushl _dbl_expected+4
334 00032D8B fe 08 effffffcf2 callf $8,_write32h
335 00032D92 # writes("\noperand 3 = ");
336 00032D92 .data 1
337 00000510 * L252:
338 00000510 * 0A6F706572616E642033203D2 .ascii "\12operand 3 = \0"
000
339 0000051e * .text
340 00032D92 dd 8f00000510 pushl $L252
341 00032D98 fe 08 effffffce5 callf $8,_writes
342 00032D9F # write32h( dbl_value_3.m );
343 00032D9F dd effffffcdf pushl _dbl_value_3
344 00032DA5 fe 08 effffffcd8 callf $8,_write32h
345 00032DAC # writec(' ');
346 00032DAC dd 20 pushl $32
347 00032DAE fe 08 effffffccf callf $8,_writec
348 00032DB5 # write32h( dbl_value_3.l );
349 00032DB5 dd effffffccd pushl _dbl_value_3+4
350 00032DBB fe 08 effffffcc2 callf $8,_write32h
351 00032DC2 # writes(", CVDL result = ");
352 00032DC2 .data 1
353 0000051e * L253:
354 0000051e * 2C20204356444C20726573756 .ascii ", CVDL result = \0"
C74203D2000
355 00000530 * .text
356 00032DC2 dd 8f0000051e pushl $L253
357 00032DC8 fe 08 effffffcb5 callf $8,_writes
358 00032DCF # write32h( sgl_value_6 );
359 00032DCF dd effffffcaf pushl _sgl_value_6
360 00032DD5 fe 08 effffffca8 callf $8,_write32h
361 00032DDC # writec('\n');
362 00032DDC dd 0a pushl $10
363 00032DDE fe 08 effffffc9f callf $8,_writec
364 00032DE5 # writes(" int expected = ");
365 00032DE5 .data 1
366 00000530 * L254:
367 00000530 * 2020202020202020202020202 .ascii " int expected = \0"
0202020202020202020202020
202020202020696E742065787
06563746564203D2000
368 0000055f * .text
369 00032DE5 dd 8f00000530 pushl $L254
370 00032DEB fe 08 effffffc92 callf $8,_writes
371 00032DF2 # write32h( index2 );
372 00032DF2 dd effffffc8c pushl _index2
373 00032DF8 fe 08 effffffc85 callf $8,_write32h
374 00032DFF # writec('\n');
375 00032DFF dd 0a pushl $10
376 00032E01 fe 08 effffffc7c callf $8,_writec
377 00032E08 # }
378 00032E08 40 ret#2
379 00032E09 .set L235,0x0
380 00032E09 L237:
381 00032E09 13 fe51 jbr L238
382 00032E0C .data
383 00000464 * .text
384 00032E0C .align 1
385 00032E0C .globl _pipe18_halt
386 00032E0C _pipe18_halt:
387 00032E0C 0000 .word L255
388 00032E0E #
389 00032E0E #
390 00032E0E #
391 00032E0E # /*
392 00032E0E # **************************************************************************
393 00032E0E # *
394 00032E0E # * HALT ON AN ERROR
395 00032E0E # *
396 00032E0E # **************************************************************************
397 00032E0E # */
398 00032E0E # pipe18_halt()
399 00032E0E # {
400 00032E0E 13 00d1 jbr L257
401 00032E11 L258:
402 00032E11 # sgl_value_1 = dbl_value_1.m;
403 00032E11 0d effffffc6d effffffc68 movl _dbl_value_1,_sgl_value_1
404 00032E1C # sgl_value_2 = dbl_value_1.l;
405 00032E1C 0d effffffc66 effffffc5d movl _dbl_value_1+4,_sgl_value_2
406 00032E27 # sgl_value_3 = dbl_value_2.m;
407 00032E27 0d effffffc57 effffffc52 movl _dbl_value_2,_sgl_value_3
408 00032E32 # sgl_value_4 = dbl_value_2.l;
409 00032E32 0d effffffc50 effffffc47 movl _dbl_value_2+4,_sgl_value_4
410 00032E3D # asm("movl _test_no,r0"); /* r0 = test number */
411 00032E3D 0d effffffc41 50 movl _test_no,r0
412 00032E44 # asm("movl $1,r1"); /* r1 = subtest number */
413 00032E44 0d 01 51 movl $1,r1
414 00032E47 # asm("movl $1,r2"); /* r2 = error code */
415 00032E47 0d 01 52 movl $1,r2
416 00032E4A # asm("movl _cycle,r3"); /* r3 = cycle count */
417 00032E4A 0d effffffc34 53 movl _cycle,r3
418 00032E51 # asm("movl _sgl_value_1,r4"); /* r4 = MS of dbl operand #1 */
419 00032E51 0d effffffc2d 54 movl _sgl_value_1,r4
420 00032E58 # asm("movl _sgl_value_2,r5"); /* r5 = LS of dbl operand #1 */
421 00032E58 0d effffffc26 55 movl _sgl_value_2,r5
422 00032E5F # asm("movl _sgl_value_3,r6"); /* r6 = MS of dbl operand #2 */
423 00032E5F 0d effffffc1f 56 movl _sgl_value_3,r6
424 00032E66 # asm("movl _sgl_value_4,r7"); /* r7 = LS of dbl operand #2 */
425 00032E66 0d effffffc18 57 movl _sgl_value_4,r7
426 00032E6D # sgl_value_1 = dbl_st_acc.m;
427 00032E6D 0d effffffc11 effffffc0c movl _dbl_st_acc,_sgl_value_1
428 00032E78 # sgl_value_2 = dbl_st_acc.l;
429 00032E78 0d effffffc0a effffffc01 movl _dbl_st_acc+4,_sgl_value_2
430 00032E83 # sgl_value_3 = dbl_expected.m;
431 00032E83 0d effffffbfb effffffbf6 movl _dbl_expected,_sgl_value_3
432 00032E8E # sgl_value_4 = dbl_expected.l;
433 00032E8E 0d effffffbf4 effffffbeb movl _dbl_expected+4,_sgl_value_4
434 00032E99 # sgl_value_5 = dbl_value_3.m;
435 00032E99 0d effffffbe5 effffffbe0 movl _dbl_value_3,_sgl_value_5
436 00032EA4 # sgl_value_6 = dbl_value_3.l;
437 00032EA4 0d effffffbde effffffbd5 movl _dbl_value_3+4,_sgl_value_6
438 00032EAF # asm("movl _sgl_value_5,r8"); /* r8 = MS of dbl operand #3 */
439 00032EAF 0d effffffbcf 58 movl _sgl_value_5,r8
440 00032EB6 # asm("movl _sgl_value_6,r9"); /* r9 = LS of dbl operand #3 */
441 00032EB6 0d effffffbc8 59 movl _sgl_value_6,r9
442 00032EBD # asm("movl _sgl_value_1,r10"); /* r10 = MS of final result */
443 00032EBD 0d effffffbc1 5a movl _sgl_value_1,r10
444 00032EC4 # asm("movl _sgl_value_2,r11"); /* r11 = LS of final result */
445 00032EC4 0d effffffbba 5b movl _sgl_value_2,r11
446 00032ECB # asm("movl _sgl_value_3,r12"); /* r12 = MS of expected result */
447 00032ECB 0d effffffbb3 5c movl _sgl_value_3,r12
448 00032ED2 # asm("movl _sgl_value_4,r13"); /* r13 = LS of expected result */
449 00032ED2 0d effffffbac 5d movl _sgl_value_4,r13
450 00032ED9 # asm("movl _index,r14"); /* r14 = data index */
451 00032ED9 0d effffffba5 5e movl _index,r14
452 00032EE0 # asm("halt"); /* HALT ... */
453 00032EE0 00 halt
454 00032EE1 # }
455 00032EE1 40 ret#2
456 00032EE2 .set L255,0x0
457 00032EE2 L257:
458 00032EE2 13 ff2c jbr L258
459 00032EE5 .data
460 00000464 * #
460 00000464 * #
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.