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