![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to muld.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 muld.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 00000d28 * .text
4 00000000 .align 1
5 00000000 .globl _muld
6 00000000 _muld:
7 000182B0 0000 .word L215
8 000182B2 #
9 000182B2 #
10 000182B2 # #include "fpp_defs.h"
11 000182B2 #
12 000182B2 #
13 000182B2 # /*****************************************************************************
14 000182B2 # *
15 000182B2 # * MULD - DOUBLE PRECISION FLOATING POINT MULTIPLY TEST
16 000182B2 # *
17 000182B2 # *****************************************************************************/
18 000182B2 # muld()
19 000182B2 # {
20 000182B2 11 7a jbr L217
21 000182B4 L218:
22 000182B4 # asm(".globl _muld_t");
23 000182B4 .globl _muld_t
24 000182B4 # asm("_muld_t:"); /* entry address */
25 000182B4 _muld_t:
26 000182B4 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
27 000182B4 1d effffffff6 01 cmpl _cycle,$1
28 000182BB 21 15 jneq L219
29 000182BD 5d efffffffed tstl _prt_hdrs
30 000182C3 31 0d jeql L219
31 000182C5 # writes(" MULD");
32 000182C5 .data 1
33 00000d28 * L221:
34 00000d28 * 204D554C4400 .ascii " MULD\0"
35 00000d2e * .text
36 000182C5 dd 8f00000d28 pushl $L221
37 000182CB fe 08 efffffffde callf $8,_writes
38 000182D2 # muld_1(); /* mul through a register */
39 000182D2 L219:
40 000182D2 fe 04 ef00000057 callf $4,_muld_1
41 000182D9 # muld_2(); /* mul through the cache */
42 000182D9 fe 04 ef000001b2 callf $4,_muld_2
43 000182E0 # muld_3(); /* wait 1 NOP before storeing */
44 000182E0 fe 04 ef000002f9 callf $4,_muld_3
45 000182E7 # for( nop_cnt = 3; nop_cnt > 0; nop_cnt-- )
46 000182E7 0d 03 efffffffc2 movl $3,_nop_cnt
47 000182EE L227:
48 000182EE 5d efffffffbc tstl _nop_cnt
49 000182F4 51 15 jleq L226
50 000182F6 # muld_3(nop_cnt); /* wait 6 ... 2 NOPs */
51 000182F6 dd efffffffb4 pushl _nop_cnt
52 000182FC fe 08 ef000002dd callf $8,_muld_3
53 00018303 L225:
54 00018303 7d efffffffa7 decl _nop_cnt
55 00018309 11 e3 jbr L227
56 0001830B L226:
57 0001830B # muld_4(); /* wait 3 NOPs */
58 0001830B fe 04 ef00000456 callf $4,_muld_4
59 00018312 # muld_5(); /* wait 1 NOP before storing */
60 00018312 fe 04 ef000005a1 callf $4,_muld_5
61 00018319 # muld_6(); /* register stability test */
62 00018319 fe 04 ef000006ea callf $4,_muld_6
63 00018320 # muld_7(); /* PSL stability test */
64 00018320 fe 04 ef000008b3 callf $4,_muld_7
65 00018327 # asm("jmp *return"); /* return to the test monitor */
66 00018327 71 ffffffff83 jmp *return
67 0001832D # }
68 0001832D 40 ret#2
69 0001832E .set L215,0x0
70 0001832E L217:
71 0001832E 11 84 jbr L218
72 00018330 .data
73 00000d28 * .text
74 00018330 .align 1
75 00018330 .globl _muld_1
76 00018330 _muld_1:
77 00018330 0000 .word L232
78 00018332 #
79 00018332 #
80 00018332 #
81 00018332 # /************************************************************************
82 00018332 # *
83 00018332 # * SUBTEST 1 - multiply through a register
84 00018332 # *
85 00018332 # ************************************************************************/
86 00018332 # muld_1()
87 00018332 # {
88 00018332 13 015a jbr L234
89 00018335 L235:
90 00018335 # force_loop = FALSE;
91 00018335 4d efffffff75 clrl _force_loop
92 0001833B # subtest = 1;
93 0001833B 0d 01 efffffff6e movl $1,_subtest
94 00018342 # for( index = 0; index < max_muld_1_index; index++ ) {
95 00018342 4d efffffff68 clrl _index
96 00018348 L238:
97 00018348 1d efffffff62 efffffff5d cmpl _index,_max_muld_1_index
98 00018353 91 03 13 0136 jgeq L237
99 00018358 # dbl_ld_acc = muld_1_data[index].op_1; /* get operand 1 */
100 00018358 5c 18 efffffff51 50 mull3 $24,_index,r0
101 00018360 0c 8f00000000 50 addl2 $_muld_1_data,r0
102 00018367 0d a004 efffffff45 movl 4(r0),_dbl_ld_acc+4
103 0001836F 0d 60 efffffff3a movl (r0),_dbl_ld_acc
104 00018376 # dbl_value_1 = muld_1_data[index].op_2; /* get operand 2 */
105 00018376 5c 18 efffffff33 50 mull3 $24,_index,r0
106 0001837E 0c 8f00000008 50 addl2 $_muld_1_data+8,r0
107 00018385 0d a004 efffffff27 movl 4(r0),_dbl_value_1+4
108 0001838D 0d 60 efffffff1c movl (r0),_dbl_value_1
109 00018394 # dbl_expected = muld_1_data[index].exp; /* get expected result */
110 00018394 5c 18 efffffff15 50 mull3 $24,_index,r0
111 0001839C 0c 8f00000010 50 addl2 $_muld_1_data+16,r0
112 000183A3 0d a004 efffffff09 movl 4(r0),_dbl_expected+4
113 000183AB 0d 60 effffffefe movl (r0),_dbl_expected
114 000183B2 # /*
115 000183B2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
116 000183B2 # * The force loop flag is set after the first error.
117 000183B2 # */
118 000183B2 # asm("_muld_1_lp1:");
119 000183B2 _muld_1_lp1:
120 000183B2 # asm("movl _dbl_ld_acc,r2"); /* move operand 1 to r2/r3 */
121 000183B2 0d effffffef8 52 movl _dbl_ld_acc,r2
122 000183B9 # asm("movl _dbl_ld_acc+4,r3");
123 000183B9 0d effffffef5 53 movl _dbl_ld_acc+4,r3
124 000183C0 # asm("movl _dbl_value_1,r4"); /* move operand 2 to r4/r5 */
125 000183C0 0d effffffeea 54 movl _dbl_value_1,r4
126 000183C7 # asm("movl _dbl_value_1+4,r5");
127 000183C7 0d effffffee7 55 movl _dbl_value_1+4,r5
128 000183CE # asm("ldd r2"); /* load the 1st operand */
129 000183CE 07 52 ldd r2
130 000183D0 # asm("muld r4"); /* multiply the 2nd operand*/
131 000183D0 e7 54 muld r4
132 000183D2 # asm("std _dbl_st_acc"); /* store the result */
133 000183D2 27 effffffed8 std _dbl_st_acc
134 000183D8 # if( force_loop )
135 000183D8 5d effffffed2 tstl _force_loop
136 000183DE 31 02 jeql L239
137 000183E0 # asm("brb _muld_1_lp1");; /* loop on the error */
138 000183E0 11 d0 brb _muld_1_lp1
139 000183E2 L239:
140 000183E2 # /*
141 000183E2 # * end error loop - test the results
142 000183E2 # */
143 000183E2 # if( (dbl_st_acc.m != dbl_expected.m) || /* verify the results */
144 000183E2 # (dbl_st_acc.l != dbl_expected.l) ) {
145 000183E2 1d effffffec8 effffffec3 cmpl _dbl_st_acc,_dbl_expected
146 000183ED 21 10 jneq L9999
147 000183EF 1d effffffebf effffffeba cmpl _dbl_st_acc+4,_dbl_expected+4
148 000183FA 21 03 13 0086 jeql L240
149 000183FF L9999:
150 000183FF # errcnt++; /* bump the error count */
151 000183FF 6d effffffeab incl _errcnt
152 00018405 # if( prt_error ) {
153 00018405 5d effffffea5 tstl _prt_error
154 0001840B 31 55 jeql L241
155 0001840D # writes(" \n"); /* start a new print line */
156 0001840D .data 1
157 00000d2e * L242:
158 00000d2e * 200A00 .ascii " \12\0"
159 00000d31 * .text
160 0001840D dd 8f00000d2e pushl $L242
161 00018413 fe 08 effffffe96 callf $8,_writes
162 0001841A # writes("cycle: ");
163 0001841A .data 1
164 00000d31 * L243:
165 00000d31 * 6379636C653A2000 .ascii "cycle: \0"
166 00000d39 * .text
167 0001841A dd 8f00000d31 pushl $L243
168 00018420 fe 08 effffffe89 callf $8,_writes
169 00018427 # writed( cycle );
170 00018427 dd effffffe83 pushl _cycle
171 0001842D fe 08 effffffe7c callf $8,_writed
172 00018434 # writes(" MULD test ");
173 00018434 .data 1
174 00000d39 * L245:
175 00000d39 * 20204D554C442074657374200 .ascii " MULD test \0"
0
176 00000d46 * .text
177 00018434 dd 8f00000d39 pushl $L245
178 0001843A fe 08 effffffe6f callf $8,_writes
179 00018441 # writed( test_no );
180 00018441 dd effffffe69 pushl _test_no
181 00018447 fe 08 effffffe62 callf $8,_writed
182 0001844E # writes(", subtest 1 (Reg. Data) - BAD FINAL ACC\n");
183 0001844E .data 1
184 00000d46 * L246:
185 00000d46 * 2C20737562746573742031202 .ascii ", subtest 1 (Reg. Data) - BAD FINAL ACC\12\0"
85265672E204461746129202D
204241442046494E414C20414
3430A00
186 00000d6f * .text
187 0001844E dd 8f00000d46 pushl $L246
188 00018454 fe 08 effffffe55 callf $8,_writes
189 0001845B # print_muld_data();
190 0001845B fe 04 ef00000952 callf $4,_print_muld_data
191 00018462 # }
192 00018462 # if( halt_flg )
193 00018462 L241:
194 00018462 5d effffffe48 tstl _halt_flg
195 00018468 31 09 jeql L248
196 0001846A # muld_er_halt( BAD_ACC_HLT ); /* halt on the error */
197 0001846A dd 01 pushl $1
198 0001846C fe 08 ef00000a37 callf $8,_muld_er_halt
199 00018473 # if( loop_on_err ) {
200 00018473 L248:
201 00018473 5d effffffe37 tstl _loop_on_err
202 00018479 31 0a jeql L250
203 0001847B # force_loop = TRUE; /* set the force loop flag */
204 0001847B 0d 01 effffffe2e movl $1,_force_loop
205 00018482 # asm("brw _muld_1_lp1");; /* and loop on the error */
206 00018482 13 ff2d brw _muld_1_lp1
207 00018485 # } /* end of loop on error */
208 00018485 # } /* end of compare error */
209 00018485 L250:
210 00018485 # } /* end of WHILE loop */
211 00018485 L240:
212 00018485 L236:
213 00018485 6d effffffe25 incl _index
214 0001848B 13 feba jbr L238
215 0001848E L237:
216 0001848E # } /* end of subtest 1 */
217 0001848E 40 ret#2
218 0001848F .set L232,0x0
219 0001848F L234:
220 0001848F 13 fea3 jbr L235
221 00018492 .data
222 00000d28 * .text
223 00018492 .align 1
224 00018492 .globl _muld_2
225 00018492 _muld_2:
226 00018492 0000 .word L251
227 00018494 #
228 00018494 #
229 00018494 #
230 00018494 # /************************************************************************
231 00018494 # *
232 00018494 # * SUBTEST 2 - mul through memory
233 00018494 # *
234 00018494 # ************************************************************************/
235 00018494 # muld_2()
236 00018494 # {
237 00018494 13 0146 jbr L253
238 00018497 L254:
239 00018497 # force_loop = FALSE;
240 00018497 4d effffffe13 clrl _force_loop
241 0001849D # subtest = 2;
242 0001849D 0d 02 effffffe0c movl $2,_subtest
243 000184A4 # for( index = 0; index < max_muld_1_index; index++ ) {
244 000184A4 4d effffffe06 clrl _index
245 000184AA L257:
246 000184AA 1d effffffe00 effffffdfb cmpl _index,_max_muld_1_index
247 000184B5 91 03 13 0122 jgeq L256
248 000184BA # dbl_ld_acc = muld_1_data[index].op_1; /* get operand 1 */
249 000184BA 5c 18 effffffdef 50 mull3 $24,_index,r0
250 000184C2 0c 8f00000000 50 addl2 $_muld_1_data,r0
251 000184C9 0d a004 effffffde3 movl 4(r0),_dbl_ld_acc+4
252 000184D1 0d 60 effffffdd8 movl (r0),_dbl_ld_acc
253 000184D8 # dbl_value_1 = muld_1_data[index].op_2; /* get operand 2 */
254 000184D8 5c 18 effffffdd1 50 mull3 $24,_index,r0
255 000184E0 0c 8f00000008 50 addl2 $_muld_1_data+8,r0
256 000184E7 0d a004 effffffdc5 movl 4(r0),_dbl_value_1+4
257 000184EF 0d 60 effffffdba movl (r0),_dbl_value_1
258 000184F6 # dbl_expected = muld_1_data[index].exp; /* get expected result */
259 000184F6 5c 18 effffffdb3 50 mull3 $24,_index,r0
260 000184FE 0c 8f00000010 50 addl2 $_muld_1_data+16,r0
261 00018505 0d a004 effffffda7 movl 4(r0),_dbl_expected+4
262 0001850D 0d 60 effffffd9c movl (r0),_dbl_expected
263 00018514 # /*
264 00018514 # * If LOOP ON ERROR is set, this is the loop for this subtest.
265 00018514 # * The force loop flag is set after the first error.
266 00018514 # */
267 00018514 # asm("_muld_2_lp1:");
268 00018514 _muld_2_lp1:
269 00018514 # asm("ldd _dbl_ld_acc"); /* load the 1st operand */
270 00018514 07 effffffd96 ldd _dbl_ld_acc
271 0001851A # asm("muld _dbl_value_1"); /* multiply the 2nd operand*/
272 0001851A e7 effffffd90 muld _dbl_value_1
273 00018520 # asm("std _dbl_st_acc"); /* store the result */
274 00018520 27 effffffd8a std _dbl_st_acc
275 00018526 # if( force_loop )
276 00018526 5d effffffd84 tstl _force_loop
277 0001852C 31 02 jeql L258
278 0001852E # asm("brb _muld_2_lp1");; /* loop on the error */
279 0001852E 11 e4 brb _muld_2_lp1
280 00018530 L258:
281 00018530 # /*
282 00018530 # * end error loop - test the results
283 00018530 # */
284 00018530 # if( (dbl_st_acc.m != dbl_expected.m) || /* verify the results */
285 00018530 # (dbl_st_acc.l != dbl_expected.l) ) {
286 00018530 1d effffffd7a effffffd75 cmpl _dbl_st_acc,_dbl_expected
287 0001853B 21 10 jneq L9998
288 0001853D 1d effffffd71 effffffd6c cmpl _dbl_st_acc+4,_dbl_expected+4
289 00018548 21 03 13 0086 jeql L259
290 0001854D L9998:
291 0001854D # errcnt++; /* bump the error count */
292 0001854D 6d effffffd5d incl _errcnt
293 00018553 # if( prt_error ) {
294 00018553 5d effffffd57 tstl _prt_error
295 00018559 31 55 jeql L260
296 0001855B # writes(" \n"); /* start a new print line */
297 0001855B .data 1
298 00000d6f * L261:
299 00000d6f * 200A00 .ascii " \12\0"
300 00000d72 * .text
301 0001855B dd 8f00000d6f pushl $L261
302 00018561 fe 08 effffffd48 callf $8,_writes
303 00018568 # writes("cycle: ");
304 00018568 .data 1
305 00000d72 * L262:
306 00000d72 * 6379636C653A2000 .ascii "cycle: \0"
307 00000d7a * .text
308 00018568 dd 8f00000d72 pushl $L262
309 0001856E fe 08 effffffd3b callf $8,_writes
310 00018575 # writed( cycle );
311 00018575 dd effffffd35 pushl _cycle
312 0001857B fe 08 effffffd2e callf $8,_writed
313 00018582 # writes(" MULD test ");
314 00018582 .data 1
315 00000d7a * L263:
316 00000d7a * 20204D554C442074657374200 .ascii " MULD test \0"
0
317 00000d87 * .text
318 00018582 dd 8f00000d7a pushl $L263
319 00018588 fe 08 effffffd21 callf $8,_writes
320 0001858F # writed( test_no );
321 0001858F dd effffffd1b pushl _test_no
322 00018595 fe 08 effffffd14 callf $8,_writed
323 0001859C # writes(", subtest 2 (Cache Data) - BAD FINAL ACC\n");
324 0001859C .data 1
325 00000d87 * L264:
326 00000d87 * 2C20737562746573742032202 .ascii ", subtest 2 (Cache Data) - BAD FINAL ACC\12\0"
8436163686520446174612920
2D204241442046494E414C204
143430A00
327 00000db1 * .text
328 0001859C dd 8f00000d87 pushl $L264
329 000185A2 fe 08 effffffd07 callf $8,_writes
330 000185A9 # print_muld_data();
331 000185A9 fe 04 ef00000804 callf $4,_print_muld_data
332 000185B0 # }
333 000185B0 # if( halt_flg )
334 000185B0 L260:
335 000185B0 5d effffffcfa tstl _halt_flg
336 000185B6 31 09 jeql L265
337 000185B8 # muld_er_halt( BAD_ACC_HLT ); /* halt on the error */
338 000185B8 dd 01 pushl $1
339 000185BA fe 08 ef000008e9 callf $8,_muld_er_halt
340 000185C1 # if( loop_on_err ) {
341 000185C1 L265:
342 000185C1 5d effffffce9 tstl _loop_on_err
343 000185C7 31 0a jeql L266
344 000185C9 # force_loop = TRUE; /* set the force loop flag */
345 000185C9 0d 01 effffffce0 movl $1,_force_loop
346 000185D0 # asm("brw _muld_2_lp1");; /* and loop on the error */
347 000185D0 13 ff41 brw _muld_2_lp1
348 000185D3 # } /* end of loop on error */
349 000185D3 # } /* end of compare error */
350 000185D3 L266:
351 000185D3 # } /* end of WHILE loop */
352 000185D3 L259:
353 000185D3 L255:
354 000185D3 6d effffffcd7 incl _index
355 000185D9 13 fece jbr L257
356 000185DC L256:
357 000185DC # } /* end of subtest 2 */
358 000185DC 40 ret#2
359 000185DD .set L251,0x0
360 000185DD L253:
361 000185DD 13 feb7 jbr L254
362 000185E0 .data
363 00000d28 * .text
364 000185E0 .align 1
365 000185E0 .globl _muld_3
366 000185E0 _muld_3:
367 000185E0 0000 .word L267
368 000185E2 #
369 000185E2 #
370 000185E2 #
371 000185E2 # /****************************************************************************
372 000185E2 # *
373 000185E2 # * SUBTEST 3 - Wait 2n NOPs before storing the results
374 000185E2 # *
375 000185E2 # ****************************************************************************/
376 000185E2 # muld_3( count )
377 000185E2 # int count; /* wait "count" * 2 NOPs */
378 000185E2 # {
379 000185E2 13 0180 jbr L269
380 000185E5 L270:
381 000185E5 # force_loop = FALSE;
382 000185E5 4d effffffcc5 clrl _force_loop
383 000185EB # subtest = 3;
384 000185EB 0d 03 effffffcbe movl $3,_subtest
385 000185F2 # sgl_dummy2 = count; /* get the NOP count */
386 000185F2 0d ad04 effffffcb6 movl 4(fp),_sgl_dummy2
387 000185FA # for( index = 0; index < max_muld_1_index; index++ ) {
388 000185FA 4d effffffcb0 clrl _index
389 00018600 L273:
390 00018600 1d effffffcaa effffffca5 cmpl _index,_max_muld_1_index
391 0001860B 91 03 13 0154 jgeq L272
392 00018610 # dbl_ld_acc = muld_1_data[index].op_1; /* get operand 1 */
393 00018610 5c 18 effffffc99 50 mull3 $24,_index,r0
394 00018618 0c 8f00000000 50 addl2 $_muld_1_data,r0
395 0001861F 0d a004 effffffc8d movl 4(r0),_dbl_ld_acc+4
396 00018627 0d 60 effffffc82 movl (r0),_dbl_ld_acc
397 0001862E # dbl_value_1 = muld_1_data[index].op_2; /* get operand 2 */
398 0001862E 5c 18 effffffc7b 50 mull3 $24,_index,r0
399 00018636 0c 8f00000008 50 addl2 $_muld_1_data+8,r0
400 0001863D 0d a004 effffffc6f movl 4(r0),_dbl_value_1+4
401 00018645 0d 60 effffffc64 movl (r0),_dbl_value_1
402 0001864C # dbl_expected = muld_1_data[index].exp; /* get expected result */
403 0001864C 5c 18 effffffc5d 50 mull3 $24,_index,r0
404 00018654 0c 8f00000010 50 addl2 $_muld_1_data+16,r0
405 0001865B 0d a004 effffffc51 movl 4(r0),_dbl_expected+4
406 00018663 0d 60 effffffc46 movl (r0),_dbl_expected
407 0001866A # /*
408 0001866A # * If LOOP ON ERROR is set, this is the loop for this subtest.
409 0001866A # * The force loop flag is set after the first error.
410 0001866A # */
411 0001866A # asm("_muld_3_lp1:");
412 0001866A _muld_3_lp1:
413 0001866A # asm("movl _sgl_dummy2,r0"); /* set the NOP count */
414 0001866A 0d effffffc40 50 movl _sgl_dummy2,r0
415 00018671 # asm("ldd _dbl_ld_acc"); /* load the 1st operand */
416 00018671 07 effffffc39 ldd _dbl_ld_acc
417 00018677 # asm("nop"); /* delay */
418 00018677 10 nop
419 00018678 # asm("muld _dbl_value_1"); /* multiply the 2nd operand*/
420 00018678 e7 effffffc32 muld _dbl_value_1
421 0001867E # asm("1:");
422 0001867E 1:
423 0001867E # asm("decl r0"); /* decrement the NOP count */
424 0001867E 7d 50 decl r0
425 00018680 # asm("bneq 1b"); /* till the count = 0 */
426 00018680 21 fc bneq 1b
427 00018682 # asm("std _dbl_st_acc"); /* store the result */
428 00018682 27 effffffc28 std _dbl_st_acc
429 00018688 # if( force_loop )
430 00018688 5d effffffc22 tstl _force_loop
431 0001868E 31 02 jeql L274
432 00018690 # asm("brb _muld_3_lp1");; /* loop on the error */
433 00018690 11 d8 brb _muld_3_lp1
434 00018692 L274:
435 00018692 # /*
436 00018692 # * end error loop - test the results
437 00018692 # */
438 00018692 # if( (dbl_st_acc.m != dbl_expected.m) || /* verify the results */
439 00018692 # (dbl_st_acc.l != dbl_expected.l) ) {
440 00018692 1d effffffc18 effffffc13 cmpl _dbl_st_acc,_dbl_expected
441 0001869D 21 10 jneq L9997
442 0001869F 1d effffffc0f effffffc0a cmpl _dbl_st_acc+4,_dbl_expected+4
443 000186AA 21 03 13 00ac jeql L275
444 000186AF L9997:
445 000186AF # errcnt++; /* bump the error count */
446 000186AF 6d effffffbfb incl _errcnt
447 000186B5 # if( prt_error ) {
448 000186B5 5d effffffbf5 tstl _prt_error
449 000186BB 31 7b jeql L276
450 000186BD # writes(" \n"); /* start a new print line */
451 000186BD .data 1
452 00000db1 * L277:
453 00000db1 * 200A00 .ascii " \12\0"
454 00000db4 * .text
455 000186BD dd 8f00000db1 pushl $L277
456 000186C3 fe 08 effffffbe6 callf $8,_writes
457 000186CA # writes("cycle: ");
458 000186CA .data 1
459 00000db4 * L278:
460 00000db4 * 6379636C653A2000 .ascii "cycle: \0"
461 00000dbc * .text
462 000186CA dd 8f00000db4 pushl $L278
463 000186D0 fe 08 effffffbd9 callf $8,_writes
464 000186D7 # writed( cycle );
465 000186D7 dd effffffbd3 pushl _cycle
466 000186DD fe 08 effffffbcc callf $8,_writed
467 000186E4 # writes(" MULD test ");
468 000186E4 .data 1
469 00000dbc * L279:
470 00000dbc * 20204D554C442074657374200 .ascii " MULD test \0"
0
471 00000dc9 * .text
472 000186E4 dd 8f00000dbc pushl $L279
473 000186EA fe 08 effffffbbf callf $8,_writes
474 000186F1 # writed( test_no );
475 000186F1 dd effffffbb9 pushl _test_no
476 000186F7 fe 08 effffffbb2 callf $8,_writed
477 000186FE # writes(", subtest 3 (wait ");
478 000186FE .data 1
479 00000dc9 * L280:
480 00000dc9 * 2C20737562746573742033202 .ascii ", subtest 3 (wait \0"
8776169742000
481 00000ddc * .text
482 000186FE dd 8f00000dc9 pushl $L280
483 00018704 fe 08 effffffba5 callf $8,_writes
484 0001870B # sgl_dummy1 = 2*count;
485 0001870B 48 01 ad04 50 shll $1,4(fp),r0
486 00018710 0d 50 effffffb99 movl r0,_sgl_dummy1
487 00018717 # writed( sgl_dummy1 ); /* write the NOP count */
488 00018717 dd effffffb93 pushl _sgl_dummy1
489 0001871D fe 08 effffffb8c callf $8,_writed
490 00018724 # writes(" NOPs) - BAD FINAL ACC\n");
491 00018724 .data 1
492 00000ddc * L281:
493 00000ddc * 204E4F507329202D204241442 .ascii " NOPs) - BAD FINAL ACC\12\0"
046494E414C204143430A00
494 00000df4 * .text
495 00018724 dd 8f00000ddc pushl $L281
496 0001872A fe 08 effffffb7f callf $8,_writes
497 00018731 # print_muld_data();
498 00018731 fe 04 ef0000067c callf $4,_print_muld_data
499 00018738 # }
500 00018738 # if( halt_flg )
501 00018738 L276:
502 00018738 5d effffffb72 tstl _halt_flg
503 0001873E 31 09 jeql L282
504 00018740 # muld_er_halt( BAD_ACC_HLT ); /* halt on the error */
505 00018740 dd 01 pushl $1
506 00018742 fe 08 ef00000761 callf $8,_muld_er_halt
507 00018749 # if( loop_on_err ) {
508 00018749 L282:
509 00018749 5d effffffb61 tstl _loop_on_err
510 0001874F 31 0a jeql L283
511 00018751 # force_loop = TRUE; /* set the force loop flag */
512 00018751 0d 01 effffffb58 movl $1,_force_loop
513 00018758 # asm("brw _muld_3_lp1");; /* and loop on the error */
514 00018758 13 ff0f brw _muld_3_lp1
515 0001875B # } /* end of loop on error */
516 0001875B # } /* end of compare error */
517 0001875B L283:
518 0001875B # } /* end of WHILE loop */
519 0001875B L275:
520 0001875B L271:
521 0001875B 6d effffffb4f incl _index
522 00018761 13 fe9c jbr L273
523 00018764 L272:
524 00018764 # } /* end of subtest 3 */
525 00018764 40 ret#2
526 00018765 .set L267,0x0
527 00018765 L269:
528 00018765 13 fe7d jbr L270
529 00018768 .data
530 00000d28 * .text
531 00018768 .align 1
532 00018768 .globl _muld_4
533 00018768 _muld_4:
534 00018768 0000 .word L284
535 0001876A #
536 0001876A #
537 0001876A #
538 0001876A # /************************************************************************
539 0001876A # *
540 0001876A # * SUBTEST 4 - Wait 2 NOPs before storing the results
541 0001876A # *
542 0001876A # ************************************************************************/
543 0001876A # muld_4()
544 0001876A # {
545 0001876A 13 0149 jbr L286
546 0001876D L287:
547 0001876D # force_loop = FALSE;
548 0001876D 4d effffffb3d clrl _force_loop
549 00018773 # subtest = 4;
550 00018773 0d 04 effffffb36 movl $4,_subtest
551 0001877A # for( index = 0; index < max_muld_1_index; index++ ) {
552 0001877A 4d effffffb30 clrl _index
553 00018780 L290:
554 00018780 1d effffffb2a effffffb25 cmpl _index,_max_muld_1_index
555 0001878B 91 03 13 0125 jgeq L289
556 00018790 # dbl_ld_acc = muld_1_data[index].op_1; /* get operand 1 */
557 00018790 5c 18 effffffb19 50 mull3 $24,_index,r0
558 00018798 0c 8f00000000 50 addl2 $_muld_1_data,r0
559 0001879F 0d a004 effffffb0d movl 4(r0),_dbl_ld_acc+4
560 000187A7 0d 60 effffffb02 movl (r0),_dbl_ld_acc
561 000187AE # dbl_value_1 = muld_1_data[index].op_2; /* get operand 2 */
562 000187AE 5c 18 effffffafb 50 mull3 $24,_index,r0
563 000187B6 0c 8f00000008 50 addl2 $_muld_1_data+8,r0
564 000187BD 0d a004 effffffaef movl 4(r0),_dbl_value_1+4
565 000187C5 0d 60 effffffae4 movl (r0),_dbl_value_1
566 000187CC # dbl_expected = muld_1_data[index].exp; /* get expected result */
567 000187CC 5c 18 effffffadd 50 mull3 $24,_index,r0
568 000187D4 0c 8f00000010 50 addl2 $_muld_1_data+16,r0
569 000187DB 0d a004 effffffad1 movl 4(r0),_dbl_expected+4
570 000187E3 0d 60 effffffac6 movl (r0),_dbl_expected
571 000187EA # /*
572 000187EA # * If LOOP ON ERROR is set, this is the loop for this subtest.
573 000187EA # * The force loop flag is set after the first error.
574 000187EA # */
575 000187EA # asm("_muld_4_lp1:");
576 000187EA _muld_4_lp1:
577 000187EA # asm("ldd _dbl_ld_acc"); /* load the 1st operand */
578 000187EA 07 effffffac0 ldd _dbl_ld_acc
579 000187F0 # asm("nop"); /* delay */
580 000187F0 10 nop
581 000187F1 # asm("muld _dbl_value_1"); /* multiply the 2nd operand*/
582 000187F1 e7 effffffab9 muld _dbl_value_1
583 000187F7 # asm("nop"); /* delay before ... */
584 000187F7 10 nop
585 000187F8 # asm("nop"); /* ... storing the result */
586 000187F8 10 nop
587 000187F9 # asm("std _dbl_st_acc"); /* store the result */
588 000187F9 27 effffffab1 std _dbl_st_acc
589 000187FF # if( force_loop )
590 000187FF 5d effffffaab tstl _force_loop
591 00018805 31 02 jeql L291
592 00018807 # asm("brb _muld_4_lp1");; /* loop on the error */
593 00018807 11 e1 brb _muld_4_lp1
594 00018809 L291:
595 00018809 # /*
596 00018809 # * end error loop - test the results
597 00018809 # */
598 00018809 # if( (dbl_st_acc.m != dbl_expected.m) || /* verify the results */
599 00018809 # (dbl_st_acc.l != dbl_expected.l) ) {
600 00018809 1d effffffaa1 effffffa9c cmpl _dbl_st_acc,_dbl_expected
601 00018814 21 10 jneq L9996
602 00018816 1d effffffa98 effffffa93 cmpl _dbl_st_acc+4,_dbl_expected+4
603 00018821 21 03 13 0086 jeql L292
604 00018826 L9996:
605 00018826 # errcnt++; /* bump the error count */
606 00018826 6d effffffa84 incl _errcnt
607 0001882C # if( prt_error ) {
608 0001882C 5d effffffa7e tstl _prt_error
609 00018832 31 55 jeql L293
610 00018834 # writes(" \n"); /* start a new print line */
611 00018834 .data 1
612 00000df4 * L294:
613 00000df4 * 200A00 .ascii " \12\0"
614 00000df7 * .text
615 00018834 dd 8f00000df4 pushl $L294
616 0001883A fe 08 effffffa6f callf $8,_writes
617 00018841 # writes("cycle: ");
618 00018841 .data 1
619 00000df7 * L295:
620 00000df7 * 6379636C653A2000 .ascii "cycle: \0"
621 00000dff * .text
622 00018841 dd 8f00000df7 pushl $L295
623 00018847 fe 08 effffffa62 callf $8,_writes
624 0001884E # writed( cycle );
625 0001884E dd effffffa5c pushl _cycle
626 00018854 fe 08 effffffa55 callf $8,_writed
627 0001885B # writes(" MULD test ");
628 0001885B .data 1
629 00000dff * L296:
630 00000dff * 20204D554C442074657374200 .ascii " MULD test \0"
0
631 00000e0c * .text
632 0001885B dd 8f00000dff pushl $L296
633 00018861 fe 08 effffffa48 callf $8,_writes
634 00018868 # writed( test_no );
635 00018868 dd effffffa42 pushl _test_no
636 0001886E fe 08 effffffa3b callf $8,_writed
637 00018875 # writes(", subtest 4 (2 NOPs) - BAD FINAL ACC\n");
638 00018875 .data 1
639 00000e0c * L297:
640 00000e0c * 2C20737562746573742034202 .ascii ", subtest 4 (2 NOPs) - BAD FINAL ACC\12\0"
832204E4F507329202D204241
442046494E414C204143430A0
0
641 00000e32 * .text
642 00018875 dd 8f00000e0c pushl $L297
643 0001887B fe 08 effffffa2e callf $8,_writes
644 00018882 # print_muld_data();
645 00018882 fe 04 ef0000052b callf $4,_print_muld_data
646 00018889 # }
647 00018889 # if( halt_flg )
648 00018889 L293:
649 00018889 5d effffffa21 tstl _halt_flg
650 0001888F 31 09 jeql L298
651 00018891 # muld_er_halt( BAD_ACC_HLT ); /* halt on the error */
652 00018891 dd 01 pushl $1
653 00018893 fe 08 ef00000610 callf $8,_muld_er_halt
654 0001889A # if( loop_on_err ) {
655 0001889A L298:
656 0001889A 5d effffffa10 tstl _loop_on_err
657 000188A0 31 0a jeql L299
658 000188A2 # force_loop = TRUE; /* set the force loop flag */
659 000188A2 0d 01 effffffa07 movl $1,_force_loop
660 000188A9 # asm("brw _muld_4_lp1");; /* and loop on the error */
661 000188A9 13 ff3e brw _muld_4_lp1
662 000188AC # } /* end of loop on error */
663 000188AC # } /* end of compare error */
664 000188AC L299:
665 000188AC # } /* end of WHILE loop */
666 000188AC L292:
667 000188AC L288:
668 000188AC 6d effffff9fe incl _index
669 000188B2 13 fecb jbr L290
670 000188B5 L289:
671 000188B5 # } /* end of subtest 4 */
672 000188B5 40 ret#2
673 000188B6 .set L284,0x0
674 000188B6 L286:
675 000188B6 13 feb4 jbr L287
676 000188B9 .data
677 00000d28 * .text
678 000188B9 00 .align 1
679 000188BA .globl _muld_5
680 000188BA _muld_5:
681 000188BA 0000 .word L300
682 000188BC #
683 000188BC #
684 000188BC #
685 000188BC # /************************************************************************
686 000188BC # *
687 000188BC # * SUBTEST 5 - Wait 1 NOP before storing the results
688 000188BC # *
689 000188BC # ************************************************************************/
690 000188BC # muld_5()
691 000188BC # {
692 000188BC 13 0148 jbr L302
693 000188BF L303:
694 000188BF # force_loop = FALSE;
695 000188BF 4d effffff9eb clrl _force_loop
696 000188C5 # subtest = 5;
697 000188C5 0d 05 effffff9e4 movl $5,_subtest
698 000188CC # for( index = 0; index < max_muld_1_index; index++ ) {
699 000188CC 4d effffff9de clrl _index
700 000188D2 L306:
701 000188D2 1d effffff9d8 effffff9d3 cmpl _index,_max_muld_1_index
702 000188DD 91 03 13 0124 jgeq L305
703 000188E2 # dbl_ld_acc = muld_1_data[index].op_1; /* get operand 1 */
704 000188E2 5c 18 effffff9c7 50 mull3 $24,_index,r0
705 000188EA 0c 8f00000000 50 addl2 $_muld_1_data,r0
706 000188F1 0d a004 effffff9bb movl 4(r0),_dbl_ld_acc+4
707 000188F9 0d 60 effffff9b0 movl (r0),_dbl_ld_acc
708 00018900 # dbl_value_1 = muld_1_data[index].op_2; /* get operand 2 */
709 00018900 5c 18 effffff9a9 50 mull3 $24,_index,r0
710 00018908 0c 8f00000008 50 addl2 $_muld_1_data+8,r0
711 0001890F 0d a004 effffff99d movl 4(r0),_dbl_value_1+4
712 00018917 0d 60 effffff992 movl (r0),_dbl_value_1
713 0001891E # dbl_expected = muld_1_data[index].exp; /* get expected result */
714 0001891E 5c 18 effffff98b 50 mull3 $24,_index,r0
715 00018926 0c 8f00000010 50 addl2 $_muld_1_data+16,r0
716 0001892D 0d a004 effffff97f movl 4(r0),_dbl_expected+4
717 00018935 0d 60 effffff974 movl (r0),_dbl_expected
718 0001893C # /*
719 0001893C # * If LOOP ON ERROR is set, this is the loop for this subtest.
720 0001893C # * The force loop flag is set after the first error.
721 0001893C # */
722 0001893C # asm("_muld_5_lp1:");
723 0001893C _muld_5_lp1:
724 0001893C # asm("ldd _dbl_ld_acc"); /* load the 1st operand */
725 0001893C 07 effffff96e ldd _dbl_ld_acc
726 00018942 # asm("nop"); /* delay */
727 00018942 10 nop
728 00018943 # asm("muld _dbl_value_1"); /* multiply the 2nd operand*/
729 00018943 e7 effffff967 muld _dbl_value_1
730 00018949 # asm("nop"); /* delay before storing */
731 00018949 10 nop
732 0001894A # asm("std _dbl_st_acc"); /* store the result */
733 0001894A 27 effffff960 std _dbl_st_acc
734 00018950 # if( force_loop )
735 00018950 5d effffff95a tstl _force_loop
736 00018956 31 02 jeql L307
737 00018958 # asm("brb _muld_5_lp1");; /* loop on the error */
738 00018958 11 e2 brb _muld_5_lp1
739 0001895A L307:
740 0001895A # /*
741 0001895A # * end error loop - test the results
742 0001895A # */
743 0001895A # if( (dbl_st_acc.m != dbl_expected.m) || /* verify the results */
744 0001895A # (dbl_st_acc.l != dbl_expected.l) ) {
745 0001895A 1d effffff950 effffff94b cmpl _dbl_st_acc,_dbl_expected
746 00018965 21 10 jneq L9995
747 00018967 1d effffff947 effffff942 cmpl _dbl_st_acc+4,_dbl_expected+4
748 00018972 21 03 13 0086 jeql L308
749 00018977 L9995:
750 00018977 # errcnt++; /* bump the error count */
751 00018977 6d effffff933 incl _errcnt
752 0001897D # if( prt_error ) {
753 0001897D 5d effffff92d tstl _prt_error
754 00018983 31 55 jeql L309
755 00018985 # writes(" \n"); /* start a new print line */
756 00018985 .data 1
757 00000e32 * L310:
758 00000e32 * 200A00 .ascii " \12\0"
759 00000e35 * .text
760 00018985 dd 8f00000e32 pushl $L310
761 0001898B fe 08 effffff91e callf $8,_writes
762 00018992 # writes("cycle: ");
763 00018992 .data 1
764 00000e35 * L311:
765 00000e35 * 6379636C653A2000 .ascii "cycle: \0"
766 00000e3d * .text
767 00018992 dd 8f00000e35 pushl $L311
768 00018998 fe 08 effffff911 callf $8,_writes
769 0001899F # writed( cycle );
770 0001899F dd effffff90b pushl _cycle
771 000189A5 fe 08 effffff904 callf $8,_writed
772 000189AC # writes(" MULD test ");
773 000189AC .data 1
774 00000e3d * L312:
775 00000e3d * 20204D554C442074657374200 .ascii " MULD test \0"
0
776 00000e4a * .text
777 000189AC dd 8f00000e3d pushl $L312
778 000189B2 fe 08 effffff8f7 callf $8,_writes
779 000189B9 # writed( test_no );
780 000189B9 dd effffff8f1 pushl _test_no
781 000189BF fe 08 effffff8ea callf $8,_writed
782 000189C6 # writes(", subtest 5 (1 NOP) - BAD FINAL ACC\n");
783 000189C6 .data 1
784 00000e4a * L313:
785 00000e4a * 2C20737562746573742035202 .ascii ", subtest 5 (1 NOP) - BAD FINAL ACC\12\0"
831204E4F5029202D20424144
2046494E414C204143430A00
786 00000e6f * .text
787 000189C6 dd 8f00000e4a pushl $L313
788 000189CC fe 08 effffff8dd callf $8,_writes
789 000189D3 # print_muld_data();
790 000189D3 fe 04 ef000003da callf $4,_print_muld_data
791 000189DA # }
792 000189DA # if( halt_flg )
793 000189DA L309:
794 000189DA 5d effffff8d0 tstl _halt_flg
795 000189E0 31 09 jeql L314
796 000189E2 # muld_er_halt( BAD_ACC_HLT ); /* halt on the error */
797 000189E2 dd 01 pushl $1
798 000189E4 fe 08 ef000004bf callf $8,_muld_er_halt
799 000189EB # if( loop_on_err ) {
800 000189EB L314:
801 000189EB 5d effffff8bf tstl _loop_on_err
802 000189F1 31 0a jeql L315
803 000189F3 # force_loop = TRUE; /* set the force loop flag */
804 000189F3 0d 01 effffff8b6 movl $1,_force_loop
805 000189FA # asm("brw _muld_5_lp1");; /* and loop on the error */
806 000189FA 13 ff3f brw _muld_5_lp1
807 000189FD # } /* end of loop on error */
808 000189FD # } /* end of compare error */
809 000189FD L315:
810 000189FD # } /* end of WHILE loop */
811 000189FD L308:
812 000189FD L304:
813 000189FD 6d effffff8ad incl _index
814 00018A03 13 fecc jbr L306
815 00018A06 L305:
816 00018A06 # } /* end of subtest 5 */
817 00018A06 40 ret#2
818 00018A07 .set L300,0x0
819 00018A07 L302:
820 00018A07 13 feb5 jbr L303
821 00018A0A .data
822 00000d28 * .text
823 00018A0A .align 1
824 00018A0A .globl _muld_6
825 00018A0A _muld_6:
826 00018A0A 0000 .word L316
827 00018A0C #
828 00018A0C #
829 00018A0C #
830 00018A0C # /************************************************************************
831 00018A0C # *
832 00018A0C # * SUBTEST 6 - Check for register corruption
833 00018A0C # *
834 00018A0C # ************************************************************************/
835 00018A0C # muld_6()
836 00018A0C # {
837 00018A0C 13 01c8 jbr L318
838 00018A0F L319:
839 00018A0F # force_loop = FALSE; /* clear force_loop flg */
840 00018A0F 4d effffff89b clrl _force_loop
841 00018A15 # subtest = 6;
842 00018A15 0d 06 effffff894 movl $6,_subtest
843 00018A1C # fill_reg_buf( load_regs ); /* get patterns for regs */
844 00018A1C dd 8f00000000 pushl $_load_regs
845 00018A22 fe 08 effffff887 callf $8,_fill_reg_buf
846 00018A29 # index = 0;
847 00018A29 4d effffff881 clrl _index
848 00018A2F # dbl_ld_acc = muld_1_data[0].op_1; /* get operand 1 */
849 00018A2F 0d effffff87f effffff87a movl _muld_1_data+4,_dbl_ld_acc+4
850 00018A3A 0d effffff870 effffff86b movl _muld_1_data,_dbl_ld_acc
851 00018A45 # dbl_value_1 = muld_1_data[0].op_2; /* get operand 2 */
852 00018A45 0d effffff871 effffff864 movl _muld_1_data+12,_dbl_value_1+4
853 00018A50 0d effffff862 effffff855 movl _muld_1_data+8,_dbl_value_1
854 00018A5B # dbl_expected = muld_1_data[0].exp; /* get expected result */
855 00018A5B 0d effffff863 effffff84e movl _muld_1_data+20,_dbl_expected+4
856 00018A66 0d effffff854 effffff83f movl _muld_1_data+16,_dbl_expected
857 00018A71 # /*
858 00018A71 # * If LOOP ON ERROR is set, this is the loop for this subtest.
859 00018A71 # * The force loop flag is set after the first error.
860 00018A71 # */
861 00018A71 # asm("_muld_6_lp1:");
862 00018A71 _muld_6_lp1:
863 00018A71 # asm("ldd _dbl_ld_acc"); /* LOAD the accumulator */
864 00018A71 07 effffff839 ldd _dbl_ld_acc
865 00018A77 # asm("nop");
866 00018A77 10 nop
867 00018A78 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
868 00018A78 ab 891fff effffff82f loadr $0x1fff,_load_regs
869 00018A81 # asm("nop");
870 00018A81 10 nop
871 00018A82 # asm("muld _dbl_value_1"); /* do the multiply */
872 00018A82 e7 effffff828 muld _dbl_value_1
873 00018A88 # asm("nop");
874 00018A88 10 nop
875 00018A89 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
876 00018A89 bb 891fff effffff81e storer $0x1fff,_store_regs
877 00018A92 # asm("std _dbl_st_acc"); /* save the accumulator */
878 00018A92 27 effffff818 std _dbl_st_acc
879 00018A98 # if( force_loop )
880 00018A98 5d effffff812 tstl _force_loop
881 00018A9E 31 02 jeql L321
882 00018AA0 # asm("brb _muld_6_lp1");; /* loop on the error */
883 00018AA0 11 cf brb _muld_6_lp1
884 00018AA2 L321:
885 00018AA2 # /*
886 00018AA2 # * Now compare the stored register values to those that were loaded
887 00018AA2 # */
888 00018AA2 # index2 = 0;
889 00018AA2 4d effffff808 clrl _index2
890 00018AA8 # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
891 00018AA8 L322:
892 00018AA8 0d effffff802 50 movl _index2,r0
893 00018AAF 0d effffff7fb 51 movl _index2,r1
894 00018AB6 1d 40effffff7f3 cmpl _load_regs[r0],_store_regs[r1]
41effffff7ed
895 00018AC3 21 11 jneq L323
896 00018AC5 1d effffff7e5 0d cmpl _index2,$13
897 00018ACC 81 08 jgeq L323
898 00018ACE # index2++; /* check reg values */
899 00018ACE 6d effffff7dc incl _index2
900 00018AD4 11 d2 jbr L322
901 00018AD6 L323:
902 00018AD6 # if( index2 < 13 ) { /* error if index2 < 13 */
903 00018AD6 1d effffff7d4 0d cmpl _index2,$13
904 00018ADD 91 03 13 00f4 jgeq L324
905 00018AE2 # errcnt++; /* bump the error count */
906 00018AE2 6d effffff7c8 incl _errcnt
907 00018AE8 # if( prt_error ) {
908 00018AE8 5d effffff7c2 tstl _prt_error
909 00018AEE 21 03 13 00c0 jeql L325
910 00018AF3 # writes(" \n"); /* start a new print line */
911 00018AF3 .data 1
912 00000e6f * L326:
913 00000e6f * 200A00 .ascii " \12\0"
914 00000e72 * .text
915 00018AF3 dd 8f00000e6f pushl $L326
916 00018AF9 fe 08 effffff7b0 callf $8,_writes
917 00018B00 # writes("cycle: ");
918 00018B00 .data 1
919 00000e72 * L327:
920 00000e72 * 6379636C653A2000 .ascii "cycle: \0"
921 00000e7a * .text
922 00018B00 dd 8f00000e72 pushl $L327
923 00018B06 fe 08 effffff7a3 callf $8,_writes
924 00018B0D # writed( cycle );
925 00018B0D dd effffff79d pushl _cycle
926 00018B13 fe 08 effffff796 callf $8,_writed
927 00018B1A # writes(" MULD test ");
928 00018B1A .data 1
929 00000e7a * L328:
930 00000e7a * 20204D554C442074657374200 .ascii " MULD test \0"
0
931 00000e87 * .text
932 00018B1A dd 8f00000e7a pushl $L328
933 00018B20 fe 08 effffff789 callf $8,_writes
934 00018B27 # writed( test_no );
935 00018B27 dd effffff783 pushl _test_no
936 00018B2D fe 08 effffff77c callf $8,_writed
937 00018B34 # writes(", subtest 6 - A REGISTER WAS CHANGED\n");
938 00018B34 .data 1
939 00000e87 * L329:
940 00000e87 * 2C20737562746573742036202 .ascii ", subtest 6 - A REGISTER WAS CHANGED\12\0"
D204120524547495354455220
574153204348414E4745440A0
0
941 00000ead * .text
942 00018B34 dd 8f00000e87 pushl $L329
943 00018B3A fe 08 effffff76f callf $8,_writes
944 00018B41 # print_muld_data(); /* print the operands */
945 00018B41 fe 04 ef0000026c callf $4,_print_muld_data
946 00018B48 # writes("register "); /* print the information */
947 00018B48 .data 1
948 00000ead * L330:
949 00000ead * 72656769737465722000 .ascii "register \0"
950 00000eb7 * .text
951 00018B48 dd 8f00000ead pushl $L330
952 00018B4E fe 08 effffff75b callf $8,_writes
953 00018B55 # writed( index2 ); /* about the corrupted */
954 00018B55 dd effffff755 pushl _index2
955 00018B5B fe 08 effffff74e callf $8,_writed
956 00018B62 # writes(" = "); /* register */
957 00018B62 .data 1
958 00000eb7 * L331:
959 00000eb7 * 203D2000 .ascii " = \0"
960 00000ebb * .text
961 00018B62 dd 8f00000eb7 pushl $L331
962 00018B68 fe 08 effffff741 callf $8,_writes
963 00018B6F # write32h( store_regs[index2] );
964 00018B6F 0d effffff73b 50 movl _index2,r0
965 00018B76 dd 40effffff733 pushl _store_regs[r0]
966 00018B7D fe 08 effffff72c callf $8,_write32h
967 00018B84 # writes(", should be = ");
968 00018B84 .data 1
969 00000ebb * L333:
970 00000ebb * 2C202073686F756C642062652 .ascii ", should be = \0"
03D2000
971 00000ecb * .text
972 00018B84 dd 8f00000ebb pushl $L333
973 00018B8A fe 08 effffff71f callf $8,_writes
974 00018B91 # write32h( load_regs[index2] );
975 00018B91 0d effffff719 50 movl _index2,r0
976 00018B98 dd 40effffff711 pushl _load_regs[r0]
977 00018B9F fe 08 effffff70a callf $8,_write32h
978 00018BA6 # writes("\n");
979 00018BA6 .data 1
980 00000ecb * L334:
981 00000ecb * 0A00 .ascii "\12\0"
982 00000ecd * .text
983 00018BA6 dd 8f00000ecb pushl $L334
984 00018BAC fe 08 effffff6fd callf $8,_writes
985 00018BB3 # }
986 00018BB3 # if( halt_flg )
987 00018BB3 L325:
988 00018BB3 5d effffff6f7 tstl _halt_flg
989 00018BB9 31 09 jeql L335
990 00018BBB # muld_er_halt( BAD_REG_HLT ); /* halt on the error */
991 00018BBB dd 02 pushl $2
992 00018BBD fe 08 ef000002e6 callf $8,_muld_er_halt
993 00018BC4 # if( loop_on_err ) {
994 00018BC4 L335:
995 00018BC4 5d effffff6e6 tstl _loop_on_err
996 00018BCA 31 0a jeql L336
997 00018BCC # force_loop = TRUE; /* set the force loop flag */
998 00018BCC 0d 01 effffff6dd movl $1,_force_loop
999 00018BD3 # asm("brw _muld_6_lp1");; /* and loop on the error */
1000 00018BD3 13 fe9b brw _muld_6_lp1
1001 00018BD6 # } /* end of loop on error */
1002 00018BD6 # } /* end of register corruption error */
1003 00018BD6 L336:
1004 00018BD6 # } /* end of subtest 6 */
1005 00018BD6 L324:
1006 00018BD6 40 ret#2
1007 00018BD7 .set L316,0x0
1008 00018BD7 L318:
1009 00018BD7 13 fe35 jbr L319
1010 00018BDA .data
1011 00000d28 * .text
1012 00018BDA .align 1
1013 00018BDA .globl _muld_7
1014 00018BDA _muld_7:
1015 00018BDA 0000 .word L337
1016 00018BDC #
1017 00018BDC #
1018 00018BDC #
1019 00018BDC # /************************************************************************
1020 00018BDC # *
1021 00018BDC # * SUBTEST 7 - Check for PSL corruption
1022 00018BDC # *
1023 00018BDC # ************************************************************************/
1024 00018BDC # muld_7()
1025 00018BDC # {
1026 00018BDC 13 01d2 jbr L339
1027 00018BDF L340:
1028 00018BDF # force_loop = FALSE; /* clear force_loop flg */
1029 00018BDF 4d effffff6cb clrl _force_loop
1030 00018BE5 # subtest = 7;
1031 00018BE5 0d 07 effffff6c4 movl $7,_subtest
1032 00018BEC # fill_reg_buf( load_regs ); /* get patterns for regs */
1033 00018BEC dd 8f00000000 pushl $_load_regs
1034 00018BF2 fe 08 effffff6b7 callf $8,_fill_reg_buf
1035 00018BF9 # for( index = 0; index < 3; index++ ) {
1036 00018BF9 4d effffff6b1 clrl _index
1037 00018BFF L343:
1038 00018BFF 1d effffff6ab 03 cmpl _index,$3
1039 00018C06 91 03 13 01a5 jgeq L342
1040 00018C0B # dbl_ld_acc = muld_1_data[index].op_1; /* get operand 1 */
1041 00018C0B 5c 18 effffff69e 50 mull3 $24,_index,r0
1042 00018C13 0c 8f00000000 50 addl2 $_muld_1_data,r0
1043 00018C1A 0d a004 effffff692 movl 4(r0),_dbl_ld_acc+4
1044 00018C22 0d 60 effffff687 movl (r0),_dbl_ld_acc
1045 00018C29 # dbl_value_1 = muld_1_data[index].op_2; /* get operand 2 */
1046 00018C29 5c 18 effffff680 50 mull3 $24,_index,r0
1047 00018C31 0c 8f00000008 50 addl2 $_muld_1_data+8,r0
1048 00018C38 0d a004 effffff674 movl 4(r0),_dbl_value_1+4
1049 00018C40 0d 60 effffff669 movl (r0),_dbl_value_1
1050 00018C47 # dbl_expected = muld_1_data[index].exp; /* get expected */
1051 00018C47 5c 18 effffff662 50 mull3 $24,_index,r0
1052 00018C4F 0c 8f00000010 50 addl2 $_muld_1_data+16,r0
1053 00018C56 0d a004 effffff656 movl 4(r0),_dbl_expected+4
1054 00018C5E 0d 60 effffff64b movl (r0),_dbl_expected
1055 00018C65 # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */
1056 00018C65 0d effffff645 50 movl _status_index,r0
1057 00018C6C 0d 40effffff63d movl _status_array[r0],_sgl_dummy1
effffff638
1058 00018C78 # /*
1059 00018C78 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1060 00018C78 # * The force loop flag is set after the first error.
1061 00018C78 # */
1062 00018C78 # asm("_muld_7_lp1:");
1063 00018C78 _muld_7_lp1:
1064 00018C78 # asm("ldd _dbl_ld_acc"); /* LOAD the accumulator */
1065 00018C78 07 effffff632 ldd _dbl_ld_acc
1066 00018C7E # asm("nop");
1067 00018C7E 10 nop
1068 00018C7F # asm("tstl _sgl_dummy1"); /* set the PSL status */
1069 00018C7F 5d effffff62b tstl _sgl_dummy1
1070 00018C85 # asm("movpsl _init_psl"); /* save the initial PSL */
1071 00018C85 cd effffff625 movpsl _init_psl
1072 00018C8B # asm("muld _dbl_value_1"); /* do the multiply */
1073 00018C8B e7 effffff61f muld _dbl_value_1
1074 00018C91 # asm("nop");
1075 00018C91 10 nop
1076 00018C92 # asm("movpsl _psl_val"); /* save the final PSL */
1077 00018C92 cd effffff618 movpsl _psl_val
1078 00018C98 # asm("std _dbl_st_acc"); /* save the accumulator */
1079 00018C98 27 effffff612 std _dbl_st_acc
1080 00018C9E # if( force_loop )
1081 00018C9E 5d effffff60c tstl _force_loop
1082 00018CA4 31 02 jeql L344
1083 00018CA6 # asm("brb _muld_7_lp1");; /* loop on the error */
1084 00018CA6 11 d0 brb _muld_7_lp1
1085 00018CA8 L344:
1086 00018CA8 # /*
1087 00018CA8 # * Now compare the final PSL to the initial PSL -they should be the same
1088 00018CA8 # */
1089 00018CA8 # exp_psl = init_psl;
1090 00018CA8 0d effffff602 effffff5fd movl _init_psl,_exp_psl
1091 00018CB3 # if( psl_val != init_psl ) {
1092 00018CB3 1d effffff5f7 effffff5f2 cmpl _psl_val,_init_psl
1093 00018CBE 21 03 13 00e4 jeql L345
1094 00018CC3 # errcnt++; /* bump the error count */
1095 00018CC3 6d effffff5e7 incl _errcnt
1096 00018CC9 # if( prt_error ) {
1097 00018CC9 5d effffff5e1 tstl _prt_error
1098 00018CCF 21 03 13 00b0 jeql L346
1099 00018CD4 # writes(" \n"); /* start a new print line */
1100 00018CD4 .data 1
1101 00000ecd * L347:
1102 00000ecd * 200A00 .ascii " \12\0"
1103 00000ed0 * .text
1104 00018CD4 dd 8f00000ecd pushl $L347
1105 00018CDA fe 08 effffff5cf callf $8,_writes
1106 00018CE1 # writes("cycle: ");
1107 00018CE1 .data 1
1108 00000ed0 * L348:
1109 00000ed0 * 6379636C653A2000 .ascii "cycle: \0"
1110 00000ed8 * .text
1111 00018CE1 dd 8f00000ed0 pushl $L348
1112 00018CE7 fe 08 effffff5c2 callf $8,_writes
1113 00018CEE # writed( cycle );
1114 00018CEE dd effffff5bc pushl _cycle
1115 00018CF4 fe 08 effffff5b5 callf $8,_writed
1116 00018CFB # writes(" MULD test ");
1117 00018CFB .data 1
1118 00000ed8 * L349:
1119 00000ed8 * 20204D554C442074657374200 .ascii " MULD test \0"
0
1120 00000ee5 * .text
1121 00018CFB dd 8f00000ed8 pushl $L349
1122 00018D01 fe 08 effffff5a8 callf $8,_writes
1123 00018D08 # writed( test_no );
1124 00018D08 dd effffff5a2 pushl _test_no
1125 00018D0E fe 08 effffff59b callf $8,_writed
1126 00018D15 # writes(", subtest 7 - INCORRECT FINAL PSL\n");
1127 00018D15 .data 1
1128 00000ee5 * L350:
1129 00000ee5 * 2C20737562746573742037202 .ascii ", subtest 7 - INCORRECT FINAL PSL\12\0"
D20494E434F52524543542046
494E414C2050534C0A00
1130 00000f08 * .text
1131 00018D15 dd 8f00000ee5 pushl $L350
1132 00018D1B fe 08 effffff58e callf $8,_writes
1133 00018D22 # print_muld_data(); /* print the operands */
1134 00018D22 fe 04 ef0000008b callf $4,_print_muld_data
1135 00018D29 # writes("initial PSL = ");
1136 00018D29 .data 1
1137 00000f08 * L351:
1138 00000f08 * 696E697469616C2050534C203 .ascii "initial PSL = \0"
D2000
1139 00000f17 * .text
1140 00018D29 dd 8f00000f08 pushl $L351
1141 00018D2F fe 08 effffff57a callf $8,_writes
1142 00018D36 # write32h( init_psl );
1143 00018D36 dd effffff574 pushl _init_psl
1144 00018D3C fe 08 effffff56d callf $8,_write32h
1145 00018D43 # writes(", final PSL = ");
1146 00018D43 .data 1
1147 00000f17 * L352:
1148 00000f17 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
03D2000
1149 00000f27 * .text
1150 00018D43 dd 8f00000f17 pushl $L352
1151 00018D49 fe 08 effffff560 callf $8,_writes
1152 00018D50 # write32h( psl_val );
1153 00018D50 dd effffff55a pushl _psl_val
1154 00018D56 fe 08 effffff553 callf $8,_write32h
1155 00018D5D # writes(", expected PSL = ");
1156 00018D5D .data 1
1157 00000f27 * L353:
1158 00000f27 * 2C20206578706563746564205 .ascii ", expected PSL = \0"
0534C203D2000
1159 00000f3a * .text
1160 00018D5D dd 8f00000f27 pushl $L353
1161 00018D63 fe 08 effffff546 callf $8,_writes
1162 00018D6A # write32h( exp_psl );
1163 00018D6A dd effffff540 pushl _exp_psl
1164 00018D70 fe 08 effffff539 callf $8,_write32h
1165 00018D77 # writes("\n");
1166 00018D77 .data 1
1167 00000f3a * L354:
1168 00000f3a * 0A00 .ascii "\12\0"
1169 00000f3c * .text
1170 00018D77 dd 8f00000f3a pushl $L354
1171 00018D7D fe 08 effffff52c callf $8,_writes
1172 00018D84 # }
1173 00018D84 # if( halt_flg )
1174 00018D84 L346:
1175 00018D84 5d effffff526 tstl _halt_flg
1176 00018D8A 31 09 jeql L355
1177 00018D8C # muld_er_halt( BAD_PSL_HLT ); /* halt on the error */
1178 00018D8C dd 03 pushl $3
1179 00018D8E fe 08 ef00000115 callf $8,_muld_er_halt
1180 00018D95 # if( loop_on_err ) {
1181 00018D95 L355:
1182 00018D95 5d effffff515 tstl _loop_on_err
1183 00018D9B 31 0a jeql L356
1184 00018D9D # force_loop = TRUE; /* set the force loop flag */
1185 00018D9D 0d 01 effffff50c movl $1,_force_loop
1186 00018DA4 # asm("brw _muld_7_lp1");; /* and loop on the error */
1187 00018DA4 13 fed1 brw _muld_7_lp1
1188 00018DA7 # } /* end of loop on error */
1189 00018DA7 # } /* end of PSL corruption error */
1190 00018DA7 L356:
1191 00018DA7 # } /* end of WHILE loop */
1192 00018DA7 L345:
1193 00018DA7 L341:
1194 00018DA7 6d effffff503 incl _index
1195 00018DAD 13 fe4f jbr L343
1196 00018DB0 L342:
1197 00018DB0 # } /* end of subtest 7 */
1198 00018DB0 40 ret#2
1199 00018DB1 .set L337,0x0
1200 00018DB1 L339:
1201 00018DB1 13 fe2b jbr L340
1202 00018DB4 .data
1203 00000d28 * .text
1204 00018DB4 .align 1
1205 00018DB4 .globl _print_muld_data
1206 00018DB4 _print_muld_data:
1207 00018DB4 0000 .word L357
1208 00018DB6 #
1209 00018DB6 #
1210 00018DB6 #
1211 00018DB6 # /**************************************************************************
1212 00018DB6 # *
1213 00018DB6 # * PRINT THE DATA AND STORE RESULTS
1214 00018DB6 # *
1215 00018DB6 # * initial Acc = xxxxxxxx xxxxxxxx, stored = xxxxxxxx xxxxxxxx, index = xx
1216 00018DB6 # * operand = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx
1217 00018DB6 # **************************************************************************/
1218 00018DB6 # print_muld_data()
1219 00018DB6 # {
1220 00018DB6 13 00ed jbr L359
1221 00018DB9 L360:
1222 00018DB9 # writes("initial Acc = ");
1223 00018DB9 .data 1
1224 00000f3c * L361:
1225 00000f3c * 696E697469616C20416363203 .ascii "initial Acc = \0"
D2000
1226 00000f4b * .text
1227 00018DB9 dd 8f00000f3c pushl $L361
1228 00018DBF fe 08 effffff4ea callf $8,_writes
1229 00018DC6 # write32h( dbl_ld_acc.m );
1230 00018DC6 dd effffff4e4 pushl _dbl_ld_acc
1231 00018DCC fe 08 effffff4dd callf $8,_write32h
1232 00018DD3 # writec(' ');
1233 00018DD3 dd 20 pushl $32
1234 00018DD5 fe 08 effffff4d4 callf $8,_writec
1235 00018DDC # write32h( dbl_ld_acc.l );
1236 00018DDC dd effffff4d2 pushl _dbl_ld_acc+4
1237 00018DE2 fe 08 effffff4c7 callf $8,_write32h
1238 00018DE9 # writes(", stored = ");
1239 00018DE9 .data 1
1240 00000f4b * L363:
1241 00000f4b * 2C2020202073746F726564203 .ascii ", stored = \0"
D2000
1242 00000f5a * .text
1243 00018DE9 dd 8f00000f4b pushl $L363
1244 00018DEF fe 08 effffff4ba callf $8,_writes
1245 00018DF6 # write32h( dbl_st_acc.m );
1246 00018DF6 dd effffff4b4 pushl _dbl_st_acc
1247 00018DFC fe 08 effffff4ad callf $8,_write32h
1248 00018E03 # writec(' ');
1249 00018E03 dd 20 pushl $32
1250 00018E05 fe 08 effffff4a4 callf $8,_writec
1251 00018E0C # write32h( dbl_st_acc.l );
1252 00018E0C dd effffff4a2 pushl _dbl_st_acc+4
1253 00018E12 fe 08 effffff497 callf $8,_write32h
1254 00018E19 # writes(", index = ");
1255 00018E19 .data 1
1256 00000f5a * L364:
1257 00000f5a * 2C202020696E646578203D200 .ascii ", index = \0"
0
1258 00000f67 * .text
1259 00018E19 dd 8f00000f5a pushl $L364
1260 00018E1F fe 08 effffff48a callf $8,_writes
1261 00018E26 # writed( index );
1262 00018E26 dd effffff484 pushl _index
1263 00018E2C fe 08 effffff47d callf $8,_writed
1264 00018E33 # writec('\n');
1265 00018E33 dd 0a pushl $10
1266 00018E35 fe 08 effffff474 callf $8,_writec
1267 00018E3C # writes(" operand = ");
1268 00018E3C .data 1
1269 00000f67 * L365:
1270 00000f67 * 202020206F706572616E64203 .ascii " operand = \0"
D2000
1271 00000f76 * .text
1272 00018E3C dd 8f00000f67 pushl $L365
1273 00018E42 fe 08 effffff467 callf $8,_writes
1274 00018E49 # write32h( dbl_value_1.m );
1275 00018E49 dd effffff461 pushl _dbl_value_1
1276 00018E4F fe 08 effffff45a callf $8,_write32h
1277 00018E56 # writec(' ');
1278 00018E56 dd 20 pushl $32
1279 00018E58 fe 08 effffff451 callf $8,_writec
1280 00018E5F # write32h( dbl_value_1.l );
1281 00018E5F dd effffff44f pushl _dbl_value_1+4
1282 00018E65 fe 08 effffff444 callf $8,_write32h
1283 00018E6C # writes(", expected = ");
1284 00018E6C .data 1
1285 00000f76 * L366:
1286 00000f76 * 2C20206578706563746564203 .ascii ", expected = \0"
D2000
1287 00000f85 * .text
1288 00018E6C dd 8f00000f76 pushl $L366
1289 00018E72 fe 08 effffff437 callf $8,_writes
1290 00018E79 # write32h( dbl_expected.m );
1291 00018E79 dd effffff431 pushl _dbl_expected
1292 00018E7F fe 08 effffff42a callf $8,_write32h
1293 00018E86 # writec(' ');
1294 00018E86 dd 20 pushl $32
1295 00018E88 fe 08 effffff421 callf $8,_writec
1296 00018E8F # write32h( dbl_expected.l );
1297 00018E8F dd effffff41f pushl _dbl_expected+4
1298 00018E95 fe 08 effffff414 callf $8,_write32h
1299 00018E9C # writec('\n');
1300 00018E9C dd 0a pushl $10
1301 00018E9E fe 08 effffff40b callf $8,_writec
1302 00018EA5 # }
1303 00018EA5 40 ret#2
1304 00018EA6 .set L357,0x0
1305 00018EA6 L359:
1306 00018EA6 13 ff10 jbr L360
1307 00018EA9 .data
1308 00000d28 * .text
1309 00018EA9 00 .align 1
1310 00018EAA .globl _muld_er_halt
1311 00018EAA _muld_er_halt:
1312 00018EAA 0000 .word L367
1313 00018EAC #
1314 00018EAC #
1315 00018EAC #
1316 00018EAC # /**************************************************************************
1317 00018EAC # *
1318 00018EAC # * HALT ON ERROR ROUTINE
1319 00018EAC # *
1320 00018EAC # **************************************************************************/
1321 00018EAC # muld_er_halt( halt_code )
1322 00018EAC # int halt_code;
1323 00018EAC # {
1324 00018EAC 13 0123 jbr L369
1325 00018EAF L370:
1326 00018EAF # sgl_value_1 = dbl_ld_acc.m;
1327 00018EAF 0d effffff3fb effffff3f6 movl _dbl_ld_acc,_sgl_value_1
1328 00018EBA # sgl_value_2 = dbl_ld_acc.l;
1329 00018EBA 0d effffff3f4 effffff3eb movl _dbl_ld_acc+4,_sgl_value_2
1330 00018EC5 # sgl_value_3 = dbl_value_1.m;
1331 00018EC5 0d effffff3e5 effffff3e0 movl _dbl_value_1,_sgl_value_3
1332 00018ED0 # sgl_value_4 = dbl_value_1.l;
1333 00018ED0 0d effffff3de effffff3d5 movl _dbl_value_1+4,_sgl_value_4
1334 00018EDB # sgl_value_5 = dbl_st_acc.m;
1335 00018EDB 0d effffff3cf effffff3ca movl _dbl_st_acc,_sgl_value_5
1336 00018EE6 # sgl_value_6 = dbl_st_acc.l;
1337 00018EE6 0d effffff3c8 effffff3bf movl _dbl_st_acc+4,_sgl_value_6
1338 00018EF1 # sgl_dummy1 = halt_code; /* get the error type */
1339 00018EF1 0d ad04 effffff3b7 movl 4(fp),_sgl_dummy1
1340 00018EF9 # asm("movl _test_no,r0"); /* r0 = test number */
1341 00018EF9 0d effffff3b1 50 movl _test_no,r0
1342 00018F00 # asm("movl _subtest,r1"); /* r1 = subtest number */
1343 00018F00 0d effffff3aa 51 movl _subtest,r1
1344 00018F07 # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1345 00018F07 0d effffff3a3 52 movl _sgl_dummy1,r2
1346 00018F0E # asm("movl _cycle,r3"); /* r3 = cycle count */
1347 00018F0E 0d effffff39c 53 movl _cycle,r3
1348 00018F15 # asm("movl _sgl_value_1,r4"); /* r4 = MS operand 1 */
1349 00018F15 0d effffff395 54 movl _sgl_value_1,r4
1350 00018F1C # asm("movl _sgl_value_2,r5"); /* r5 = LS operand 1 */
1351 00018F1C 0d effffff38e 55 movl _sgl_value_2,r5
1352 00018F23 # asm("movl _sgl_value_3,r6"); /* r6 = MS operand 2 */
1353 00018F23 0d effffff387 56 movl _sgl_value_3,r6
1354 00018F2A # asm("movl _sgl_value_4,r7"); /* r7 = LS operand 2 */
1355 00018F2A 0d effffff380 57 movl _sgl_value_4,r7
1356 00018F31 # asm("movl _sgl_value_5,r8"); /* r8 = MS stored */
1357 00018F31 0d effffff379 58 movl _sgl_value_5,r8
1358 00018F38 # asm("movl _sgl_value_6,r9"); /* r9 = LS stored */
1359 00018F38 0d effffff372 59 movl _sgl_value_6,r9
1360 00018F3F # if( halt_code == BAD_ACC_HLT ) {
1361 00018F3F 1d ad04 01 cmpl 4(fp),$1
1362 00018F43 21 2d jneq L371
1363 00018F45 # sgl_value_1 = dbl_expected.m;
1364 00018F45 0d effffff365 effffff360 movl _dbl_expected,_sgl_value_1
1365 00018F50 # sgl_value_2 = dbl_expected.l;
1366 00018F50 0d effffff35e effffff355 movl _dbl_expected+4,_sgl_value_2
1367 00018F5B # asm("movl _sgl_value_1,r10"); /* r10 = MS expected */
1368 00018F5B 0d effffff34f 5a movl _sgl_value_1,r10
1369 00018F62 # asm("movl _sgl_value_2,r11"); /* r11 = LS expected */
1370 00018F62 0d effffff348 5b movl _sgl_value_2,r11
1371 00018F69 # asm("movl _index2,r12"); /* r12 = data index */
1372 00018F69 0d effffff341 5c movl _index2,r12
1373 00018F70 # } else
1374 00018F70 11 5e jbr L372
1375 00018F72 L371:
1376 00018F72 # if( halt_code == BAD_REG_HLT ) {
1377 00018F72 1d ad04 02 cmpl 4(fp),$2
1378 00018F76 21 3d jneq L373
1379 00018F78 # sgl_dummy1 = load_regs[index2];
1380 00018F78 0d effffff332 50 movl _index2,r0
1381 00018F7F 0d 40effffff32a movl _load_regs[r0],_sgl_dummy1
effffff325
1382 00018F8B # sgl_dummy2 = store_regs[index2];
1383 00018F8B 0d effffff31f 50 movl _index2,r0
1384 00018F92 0d 40effffff317 movl _store_regs[r0],_sgl_dummy2
effffff312
1385 00018F9E # asm("movl _index2,r10"); /* r10 = bad register # */
1386 00018F9E 0d effffff30c 5a movl _index2,r10
1387 00018FA5 # asm("movl _sgl_dummy2,r11"); /* r11 = actual value */
1388 00018FA5 0d effffff305 5b movl _sgl_dummy2,r11
1389 00018FAC # asm("movl _sgl_dummy1,r12"); /* r12 = expected value */
1390 00018FAC 0d effffff2fe 5c movl _sgl_dummy1,r12
1391 00018FB3 # } else
1392 00018FB3 11 1b jbr L374
1393 00018FB5 L373:
1394 00018FB5 # if( halt_code == BAD_PSL_HLT ) {
1395 00018FB5 1d ad04 03 cmpl 4(fp),$3
1396 00018FB9 21 15 jneq L375
1397 00018FBB # asm("movl _init_psl,r10"); /* r10 = initial PSL */
1398 00018FBB 0d effffff2ef 5a movl _init_psl,r10
1399 00018FC2 # asm("movl _psl_val,r11"); /* r11 = final PSL */
1400 00018FC2 0d effffff2e8 5b movl _psl_val,r11
1401 00018FC9 # asm("movl _exp_psl,r12"); /* r12 = expected PSL */
1402 00018FC9 0d effffff2e1 5c movl _exp_psl,r12
1403 00018FD0 # };
1404 00018FD0 L375:
1405 00018FD0 L374:
1406 00018FD0 L372:
1407 00018FD0 # asm("halt"); /* HALT ... */
1408 00018FD0 00 halt
1409 00018FD1 # }
1410 00018FD1 40 ret#2
1411 00018FD2 .set L367,0x0
1412 00018FD2 L369:
1413 00018FD2 13 feda jbr L370
1414 00018FD5 .data
1414 00031285 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.